qdict.h

Go to the documentation of this file.

/********************************************************************************
*                                                                               *
*                            Q D i c t   T h u n k                              *
*                                                                               *
*********************************************************************************
*        Copyright (C) 2003 by Niall Douglas.   All Rights Reserved.            *
*       NOTE THAT I DO NOT PERMIT ANY OF MY CODE TO BE PROMOTED TO THE GPL      *
*********************************************************************************
* This code is free software; you can redistribute it and/or modify it under    *
* the terms of the GNU Library General Public License v2.1 as published by the  *
* Free Software Foundation EXCEPT that clause 3 does not apply ie; you may not  *
* "upgrade" this code to the GPL without my prior written permission.           *
* Please consult the file "License_Addendum2.txt" accompanying this file.       *
*                                                                               *
* This code is distributed in the hope that it will be useful,                  *
* but WITHOUT ANY WARRANTY; without even the implied warranty of                *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.                          *
*********************************************************************************
* $Id:                                                                          *
********************************************************************************/

#ifndef QDICT_H
#define QDICT_H

#include "qdictbase.h"

namespace FX {

template<class type> class QDict : public QDictBase<FXString, type>
{
    typedef QDictBase<FXString, type> Base;
    bool checkcase;
    FXuint hash(const FXString &str) const
    {   // Fast hash as QDictBase does its own hashing
        return str.hash();
        //const FXchar *txt=str.text();
        //const FXchar *end=txt+str.length();
        //FXuint h=0;
        //for(int n=0; end>=txt && n<6; n++, end--)
        //{
        //  h=(h & 0xffffffc0)^(h<<5)^((*end)-32);
        //}
        //return h;
    }
public:
    enum { HasSlowKeyCompare=true };
    explicit QDict(int size=13, bool caseSensitive=true, bool wantAutoDel=false)
        : checkcase(caseSensitive), Base(size, wantAutoDel)
    {
    }
    QDict(const QDict<type> &o) : checkcase(o.checkcase), Base(o) { }
    ~QDict() { Base::clear(); }
    FXADDMOVEBASECLASS(QDict, Base)
    bool caseSensitive() const throw() { return checkcase; }
    void setCaseSensitive(bool c) throw() { checkcase=c; }
    void insert(const FXString &k, const type *d)
    {
        if(checkcase)
            Base::insert(hash(k), k, const_cast<type *>(d));
        else
        {
            FXString key(k);
            key.lower();
            Base::insert(hash(key), key, const_cast<type *>(d));
        }
    }
    void replace(const FXString &k, const type *d)
    {
        if(checkcase)
            Base::replace(hash(k), k, const_cast<type *>(d));
        else
        {
            FXString key(k);
            key.lower();
            Base::replace(hash(key), key, const_cast<type *>(d));
        }
    }
    bool remove(const FXString &k)
    {
        if(checkcase)
            return Base::remove(hash(k), k);
        else
        {
            FXString key(k);
            key.lower();
            return Base::remove(hash(key), key);
        }
    }
    type *take(const FXString &k)
    {
        if(checkcase)
            return Base::take(hash(k), k);
        else
        {
            FXString key(k);
            key.lower();
            return Base::take(hash(key), key);
        }
    }
    type *find(const FXString &k) const
    {
        if(checkcase)
            return Base::find(hash(k), k);
        else
        {
            FXString key(k);
            key.lower();
            return Base::find(hash(key), key);
        }
    }
    type *operator[](const FXString &k) const { return find(k); }
protected:
    virtual void deleteItem(type *d);
};

template<class type> inline void QDict<type>::deleteItem(type *d)
{
    if(Base::autoDelete())
    {
        //fxmessage("QDB delete %p\n", d);
        delete d;
    }
}
// Don't delete void *
template<> inline void QDict<void>::deleteItem(void *)
{
}

template<class type> class QDictIterator : public QDictBaseIterator<FXString, type>
{
public:
    QDictIterator() { }
    QDictIterator(const QDict<type> &d) : QDictBaseIterator<FXString, type>(d) { }
};

template<class type> FXStream &operator<<(FXStream &s, const QDict<type> &i)
{
    FXuint mysize=i.count();
    s << mysize;
    for(QDictIterator<type> it(i); it.current(); ++it)
    {
        s << it.currentKey();
        s << *it.current();
    }
    return s;
}
template<class type> FXStream &operator>>(FXStream &s, QDict<type> &i)
{
    FXuint mysize;
    s >> mysize;
    i.clear();
    FXString key;
    for(FXuint n=0; n<mysize; n++)
    {
        type *item;
        FXERRHM(item=new type);
        s >> key;
        s >> *item;
        i.insert(key, item);
    }
    return s;
}

} // namespace

#endif

---

(C) 2002-2009 Niall Douglas. Some parts (C) to assorted authors.