QGDict Class Reference

The QGDict class is an internal class for implementing QDict template classes. More...

#include <qgdict.h>

Inheritance diagram for QGDict:

Public Member Functions
uint	count () const
uint	size () const
QCollection::Item	look_string (const QString &key, QCollection::Item, int)
QCollection::Item	look_ascii (const char *key, QCollection::Item, int)
QCollection::Item	look_int (long key, QCollection::Item, int)
QCollection::Item	look_ptr (void *key, QCollection::Item, int)
QDataStream &	read (QDataStream &)
QDataStream &	write (QDataStream &) const
Public Member Functions inherited from QCollection
bool	autoDelete () const
void	setAutoDelete (bool enable)

Protected Types
enum	KeyType { StringKey, AsciiKey, IntKey, PtrKey }

Protected Member Functions
	QGDict (uint len, KeyType kt, bool cs, bool ck)
	QGDict (const QGDict &)
	~QGDict ()
QGDict &	operator= (const QGDict &)
bool	remove_string (const QString &key, QCollection::Item item=0)
bool	remove_ascii (const char *key, QCollection::Item item=0)
bool	remove_int (long key, QCollection::Item item=0)
bool	remove_ptr (void *key, QCollection::Item item=0)
QCollection::Item	take_string (const QString &key)
QCollection::Item	take_ascii (const char *key)
QCollection::Item	take_int (long key)
QCollection::Item	take_ptr (void *key)
void	clear ()
void	resize (uint)
int	hashKeyString (const QString &)
int	hashKeyAscii (const char *)
void	statistics () const
virtual QDataStream &	read (QDataStream &, QCollection::Item &)
virtual QDataStream &	write (QDataStream &, QCollection::Item) const
Protected Member Functions inherited from QCollection
	QCollection ()
	QCollection (const QCollection &)
virtual	~QCollection ()
virtual Item	newItem (Item)
virtual void	deleteItem (Item)

Private Member Functions
void	unlink_common (int, QBaseBucket *, QBaseBucket *)
QStringBucket *	unlink_string (const QString &, QCollection::Item item=0)
QAsciiBucket *	unlink_ascii (const char *, QCollection::Item item=0)
QIntBucket *	unlink_int (long, QCollection::Item item=0)
QPtrBucket *	unlink_ptr (void *, QCollection::Item item=0)
void	init (uint, KeyType, bool, bool)

Private Attributes
QBaseBucket **	vec
uint	vlen
uint	numItems
uint	keytype: 2
uint	cases: 1
uint	copyk: 1
QGDItList *	iterators

Friends
class	QGDictIterator

Additional Inherited Members
Public Types inherited from QCollection
typedef void *	Item
Protected Attributes inherited from QCollection
bool	del_item

Detailed Description

The QGDict class is an internal class for implementing QDict template classes.

QGDict is a strictly internal class that acts as a base class for the collection classes QDict and QIntDict.

QGDict has some virtual functions that can be reimplemented to customize the subclasses.

• read() reads a collection/dictionary item from a QDataStream.
• write() writes a collection/dictionary item to a QDataStream.

Normally, you do not have to reimplement any of these functions.

Definition at line 104 of file qgdict.h.

Member Enumeration Documentation

enum QGDict::KeyType

protected

Enumerator
StringKey
AsciiKey
IntKey
PtrKey

Definition at line 119 of file qgdict.h.

{ StringKey, AsciiKey, IntKey, PtrKey };

Constructor & Destructor Documentation

QGDict::QGDict ( uint  len, KeyType  kt, bool  cs, bool  ck  )

protected

Definition at line 222 of file qgdict.cpp.

{
    init( len, kt, caseSensitive, copyKeys );
}

QGDict::QGDict ( const QGDict &  dict )

protected

Definition at line 259 of file qgdict.cpp.

    : QCollection( dict )
{
    init( dict.vlen, (KeyType)dict.keytype, dict.cases, dict.copyk );
    QGDictIterator it( dict );
    while ( it.get() ) {                        // copy from other dict
        switch ( keytype ) {
            case StringKey:
                look_string( it.getKeyString(), it.get(), op_insert );
                break;
            case AsciiKey:
                look_ascii( it.getKeyAscii(), it.get(), op_insert );
                break;
            case IntKey:
                look_int( it.getKeyInt(), it.get(), op_insert );
                break;
            case PtrKey:
                look_ptr( it.getKeyPtr(), it.get(), op_insert );
                break;
        }
        ++it;
    }
}

