tuples.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

#ifndef OGDF_TUPLE_H
#define OGDF_TUPLE_H


#include <ogdf/basic/basic.h>
#include <ogdf/basic/Hashing.h>


namespace ogdf {

template<class E1, class E2> class Tuple2 {
public:
    E1 m_x1; 
    E2 m_x2; 

    Tuple2() { }
    Tuple2(const E1 &y1, const E2 &y2) : m_x1(y1), m_x2(y2) { }
    Tuple2(const Tuple2<E1,E2> &t2) : m_x1(t2.m_x1), m_x2(t2.m_x2) { }

    const E1 &x1() const { return m_x1; }
    const E2 &x2() const { return m_x2; }

    E1 &x1() { return m_x1; }
    E2 &x2() { return m_x2; }

    // default assignment operator

    OGDF_NEW_DELETE
};

template<class E1, class E2>
bool operator==(const Tuple2<E1,E2> &t1, const Tuple2<E1,E2> &t2)
{
    return t1.x1() == t2.x1() && t1.x2() == t2.x2();
}

template<class E1, class E2>
bool operator!=(const Tuple2<E1,E2> &t1, const Tuple2<E1,E2> &t2)
{
    return t1.x1() != t2.x1() || t1.x2() != t2.x2();
}

template<class E1, class E2>
ostream &operator<<(ostream &os, const Tuple2<E1,E2> &t2)
{
    os << "(" << t2.x1() << " " << t2.x2() << ")";
    return os;
}


template<class E1, class E2, class E3> class Tuple3 {
public:
    E1 m_x1; 
    E2 m_x2; 
    E3 m_x3; 

    Tuple3() { }
    Tuple3(const E1 &y1, const E2 &y2, const E3 &y3) :
        m_x1(y1), m_x2(y2), m_x3(y3) { }
    Tuple3(const Tuple3<E1,E2,E3> &t3) :
        m_x1(t3.m_x1), m_x2(t3.m_x2), m_x3(t3.m_x3) { }

    const E1 &x1() const { return m_x1; }
    const E2 &x2() const { return m_x2; }
    const E3 &x3() const { return m_x3; }

    E1 &x1() { return m_x1; }
    E2 &x2() { return m_x2; }
    E3 &x3() { return m_x3; }

    // default assignment operator

    OGDF_NEW_DELETE
};

template<class E1, class E2, class E3>
bool operator==(const Tuple3<E1,E2,E3> &t1, const Tuple3<E1,E2,E3> &t2)
{
    return t1.x1() == t2.x1() && t1.x2() == t2.x2() && t1.x3() == t2.x3();
}

template<class E1, class E2, class E3>
bool operator!=(const Tuple3<E1,E2,E3> &t1, const Tuple3<E1,E2,E3> &t2)
{
    return t1.x1() != t2.x1() || t1.x2() != t2.x2() || t1.x3() != t2.x3();
}

template<class E1, class E2, class E3>
ostream &operator<<(ostream &os, const Tuple3<E1,E2,E3> &t3)
{
    os << "(" << t3.x1() << " " << t3.x2() << " " << t3.x3() << ")";
    return os;
}


template<class E1, class E2, class E3, class E4> class Tuple4 {
public:
    E1 m_x1; 
    E2 m_x2; 
    E3 m_x3; 
    E4 m_x4; 

    Tuple4() { }
    Tuple4(const E1 &y1, const E2 &y2, const E3 &y3, const E4 &y4) :
        m_x1(y1), m_x2(y2), m_x3(y3), m_x4(y4) { }
    Tuple4(const Tuple4<E1,E2,E3,E4> &t4) :
        m_x1(t4.m_x1), m_x2(t4.m_x2), m_x3(t4.m_x3), m_x4(t4.m_x4) { }

    const E1 &x1() const { return m_x1; }
    const E2 &x2() const { return m_x2; }
    const E3 &x3() const { return m_x3; }
    const E4 &x4() const { return m_x4; }

    E1 &x1() { return m_x1; }
    E2 &x2() { return m_x2; }
    E3 &x3() { return m_x3; }
    E4 &x4() { return m_x4; }

    // default assignment operator

    OGDF_NEW_DELETE
};

template<class E1, class E2, class E3, class E4>
bool operator==(const Tuple4<E1,E2,E3,E4> &t1, const Tuple4<E1,E2,E3,E4> &t2)
{
    return t1.x1() == t2.x1() && t1.x2() == t2.x2() &&
        t1.x3() == t2.x3() && t1.x4() == t2.x4();
}

template<class E1, class E2, class E3, class E4>
bool operator!=(const Tuple4<E1,E2,E3,E4> &t1, const Tuple4<E1,E2,E3,E4> &t2)
{
    return t1.x1() != t2.x1() || t1.x2() != t2.x2() ||
        t1.x3() != t2.x3() || t1.x4() != t2.x4();
}

template<class E1, class E2, class E3, class E4>
ostream &operator<<(ostream &os, const Tuple4<E1,E2,E3,E4> &t4)
{
    os << "(" << t4.x1() << " " << t4.x2() << " " <<
        t4.x3() << " " << t4.x4() << ")";
    return os;
}

template<typename K1_, typename K2_,
    typename Hash1_ = DefHashFunc<K1_>,
    typename Hash2_ = DefHashFunc<K2_> >
class HashFuncTuple
{
public:
    HashFuncTuple() { }

    HashFuncTuple(const Hash1_ &hash1, const Hash2_ &hash2)
        : m_hash1(hash1), m_hash2(hash2) { }

    size_t hash(const Tuple2<K1_,K2_> &key) const {
        return 23*m_hash1.hash(key.x1()) + 443*m_hash2.hash(key.x2());
    }

private:
    Hash1_ m_hash1;
    Hash2_ m_hash2;
};

} // namespace ogdf


#endif