tuples.hh

  tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8) {
    return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&>
             (t1, t2, t3, t4, t5, t6, t7, t8);
  }

  template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
      class T8, class T9>
  inline tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
  tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8, T9& t9) {
    return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&>
             (t1, t2, t3, t4, t5, t6, t7, t8, t9);
  }

  template<class T1>
  inline tuple<T1> make_tuple(const T1& t1) {
    return tuple<T1> (t1);
  }

  template<class T1, class T2>
  inline tuple<T1, T2> make_tuple(const T1& t1, const T2& t2) {
    return tuple<T1, T2> (t1, t2);
  }

  template<class T1, class T2, class T3>
  inline tuple<T1, T2, T3> make_tuple(const T1& t1, const T2& t2, const T3& t3) {
    return tuple<T1, T2, T3> (t1, t2, t3);
  }

  template<class T1, class T2, class T3, class T4>
  inline tuple<T1, T2, T3, T4> make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4) {
    return tuple<T1, T2, T3, T4> (t1, t2, t3, t4);
  }

  template<class T1, class T2, class T3, class T4, class T5>
  inline tuple<T1, T2, T3, T4, T5>
  make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) {
    return tuple<T1, T2, T3, T4, T5> (t1, t2, t3, t4, t5);
  }

  template<class T1, class T2, class T3, class T4, class T5, class T6>
  inline tuple<T1, T2, T3, T4, T5, T6>
  make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6) {
    return tuple<T1, T2, T3, T4, T5, T6> (t1, t2, t3, t4, t5, t6);
  }

  template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
  inline tuple<T1, T2, T3, T4, T5, T6, T7>
  make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6,
             const T7& t7) {
    return tuple<T1, T2, T3, T4, T5, T6, T7> (t1, t2, t3, t4, t5, t6, t7);
  }

  template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
      class T8>
  inline tuple<T1, T2, T3, T4, T5, T6, T7, T8>
  make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6,
             const T7& t7, const T8& t8) {
    return tuple<T1, T2, T3, T4, T5, T6, T7, T8>
             (t1, t2, t3, t4, t5, t6, t7, t8);
  }

  template<class T1, class T2, class T3, class T4, class T5, class T6, class T7,
      class T8, class T9>
  inline tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>
  make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6,
             const T7& t7, const T8& t8, const T9& t9) {
    return tuple<T1, T2, T3, T4, T5, T6, T7, T8, T9>
             (t1, t2, t3, t4, t5, t6, t7, t8, t9);
  }

  template<typename T1, typename TT>
  template<typename T2, typename T3, typename T4, typename T5,
      typename T6, typename T7, typename T8, typename T9>
  inline Pair<T1,TT>::Pair(typename TupleAccessTraits<T1>::ParameterType first,
                           T2& t2, T3& t3, T4& t4, T5& t5,
                           T6& t6, T7& t7, T8& t8, T9& t9)
    : first_(first), second_(t2,t3,t4,t5,t6,t7,t8,t9, nullType())
  {}

  template <typename T1, typename TT>
  inline Pair<T1, TT>::Pair(typename TupleAccessTraits<T1>::ParameterType first, TT& second)
    : first_(first), second_(second)
  {}

  template<typename T1, typename T2>
  inline Pair<T1,T2>::Pair()
    : first_(), second_()
  {}

  template<typename T1, typename T2>
  template<typename U1, typename U2>
  inline Pair<T1,T2>::Pair(const Pair<U1,U2>& other)
    : first_(other.first_), second_(other.second_)
  {}

  template<typename T1, typename T2>
  template<typename U1, typename U2>
  inline Pair<T1,T2>& Pair<T1,T2>::operator=(const Pair<U1,U2>& other)
  {
    first_=other.first_;
    second_=other.second_;
    return *this;
  }

  template<typename T1, typename T2>
  inline Pair<T1,T2>& Pair<T1,T2>::operator=(const Pair& other)
  {
    first_=other.first_;
    second_=other.second_;
    return *this;
  }

  template<typename T1, typename T2>
  inline typename TupleAccessTraits<T1>::NonConstType
  Pair<T1,T2>::first()
  {
    return first_;
  }

  template<typename T1, typename T2>
  inline typename TupleAccessTraits<T1>::ConstType
  Pair<T1,T2>::first() const
  {
    return first_;
  }


  template<typename T1, typename T2>
  inline typename TupleAccessTraits<T2>::NonConstType
  Pair<T1,T2>::second()
  {
    return second_;
  }

  template<typename T1, typename T2>
  inline typename TupleAccessTraits<T2>::ConstType
  Pair<T1,T2>::second() const
  {
    return second_;
  }

  template<typename T1>
  inline Pair<T1,Nil>::Pair(typename TupleAccessTraits<T1>::ParameterType first,
                            const Nil&, const Nil&, const Nil&, const Nil&,
                            const Nil&, const Nil&, const Nil&, const Nil&)
    : first_(first)
  {}

  template <typename T1>
  inline Pair<T1, Nil>::Pair(typename TupleAccessTraits<T1>::ParameterType first,
                             const Nil&)
    : first_(first)
  {}

  template<typename T1>
  inline Pair<T1,Nil>::Pair()
    : first_()
  {}

  template<typename T1>
  template<typename T2>
  inline Pair<T1,Nil>::Pair(const Pair<T2,Nil>& other)
    : first_(other.first_)
  {}

  template<typename T1>
  template<typename T2>
  Pair<T1,Nil>& Pair<T1,Nil>::operator=(const Pair<T2,Nil>& other)
  {
    first_ = other.first_;
    return *this;
  }


  template<typename T1>
  Pair<T1,Nil>& Pair<T1,Nil>::operator=(const Pair& other)
  {
    first_ = other.first_;
    return *this;
  }

  template<typename T1>
  inline typename TupleAccessTraits<T1>::NonConstType
  Pair<T1,Nil>::first()
  {
    return first_;
  }

  template<typename T1>
  inline typename TupleAccessTraits<T1>::ConstType
  Pair<T1,Nil>::first() const
  {
    return first_;
  }

  /** }@ */
#endif
}
#endif