HashArray2D.h

Go to the documentation of this file.

/*
 * $Revision: 2027 $
 * 
 * last checkin:
 *   $Author: gutwenger $ 
 *   $Date: 2010-09-01 11:55:17 +0200 (Wed, 01 Sep 2010) $ 
 ***************************************************************/
 
#ifdef _MSC_VER
#pragma once
#endif

#include <ogdf/basic/HashArray.h>
#include <ogdf/basic/tuples.h>
#include <ogdf/basic/HashIterator2D.h>

#ifndef OGDF_HASHARRAY2D_H
#define OGDF_HASHARRAY2D_H


namespace ogdf {


template< class I1_, class I2_, class E_,
    class Hash1_ = DefHashFunc<I1_>,
    class Hash2_ = DefHashFunc<I2_> >
class HashArray2D : private Hashing<Tuple2<I1_,I2_>, E_,
    HashFuncTuple<I1_,I2_,Hash1_,Hash2_> >
{
public:
    typedef HashConstIterator2D<I1_,I2_,E_,Hash1_,Hash2_> const_iterator;

    HashArray2D() /*: m_size(0)*/ {}

    HashArray2D(const E_ &defaultValue,
        const Hash1_ &hashFunc1 = Hash1_(),
        const Hash2_ &hashFunc2 = Hash2_())
        : Hashing<Tuple2<I1_,I2_>,E_,HashFuncTuple<I1_,I2_,Hash1_,Hash2_> >(256,
            HashFuncTuple<I1_,I2_,Hash1_,Hash2_>(hashFunc1,hashFunc2)),
        m_defaultValue(defaultValue) {}

    HashArray2D(const HashArray2D<I1_,I2_,E_,Hash1_,Hash2_> &A) :
        Hashing<Tuple2<I1_,I2_>,E_,HashFuncTuple<I1_,I2_,Hash1_,Hash2_> >(A),
            m_defaultValue(A.m_defaultValue) { }

    HashArray2D &operator=(const HashArray2D<I1_,I2_,E_,Hash1_,Hash2_> &A) {
        m_defaultValue = A.m_defaultValue;
        Hashing<Tuple2<I1_,I2_>,E_,HashFuncTuple<I1_,I2_,Hash1_,Hash2_> >::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_,Hash1_,Hash2_> >::lookup(Tuple2<I1_,I2_>(i,j));
        if (pElement) return pElement->info();
        else return 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_,Hash1_,Hash2_> >::lookup(t);
        if (!pElement)
            pElement = Hashing<Tuple2<I1_,I2_>,E_,HashFuncTuple<I1_,I2_,Hash1_,Hash2_> >::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_,Hash1_,Hash2_> >::member(Tuple2<I1_,I2_>(i,j));
    }

    void undefine(const I1_ &i, const I2_ &j) {
        return Hashing<Tuple2<I1_,I2_>,E_,HashFuncTuple<I1_,I2_,Hash1_,Hash2_> >::del(Tuple2<I1_,I2_>(i,j));
    }

    HashConstIterator2D<I1_,I2_,E_,Hash1_,Hash2_> begin() const {
        return HashConstIterator2D<I1_,I2_,E_>(
            Hashing<Tuple2<I1_,I2_>,E_,HashFuncTuple<I1_,I2_,Hash1_,Hash2_> >::begin());
    }

    int size() const {
        return Hashing<Tuple2<I1_,I2_>,E_,HashFuncTuple<I1_,I2_,Hash1_,Hash2_> >::size();
    }
    
    int empty() const { 
        return Hashing<Tuple2<I1_,I2_>,E_,HashFuncTuple<I1_,I2_,Hash1_,Hash2_> >::empty();
    }


    void clear() {
        Hashing<Tuple2<I1_,I2_>,E_,HashFuncTuple<I1_,I2_,Hash1_,Hash2_> >::clear();
    }

private:
    E_ m_defaultValue; 
};

}

#endif