HashArray2D.h

Go to the documentation of this file.

 
#pragma once
 
#include <ogdf/basic/HashArray.h>
#include <ogdf/basic/HashIterator2D.h>
#include <ogdf/basic/tuples.h>
 
namespace ogdf {
 
 
 
template<class I1, class I2, class E, class H1 = DefHashFunc<I1>, class H2 = DefHashFunc<I2>>
class HashArray2D : private Hashing<Tuple2<I1, I2>, E, HashFuncTuple<I1, I2, H1, H2>> {
public:
    using const_iterator = HashConstIterator2D<I1, I2, E, H1, H2>;
 
    HashArray2D() { }
 
    explicit HashArray2D(const E& defaultValue, const H1& hashFunc1 = H1(),
            const H2& hashFunc2 = H2())
        : Hashing<Tuple2<I1, I2>, E, HashFuncTuple<I1, I2, H1, H2>>(256,
                HashFuncTuple<I1, I2, H1, H2>(hashFunc1, hashFunc2))
        , m_defaultValue(defaultValue) { }
 
    HashArray2D(const HashArray2D<I1, I2, E, H1, H2>& A)
        : Hashing<Tuple2<I1, I2>, E, HashFuncTuple<I1, I2, H1, H2>>(A)
        , m_defaultValue(A.m_defaultValue) { }
 
    HashArray2D& operator=(const HashArray2D<I1, I2, E, H1, H2>& A) {
        m_defaultValue = A.m_defaultValue;
        Hashing<Tuple2<I1, I2>, E, HashFuncTuple<I1, I2, H1, H2>>::operator=(A);
 
        return *this;
    }
 
    ~HashArray2D() { }
 
    const E& operator()(const I1& i, const I2& j) const {
        HashElement<Tuple2<I1, I2>, E>* pElement =
                Hashing<Tuple2<I1, I2>, E, HashFuncTuple<I1, I2, H1, H2>>::lookup(
                        Tuple2<I1, I2>(i, j));
        return (pElement) ? pElement->info() : m_defaultValue;
    }
 
    E& operator()(const I1& i, const I2& j) {
        Tuple2<I1, I2> t(i, j);
        HashElement<Tuple2<I1, I2>, E>* pElement =
                Hashing<Tuple2<I1, I2>, E, HashFuncTuple<I1, I2, H1, H2>>::lookup(t);
        if (!pElement) {
            pElement = Hashing<Tuple2<I1, I2>, E, HashFuncTuple<I1, I2, H1, H2>>::fastInsert(t,
                    m_defaultValue);
        }
        return pElement->info();
    }
 
    bool isDefined(const I1& i, const I2& j) const {
        return Hashing<Tuple2<I1, I2>, E, HashFuncTuple<I1, I2, H1, H2>>::member(
                Tuple2<I1, I2>(i, j));
    }
 
    void undefine(const I1& i, const I2& j) {
        return Hashing<Tuple2<I1, I2>, E, HashFuncTuple<I1, I2, H1, H2>>::del(Tuple2<I1, I2>(i, j));
    }
 
    HashConstIterator2D<I1, I2, E, H1, H2> begin() const {
        return HashConstIterator2D<I1, I2, E>(
                Hashing<Tuple2<I1, I2>, E, HashFuncTuple<I1, I2, H1, H2>>::begin());
    }
 
    int size() const { return Hashing<Tuple2<I1, I2>, E, HashFuncTuple<I1, I2, H1, H2>>::size(); }
 
    int empty() const { return Hashing<Tuple2<I1, I2>, E, HashFuncTuple<I1, I2, H1, H2>>::empty(); }
 
    void clear() { Hashing<Tuple2<I1, I2>, E, HashFuncTuple<I1, I2, H1, H2>>::clear(); }
 
private:
    E m_defaultValue; 
};
 
}