QGDict::~QGDict ( )

protected

Definition at line 289 of file qgdict.cpp.

{
    clear();                                    // delete everything
    delete [] vec;
    if ( !iterators )                           // no iterators for this dict
        return;
    QGDictIterator *i = iterators->first();
    while ( i ) {                               // notify all iterators that
        i->dict = 0;                            // this dict is deleted
        i = iterators->next();
    }
    delete iterators;
}

Member Function Documentation

void QGDict::clear ( )

protectedvirtual

Removes all objects from the collection. The objects will be deleted if auto-delete has been enabled.

See also

setAutoDelete()

Implements QCollection.

Reimplemented in QAsciiDict< Entry >, QIntDict< type >, QPtrDict< type >, QIntDict< MemberDef >, QIntDict< Definition >, QIntDict< MemberGroup >, QIntDict< T >, QIntDict< MemberGroupInfo >, QIntDict< URL >, QIntDict< URLInfo >, QIntDict< ClassDef >, QIntDict< RefItem >, QIntDict< char >, QIntDict< uint >, and QIntDict< SearchIndexList >.

Definition at line 857 of file qgdict.cpp.

{
    if ( !numItems )
        return;
    numItems = 0;                               // disable remove() function
    for ( uint j=0; j<vlen; j++ ) {             // destroy hash table
        if ( vec[j] ) {
            switch ( keytype ) {
                case StringKey:
                    {
                        QStringBucket *n=(QStringBucket *)vec[j];
                        while ( n ) {
                            QStringBucket *next = (QStringBucket*)n->getNext();
                            deleteItem( n->getData() );
                            delete n;
                            n = next;
                        }
                    }
                    break;
                case AsciiKey:
                    {
                        QAsciiBucket *n=(QAsciiBucket *)vec[j];
                        while ( n ) {
                            QAsciiBucket *next = (QAsciiBucket*)n->getNext();
                            if ( copyk )
                                delete [] (char *)n->getKey();
                            deleteItem( n->getData() );
                            delete n;
                            n = next;
                        }
                    }
                    break;
                case IntKey:
                    {
                        QIntBucket *n=(QIntBucket *)vec[j];
                        while ( n ) {
                            QIntBucket *next = (QIntBucket*)n->getNext();
                            deleteItem( n->getData() );
                            delete n;
                            n = next;
                        }
                    }
                    break;
                case PtrKey:
                    {
                        QPtrBucket *n=(QPtrBucket *)vec[j];
                        while ( n ) {
                            QPtrBucket *next = (QPtrBucket*)n->getNext();
                            deleteItem( n->getData() );
                            delete n;
                            n = next;
                        }
                    }
                    break;
            }
            vec[j] = 0;                         // detach list of buckets
        }
    }
    if ( iterators && iterators->count() ) {    // invalidate all iterators
        QGDictIterator *i = iterators->first();
        while ( i ) {
            i->curNode = 0;
            i = iterators->next();
        }
    }
}

uint QGDict::count ( ) const

inlinevirtual

Returns the number of objects in the collection.

Implements QCollection.

Reimplemented in QAsciiDict< Entry >, QIntDict< type >, QPtrDict< type >, QIntDict< MemberDef >, QIntDict< Definition >, QIntDict< MemberGroup >, QIntDict< T >, QIntDict< MemberGroupInfo >, QIntDict< URL >, QIntDict< URLInfo >, QIntDict< ClassDef >, QIntDict< RefItem >, QIntDict< char >, QIntDict< uint >, and QIntDict< SearchIndexList >.

Definition at line 107 of file qgdict.h.

{ return numItems; }

int QGDict::hashKeyAscii ( const char *  key )

protected

Definition at line 123 of file qgdict.cpp.

