tuple.h.svn-base

来自「ffshow源码」· SVN-BASE 代码 · 共 604 行 · 第 1/2 页

// typename tuple_element_type<N,T>::type gets the type of the 
// Nth element ot T
// -------------------------------------------------------

template<int N, class T>
struct tuple_element_type
{
  typedef typename T::tail_type Next;
  typedef typename tuple_element_type<N-1, Next>::type type;
};
template<class T>
struct tuple_element_type<1,T>
{
  typedef typename T::head_type type;
};

// -get function templates -----------------------------------------------
// Usage: get<N>(aTuple)

// non-const version, returns a non-const reference 
// (unless the element itself is const)

  template<int N, class HT, class TT>
  inline typename convert<
                    typename tuple_element_type<N, cons<HT, TT> >::type
                  >::plain_to_reference
  get(cons<HT, TT>& c) { 
    return tuple_element<N>::template get<
             typename convert<
               typename tuple_element_type<N, cons<HT, TT> 
             >::type
           >::plain_to_reference>(c); 
  } 

// const version, returns a const reference to element
  template<int N, class HT, class TT>
  inline typename convert<
                    typename tuple_element_type<N, cons<HT, TT> 
                  >::type>::plain_to_c_reference
  get(const cons<HT, TT>& c) { 
    return tuple_element<N>::template get<
             typename convert<
               typename tuple_element_type<N, cons<HT, TT> 
             >::type
           >::plain_to_c_reference>(c);
  } 


// -- the cons template  --------------------------------------------------
template <class HT, class TT>
struct cons {
  typedef HT head_type;
  typedef TT tail_type;
  HT head;
  TT tail;
 
  template <class T1, LL_REPEAT1(class T,), class LL_TLAST>
  cons( T1& t1, LL_REPEAT2( T, & t,), LL_TLAST& tlast)
  : head (t1) , tail (LL_REPEAT1(t,), tlast, cnil()) {}

   template <class HT2, class TT2>
   cons( const cons<HT2, TT2>& u ) : head(u.head), tail(u.tail) {}

  template <class HT2, class TT2>
  cons& operator=( const cons<HT2, TT2>& u ) { 
    head=u.head; tail=u.tail; return *this; 
  }

  // must define assignment operator explicitely, implicit version is illformed if HT is a reference
  cons& operator=(const cons& u) { head = u.head; tail = u.tail; return *this; }


  template <class T1, class T2>
  cons& operator=( const std::pair<T1, T2>& u ) { 
    tuple_internal::ct_assert<(tuple_length<cons>::value == 2)>(); // check_length = 2
    head = u.first; tail.head = u.second; return *this;
  }

  // get member functions (non-const and const)
  template <int N>
  typename convert<
             typename tuple_element_type<N, cons>::type
           >::plain_to_reference
  get() {
    return std::get<N>(*this); // delegate to non-member get
  }

  template <int N>
  typename convert<
             typename tuple_element_type<N, cons>::type
           >::plain_to_c_reference
  get() const {
    return std::get<N>(*this); // delegate to non-member get
  }


};

template <class HT>
struct cons<HT, nil> {

  typedef HT head_type;
  typedef nil tail_type;

  head_type head;
  
  template<class T1>
  cons( T1& t1, LL_REPEAT0(const nil&), const nil&)
  : head (t1) {}

  template <class HT2>
  cons( const cons<HT2, nil>& u ) : head(u.head) {}
  
  template <class HT2>
  cons& operator=(const cons<HT2, nil>& u ) {  head = u.head; return *this; }

  // must define assignment operator explicitely, implicit version is illformed if HT is a reference
  cons& operator=(const cons& u) { head = u.head; return *this; }

  template <int N>
  typename convert<
             typename tuple_element_type<N, cons>::type
           >::plain_to_reference
  get() {
    return std::get<N>(*this);
  }

