QGCache Class Reference

The QGCache class is an internal class for implementing QCache template classes. More...

#include <qgcache.h>

Inheritance diagram for QGCache:

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

Protected Member Functions
	QGCache (int maxCost, uint size, KeyType kt, bool caseSensitive, bool copyKeys)
	QGCache (const QGCache &)
	~QGCache ()
QGCache &	operator= (const QGCache &)
uint	count () const
uint	size () const
int	maxCost () const
int	totalCost () const
void	setMaxCost (int maxCost)
void	clear ()
bool	insert_string (const QString &key, QCollection::Item, int cost, int priority)
bool	insert_other (const char *key, QCollection::Item, int cost, int priority)
bool	remove_string (const QString &key)
bool	remove_other (const char *key)
QCollection::Item	take_string (const QString &key)
QCollection::Item	take_other (const char *key)
QCollection::Item	find_string (const QString &key, bool ref=TRUE) const
QCollection::Item	find_other (const char *key, bool ref=TRUE) const
void	statistics () const
int	hits () const
int	misses () const
Protected Member Functions inherited from QCollection
	QCollection ()
	QCollection (const QCollection &)
virtual	~QCollection ()
virtual Item	newItem (Item)
virtual void	deleteItem (Item)

Private Member Functions
bool	makeRoomFor (int cost, int priority=-1)

Private Attributes
KeyType	keytype
QCList *	lruList
QCDict *	dict
int	mCost
int	tCost
bool	copyk

Friends
class	QGCacheIterator

Additional Inherited Members
Public Types inherited from QCollection
typedef void *	Item
Public Member Functions inherited from QCollection
bool	autoDelete () const
void	setAutoDelete (bool enable)
Protected Attributes inherited from QCollection
bool	del_item

Detailed Description

The QGCache class is an internal class for implementing QCache template classes.

QGCache is a strictly internal class that acts as a base class for the collection classes QCache and QIntCache.

Definition at line 53 of file qgcache.h.

Member Enumeration Documentation

enum QGCache::KeyType

protected

Enumerator
StringKey
AsciiKey
IntKey
PtrKey

Definition at line 57 of file qgcache.h.

{ StringKey, AsciiKey, IntKey, PtrKey };

Constructor & Destructor Documentation

QGCache::QGCache ( int  maxCost, uint  size, KeyType  kt, bool  caseSensitive, bool  copyKeys  )

protected

Definition at line 234 of file qgcache.cpp.

{
    keytype = kt;
    lruList = new QCList;
    CHECK_PTR( lruList );
    lruList->setAutoDelete( TRUE );
    copyk   = ((keytype == AsciiKey) && copyKeys);
    dict    = new QCDict( size, kt, caseSensitive, FALSE );
    CHECK_PTR( dict );
    mCost   = maxCost;
    tCost   = 0;
#if defined(DEBUG)
    lruList->inserts      = 0;
    lruList->insertCosts  = 0;
    lruList->insertMisses = 0;
    lruList->finds        = 0;
    lruList->hits         = 0;
    lruList->hitCosts     = 0;
    lruList->dumps        = 0;
    lruList->dumpCosts    = 0;
#endif
}

QGCache::QGCache ( const QGCache &  )

protected

Definition at line 263 of file qgcache.cpp.

    : QCollection()
{
#if defined(CHECK_NULL)
    qFatal( "QGCache::QGCache(QGCache &): Cannot copy a cache" );
#endif
}

QGCache::~QGCache ( )

protected

Definition at line 276 of file qgcache.cpp.

{
    clear();                                    // delete everything first
    delete dict;
    delete lruList;
}

Member Function Documentation

void QGCache::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 QCache< LookupInfo >.

Definition at line 493 of file qgcache.cpp.

{
    QCacheItem *ci;
    while ( (ci = lruList->first()) ) {
        switch ( keytype ) {
            case StringKey:
                dict->remove_string( ci );
                delete (QString*)ci->key;
                break;
            case AsciiKey:
                dict->remove_ascii( ci );
                if ( copyk )
                    delete [] (char*)ci->key;
                break;
            case IntKey:
                dict->remove_int( ci );
                break;
            case PtrKey:                        // unused
                break;
        }
        deleteItem( ci->data );                 // delete data
        lruList->removeFirst();                 // remove from list
    }
    tCost = 0;
}

uint QGCache::count ( ) const

inlineprotectedvirtual

Returns the number of objects in the collection.

Implements QCollection.

Reimplemented in QCache< LookupInfo >.

Definition at line 66 of file qgcache.h.

{ return ((QGDict*)dict)->count(); }

QCollection::Item QGCache::find_other ( const char *  key, bool  ref = TRUE  ) const

protected

