resTable< T, ID > Class Template Reference

#include "resourceLib.h"

Public Types
typedef resTableIter< T, ID >	iterator
typedef resTableIterConst< T, ID >	iteratorConst

Public Member Functions
	resTable ()
virtual	~resTable ()
void	show (unsigned level) const
void	verify () const
int	add (T &res)
T *	remove (const ID &idIn)
void	removeAll (tsSLList< T > &destination)
T *	lookup (const ID &idIn) const
void	traverse (void(T::*pCB)())
void	traverseConst (void(T::*pCB)() const ) const
unsigned	numEntriesInstalled () const
void	setTableSize (const unsigned newTableSize)
iterator	firstIter ()
iteratorConst	firstIter () const

Friends
class	resTableIter< T, ID >
class	resTableIterConst< T, ID >

Detailed Description

template<class T, class ID>
class resTable< T, ID >

Definition at line 76 of file resourceLib.h.

Member Typedef Documentation

template<class T, class ID>

typedef resTableIter< T, ID > resTable< T, ID >::iterator

Definition at line 95 of file resourceLib.h.

template<class T, class ID>

typedef resTableIterConst< T, ID > resTable< T, ID >::iteratorConst

Definition at line 96 of file resourceLib.h.

Constructor & Destructor Documentation

template<class T , class ID >

resTable< T, ID >::resTable ( )

inline

Definition at line 280 of file resourceLib.h.

                                 :
    pTable ( 0 ), nextSplitIndex ( 0 ), hashIxMask ( 0 ),
    hashIxSplitMask ( 0 ), nBitsHashIxSplitMask ( 0 ),
    logBaseTwoTableSize ( 0 ), nInUse ( 0 ) {}

template<class T , class ID >

resTable< T, ID >::~resTable ( )

virtual

Definition at line 690 of file resourceLib.h.

{
    operator delete ( this->pTable );
}

Member Function Documentation

template<class T, class ID >

int resTable< T, ID >::add

(

T &

res

)

Definition at line 643 of file resourceLib.h.

{
    if ( ! this->pTable ) {
        this->setTableSizePrivate ( 10 );
    }
    else if ( this->nInUse >= this->tableSize() ) {
        this->splitBucket ();
        tsSLList<T> &list = this->pTable[this->hash(res)];
        if ( this->find ( list, res ) != 0 ) {
            return -1;
        }
    }
    tsSLList<T> &list = this->pTable[this->hash(res)];
    if ( this->find ( list, res ) != 0 ) {
        return -1;
    }
    list.add ( res );
    this->nInUse++;
    return 0;
}

template<class T , class ID >

resTableIter< T, ID > resTable< T, ID >::firstIter ( )

inline

Definition at line 721 of file resourceLib.h.

{
    return resTableIter < T, ID > ( *this );
}

template<class T , class ID >

resTableIterConst< T, ID > resTable< T, ID >::firstIter ( ) const

inline

Definition at line 715 of file resourceLib.h.

{
    return resTableIterConst < T, ID > ( *this );
}

template<class T , class ID>

T * resTable< T, ID >::lookup ( const ID &  idIn ) const

inline

Definition at line 342 of file resourceLib.h.

{
    if ( this->pTable ) {
        tsSLList<T> & list = this->pTable [ this->hash ( idIn ) ];
        return this->find ( list, idIn );
    }
    else {
        return 0;
    }
}

template<class T , class ID >

unsigned resTable< T, ID >::numEntriesInstalled ( ) const

inline

Definition at line 509 of file resourceLib.h.

{
    return this->nInUse;
}

template<class T , class ID>

T * resTable< T, ID >::remove

(

const ID &

idIn

)

Definition at line 297 of file resourceLib.h.

{
    if ( this->pTable ) {
        // search list for idIn and remove the first match
        tsSLList<T> & list = this->pTable [ this->hash(idIn) ];
        tsSLIter <T> pItem = list.firstIter ();
        T *pPrev = 0;
        while ( pItem.valid () ) {
            const ID & idOfItem = *pItem;
            if ( idOfItem == idIn ) {
                if ( pPrev ) {
                    list.remove ( *pPrev );
                }
                else {
                    list.get ();
                }
                this->nInUse--;
                break;
            }
            pPrev = pItem.pointer ();
            pItem++;
        }
        return pItem.pointer ();
    }
    else {
        return 0;
    }
}

template<class T, class ID >

void resTable< T, ID >::removeAll

(

tsSLList< T > &

destination

)

Definition at line 327 of file resourceLib.h.

{
    const unsigned N = this->tableSize ();
    for ( unsigned i = 0u; i < N; i++ ) {
        while ( T * pItem = this->pTable[i].get() ) {
            destination.add ( *pItem );
        }
    }
    this->nInUse = 0;
}

template<class T , class ID >

void resTable< T, ID >::setTableSize

(

const unsigned

newTableSize

)

Definition at line 528 of file resourceLib.h.