  template <int N>
  typename convert<
             typename tuple_element_type<N, cons>::type
           >::plain_to_c_reference
  get() const {
    return std::get<N>(*this);
  }
};

// templates for finding out the length of the tuple -------------------

template<class HT, class TT> struct tuple_length<cons<HT, TT> > {
  enum { value = 1 + tuple_length<TT>::value };
};

template<class HT> struct tuple_length<cons<HT, nil> > {
  enum { value = 1 };
};

// If K=tuple type, allows to write tuple_length<K> instead of 
// tuple_lenght<typename K::inherited>
template <class T1, LL_REPEAT1(class T,), class LL_TLAST> 
struct tuple_length<tuple<T1, LL_REPEAT1(T,), LL_TLAST> >
{
  enum { value = tuple_length<
                   typename tuple<T1, LL_REPEAT1(T,), LL_TLAST>::inherited
                 >::value };
};


// Tuple to cons mapper --------------------------------------------------
template <class T1, LL_REPEAT1(class T,), class LL_TLAST> 
struct map_tuple_to_cons
{
  typedef cons<T1, 
               typename map_tuple_to_cons<LL_REPEAT1(T,), LL_TLAST, nil>::type
              > type;
};

template <class T1>
struct map_tuple_to_cons<T1, LL_REPEAT0(nil), nil>
{
  typedef cons<T1, nil> type;
};

// -------------------------------------------------------------------
// -- tuple ------------------------------------------------------
template <class T1, LL_REPEAT1(class T,), class LL_TLAST> 
class tuple : public map_tuple_to_cons<T1, LL_REPEAT1(T,), LL_TLAST>::type   
{
public:
  typedef typename map_tuple_to_cons<T1, LL_REPEAT1(T,), LL_TLAST>::type inherited;
  
  explicit tuple(typename convert<T1>::plain_to_c_reference t1
          = tuple_default_arg_wrap<T1>::f(),
        LL_REPEAT3(typename convert<T,>::plain_to_c_reference t,
          = tuple_default_arg_wrap<T,>::f()), 
        typename convert<LL_TLAST>::plain_to_c_reference tlast
          = tuple_default_arg_wrap<LL_TLAST>::f()) 
        : inherited(t1, LL_REPEAT1(t,), tlast) {}

  template<class U1, class U2>
  tuple( const cons<U1, U2>& p) : inherited(p) {}

  template <class U1, LL_REPEAT1(class U,), class LL_ULAST>
  tuple& operator=(const tuple<U1, LL_REPEAT1(U,), LL_ULAST>& k) { 
    inherited::operator=(k); 
    return *this;
  }

  template <class U1, class U2>
  tuple& operator=(const std::pair<U1, U2>& k) { 
    tuple_internal::ct_assert<(tuple_length<tuple>::value == 2)>();// check_length = 2
    this->head = k.first;
    this->tail.head =  k.second; 
    return *this;
  }

};