{
#if defined(CHECK_NULL)
    if ( key == 0 )
    {
        qWarning( "QGDict::hashAsciiKey: Invalid null key" );
        return 0;
    }
#endif
    register const char *k = key;
    register uint h=0;
    uint g;
    if ( cases ) {                              // case sensitive
        while ( *k ) {
            h = (h<<4) + *k++;
            if ( (g = h & 0xf0000000) )
                h ^= g >> 24;
            h &= ~g;
        }
    } else {                                    // case insensitive
        while ( *k ) {
            h = (h<<4) + tolower(*k);
            if ( (g = h & 0xf0000000) )
                h ^= g >> 24;
            h &= ~g;
            k++;
        }
    }
    int index = h;
    if ( index < 0 )                            // adjust index to table size
        index = -index;
    return index;
}

int QGDict::hashKeyString ( const QString &  key )

protected

Definition at line 86 of file qgdict.cpp.

{
#if defined(CHECK_NULL)
    if ( key.isNull() ) 
        qWarning( "QGDict::hashStringKey: Invalid null key" ); 
#endif
    int i;
    register uint h=0;
    uint g;
    int len = key.length();
    const QChar *p = key.unicode();
    if ( cases ) {                              // case sensitive
        for ( i=0; i<len; i++ ) {
            h = (h<<4) + p[i].cell();
            if ( (g = h & 0xf0000000) )
                h ^= g >> 24;
            h &= ~g;
        }
    } else {                                    // case insensitive
        for ( i=0; i<len; i++ ) {
            h = (h<<4) + p[i].lower().cell();
            if ( (g = h & 0xf0000000) )
                h ^= g >> 24;
            h &= ~g;
        }
    }
    int index = h;
    if ( index < 0 )                            // adjust index to table size
        index = -index;
    return index;
}

void QGDict::init ( uint  len, KeyType  kt, bool  caseSensitive, bool  copyKeys  )

private

Definition at line 228 of file qgdict.cpp.

{
    vec = new QBaseBucket *[vlen = len];                // allocate hash table
    CHECK_PTR( vec );
    memset( (char*)vec, 0, vlen*sizeof(QBaseBucket*) );
    numItems  = 0;
    iterators = 0;
    // The caseSensitive and copyKey options don't make sense for
    // all dict types.
    switch ( (keytype = (uint)kt) ) {
        case StringKey:
            cases = caseSensitive;
            copyk = FALSE;
            break;
        case AsciiKey:
            cases = caseSensitive;
            copyk = copyKeys;
            break;
        default:
            cases = FALSE;
            copyk = FALSE;
            break;
    }
}

QCollection::Item QGDict::look_ascii	(	const char *	key,
		QCollection::Item	d,
		int	op
	)

Definition at line 422 of file qgdict.cpp.

{
    QAsciiBucket *n;
    int index = hashKeyAscii(key) % vlen;
    if ( op == op_find ) {                      // find
        if ( cases ) {
            for ( n=(QAsciiBucket*)vec[index]; n;
                  n=(QAsciiBucket*)n->getNext() ) {
                if ( qstrcmp(n->getKey(),key) == 0 )
                    return n->getData();        // item found
            }
        } else {
            for ( n=(QAsciiBucket*)vec[index]; n;
                  n=(QAsciiBucket*)n->getNext() ) {
                if ( qstricmp(n->getKey(),key) == 0 )
                    return n->getData();        // item found
            }
        }
        return 0;                               // not found
    }
    if ( op == op_replace ) {                   // replace
        if ( vec[index] != 0 )                  // maybe something there
            remove_ascii( key );
    }
    // op_insert or op_replace
    n = new QAsciiBucket(copyk ? qstrdup(key) : key,newItem(d),vec[index]);
    CHECK_PTR( n );
#if defined(CHECK_NULL)
    if ( n->getData() == 0 )
        qWarning( "QAsciiDict: Cannot insert null item" );
#endif
    vec[index] = n;
    numItems++;
    return n->getData();
}

QCollection::Item QGDict::look_int	(	long	key,
		QCollection::Item	d,
		int	op
	)

Definition at line 461 of file qgdict.cpp.

{
    QIntBucket *n;
    int index = (int)((ulong)key % vlen);       // simple hash
    if ( op == op_find ) {                      // find
        for ( n=(QIntBucket*)vec[index]; n;
              n=(QIntBucket*)n->getNext() ) {
            if ( n->getKey() == key )
                return n->getData();            // item found
        }
        return 0;                               // not found
    }
    if ( op == op_replace ) {                   // replace
        if ( vec[index] != 0 )                  // maybe something there
            remove_int( key );
    }
    // op_insert or op_replace
    n = new QIntBucket(key,newItem(d),vec[index]);
    CHECK_PTR( n );
#if defined(CHECK_NULL)
    if ( n->getData() == 0 )
        qWarning( "QIntDict: Cannot insert null item" );
#endif
    vec[index] = n;
    numItems++;
    return n->getData();
}

