* src/lemon/extended_pair.h - Part of LEMON, a generic C++ optimization library

  * src/lemon/bits/extended_pair.h - Part of LEMON, a generic C++ optimization library

 template <typename T1, typename A1, typename T2, typename A2>

 ///\ingroup misc

 struct extended_pair {

 ///\file

   typedef T1 first_type;

 ///\brief A more customizable pair type than std::pair.

   typedef T2 second_type;

   extended_pair() : first(), second() {}

 namespace lemon {

   /// \brief A more customizable pair type than std::pair.

   ///

   /// This type is a customizable pair type. The main goal

   /// is that the constructor's parameter type does not depend

   /// on the stored data type. This way it is possible to store

   /// references in the extended_pair.

   /// \code

   /// int a; char b;

   /// typedef extended_pair<int&, int&, char&, char&> ICPair;

   /// ICPair p(a, b); 

   /// // like a real reference to an std::pair<int, char>

   /// // but the pair does not exist

   /// p.first = 42;

   /// p.second = '@';

   /// \endcode

   /// \param T1 The type of first.

   /// \param A1 The parameter type for first.

   /// \param T2 The type of second.

   /// \param A2 The parameter type for second.

   template <typename T1, typename A1, typename T2, typename A2>

   struct extended_pair {

     /// \brief The type of first.

     ///

     /// The type of first.

     typedef T1 first_type;

     /// \brief The type of second.

     ///

     /// The type of second.

     typedef T2 second_type;

   extended_pair(A1 f, A2 s) : first(f), second(s) {}

     /// \brief Default constructor.

     ///

     /// Default constructor. It calls the default constructor of

     /// first and second.

     extended_pair() : first(), second() {}

   template <class Pair>

     /// \brief Constructor.

   extended_pair(const Pair& pair) : first(pair.first), second(pair.second) {}

     ///

     /// Constructor. 

     extended_pair(A1 f, A2 s) : first(f), second(s) {}

   T1 first;

     /// \brief Template constructor.

   T2 second;

     ///

 };

     /// Template constructor. It copies everything which has

     /// \c first and \c second member.

     template <class Pair>

     extended_pair(const Pair& pair) : first(pair.first), second(pair.second) {}

 template <typename T1, typename T2, 

     /// \brief The first value

 	  typename LA1, typename LA2, typename RA1, typename RA2>

     /// 

 bool operator==(const extended_pair<T1, LA1, T2, LA2>& left, 

     /// The first value

 		const extended_pair<T1, RA1, T2, RA2>& right) {

     T1 first;

   return left.first == right.first && left.second == right.second;

     /// \brief The second value

     /// 

     /// The second value

     T2 second;

   };

   /// \brief Equality operator

   /// 

   /// Equality operator

   template <typename T1, typename T2, 

 	    typename LA1, typename LA2, typename RA1, typename RA2>

   bool operator==(const extended_pair<T1, LA1, T2, LA2>& left, 

 		  const extended_pair<T1, RA1, T2, RA2>& right) {

     return left.first == right.first && left.second == right.second;

   }

   /// \brief Inequality operator.

   /// 

   /// Inequality operator.

   template <typename T1, typename T2, 

 	    typename LA1, typename LA2, typename RA1, typename RA2>

   bool operator!=(const extended_pair<T1, LA1, T2, LA2>& left, 

 		  const extended_pair<T1, RA1, T2, RA2>& right) {

     return  !(left == right);

   }

   /// \brief Less operator.

   /// 

   /// Less operator.

   template <typename T1, typename T2, 

 	    typename LA1, typename LA2, typename RA1, typename RA2>

   bool operator<(const extended_pair<T1, LA1, T2, LA2>& left, 

 		 const extended_pair<T1, RA1, T2, RA2>& right) {

     return left.first < right.first || 

       (!(right.first<left.first) && left.second < right.second);

   }

   /// \brief Greater operator.

   /// 

   /// Greater operator.

   template <typename T1, typename T2, 

 	    typename LA1, typename LA2, typename RA1, typename RA2>

   bool operator>(const extended_pair<T1, LA1, T2, LA2>& left, 

 		 const extended_pair<T1, RA1, T2, RA2>& right) {

     return right < left;

   }

   /// \brief Less or equal operator.

   /// 

   /// Less or equal operator.

   template <typename T1, typename T2, 

 	    typename LA1, typename LA2, typename RA1, typename RA2>

   bool operator<=(const extended_pair<T1, LA1, T2, LA2>& left, 

 		  const extended_pair<T1, RA1, T2, RA2>& right) {

     return !(right > left);

   }

   /// \brief Greater or equal operator.

   /// 

   /// Greater or equal operator.

   template <typename T1, typename T2, 

 	    typename LA1, typename LA2, typename RA1, typename RA2>

   bool operator>=(const extended_pair<T1, LA1, T2, LA2>& left, 

 		  const extended_pair<T1, RA1, T2, RA2>& right) {

     return !(right < left);

   }