/*
* $Revision: 2615 $
*
* last checkin:
* $Author: gutwenger $
* $Date: 2012-07-16 14:23:36 +0200 (Mo, 16. Jul 2012) $
***************************************************************/
/** \file
* \brief Declaration and implementation of class Tuple2, Tuple3
* and Tuple4.
*
* \author Carsten Gutwenger
*
* \par License:
* This file is part of the Open Graph Drawing Framework (OGDF).
*
* \par
* Copyright (C)
* See README.txt in the root directory of the OGDF installation for details.
*
* \par
* This program is free software; you can redistribute it and/or
* modify it under the terms of the GNU General Public License
* Version 2 or 3 as published by the Free Software Foundation;
* see the file LICENSE.txt included in the packaging of this file
* for details.
*
* \par
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* \par
* You should have received a copy of the GNU General Public
* License along with this program; if not, write to the Free
* Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
* \see http://www.gnu.org/copyleft/gpl.html
***************************************************************/
#ifdef _MSC_VER
#pragma once
#endif
#ifndef OGDF_TUPLE_H
#define OGDF_TUPLE_H
#include "basic.h"
#include "Hashing.h"
namespace ogdf {
//! Tuples of two elements (2-tuples).
/**
* @tparam E1 is the data type for the first element.
* @tparam E2 is the data type for the second element.
*/
template class Tuple2 {
public:
E1 m_x1; //!< The first element.
E2 m_x2; //!< The second element.
//! Constructs a 2-tuple using default constructors.
Tuple2() { }
//! Constructs a 2-tuple for given values.
Tuple2(const E1 &y1, const E2 &y2) : m_x1(y1), m_x2(y2) { }
//! Constructs a 2-tuple that is a copy of \a t2.
Tuple2(const Tuple2 &t2) : m_x1(t2.m_x1), m_x2(t2.m_x2) { }
//! Returns a reference the first element.
const E1 &x1() const { return m_x1; }
//! Returns a reference the second element.
const E2 &x2() const { return m_x2; }
//! Returns a reference the first element.
E1 &x1() { return m_x1; }
//! Returns a reference the second element.
E2 &x2() { return m_x2; }
// default assignment operator
OGDF_NEW_DELETE
};
//! Equality operator for 2-tuples
template
bool operator==(const Tuple2 &t1, const Tuple2 &t2)
{
return t1.x1() == t2.x1() && t1.x2() == t2.x2();
}
//! Inequality operator for 2-tuples
template
bool operator!=(const Tuple2 &t1, const Tuple2 &t2)
{
return t1.x1() != t2.x1() || t1.x2() != t2.x2();
}
//! Output operator for 2-tuples.
template
ostream &operator<<(ostream &os, const Tuple2 &t2)
{
os << "(" << t2.x1() << " " << t2.x2() << ")";
return os;
}
//! Tuples of three elements (3-tuples).
/**
* @tparam E1 is the data type for the first element.
* @tparam E2 is the data type for the second element.
* @tparam E3 is the data type for the third element.
*/
template class Tuple3 {
public:
E1 m_x1; //!< The first element.
E2 m_x2; //!< The second element.
E3 m_x3; //!< The third element.
//! Constructs a 3-tuple using default constructors.
Tuple3() { }
//! Constructs a 3-tuple for given values.
Tuple3(const E1 &y1, const E2 &y2, const E3 &y3) :
m_x1(y1), m_x2(y2), m_x3(y3) { }
//! Constructs a 3-tuple that is a copy of \a t3.
Tuple3(const Tuple3 &t3) :
m_x1(t3.m_x1), m_x2(t3.m_x2), m_x3(t3.m_x3) { }
//! Returns a reference the first element.
const E1 &x1() const { return m_x1; }
//! Returns a reference the second element.
const E2 &x2() const { return m_x2; }
//! Returns a reference the third element.
const E3 &x3() const { return m_x3; }
//! Returns a reference the first element.
E1 &x1() { return m_x1; }
//! Returns a reference the second element.
E2 &x2() { return m_x2; }
//! Returns a reference the third element.
E3 &x3() { return m_x3; }
// default assignment operator
OGDF_NEW_DELETE
};
//! Equality operator for 3-tuples
template
bool operator==(const Tuple3 &t1, const Tuple3 &t2)
{
return t1.x1() == t2.x1() && t1.x2() == t2.x2() && t1.x3() == t2.x3();
}
//! Inequality operator for 3-tuples
template
bool operator!=(const Tuple3 &t1, const Tuple3 &t2)
{
return t1.x1() != t2.x1() || t1.x2() != t2.x2() || t1.x3() != t2.x3();
}
//! Output operator for 3-tuples
template
ostream &operator<<(ostream &os, const Tuple3 &t3)
{
os << "(" << t3.x1() << " " << t3.x2() << " " << t3.x3() << ")";
return os;
}
//! Tuples of four elements (4-tuples).
/**
* @tparam E1 is the data type for the first element.
* @tparam E2 is the data type for the second element.
* @tparam E3 is the data type for the third element.
* @tparam E4 is the data type for the fourth element.
*/
template class Tuple4 {
public:
E1 m_x1; //!< The first element.
E2 m_x2; //!< The second element.
E3 m_x3; //!< The third element.
E4 m_x4; //!< The fourth element.
//! Constructs a 4-tuple using default constructors.
Tuple4() { }
//! Constructs a 4-tuple for given values.
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) { }
//! Constructs a 4-tuple that is a copy of \a t4.
Tuple4(const Tuple4 &t4) :
m_x1(t4.m_x1), m_x2(t4.m_x2), m_x3(t4.m_x3), m_x4(t4.m_x4) { }
//! Returns a reference the first element.
const E1 &x1() const { return m_x1; }
//! Returns a reference the second element.
const E2 &x2() const { return m_x2; }
//! Returns a reference the third element.
const E3 &x3() const { return m_x3; }
//! Returns a reference the fourth element.
const E4 &x4() const { return m_x4; }
//! Returns a reference the first element.
E1 &x1() { return m_x1; }
//! Returns a reference the second element.
E2 &x2() { return m_x2; }
//! Returns a reference the third element.
E3 &x3() { return m_x3; }
//! Returns a reference the fourth element.
E4 &x4() { return m_x4; }
// default assignment operator
OGDF_NEW_DELETE
};
//! Equality operator for 4-tuples
template
bool operator==(const Tuple4 &t1, const Tuple4 &t2)
{
return t1.x1() == t2.x1() && t1.x2() == t2.x2() &&
t1.x3() == t2.x3() && t1.x4() == t2.x4();
}
//! Inequality operator for 4-tuples
template
bool operator!=(const Tuple4 &t1, const Tuple4 &t2)
{
return t1.x1() != t2.x1() || t1.x2() != t2.x2() ||
t1.x3() != t2.x3() || t1.x4() != t2.x4();
}
//! Output operator for 4-tuples
template
ostream &operator<<(ostream &os, const Tuple4 &t4)
{
os << "(" << t4.x1() << " " << t4.x2() << " " <<
t4.x3() << " " << t4.x4() << ")";
return os;
}
template,
typename Hash2_ = DefHashFunc >
class HashFuncTuple
{
public:
HashFuncTuple() { }
HashFuncTuple(const Hash1_ &hash1, const Hash2_ &hash2)
: m_hash1(hash1), m_hash2(hash2) { }
size_t hash(const Tuple2 &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