QCollection::Item QGDict::look_ptr	(	void *	key,
		QCollection::Item	d,
		int	op
	)

Definition at line 492 of file qgdict.cpp.

{
    QPtrBucket *n;
    int index = (int)((uintptr_t)key % vlen);   // simple hash
    if ( op == op_find ) {                      // find
        for ( n=(QPtrBucket*)vec[index]; n;
              n=(QPtrBucket*)n->getNext() ) {
            if ( n->getKey() == key )
                return n->getData();            // item found
        }
        return 0;                               // not found
    }
    if ( op == op_replace ) {                   // replace
        if ( vec[index] != 0 )                  // maybe something there
            remove_ptr( key );
    }
    // op_insert or op_replace
    n = new QPtrBucket(key,newItem(d),vec[index]);
    CHECK_PTR( n );
#if defined(CHECK_NULL)
    if ( n->getData() == 0 )
        qWarning( "QPtrDict: Cannot insert null item" );
#endif
    vec[index] = n;
    numItems++;
    return n->getData();
}

QCollection::Item QGDict::look_string	(	const QString &	key,
		QCollection::Item	d,
		int	op
	)

Definition at line 382 of file qgdict.cpp.

{
    QStringBucket *n;
    int index = hashKeyString(key) % vlen;
    if ( op == op_find ) {                      // find
        if ( cases ) {
            for ( n=(QStringBucket*)vec[index]; n;
                  n=(QStringBucket*)n->getNext() ) {
                if ( key == n->getKey() )
                    return n->getData();        // item found
            }
        } else {
            QString k = key.lower();
            for ( n=(QStringBucket*)vec[index]; n;
                  n=(QStringBucket*)n->getNext() ) {
                if ( k == n->getKey().lower() )
                    return n->getData();        // item found
            }
        }
        return 0;                               // not found
    }
    if ( op == op_replace ) {                   // replace
        if ( vec[index] != 0 )                  // maybe something there
            remove_string( key );
    }
    // op_insert or op_replace
    n = new QStringBucket(key,newItem(d),vec[index]);
    CHECK_PTR( n );
#if defined(CHECK_NULL)
    if ( n->getData() == 0 )
        qWarning( "QDict: Cannot insert null item" );
#endif
    vec[index] = n;
    numItems++;
    return n->getData();
}

QGDict & QGDict::operator= ( const QGDict &  dict )

protected

Definition at line 309 of file qgdict.cpp.

{
    clear();
    QGDictIterator it( dict );
    while ( it.get() ) {                        // copy from other dict
        switch ( keytype ) {
            case StringKey:
                look_string( it.getKeyString(), it.get(), op_insert );
                break;
            case AsciiKey:
                look_ascii( it.getKeyAscii(), it.get(), op_insert );
                break;
            case IntKey:
                look_int( it.getKeyInt(), it.get(), op_insert );
                break;
            case PtrKey:
                look_ptr( it.getKeyPtr(), it.get(), op_insert );
                break;
        }
        ++it;
    }
    return *this;
}

QDataStream & QGDict::read

(

QDataStream &

s

)

Definition at line 997 of file qgdict.cpp.

{
    uint num;
    s >> num;                                   // read number of items
    clear();                                    // clear dict
    while ( num-- ) {                           // read all items
        Item d;
        switch ( keytype ) {
            case StringKey:
                {
                    QString k;
                    s >> k;
                    read( s, d );
                    look_string( k, d, op_insert );
                }
                break;
            case AsciiKey:
                {
                    char *k;
                    s >> k;
                    read( s, d );
                    look_ascii( k, d, op_insert );
                    if ( copyk )
                        delete [] k;
                }
                break;
            case IntKey:
                {
                    Q_UINT32 k;
                    s >> k;
                    read( s, d );
                    look_int( k, d, op_insert );
                }
                break;
            case PtrKey:
                {
                    Q_UINT32 k;
                    s >> k;
                    read( s, d );
                    // ### cannot insert 0 - this renders the thing
                    // useless since all pointers are written as 0,
                    // but hey, serializing pointers?  can it be done
                    // at all, ever?
                    if ( k )
                        look_ptr( (void *)(uintptr_t)k, d, op_insert );
                }
                break;
        }
    }
    return s;
}