{
    if ( newTableSize == 0u ) {
        return;
    }

    //
    // count the number of bits in newTableSize and round up
    // to the next power of two
    //
    unsigned newMask = newTableSize - 1;
    unsigned nbits;
    for ( nbits = 0; nbits < sizeof (newTableSize) * CHAR_BIT; nbits++ ) {
        unsigned nBitsMask = resTableBitMask ( nbits );
        if ( ( newMask & ~nBitsMask ) == 0){
            break;
        }
    }
    setTableSizePrivate ( nbits );
}

template<class T , class ID >

void resTable< T, ID >::show

(

unsigned

level

)

const

Definition at line 371 of file resourceLib.h.

{
    const unsigned N = this->tableSize ();

    printf ( "Hash table with %u buckets and %u items of type %s installed\n",
        N, this->nInUse, typeid(T).name() );

    if ( level >= 1u && N ) {

        if ( level >= 2u ) {
            tsSLList<T> * pList = this->pTable;
            while ( pList < & this->pTable[N] ) {
                tsSLIter<T> pItem = pList->firstIter ();
                while ( pItem.valid () ) {
                    tsSLIter<T> pNext = pItem;
                    pNext++;
                    pItem.pointer()->show ( level - 2u );
                    pItem = pNext;
                }
                pList++;
            }
        }

        double X = 0.0;
        double XX = 0.0;
        unsigned maxEntries = 0u;
        unsigned empty = 0;
        for ( unsigned i = 0u; i < N; i++ ) {
            tsSLIter<T> pItem = this->pTable[i].firstIter ();
            unsigned count = 0;
            while ( pItem.valid () ) {
                if ( level >= 3u ) {
                    pItem->show ( level );
                }
                count++;
                pItem++;
            }
            if ( count > 0u ) {
                X += count;
                XX += count * count;
                if ( count > maxEntries ) {
                    maxEntries = count;
                }
            } else
                empty++;
        }

        double mean = X / N;
        double stdDev = sqrt( XX / N - mean * mean );
        printf (
    "entries per bucket: mean = %f std dev = %f max = %u\n",
            mean, stdDev, maxEntries );
        printf("%u empty buckets\n", empty);
        if ( X != this->nInUse ) {
            printf ("this->nInUse didnt match items counted which was %f????\n", X );
        }
    }
}

template<class T, class ID >

void resTable< T, ID >::traverse

(

void(T::*)()

pCB

)

Definition at line 475 of file resourceLib.h.

{
    const unsigned N = this->tableSize ();
    for ( unsigned i = 0u; i < N; i++ ) {
        tsSLIter<T> pItem = this->pTable[i].firstIter ();
        while ( pItem.valid () ) {
            tsSLIter<T> pNext = pItem;
            pNext++;
            ( pItem.pointer ()->*pCB ) ();
            pItem = pNext;
        }
    }
}

template<class T, class ID >

void resTable< T, ID >::traverseConst

(

void(T::*)() const

pCB

)

const

Definition at line 493 of file resourceLib.h.

{
    const unsigned N = this->tableSize ();
    for ( unsigned i = 0u; i < N; i++ ) {
        const tsSLList < T > & table = this->pTable[i];
        tsSLIterConst<T> pItem = table.firstIter ();
        while ( pItem.valid () ) {
            tsSLIterConst<T> pNext = pItem;
            pNext++;
            ( pItem.pointer ()->*pCB ) ();
            pItem = pNext;
        }
    }
}

template<class T , class ID >

void resTable< T, ID >::verify

(

)

const

Definition at line 432 of file resourceLib.h.

{
    const unsigned N = this->tableSize ();

    if ( this->pTable ) {
        assert ( this->nextSplitIndex <= this->hashIxMask + 1 );
        assert ( this->hashIxMask );
        assert ( this->hashIxMask == ( this->hashIxSplitMask >> 1 ) );
        assert ( this->hashIxSplitMask );
        assert ( this->nBitsHashIxSplitMask );
        assert ( resTableBitMask ( this->nBitsHashIxSplitMask )
                        == this->hashIxSplitMask );
        assert ( this->logBaseTwoTableSize );
        assert ( this->nBitsHashIxSplitMask <= this->logBaseTwoTableSize );
    }
    else {
        assert ( this->nextSplitIndex == 0 );
        assert ( this->hashIxMask == 0 );
        assert ( this->hashIxSplitMask == 0 );
        assert ( this->nBitsHashIxSplitMask == 0 );
        assert ( this->logBaseTwoTableSize == 0 );
    }

    unsigned total = 0u;
    for ( unsigned i = 0u; i < N; i++ ) {
        tsSLIter<T> pItem = this->pTable[i].firstIter ();
        unsigned count = 0;
        while ( pItem.valid () ) {
            resTableIndex index = this->hash ( *pItem );
            assert ( index == i );
            count++;
            pItem++;
        }
        total += count;
    }
    assert ( total == this->nInUse );
}

Friends And Related Function Documentation

template<class T, class ID>

friend class resTableIter< T, ID >

friend

Definition at line 115 of file resourceLib.h.

template<class T, class ID>

friend class resTableIterConst< T, ID >

friend

Definition at line 116 of file resourceLib.h.

---

The documentation for this class was generated from the following file:

• modules/libcom/src/cxxTemplates/resourceLib.h