Definition at line 549 of file qgcache.cpp.

{
    QCacheItem *ci = keytype == AsciiKey ? dict->find_ascii(key)
                                         : dict->find_int((intptr_t)key);
#if defined(DEBUG)
    lruList->finds++;
#endif
    if ( ci ) {
#if defined(DEBUG)
        lruList->hits++;
        lruList->hitCosts += ci->cost;
#endif
        if ( ref )
            lruList->reference( ci );
        return ci->data;
    }
    return 0;
}

QCollection::Item QGCache::find_string ( const QString &  key, bool  ref = TRUE  ) const

protected

Definition at line 525 of file qgcache.cpp.

{
    QCacheItem *ci = dict->find_string( key );
#if defined(DEBUG)
    lruList->finds++;
#endif
    if ( ci ) {
#if defined(DEBUG)
        lruList->hits++;
        lruList->hitCosts += ci->cost;
#endif
        if ( ref )
            lruList->reference( ci );
        return ci->data;
    }
    return 0;
}

int QGCache::hits ( ) const

protected

Definition at line 658 of file qgcache.cpp.

{
  return lruList->hits;
}

bool QGCache::insert_other ( const char *  key, QCollection::Item  data, int  cost, int  priority  )

protected

Definition at line 380 of file qgcache.cpp.

{
    if ( tCost + cost > mCost ) {
        if ( !makeRoomFor(tCost + cost - mCost, priority) ) {
#if defined(DEBUG)
            lruList->insertMisses++;
#endif
            return FALSE;
        }
    }
#if defined(DEBUG)
    ASSERT( keytype != StringKey );
    lruList->inserts++;
    lruList->insertCosts += cost;
#endif
    if ( keytype == AsciiKey && copyk )
        key = qstrdup( key );
    if ( priority < -32768 )
        priority = -32768;
    else if ( priority > 32767 )
        priority = 32677;
    QCacheItem *ci = new QCacheItem( (void*)key, newItem(data), cost,
                                     (short)priority );
    CHECK_PTR( ci );
    lruList->insert( 0, ci );
    if ( keytype == AsciiKey )
        dict->insert_ascii( key, ci );
    else
        dict->insert_int( (intptr_t)key, ci );
    tCost += cost;
    return TRUE;
}

bool QGCache::insert_string ( const QString &  key, QCollection::Item  data, int  cost, int  priority  )

protected

Definition at line 348 of file qgcache.cpp.

{
    if ( tCost + cost > mCost ) {
        if ( !makeRoomFor(tCost + cost - mCost, priority) ) {
#if defined(DEBUG)
            lruList->insertMisses++;
#endif
            return FALSE;
        }
    }
#if defined(DEBUG)
    ASSERT( keytype == StringKey );
    lruList->inserts++;
    lruList->insertCosts += cost;
#endif
    if ( priority < -32768 )
        priority = -32768;
    else if ( priority > 32767 )
        priority = 32677;
    QCacheItem *ci = new QCacheItem( new QString(key), newItem(data),
                                     cost, (short)priority );
    CHECK_PTR( ci );
    lruList->insert( 0, ci );
    dict->insert_string( key, ci );
    tCost += cost;
    return TRUE;
}

bool QGCache::makeRoomFor ( int  cost, int  priority = -1  )

private

Definition at line 574 of file qgcache.cpp.

{
    if ( cost > mCost )                         // cannot make room for more
        return FALSE;                           //   than maximum cost
    if ( priority == -1 )
        priority = 32767;
    register QCacheItem *ci = lruList->last();
    int cntCost = 0;
    int dumps   = 0;                            // number of items to dump
    while ( cntCost < cost && ci && ci->skipPriority <= priority ) {
        cntCost += ci->cost;
        ci       = lruList->prev();
        dumps++;
    }
    if ( cntCost < cost )                       // can enough cost be dumped?
        return FALSE;                           // no
#if defined(DEBUG)
    ASSERT( dumps > 0 );
#endif
    while ( dumps-- ) {
        ci = lruList->last();
#if defined(DEBUG)
        lruList->dumps++;
        lruList->dumpCosts += ci->cost;
#endif
        switch ( keytype ) {
            case StringKey:
                dict->remove_string( ci );
                delete (QString*)ci->key;
                break;
            case AsciiKey:
                dict->remove_ascii( ci );
                if ( copyk )
                    delete [] (char *)ci->key;
                break;
            case IntKey:
                dict->remove_int( ci );
                break;
            case PtrKey:                        // unused
                break;
        }
        deleteItem( ci->data );                 // delete data
        lruList->removeLast();                  // remove from list
    }
    tCost -= cntCost;
    return TRUE;
}

int QGCache::maxCost ( ) const

