dictionary.hpp

Go to the documentation of this file.

 
#ifndef DICTIONARY_HPP
#define DICTIONARY_HPP
 
#include "rbtree.hpp"
#include "access.hpp"
#include "object.hpp"
 
namespace BF {
 
template <typename K, typename V, typename S = int>
class Dictionary : public Object {
public:
 
    class Entry : public Object {
        friend class Dictionary<K,V,S>;
    public:
        static int Compare(Entry * a, Entry * b) {
            return a->runCompare(b);
        }
 
        K key() const { return this->_key; }
        V value() const { return this->_value; }
 
    private:
 
        Entry(K k, V v, Dictionary<K,V,S> * dictRef) : Object() {
            this->_dictRef = dictRef;
 
            // See how the dict owner wants to retain key and values
            if (this->_dictRef->_keyValueRetain) {
                this->_dictRef->_keyValueRetain(&k, &v);
            }
 
            this->_key = k;
            this->_value = v;
        }
 
        virtual ~Entry() {
            if (this->_dictRef->_keyValueRelease) {
                this->_dictRef->_keyValueRelease(&this->_key, &this->_value);
            }
        }
 
        int runCompare(Entry * b) const {
            return this->_dictRef->runCompare(this->key(), b->key());
        }
 
        K _key;
        V _value;
 
        const Dictionary<K,V,S> * _dictRef;
    };
    
    friend class Entry;
 
    Dictionary() : Object() {
        this->_keyCompare = 0;
        this->_keyValueRelease = 0;
        this->_keyValueRetain = 0;
 
        // Establish how the tree will compare the entries
        this->_tree.setCompareCallback(Entry::Compare);
    }
 
    Dictionary(
        int (* keyCompareCallback) (K a1, K a2), 
        void (* retainCallback) (K * k, V * v), 
        void (* releaseCallback) (K * k, V * v)) : Dictionary() {
        this->_keyCompare = keyCompareCallback;
        this->_keyValueRelease = releaseCallback;
        this->_keyValueRetain = retainCallback;
    }
 
    virtual ~Dictionary() {
        this->_keyCompare = 0;
        this->_keyValueRelease = 0;
        this->_keyValueRetain = 0;
    }
 
    S size() const {
        return this->_tree.count();
    }
 
    void setKeyCompareCallback(int (* cb) (K a1, K a2)) {
        this->_keyCompare = cb;
    }
 
    void setEntryReleaseCallback(void (* cb) (K * k, V * v)) {
        this->_keyValueRelease = cb;
    }
 
    void setEntryRetainCallback(void (* cb) (K * k, V * v)) {
        this->_keyValueRetain = cb;
    }
 
    V valueForKey(K key) {
        int error = 0;
        Entry * obj = this->getEntryForKey(key, this->_tree.root(), &error);
 
        if (!error && obj) {
            return obj->value();
        }
 
        return 0;
    }
 
    int setValueForKey(K key, V value) {
        Entry * ent = new Entry(key, value, this);
        return this->_tree.insert(ent);
    }
 
    int removeValueForKey(K key) {
        int error = 0;
        const typename RBTree<Entry *>::RBNode * n = this->getEntryNodeForKey(key, this->_tree.root(), &error);
 
        if (n && !error) {
            return this->_tree.deleteNode(n);
        } else {
            return error == 0 ? 15 : error;
        }
    }
 
    void print() {
        this->print(this->_tree.root());
    }
 
    typedef typename RBTree<Entry *, S>::Iterator Iterator;
 
    int createIterator(Iterator ** itr) {
        return this->_tree.createIterator(itr);
    }
private:
 
    void print(const typename RBTree<Entry *>::RBNode * node) {
        if (node) {
            if (!node->isNull()) {
                this->print(node->left());
 
                Entry * entry = node->object();
                if (entry) {
                    std::cout << entry->key() << " : " << entry->value() << std::endl;
                }
 
                this->print(node->right());
            }
        }
    }
 
    Entry * getEntryForKey(K key, const typename RBTree<Entry *>::RBNode * node, int * err) {
        int error = 0;
        const typename RBTree<Entry *>::RBNode * n = this->getEntryNodeForKey(key, node, &error);
 
        if (n && !error) {
            return n->object();
        } else {
            if (err) *err = error;
            return NULL;
        }
    }
    
    const typename RBTree<Entry *>::RBNode * getEntryNodeForKey(K key, const typename RBTree<Entry *>::RBNode * node, int * err) {
        // If the pointer is null then we will throw an error
        if (node == NULL) {
            if (err) *err = 13;
            return NULL;
        // if we are at a null node, return null
        } else if (node->isNull()) return NULL;
 
        Entry * obj = NULL;
 
        // If the object is null then we are going to return null with error
        if ((obj = node->object()) == NULL) {
            if (err) *err = 14;
            return NULL;
        }
 
        int comp = this->runCompare(key, obj->key());
        if (comp == -1) return this->getEntryNodeForKey(key, node->left(), err);
        else if (comp == 1) return this->getEntryNodeForKey(key, node->right(), err);
        else return node;
    }
 
    int runCompare(K a1, K a2) const {
        if (this->_keyCompare) return this->_keyCompare(a1, a2);
        else {
            if (a1 < a2) return -1;
            else if (a1 > a2) return 1;
            else return 0;
        }
    }
 
    RBTree<Entry *, S> _tree;
 
    int (* _keyCompare) (K a1, K a2);
 
    void (* _keyValueRelease) (K * key, V * value);
 
    void (* _keyValueRetain) (K * key, V * value);
};
 
} // namespace BF
 
#endif // DICTIONARY_HPP