From df30f1bfc5fd678ef2040ae638cb4ca9d0d5a79c Mon Sep 17 00:00:00 2001 From: Jeff Hill Date: Tue, 14 May 2002 20:21:15 +0000 Subject: [PATCH] added iterator classes --- src/libCom/cxxTemplates/resourceLib.h | 291 +++++++++++++++++++++----- 1 file changed, 243 insertions(+), 48 deletions(-) diff --git a/src/libCom/cxxTemplates/resourceLib.h b/src/libCom/cxxTemplates/resourceLib.h index 47224924b..7f714b3dd 100644 --- a/src/libCom/cxxTemplates/resourceLib.h +++ b/src/libCom/cxxTemplates/resourceLib.h @@ -69,7 +69,8 @@ #include "locationException.h" typedef size_t resTableIndex; -template class resTableIter; +template < class T, class ID > class resTableIter; +template < class T, class ID > class resTableIterConst; // // class resTable @@ -102,17 +103,19 @@ public: resTable (); virtual ~resTable(); // Call " void T::show (unsigned level)" for each entry - void show (unsigned level) const; + void show ( unsigned level ) const; void verify () const; int add ( T & res ); // returns -1 (id exists in table), 0 (success) - T * remove (const ID &idIn); // remove entry - void removeAll (tsSLList & destination); // remove all entries - T * lookup (const ID &idIn) const; // locate entry + T * remove ( const ID &idIn ); // remove entry + void removeAll ( tsSLList & destination ); // remove all entries + T * lookup ( const ID &idIn ) const; // locate entry // Call (pT->*pCB) () for each entry void traverse ( void (T::*pCB)() ); void traverseConst ( void (T::*pCB)() const ) const; unsigned numEntriesInstalled () const; void setTableSize ( const unsigned newTableSize ); + resTableIter < T, ID > firstIter (); + resTableIterConst < T, ID > firstIter () const; private: tsSLList < T > * pTable; unsigned nextSplitIndex; @@ -129,7 +132,8 @@ private: resTable ( const resTable & ); resTable & operator = ( const resTable & ); static unsigned resTableBitMask ( const unsigned nBits ); - friend class resTableIter; + friend class resTableIter < T, ID >; + friend class resTableIterConst < T, ID >; }; // @@ -137,16 +141,53 @@ private: // // an iterator for the resource table class // -template +template < class T, class ID > class resTableIter { public: - resTableIter (const resTable &tableIn); - T * next (); - T * operator () (); + resTableIter (); + bool valid () const; + bool operator == ( const resTableIter < T,ID > & rhs ) const; + bool operator != ( const resTableIter < T,ID > & rhs ) const; + resTableIter < T, ID > & operator = ( const resTableIter < T, ID > & ); + T & operator * () const; + T * operator -> () const; + resTableIter < T, ID > & operator ++ (); + resTableIter < T, ID > operator ++ ( int ); + T * pointer (); private: - tsSLIter iter; + tsSLIter < T > iter; unsigned index; - const resTable &table; + resTable < T,ID > * pResTable; + resTableIter ( resTable < T,ID > & tableIn ); + void findNextEntry (); + friend class resTable < T, ID >; +}; + +// +// class resTableIterConst +// +// an iterator for a const resource table class +// +template < class T, class ID > +class resTableIterConst { +public: + resTableIterConst (); + bool valid () const; + bool operator == ( const resTableIterConst < T,ID > & rhs ) const; + bool operator != ( const resTableIterConst < T,ID > & rhs ) const; + resTableIterConst < T, ID > & operator = ( const resTableIterConst < T, ID > & ); + const T & operator * () const; + const T * operator -> () const; + resTableIterConst < T, ID > & operator ++ (); + resTableIterConst < T, ID > operator ++ ( int ); + const T * pointer () const; +private: + tsSLIterConst < T > iter; + unsigned index; + const resTable < T,ID > * pResTable; + resTableIterConst ( const resTable < T,ID > & tableIn ); + void findNextEntry (); + friend class resTable < T, ID >; }; // @@ -645,7 +686,7 @@ int resTable::add ( T &res ) // (or NULL if nothing matching was found) // template -T *resTable::find ( tsSLList &list, const ID &idIn ) const +T * resTable::find ( tsSLList &list, const ID &idIn ) const { tsSLIter pItem = list.firstIter (); while ( pItem.valid () ) { @@ -686,51 +727,205 @@ inline resTable & resTable::operator = ( const resTable & ) return *this; } +template +resTableIterConst < T, ID > resTable::firstIter () const +{ + return resTableIterConst < T, ID > ( *this ); +} + +template +resTableIter < T, ID > resTable::firstIter () +{ + return resTableIter < T, ID > ( *this ); +} + ////////////////////////////////////////////// // resTableIter member functions ////////////////////////////////////////////// -// -// resTableIter::resTableIter () -// -template -inline resTableIter::resTableIter (const resTable &tableIn) : - iter ( tableIn.pTable ? tableIn.pTable[0].firstIter () : - tsSLList::invalidIter() ), - index (1), table ( tableIn ) {} - -// -// resTableIter::next () -// -template -T * resTableIter::next () +template < class T, class ID > +inline resTableIter::resTableIter ( resTable < T,ID > & tableIn ) : + index ( 0 ), pResTable ( & tableIn ) { - if ( this->iter.valid () ) { - T *p = this->iter.pointer (); - this->iter++; - return p; - } - unsigned N = this->table.tableSize(); - while ( true ) { - if ( this->index >= N ) { - return 0; - } - this->iter = tsSLIter ( this->table.pTable[this->index++].firstIter () ); - if ( this->iter.valid () ) { - T *p = this->iter.pointer (); - this->iter++; - return p; + this->findNextEntry (); +} + +template < class T, class ID > +inline resTableIter::resTableIter () : + iter ( tsSLList::invalidIter() ), + index ( 0 ), pResTable ( 0 ) +{ +} + +template < class T, class ID > +void resTableIter::findNextEntry () +{ + if ( this->pResTable ) { + while ( this->index < this->pResTable->tableSize() ) { + this->iter = this->pResTable->pTable[this->index++].firstIter (); + if ( this->iter.valid () ) { + break; + } } } +} + +template < class T, class ID > +inline bool resTableIter::valid () const +{ + return this->iter.valid (); } -// -// resTableIter::operator () () -// -template -inline T * resTableIter::operator () () +template < class T, class ID > +inline bool resTableIter::operator == ( const resTableIter < T,ID > & rhs ) const { - return this->next (); + return ( this->pResTable == rhs.pResTable && this->index == rhs.index && this->iter == rhs.iter ); +} + +template < class T, class ID > +inline bool resTableIter::operator != ( const resTableIter < T,ID > & rhs ) const +{ + return ! this->operator == ( rhs ); +} + +template < class T, class ID > +inline resTableIter < T, ID > & resTableIter::operator = ( const resTableIter < T, ID > & ) +{ + this->pTable = rhs.pTable; + this->index = rhs.index; + this->iter = rhs.iter; + return *this; +} + +template < class T, class ID > +inline T & resTableIter::operator * () const +{ + return this->iter.operator * (); +} + +template < class T, class ID > +inline T * resTableIter::operator -> () const +{ + return this->iter.operator -> (); +} + +template < class T, class ID > +inline resTableIter & resTableIter::operator ++ () +{ + this->iter++; + if ( ! this->iter.valid() ) { + this->findNextEntry (); + } + return *this; +} + +template < class T, class ID > +inline resTableIter resTableIter::operator ++ ( int ) +{ + resTableIter tmp = *this; + this->operator ++ (); + return tmp; +} + +template < class T, class ID > +inline T * resTableIter::pointer () +{ + return this->iter.pointer (); +} + +////////////////////////////////////////////// +// resTableIterConst member functions +////////////////////////////////////////////// + +template < class T, class ID > +inline resTableIterConst::resTableIterConst ( const resTable < T,ID > & tableIn ) : + index ( 0 ), pResTable ( & tableIn ) +{ + this->findNextEntry (); +} + +template < class T, class ID > +inline resTableIterConst::resTableIterConst () : + iter ( tsSLList::invalidIter() ), + index ( 0 ), pResTable ( 0 ) +{ +} + +template < class T, class ID > +void resTableIterConst::findNextEntry () +{ + if ( this->pResTable ) { + while ( this->index < this->pResTable->tableSize() ) { + const tsSLList * pList = & this->pResTable->pTable[this->index++]; + this->iter = pList->firstIter (); + if ( this->iter.valid () ) { + break; + } + } + } +} + +template < class T, class ID > +inline bool resTableIterConst::valid () const +{ + return this->iter.valid (); +} + +template < class T, class ID > +inline bool resTableIterConst::operator == ( const resTableIterConst < T,ID > & rhs ) const +{ + return ( this->pTable == rhs.pTable && this->index == rhs.index && this->iter == rhs.iter ); +} + +template < class T, class ID > +inline bool resTableIterConst::operator != ( const resTableIterConst < T,ID > & rhs ) const +{ + return ! this->operator == ( rhs ); +} + +template < class T, class ID > +inline resTableIterConst < T, ID > & resTableIterConst::operator = ( const resTableIterConst < T, ID > & ) +{ + this->pTable = rhs.pTable; + this->index = rhs.index; + this->iter = rhs.iter; + return *this; +} + +template < class T, class ID > +inline const T & resTableIterConst::operator * () const +{ + return this->iter.operator * (); +} + +template < class T, class ID > +inline const T * resTableIterConst::operator -> () const +{ + return this->iter.operator -> (); +} + +template < class T, class ID > +inline resTableIterConst & resTableIterConst::operator ++ () +{ + this->iter++; + if ( ! this->iter.valid() ) { + this->findNextEntry (); + } + return *this; +} + +template < class T, class ID > +inline resTableIterConst resTableIterConst::operator ++ ( int ) +{ + resTableIterConst tmp = *this; + this->operator ++ (); + return tmp; +} + +template < class T, class ID > +inline const T * resTableIterConst::pointer () const +{ + return this->iter.pointer (); } //////////////////////////////////////////////