// -make_tuple function templates -----------------------------------
template<class T1>
tuple<typename convert_to_plain_by_default<T1>::type> inline make_tuple(const T1& t1) {
  return tuple<typename convert_to_plain_by_default<T1>::type> (t1);
}
template<class T1, class T2>
tuple<typename convert_to_plain_by_default<T1>::type, typename convert_to_plain_by_default<T2>::type> inline make_tuple(const T1& t1, const T2& t2) {
  return tuple<typename convert_to_plain_by_default<T1>::type, typename convert_to_plain_by_default<T2>::type> (t1, t2);
}
template<class T1, class T2, class T3>
tuple<typename convert_to_plain_by_default<T1>::type, typename convert_to_plain_by_default<T2>::type, typename convert_to_plain_by_default<T3>::type> inline make_tuple(const T1& t1, const T2& t2, const T3& t3) {
  return tuple<typename convert_to_plain_by_default<T1>::type, typename convert_to_plain_by_default<T2>::type, typename convert_to_plain_by_default<T3>::type> (t1, t2, t3);
}
template<class T1, class T2, class T3, class T4>
tuple<typename convert_to_plain_by_default<T1>::type, typename convert_to_plain_by_default<T2>::type, typename convert_to_plain_by_default<T3>::type, typename convert_to_plain_by_default<T4>::type> inline make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4) {
  return tuple<typename convert_to_plain_by_default<T1>::type, typename convert_to_plain_by_default<T2>::type, typename convert_to_plain_by_default<T3>::type, typename convert_to_plain_by_default<T4>::type> (t1, t2, t3, t4);
}
template<class T1, class T2, class T3, class T4, class T5>
tuple<typename convert_to_plain_by_default<T1>::type, typename convert_to_plain_by_default<T2>::type, typename convert_to_plain_by_default<T3>::type, typename convert_to_plain_by_default<T4>::type, typename convert_to_plain_by_default<T5>::type> inline make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5) {
  return tuple<typename convert_to_plain_by_default<T1>::type, typename convert_to_plain_by_default<T2>::type, typename convert_to_plain_by_default<T3>::type, typename convert_to_plain_by_default<T4>::type, typename convert_to_plain_by_default<T5>::type> (t1, t2, t3, t4, t5);
}
template<class T1, class T2, class T3, class T4, class T5, class T6>
tuple<typename convert_to_plain_by_default<T1>::type, typename convert_to_plain_by_default<T2>::type, typename convert_to_plain_by_default<T3>::type, typename convert_to_plain_by_default<T4>::type, typename convert_to_plain_by_default<T5>::type, typename convert_to_plain_by_default<T6>::type> inline make_tuple(const T1& t1, const T2& t2, const T3& t3, const T4& t4, const T5& t5, const T6& t6) {
  return tuple<typename convert_to_plain_by_default<T1>::type, typename convert_to_plain_by_default<T2>::type, typename convert_to_plain_by_default<T3>::type, typename convert_to_plain_by_default<T4>::type, typename convert_to_plain_by_default<T5>::type, typename convert_to_plain_by_default<T6>::type> (t1, t2, t3, t4, t5, t6);
}
template<class T1, class T2, class T3, class T4, class T5, class T6, class T7>
tuple<typename convert_to_plain_by_default<T1>::type, typename convert_to_plain_by_default<T2>::type, typename convert_to_plain_by_default<T3>::type, typename convert_to_plain_by_default<T4>::type, typename convert_to_plain_by_default<T5>::type, typename convert_to_plain_by_default<T6>::type, typename convert_to_plain_by_default<T7>::type> inline 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<typename convert_to_plain_by_default<T1>::type, typename convert_to_plain_by_default<T2>::type, typename convert_to_plain_by_default<T3>::type, typename convert_to_plain_by_default<T4>::type, typename convert_to_plain_by_default<T5>::type, typename convert_to_plain_by_default<T6>::type, typename convert_to_plain_by_default<T7>::type> (t1, t2, t3, t4, t5, t6, t7);
}
template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8>
tuple<typename convert_to_plain_by_default<T1>::type, typename convert_to_plain_by_default<T2>::type, typename convert_to_plain_by_default<T3>::type, typename convert_to_plain_by_default<T4>::type, typename convert_to_plain_by_default<T5>::type, typename convert_to_plain_by_default<T6>::type, typename convert_to_plain_by_default<T7>::type, typename convert_to_plain_by_default<T8>::type> inline 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<typename convert_to_plain_by_default<T1>::type, typename convert_to_plain_by_default<T2>::type, typename convert_to_plain_by_default<T3>::type, typename convert_to_plain_by_default<T4>::type, typename convert_to_plain_by_default<T5>::type, typename convert_to_plain_by_default<T6>::type, typename convert_to_plain_by_default<T7>::type, typename convert_to_plain_by_default<T8>::type> (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>
tuple<typename convert_to_plain_by_default<T1>::type, typename convert_to_plain_by_default<T2>::type, typename convert_to_plain_by_default<T3>::type, typename convert_to_plain_by_default<T4>::type, typename convert_to_plain_by_default<T5>::type, typename convert_to_plain_by_default<T6>::type, typename convert_to_plain_by_default<T7>::type, typename convert_to_plain_by_default<T8>::type, typename convert_to_plain_by_default<T9>::type> inline 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<typename convert_to_plain_by_default<T1>::type, typename convert_to_plain_by_default<T2>::type, typename convert_to_plain_by_default<T3>::type, typename convert_to_plain_by_default<T4>::type, typename convert_to_plain_by_default<T5>::type, typename convert_to_plain_by_default<T6>::type, typename convert_to_plain_by_default<T7>::type, typename convert_to_plain_by_default<T8>::type, typename convert_to_plain_by_default<T9>::type> (t1, t2, t3, t4, t5, t6, t7, t8, t9);
}
template<class T1, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
tuple<typename convert_to_plain_by_default<T1>::type, typename convert_to_plain_by_default<T2>::type, typename convert_to_plain_by_default<T3>::type, typename convert_to_plain_by_default<T4>::type, typename convert_to_plain_by_default<T5>::type, typename convert_to_plain_by_default<T6>::type, typename convert_to_plain_by_default<T7>::type, typename convert_to_plain_by_default<T8>::type, typename convert_to_plain_by_default<T9>::type, typename convert_to_plain_by_default<T10>::type> inline 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, const T10& t10) {
  return tuple<typename convert_to_plain_by_default<T1>::type, typename convert_to_plain_by_default<T2>::type, typename convert_to_plain_by_default<T3>::type, typename convert_to_plain_by_default<T4>::type, typename convert_to_plain_by_default<T5>::type, typename convert_to_plain_by_default<T6>::type, typename convert_to_plain_by_default<T7>::type, typename convert_to_plain_by_default<T8>::type, typename convert_to_plain_by_default<T9>::type, typename convert_to_plain_by_default<T10>::type> (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
}

// Tie function templates -------------------------------------------------
template<class T1>
tuple<T1&> inline tie(T1& t1) {
  return tuple<T1&> (t1);
}
template<class T1, class T2>
tuple<T1&, T2&> inline tie(T1& t1, T2& t2) {
  return tuple<T1&, T2&> (t1, t2);
}
template<class T1, class T2, class T3>
tuple<T1&, T2&, T3&> inline tie(T1& t1, T2& t2, T3& t3) {
  return tuple<T1&, T2&, T3&> (t1, t2, t3);
}
template<class T1, class T2, class T3, class T4>
tuple<T1&, T2&, T3&, T4&> inline tie(T1& t1, T2& t2, T3& t3, T4& t4) {
  return tuple<T1&, T2&, T3&, T4&> (t1, t2, t3, t4);
}
template<class T1, class T2, class T3, class T4, class T5>
tuple<T1&, T2&, T3&, T4&, T5&> inline tie(T1& t1, T2& t2, T3& t3, T4& t4, 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>
tuple<T1&, T2&, T3&, T4&, T5&, T6&> inline tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, 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>
tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&> inline tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, 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>
tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&> inline 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>
tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&> inline 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, class T2, class T3, class T4, class T5, class T6, class T7, class T8, class T9, class T10>
tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&> inline tie(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5, T6& t6, T7& t7, T8& t8, T9& t9, T10& t10) {
  return tuple<T1&, T2&, T3&, T4&, T5&, T6&, T7&, T8&, T9&, T10&> (t1, t2, t3, t4, t5, t6, t7, t8, t9, t10);
}

} //namespace std

#undef LL_TLAST
#undef LL_ULAST
#undef LL_REPEAT0
#undef LL_REPEAT1
#undef LL_REPEAT2
#undef LL_REPEAT3

#endif