QDataStream & QGDict::read ( QDataStream &  s, QCollection::Item &  item  )

protectedvirtual

Reads a collection/dictionary item from the stream s and returns a reference to the stream.

The default implementation sets item to 0.

See also

write()

Definition at line 194 of file qgdict.cpp.

{
    item = 0;
    return s;
}

bool QGDict::remove_ascii ( const char *  key, QCollection::Item  item = 0  )

protected

Definition at line 747 of file qgdict.cpp.

{
    QAsciiBucket *n = unlink_ascii( key, item );
    if ( n ) {
        if ( copyk )
            delete [] (char *)n->getKey();
        deleteItem( n->getData() );
        delete n;
    }
    return n != 0;
}

bool QGDict::remove_int ( long  key, QCollection::Item  item = 0  )

protected

Definition at line 762 of file qgdict.cpp.

{
    QIntBucket *n = unlink_int( key, item );
    if ( n ) {
        deleteItem( n->getData() );
        delete n;
    }
    return n != 0;
}

bool QGDict::remove_ptr ( void *  key, QCollection::Item  item = 0  )

protected

Definition at line 775 of file qgdict.cpp.

{
    QPtrBucket *n = unlink_ptr( key, item );
    if ( n ) {
        deleteItem( n->getData() );
        delete n;
    }
    return n != 0;
}

bool QGDict::remove_string ( const QString &  key, QCollection::Item  item = 0  )

protected

Definition at line 732 of file qgdict.cpp.

{
    QStringBucket *n = unlink_string( key, item );
    if ( n ) {
        deleteItem( n->getData() );
        delete n;
        return TRUE;
    } else {
        return FALSE;
    }
}

void QGDict::resize ( uint  newsize )

protected

Definition at line 527 of file qgdict.cpp.

{
    // Save old information
    QBaseBucket **old_vec = vec;
    uint old_vlen  = vlen;
    bool old_copyk = copyk;

    vec = new QBaseBucket *[vlen = newsize];
    CHECK_PTR( vec );
    memset( (char*)vec, 0, vlen*sizeof(QBaseBucket*) );
    numItems = 0;
    copyk = FALSE;

    // Reinsert every item from vec, deleting vec as we go
    for ( uint index = 0; index < old_vlen; index++ ) {
        switch ( keytype ) {
            case StringKey:
                {
                    QStringBucket *n=(QStringBucket *)old_vec[index];
                    while ( n ) {
                        look_string( n->getKey(), n->getData(), op_insert );
                        QStringBucket *t=(QStringBucket *)n->getNext();
                        delete n;
                        n = t;
                    }
                }
                break;
            case AsciiKey:
                {
                    QAsciiBucket *n=(QAsciiBucket *)old_vec[index];
                    while ( n ) {
                        look_ascii( n->getKey(), n->getData(), op_insert );
                        QAsciiBucket *t=(QAsciiBucket *)n->getNext();
                        delete n;
                        n = t;
                    }
                }
                break;
            case IntKey:
                {
                    QIntBucket *n=(QIntBucket *)old_vec[index];
                    while ( n ) {
                        look_int( n->getKey(), n->getData(), op_insert );
                        QIntBucket *t=(QIntBucket *)n->getNext();
                        delete n;
                        n = t;
                    }
                }
                break;
            case PtrKey:
                {
                    QPtrBucket *n=(QPtrBucket *)old_vec[index];
                    while ( n ) {
                        look_ptr( n->getKey(), n->getData(), op_insert );
                        QPtrBucket *t=(QPtrBucket *)n->getNext();
                        delete n;
                        n = t;
                    }
                }
                break;
        }
    }
    delete [] old_vec;

    // Restore state
    copyk = old_copyk;

    // Invalidate all iterators, since order is lost
    if ( iterators && iterators->count() ) {
        QGDictIterator *i = iterators->first();
        while ( i ) {
            i->toFirst();
            i = iterators->next();
        }
    }
}

uint QGDict::size ( ) const

inline

