Pair.h

#ifndef DASH_DASH_INCLUDE_DASH_PAIR_H_
#define DASH_DASH_INCLUDE_DASH_PAIR_H_

#include <dash/Meta.h>

#include <type_traits>
#include <iostream>
#include <sstream>


namespace dash {

  template<class T1, class T2>
  struct Pair
  {
    typedef T1 first_type;    
    typedef T2 second_type;   

    T1 first;                 
    T2 second;                

    constexpr Pair()
      : first(), second()
    { }

    constexpr Pair(const T1& __a, const T2& __b)
      : first(__a), second(__b)
    { }

    template<class U1, class U2, class = typename
              std::enable_if<
                std::is_convertible<const U1&, T1>::value &&
                std::is_convertible<const U2&, T2>::value>::value>
    constexpr Pair(const Pair<U1, U2>& p)
      : first(p.first), second(p.second)
    { }

    constexpr Pair(const Pair&) = default;
    constexpr Pair(Pair&&) = default;

    template<class U1, class = typename
        std::enable_if<std::is_convertible<U1, T1>::value>::type>
    constexpr Pair(U1&& x, const T2& y)
      : first(std::forward<U1>(x)), second(y)
    { }

    template<class U2, class = typename
        std::enable_if<std::is_convertible<U2, T2>::value>::type>
    constexpr Pair(const T1& x, U2&& y)
      : first(x), second(std::forward<U2>(y))
    { }

    template<class U1, class U2, class = typename
        std::enable_if<std::is_convertible<U1, T1>::value &&
                       std::is_convertible<U2, T2>::value>::type>
    constexpr Pair(U1&& x, U2&& y)
      : first(std::forward<U1>(x)), second(std::forward<U2>(y))
    { }

    template<class U1, class U2, class = typename
        std::enable_if<std::is_convertible<U1, T1>::value &&
                       std::is_convertible<U2, T2>::value>::type>
    constexpr Pair(Pair<U1, U2>&& p)
      : first(std::forward<U1>(p.first)),
        second(std::forward<U2>(p.second))
    { }

    Pair&
    operator=(const Pair& p) = default;

    Pair&
    operator=(Pair&& p)
    noexcept(
        std::is_nothrow_move_assignable<T1>::value &&
        std::is_nothrow_move_assignable<T2>::value) = default;

    template<class U1, class U2>
    Pair&
    operator=(const Pair<U1, U2>& p)
    {
      first  = p.first;
      second = p.second;
      return *this;
    }

    template<class U1, class U2>
    Pair&
    operator=(Pair<U1, U2>&& p)
    {
      first  = std::forward<U1>(p.first);
      second = std::forward<U2>(p.second);
      return *this;
    }

    void
    swap(Pair& p)
    noexcept(noexcept(swap(first, p.first))
        && noexcept(swap(second, p.second)))
    {
      std::swap(first, p.first);
      std::swap(second, p.second);
    }
  };

  template<class T1, class T2>
  inline constexpr bool
  operator==(const Pair<T1, T2>& x, const Pair<T1, T2>& y)
  {
    return x.first == y.first && x.second == y.second;
  }

  template<class T1, class T2>
  inline constexpr bool
  operator<(const Pair<T1, T2>& x, const Pair<T1, T2>& y)
  {
    return  x.first < y.first
      || (!(y.first < x.first) && !(x.second >= y.second));
  }

  template<class T1, class T2>
  inline constexpr bool
  operator!=(const Pair<T1, T2>& x, const Pair<T1, T2>& y)
  {
    return !(x == y);
  }

  template<class T1, class T2>
  inline constexpr bool
  operator>(const Pair<T1, T2>& x, const Pair<T1, T2>& y)
  {
    return y < x;
  }

  template<class T1, class T2>
  inline constexpr bool
  operator<=(const Pair<T1, T2>& x, const Pair<T1, T2>& y)
  {
    return !(y < x);
  }

  template<class T1, class T2>
  inline constexpr bool
  operator>=(const Pair<T1, T2>& x, const Pair<T1, T2>& y)
  {
    return !(x < y);
  }

  template<class T1, class T2>
  inline void
  swap(Pair<T1, T2>& x, Pair<T1, T2>& y)
  noexcept(noexcept(x.swap(y)))
  {
    x.swap(y);
  }

  namespace internal {
    template <class T>
    struct strip
    {
      typedef T type;
    };
    template <class T>
    struct strip<std::reference_wrapper<T>>
    {
        typedef T& type;
    };
    template <class T>
    struct decay_and_strip
    {
        typedef typename strip<typename std::decay<T>::type>::type type;
    };
  } // namespace internal

  template<class T1, class T2>
  constexpr Pair<typename internal::decay_and_strip<T1>::type,
                 typename internal::decay_and_strip<T2>::type>
  make_pair(T1&& x, T2&& y)
  {
    typedef typename internal::decay_and_strip<T1>::type ds_type1;
    typedef typename internal::decay_and_strip<T2>::type ds_type2;
    typedef Pair<ds_type1, ds_type2>                     pair_type;
    return pair_type(std::forward<T1>(x), std::forward<T2>(y));
  }

  template<class T1, class T2>
  std::ostream & operator<<(
    std::ostream       & os,
    const Pair<T1, T2> & pair)
  {
    std::ostringstream ss;
    ss << dash::typestr(pair)
       << " { " << pair.first
       << " , " << pair.second
       << " } ";
    return operator<<(os, ss.str());
  }

} // namespace dash


#endif /* DASH_DASH_INCLUDE_DASH_PAIR_H_ */