HashArray.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/Hashing.h>
 
namespace ogdf {
 
 
 
template<class I, class E, class H = DefHashFunc<I>>
class HashArray : private Hashing<I, E, H> {
    E m_defaultValue; 
 
public:
    using const_iterator = HashConstIterator<I, E, H>;
 
    HashArray() : Hashing<I, E, H>() { }
 
    explicit HashArray(const E& defaultValue, const H& hashFunc = H())
        : Hashing<I, E, H>(256, hashFunc), m_defaultValue(defaultValue) { }
 
    HashArray(const HashArray<I, E, H>& A)
        : Hashing<I, E, H>(A), m_defaultValue(A.m_defaultValue) { }
 
    HashConstIterator<I, E, H> begin() const { return Hashing<I, E, H>::begin(); }
 
    int size() const { return Hashing<I, E, H>::size(); }
 
    int empty() const { return Hashing<I, E, H>::empty(); }
 
    const E& operator[](const I& i) const {
        HashElement<I, E>* pElement = Hashing<I, E, H>::lookup(i);
        if (pElement) {
            return pElement->info();
        } else {
            return m_defaultValue;
        }
    }
 
    E& operator[](const I& i) {
        HashElement<I, E>* pElement = Hashing<I, E, H>::lookup(i);
        if (!pElement) {
            pElement = Hashing<I, E, H>::fastInsert(i, m_defaultValue);
        }
        return pElement->info();
    }
 
    bool isDefined(const I& i) const { return Hashing<I, E, H>::member(i); }
 
    void undefine(const I& i) { Hashing<I, E, H>::del(i); }
 
    HashArray<I, E, H>& operator=(const HashArray<I, E, H>& A) {
        m_defaultValue = A.m_defaultValue;
        Hashing<I, E, H>::operator=(A);
        return *this;
    }
 
    void clear() { Hashing<I, E, H>::clear(); }
};
 
}