Definition at line 108 of file qgdict.h.

{ return vlen; }

void QGDict::statistics ( ) const

protected

Definition at line 930 of file qgdict.cpp.

{
#if defined(DEBUG)
    QString line;
    line.fill( '-', 60 );
    double real, ideal;
    qDebug( "%s",line.ascii() );
    qDebug( "DICTIONARY STATISTICS:" );
    if ( count() == 0 ) {
        qDebug( "Empty!" );
        qDebug( "%s", line.ascii() );
        return;
    }
    real = 0.0;
    ideal = (float)count()/(2.0*size())*(count()+2.0*size()-1);
    uint i = 0;
    while ( i<size() ) {
        QBaseBucket *n = vec[i];
        int b = 0;
        while ( n ) {                           // count number of buckets
            b++;
            n = n->getNext();
        }
        real = real + (double)b * ((double)b+1.0)/2.0;
        char buf[80], *pbuf;
        if ( b > 78 )
            b = 78;
        pbuf = buf;
        while ( b-- )
            *pbuf++ = '*';
        *pbuf = '\0';
        qDebug( "%s", buf );
        i++;
    }
    qDebug( "Array size = %d", size() );
    qDebug( "# items    = %d", count() );
    qDebug( "Real dist  = %g", real );
    qDebug( "Rand dist  = %g", ideal );
    qDebug( "Real/Rand  = %g", real/ideal );
    qDebug( "%s",line.ascii() );
#endif // DEBUG
}

QCollection::Item QGDict::take_ascii ( const char *  key )

protected

Definition at line 804 of file qgdict.cpp.

{
    QAsciiBucket *n = unlink_ascii( key );
    Item d;
    if ( n ) {
        if ( copyk )
            delete [] (char *)n->getKey();
        d = n->getData();
        delete n;
    } else {
        d = 0;
    }
    return d;
}

QCollection::Item QGDict::take_int ( long  key )

protected

Definition at line 822 of file qgdict.cpp.

{
    QIntBucket *n = unlink_int( key );
    Item d;
    if ( n ) {
        d = n->getData();
        delete n;
    } else {
        d = 0;
    }
    return d;
}

QCollection::Item QGDict::take_ptr ( void *  key )

protected

Definition at line 838 of file qgdict.cpp.

{
    QPtrBucket *n = unlink_ptr( key );
    Item d;
    if ( n ) {
        d = n->getData();
        delete n;
    } else {
        d = 0;
    }
    return d;
}

QCollection::Item QGDict::take_string ( const QString &  key )

protected

Definition at line 788 of file qgdict.cpp.

{
    QStringBucket *n = unlink_string( key );
    Item d;
    if ( n ) {
        d = n->getData();
        delete n;
    } else {
        d = 0;
    }
    return d;
}

QAsciiBucket * QGDict::unlink_ascii ( const char *  key, QCollection::Item  item = 0  )

private

Definition at line 663 of file qgdict.cpp.

{
    if ( numItems == 0 )                        // nothing in dictionary
        return 0;
    QAsciiBucket *n;
    QAsciiBucket *prev = 0;
    int index = hashKeyAscii(key) % vlen;       
    for ( n=(QAsciiBucket *)vec[index]; n; n=(QAsciiBucket *)n->getNext() ) {
        bool found = (cases ? qstrcmp(n->getKey(),key)
                       : qstricmp(n->getKey(),key)) == 0;
        if ( found && d )
            found = (n->getData() == d);
        if ( found ) {
            unlink_common(index,n,prev);
            return n;
        }
        prev = n;
    }
    return 0;
}

void QGDict::unlink_common ( int  index, QBaseBucket *  node, QBaseBucket *  prev  )

private

Definition at line 610 of file qgdict.cpp.

{
    if ( iterators && iterators->count() ) {    // update iterators
        QGDictIterator *i = iterators->first();
        while ( i ) {                           // invalidate all iterators
            if ( i->curNode == node )           // referring to pending node
                i->operator++();
            i = iterators->next();
        }
    }
    if ( prev )                                 // unlink node
        prev->setNext( node->getNext() );
    else
        vec[index] = node->getNext();
    numItems--;
}

QIntBucket * QGDict::unlink_int ( long  key, QCollection::Item  item = 0  )

private

Definition at line 684 of file qgdict.cpp.

