/* -*- C++ -*-

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

 *

 * Copyright (C) 2005 Egervary Jeno Kombinatorikus Optimalizalasi Kutatocsoport

 * (Egervary Research Group on Combinatorial Optimization, EGRES).

 *

 * Permission to use, modify and distribute this software is granted

 * provided that this copyright notice appears in all copies. For

 * precise terms see the accompanying LICENSE file.

 *

 * This software is provided "AS IS" with no warranty of any kind,

 * express or implied, and with no claim as to its suitability for any

 * purpose.

 *

 */

#ifndef LEMON_EXTENDED_PAIR_H

#define LEMON_EXTENDED_PAIR_H

///\ingroup misc

///\file

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

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;

    /// \brief Default constructor.

    ///

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

    /// first and second.

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

    /// \brief Constructor.

    ///

    /// Constructor. 

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

    /// \brief Template constructor.

    ///

    /// 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) {}

    /// \brief The first value

    /// 

    /// The first value

    T1 first;

    /// \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);

  }

}

#endif