source: trunk/src/qt3support/tools/q3gcache.cpp@ 504

/****************************************************************************
**
** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
** Contact: Qt Software Information ([email protected])
**
** This file is part of the Qt3Support module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial Usage
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain
** additional rights. These rights are described in the Nokia Qt LGPL
** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
** package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file.  Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** If you are unsure which license is appropriate for your use, please
** contact the sales department at [email protected].
** $QT_END_LICENSE$
**
****************************************************************************/

#include "q3gcache.h"
#include "q3ptrlist.h"
#include "q3dict.h"
#include "qstring.h"

QT_BEGIN_NAMESPACE

/*!
  \class Q3GCache
  \reentrant
  \brief The Q3GCache class is an internal class for implementing Q3Cache
  template classes.

  \internal

  Q3GCache is a strictly internal class that acts as a base class for the
  \link collection.html collection classes\endlink Q3Cache and QIntCache.
*/


/*****************************************************************************
  Q3GCacheItem class (internal cache item)
 *****************************************************************************/

struct Q3CacheItem
{
    Q3CacheItem(void *k, Q3PtrCollection::Item d, int c, short p)
        : priority(p), skipPriority(p), cost(c), key(k), data(d), node(0) {}
    short       priority;
    short       skipPriority;
    int         cost;
    void       *key;
    Q3PtrCollection::Item data;
    Q3LNode     *node;
};


/*****************************************************************************
  Q3CList class (internal list of cache items)
 *****************************************************************************/

class Q3CList : private Q3PtrList<Q3CacheItem>
{
friend class Q3GCacheIterator;
friend class Q3CListIt;
public:
    Q3CList()   {}
   ~Q3CList();

    void        insert(Q3CacheItem *);          // insert according to priority
    void        insert(int, Q3CacheItem *);
    void        take(Q3CacheItem *);
    void        reference(Q3CacheItem *);

    void        setAutoDelete(bool del) { Q3PtrCollection::setAutoDelete(del); }

    bool        removeFirst()   { return Q3PtrList<Q3CacheItem>::removeFirst(); }
    bool        removeLast()    { return Q3PtrList<Q3CacheItem>::removeLast(); }

    Q3CacheItem *first()                { return Q3PtrList<Q3CacheItem>::first(); }
    Q3CacheItem *last()         { return Q3PtrList<Q3CacheItem>::last(); }
    Q3CacheItem *prev()         { return Q3PtrList<Q3CacheItem>::prev(); }
    Q3CacheItem *next()         { return Q3PtrList<Q3CacheItem>::next(); }

#if defined(QT_DEBUG)
    int         inserts;                        // variables for statistics
    int         insertCosts;
    int         insertMisses;
    int         finds;
    int         hits;
    int         hitCosts;
    int         dumps;
    int         dumpCosts;
#endif
};


Q3CList::~Q3CList()
{
#if defined(QT_DEBUG)
    Q_ASSERT(count() == 0);
#endif
}


void Q3CList::insert(Q3CacheItem *ci)
{
    Q3CacheItem *item = first();
    while(item && item->skipPriority > ci->priority) {
        item->skipPriority--;
        item = next();
    }
    if (item)
        Q3PtrList<Q3CacheItem>::insert(at(), ci);
    else
        append(ci);
#if defined(QT_DEBUG)
    Q_ASSERT(ci->node == 0);
#endif
    ci->node = currentNode();
}

inline void Q3CList::insert(int i, Q3CacheItem *ci)
{
    Q3PtrList<Q3CacheItem>::insert(i, ci);
#if defined(QT_DEBUG)
    Q_ASSERT(ci->node == 0);
#endif
    ci->node = currentNode();
}


void Q3CList::take(Q3CacheItem *ci)
{
    if (ci) {
#if defined(QT_DEBUG)
        Q_ASSERT(ci->node != 0);
#endif
        takeNode(ci->node);
        ci->node = 0;
    }
}


inline void Q3CList::reference(Q3CacheItem *ci)
{
#if defined(QT_DEBUG)
    Q_ASSERT(ci != 0 && ci->node != 0);
#endif
    ci->skipPriority = ci->priority;
    relinkNode(ci->node);                       // relink as first item
}


class Q3CListIt: public Q3PtrListIterator<Q3CacheItem>
{
public:
    Q3CListIt(const Q3CList *p): Q3PtrListIterator<Q3CacheItem>(*p) {}
    Q3CListIt(const Q3CListIt *p): Q3PtrListIterator<Q3CacheItem>(*p) {}
};


/*****************************************************************************
  Q3CDict class (internal dictionary of cache items)
 *****************************************************************************/

//
// Since we need to decide if the dictionary should use an int or const
// char * key (the "bool trivial" argument in the constructor below)
// we cannot use the macro/template dict, but inherit directly from Q3GDict.
//

class Q3CDict : public Q3GDict
{
public:
    Q3CDict(uint size, uint kt, bool caseSensitive, bool copyKeys)
        : Q3GDict(size, (KeyType)kt, caseSensitive, copyKeys) {}
    ~Q3CDict();

    void clear() { Q3GDict::clear(); }

    Q3CacheItem *find_string(const QString &key) const
        { return (Q3CacheItem*)((Q3CDict*)this)->look_string(key, 0, 0); }
    Q3CacheItem *find_ascii(const char *key) const
        { return (Q3CacheItem*)((Q3CDict*)this)->look_ascii(key, 0, 0); }
    Q3CacheItem *find_int(long key) const
        { return (Q3CacheItem*)((Q3CDict*)this)->look_int(key, 0, 0); }

    Q3CacheItem *take_string(const QString &key)
        { return (Q3CacheItem*)Q3GDict::take_string(key); }
    Q3CacheItem *take_ascii(const char *key)
        { return (Q3CacheItem*)Q3GDict::take_ascii(key); }
    Q3CacheItem *take_int(long key)
        { return (Q3CacheItem*)Q3GDict::take_int(key); }

    bool  insert_string(const QString &key, const Q3CacheItem *ci)
        { return Q3GDict::look_string(key,(Item)ci,1)!=0;}
    bool  insert_ascii(const char *key, const Q3CacheItem *ci)
        { return Q3GDict::look_ascii(key,(Item)ci,1)!=0;}
    bool  insert_int(long key, const Q3CacheItem *ci)
        { return Q3GDict::look_int(key,(Item)ci,1)!=0;}

    bool  remove_string(Q3CacheItem *item)
        { return Q3GDict::remove_string(*((QString*)(item->key)),item); }
    bool  remove_ascii(Q3CacheItem *item)
        { return Q3GDict::remove_ascii((const char *)item->key,item); }
    bool  remove_int(Q3CacheItem *item)
        { return Q3GDict::remove_int((long)item->key,item);}

    void  statistics()                  { Q3GDict::statistics(); }

private:
    void deleteItem(void *item)
        { if (del_item) { Q3CacheItem *d = (Q3CacheItem*)item; delete d; } }
};

inline Q3CDict::~Q3CDict()
{
    clear();
}

/*****************************************************************************
  Q3GDict member functions
 *****************************************************************************/

/*!
  Constructs a cache.
  The maximum cost of the cache is given by \a maxCost and the size by \a
  size. The key type is \a kt which may be \c StringKey, \c AsciiKey,