inlineprotected

Definition at line 68 of file qgcache.h.

{ return mCost; }

int QGCache::misses ( ) const

protected

Definition at line 663 of file qgcache.cpp.

{
  return lruList->finds - lruList->hits;
}

QGCache & QGCache::operator= ( const QGCache &  )

protected

Definition at line 288 of file qgcache.cpp.

{
#if defined(CHECK_NULL)
    qFatal( "QGCache::operator=: Cannot copy a cache" );
#endif
    return *this;                               // satisfy the compiler
}

bool QGCache::remove_other ( const char *  key )

protected

Definition at line 431 of file qgcache.cpp.

{
    Item d = take_other( key );
    if ( d )
        deleteItem( d );
    return d != 0;
}

bool QGCache::remove_string ( const QString &  key )

protected

Definition at line 420 of file qgcache.cpp.

{
    Item d = take_string( key );
    if ( d )
        deleteItem( d );
    return d != 0;
}

void QGCache::setMaxCost ( int  maxCost )

protected

Definition at line 326 of file qgcache.cpp.

{
    if ( maxCost < tCost ) {
        if ( !makeRoomFor(tCost - maxCost) )    // remove excess cost
            return;
    }
    mCost = maxCost;
}

uint QGCache::size ( ) const

inlineprotected

Definition at line 67 of file qgcache.h.

{ return ((QGDict*)dict)->size(); }

void QGCache::statistics ( ) const

protected

Definition at line 628 of file qgcache.cpp.

{
#if defined(DEBUG)
    QString line;
    line.fill( '*', 80 );
    qDebug( "%s",line.ascii() );
    qDebug( "CACHE STATISTICS:" );
    qDebug( "cache contains %d item%s, with a total cost of %d",
           count(), count() != 1 ? "s" : "", tCost );
    qDebug( "maximum cost is %d, cache is %d%% full.",
           mCost, (200*tCost + mCost) / (mCost*2) );
    qDebug( "find() has been called %d time%s",
           lruList->finds, lruList->finds != 1 ? "s" : "" );
    qDebug( "%d of these were hits, items found had a total cost of %d.",
           lruList->hits,lruList->hitCosts );
    qDebug( "%d item%s %s been inserted with a total cost of %d.",
           lruList->inserts,lruList->inserts != 1 ? "s" : "",
           lruList->inserts != 1 ? "have" : "has", lruList->insertCosts );
    qDebug( "%d item%s %s too large or had too low priority to be inserted.",
           lruList->insertMisses, lruList->insertMisses != 1 ? "s" : "",
           lruList->insertMisses != 1 ? "were" : "was" );
    qDebug( "%d item%s %s been thrown away with a total cost of %d.",
           lruList->dumps, lruList->dumps != 1 ? "s" : "",
           lruList->dumps != 1 ? "have" : "has", lruList->dumpCosts );
    qDebug( "Statistics from internal dictionary class:" );
    dict->statistics();
    qDebug( "%s",line.ascii() );
#endif
}

QCollection::Item QGCache::take_other ( const char *  key )

protected

Definition at line 466 of file qgcache.cpp.

{
    QCacheItem *ci;
    if ( keytype == AsciiKey )
        ci = dict->take_ascii( key );
    else
        ci = dict->take_int( (intptr_t)key );
    Item d;
    if ( ci ) {
        d = ci->data;
        tCost -= ci->cost;
        lruList->take( ci );                    // take from list
        if ( copyk )
            delete [] (char *)ci->key;
        delete ci;
    } else {
        d = 0;
    }
    return d;
}

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

protected

Definition at line 445 of file qgcache.cpp.

{
    QCacheItem *ci = dict->take_string( key );  // take from dict
    Item d;
    if ( ci ) {
        d = ci->data;
        tCost -= ci->cost;
        lruList->take( ci );                    // take from list
        delete (QString*)ci->key;
        delete ci;
    } else {
        d = 0;
    }
    return d;
}

int QGCache::totalCost ( ) const

inlineprotected

Definition at line 69 of file qgcache.h.

{ return tCost; }

Friends And Related Function Documentation

friend class QGCacheIterator

friend

Definition at line 55 of file qgcache.h.

Member Data Documentation

bool QGCache::copyk

private

Definition at line 96 of file qgcache.h.

QCDict* QGCache::dict

private

Definition at line 93 of file qgcache.h.

KeyType QGCache::keytype

private

Definition at line 91 of file qgcache.h.

QCList* QGCache::lruList

private

Definition at line 92 of file qgcache.h.

int QGCache::mCost

private

Definition at line 94 of file qgcache.h.

int QGCache::tCost

private

Definition at line 95 of file qgcache.h.

---

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

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