{
    if ( numItems == 0 )                        // nothing in dictionary
        return 0;
    QIntBucket *n;
    QIntBucket *prev = 0;
    int index = (int)((ulong)key % vlen);
    for ( n=(QIntBucket *)vec[index]; n; n=(QIntBucket *)n->getNext() ) {
        bool found = (n->getKey() == key);
        if ( found && d )
            found = (n->getData() == d);
        if ( found ) {
            unlink_common(index,n,prev);
            return n;
        }
        prev = n;
    }
    return 0;
}

QPtrBucket * QGDict::unlink_ptr ( void *  key, QCollection::Item  item = 0  )

private

Definition at line 704 of file qgdict.cpp.

{
    if ( numItems == 0 )                        // nothing in dictionary
        return 0;
    QPtrBucket *n;
    QPtrBucket *prev = 0;
    int index = (int)((uintptr_t)key % vlen);
    for ( n=(QPtrBucket *)vec[index]; n; n=(QPtrBucket *)n->getNext() ) {
        bool found = (n->getKey() == key);
        if ( found && d )
            found = (n->getData() == d);
        if ( found ) {
            unlink_common(index,n,prev);
            return n;
        }
        prev = n;
    }
    return 0;
}

QStringBucket * QGDict::unlink_string ( const QString &  key, QCollection::Item  item = 0  )

private

Definition at line 627 of file qgdict.cpp.

{
    if ( numItems == 0 )                        // nothing in dictionary
        return 0;
    QStringBucket *n;
    QStringBucket *prev = 0;
    int index = hashKeyString(key) % vlen;
    if ( cases ) {
        for ( n=(QStringBucket*)vec[index]; n;
              n=(QStringBucket*)n->getNext() ) {
            bool found = (key == n->getKey());
            if ( found && d )
                found = (n->getData() == d);
            if ( found ) {
                unlink_common(index,n,prev);
                return n;
            }
            prev = n;
        }
    } else {
        QString k = key.lower();
        for ( n=(QStringBucket*)vec[index]; n;
              n=(QStringBucket*)n->getNext() ) {
            bool found = (k == n->getKey().lower());
            if ( found && d )
                found = (n->getData() == d);
            if ( found ) {
                unlink_common(index,n,prev);
                return n;
            }
            prev = n;
        }
    }
    return 0;
}

QDataStream & QGDict::write

(

QDataStream &

s

)

const

Definition at line 1054 of file qgdict.cpp.

{
    s << count();                               // write number of items
    uint i = 0;
    while ( i<size() ) {
        QBaseBucket *n = vec[i];
        while ( n ) {                           // write all buckets
            switch ( keytype ) {
                case StringKey:
                    s << ((QStringBucket*)n)->getKey();
                    break;
                case AsciiKey:
                    s << ((QAsciiBucket*)n)->getKey();
                    break;
                case IntKey:
                    s << (Q_UINT32)((QIntBucket*)n)->getKey();
                    break;
                case PtrKey:
                    s << (Q_UINT32)0; // ### cannot serialize a pointer
                    break;
            }
            write( s, n->getData() );           // write data
            n = n->getNext();
        }
        i++;
    }
    return s;
}

QDataStream & QGDict::write ( QDataStream &  s, QCollection::Item    ) const

protectedvirtual

Writes a collection/dictionary item to the stream s and returns a reference to the stream.

See also

read()

Definition at line 207 of file qgdict.cpp.

{
    return s;
}

Friends And Related Function Documentation

friend class QGDictIterator

friend

Definition at line 163 of file qgdict.h.

Member Data Documentation

uint QGDict::cases

private

Definition at line 153 of file qgdict.h.

uint QGDict::copyk

private

Definition at line 154 of file qgdict.h.

QGDItList* QGDict::iterators

private

Definition at line 155 of file qgdict.h.

uint QGDict::keytype

private

Definition at line 152 of file qgdict.h.

uint QGDict::numItems

private

Definition at line 151 of file qgdict.h.

QBaseBucket** QGDict::vec

private

Definition at line 149 of file qgdict.h.

uint QGDict::vlen

private

Definition at line 150 of file qgdict.h.

---

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

• doxygen-1.8.11/qtools/qgdict.h
• doxygen-1.8.11/qtools/qgdict.cpp