faithtools/faith/dict.h

Go to the documentation of this file.

#ifndef KDE__DICT_H
#define KDE__DICT_H

#include <faith/list.h>

namespace Faith
{

template<class TypeKey, class TypeValue>
class FAITH_TOOLS_EXPORT Dict
{
        struct Map
        {
                TypeKey key;
                TypeValue *value;
        };

        mutable VList list;

public:
        Dict() {}
        ~Dict() {}

        TypeValue *& insert(const TypeKey &key, TypeValue *value)
        {
                Map *map=new Map;
                map->key = key;
                map->value = value;
                list.append(map);
                return map->value;
        }

        bool contains(const TypeKey &key) const
        {
                return find(key);
        }

        TypeKey *keyOf(const TypeValue *value)
        {
                VList::Iterator i(list);
                while (*i)
                {
                        if (((Map*)(*i))->value == value)
                                return &((Map*)(*i))->key;
                        ++i;
                }
                return 0;
        }

        TypeValue *operator [](const TypeKey &key)
        {
                VList::Iterator i(find(key));
                if (*i) return ((Map*)*i)->value;
                return 0;
        }

        void remove(const TypeKey &key)
        {
                VList::Iterator i(find(key));
                if (*i)
                {
                        delete (Map*)*i;
                        i.remove();
                }
        }

        List<const TypeKey> keys() const
        {
                List<const TypeKey> k;
                VList::Iterator i(list);
                while (*i)
                {
                        k.append(&((Map*)(*i)->key));
                }
                return k;
        }

        List<TypeKey> keys()
        {
                List<TypeKey> k;
                VList::Iterator i(list);
                while (*i)
                {
                        k.append(&((Map*)(*i)->key));
                }
                return k;
        }

private:
        VList::Iterator find(const TypeKey &key) const
        {
                VList::Iterator i(list);
                while (*i)
                {
                        if (((Map*)*i)->key == key)
                                break;
                        ++i;
                }
                return i;
        }

};

}

#endif

---