gcc/testsuite/g++.dg/cpp0x/variadic-tuple.C

   1 // { dg-do run { target c++11 } }
   2 // { dg-additional-options "-fexcess-precision=fast" }
   3 // { dg-skip-if "requires hosted libstdc++ for string" { ! hostedlib } }
   4 // An implementation of TR1's <tuple> using variadic teplates
   5 // Contributed by Douglas Gregor <doug.gregor@gmail.com>
   6
   7 #include <string>
   8 #include <cassert>
   9 #include <cstring>
  10
  11 // Trivial reference_wrapper
  12 template<typename T>
  13 struct reference_wrapper
  14 {
  15   reference_wrapper(T& x) : ptr(&x) { }
  16
  17   operator T&() const { return *ptr; }
  18
  19   T* ptr;
  20 };
  21
  22 template<typename T> reference_wrapper<T> ref(T& x) { return x; }
  23 template<typename T> reference_wrapper<const T> cref(const T& x) { return x; }
  24
  25 // Simple type-traits we'll need
  26 template<typename T>
  27 struct add_reference
  28 {
  29   typedef T& type;
  30 };
  31
  32 template<typename T>
  33 struct add_reference<T&>
  34 {
  35   typedef T& type;
  36 };
  37
  38 template<typename T, typename U>
  39 struct is_same
  40 {
  41   static const bool value = false;
  42 };
  43
  44 template<typename T>
  45 struct is_same<T, T>
  46 {
  47   static const bool value = true;
  48 };
  49
  50 // For creating the constructor parameters of tuple<>
  51 template<typename T>
  52 struct add_const_reference
  53 {
  54   typedef const T& type;
  55 };
  56
  57 template<typename T>
  58 struct add_const_reference<T&>
  59 {
  60   typedef T& type;
  61 };
  62
  63 // 6.1.3 Class template tuple
  64 template<typename... Values>
  65 class tuple;
  66
  67 template<> class tuple<> { };
  68
  69 template<typename Head, typename... Tail>
  70 class tuple<Head, Tail...>
  71   : private tuple<Tail...>
  72 {
  73   typedef tuple<Tail...> inherited;
  74
  75  public:
  76   tuple() { }
  77
  78   // implicit copy-constructor is okay
  79
  80   tuple(typename add_const_reference<Head>::type v,
  81         typename add_const_reference<Tail>::type... vtail)
  82     : m_head(v), inherited(vtail...) { }
  83
  84   template<typename... VValues>
  85   tuple(const tuple<VValues...>& other)
  86     : m_head(other.head()), inherited(other.tail()) { }
  87
  88   template<typename... VValues>
  89   tuple& operator=(const tuple<VValues...>& other)
  90   {
  91     m_head = other.head();
  92     tail() = other.tail();
  93     return *this;
  94   }
  95
  96   typename add_reference<Head>::type       head()       { return m_head; }
  97   typename add_reference<const Head>::type head() const { return m_head; }
  98   inherited&                               tail()       { return *this; }
  99   const inherited&                         tail() const { return *this; }
 100
 101  protected:
 102   Head m_head;
 103 };
 104
 105 template<typename T>
 106 struct make_tuple_result
 107 {
 108   typedef T type;
 109 };
 110
 111 template<typename T>
 112 struct make_tuple_result<reference_wrapper<T> >
 113 {
 114   typedef T& type;
 115 };
 116
 117 // 6.1.3.2 Tuple creation functions
 118 struct ignore_t {
 119   template<typename T> ignore_t& operator=(const T&) { return *this; }
 120 } ignore;
 121
 122 template<typename... Values>
 123 tuple<typename make_tuple_result<Values>::type...>
 124 make_tuple(const Values&... values)
 125 {
 126   return tuple<typename make_tuple_result<Values>::type...>(values...);
 127 }
 128
 129 template<typename... Values>
 130 tuple<Values&...> tie(Values&... values)
 131 {
 132   return tuple<Values&...>(values...);
 133 }
 134
 135 // 6.1.3.3 Tuple helper classes
 136 template<typename Tuple>
 137 struct tuple_size;
 138
 139 template<>
 140 struct tuple_size<tuple<> >
 141 {
 142   static const std::size_t value = 0;
 143 };
 144
 145 template<typename Head, typename... Tail>
 146 struct tuple_size<tuple<Head, Tail...> >
 147 {
 148   static const std::size_t value = 1 + tuple_size<tuple<Tail...> >::value;
 149 };
 150
 151 template<int I, typename Tuple>
 152 struct tuple_element;
 153
 154 template<int I, typename Head, typename... Tail>
 155 struct tuple_element<I, tuple<Head, Tail...> >
 156 {
 157   typedef typename tuple_element<I-1, tuple<Tail...> >::type type;
 158 };
 159
 160 template<typename Head, typename... Tail>
 161 struct tuple_element<0, tuple<Head, Tail...> >
 162 {
 163   typedef Head type;
 164 };
 165
 166 // 6.1.3.4 Element access
 167 template<int I, typename Tuple>
 168 class get_impl;
 169
 170 template<int I, typename Head, typename... Values>
 171 class get_impl<I, tuple<Head, Values...> >
 172 {
 173   typedef typename tuple_element<I-1, tuple<Values...> >::type Element;
 174   typedef typename add_reference<Element>::type RJ;
 175   typedef typename add_const_reference<Element>::type PJ;
 176   typedef get_impl<I-1, tuple<Values...> > Next;
 177
 178  public:
 179   static RJ get(tuple<Head, Values...>& t)
 180   { return Next::get(t.tail()); }
 181
 182   static PJ get(const tuple<Head, Values...>& t)
 183   { return Next::get(t.tail()); }
 184 };
 185
 186 template<typename Head, typename... Values>
 187 class get_impl<0, tuple<Head, Values...> >
 188 {
 189   typedef typename add_reference<Head>::type RJ;
 190   typedef typename add_const_reference<Head>::type PJ;
 191
 192  public:
 193   static RJ get(tuple<Head, Values...>& t)       { return t.head(); }
 194   static PJ get(const tuple<Head, Values...>& t) { return t.head(); }
 195 };
 196
 197 template<int I, typename... Values>
 198 typename add_reference<
 199            typename tuple_element<I, tuple<Values...> >::type
 200          >::type
 201 get(tuple<Values...>& t)
 202 {
 203   return get_impl<I, tuple<Values...> >::get(t);
 204 }
 205
 206 template<int I, typename... Values>
 207 typename add_const_reference<
 208            typename tuple_element<I, tuple<Values...> >::type
 209          >::type
 210 get(const tuple<Values...>& t)
 211 {
 212   return get_impl<I, tuple<Values...> >::get(t);
 213 }
 214
 215 // 6.1.3.5 Relational operators
 216 inline bool operator==(const tuple<>&, const tuple<>&) { return true; }
 217
 218 template<typename T, typename... TTail, typename U, typename... UTail>
 219 bool operator==(const tuple<T, TTail...>& t, const tuple<U, UTail...>& u)
 220 {
 221   return t.head() == u.head() && t.tail() == u.tail();
 222 }
 223
 224 template<typename... TValues, typename... UValues>
 225 bool operator!=(const tuple<TValues...>& t, const tuple<UValues...>& u)
 226 {
 227   return !(t == u);
 228 }
 229
 230 inline bool operator<(const tuple<>&, const tuple<>&) { return false; }
 231
 232 template<typename T, typename... TTail, typename U, typename... UTail>
 233 bool operator<(const tuple<T, TTail...>& t, const tuple<U, UTail...>& u)
 234 {
 235   return (t.head() < u.head() ||
 236           (!(t.head() < u.head()) && t.tail() < u.tail()));
 237 }
 238
 239 template<typename... TValues, typename... UValues>
 240 bool operator>(const tuple<TValues...>& t, const tuple<UValues...>& u)
 241 {
 242   return u < t;
 243 }
 244
 245 template<typename... TValues, typename... UValues>
 246 bool operator<=(const tuple<TValues...>& t, const tuple<UValues...>& u)
 247 {
 248   return !(u < t);
 249 }
 250
 251 template<typename... TValues, typename... UValues>
 252 bool operator>=(const tuple<TValues...>& t, const tuple<UValues...>& u)
 253 {
 254   return !(t < u);
 255 }
 256
 257 int a0[tuple_size<tuple<> >::value == 0? 1 : -1];
 258 int a1[tuple_size<tuple<int, float, double> >::value == 3? 1 : -1];
 259 int a2a[is_same<tuple_element<0, tuple<int, float, double> >::type, int>
 260          ::value? 1 : -1];
 261 int a2b[is_same<tuple_element<1, tuple<int, float, double> >::type, float>
 262          ::value? 1 : -1];
 263 int a2c[is_same<tuple_element<2, tuple<int, float, double> >::type, double>
 264          ::value? 1 : -1];
 265
 266 int main()
 267 {
 268   tuple<> t0;
 269   tuple<int> t1(1);
 270   tuple<int, float> t2(1, 3.14159f);
 271   tuple<int, float, const char*> t3a(1, 3.14159f, "Hello, world!");
 272   tuple<long, double, std::string> t3b(t3a);
 273   t3b = t3a;
 274   //  t3a = t3b; DPG: triggers an error, as it should.
 275
 276   tuple<int, float, std::string> t3c =
 277     ::make_tuple(17, 2.718281828, std::string("Fun"));
 278
 279   int seventeen = 17;
 280   double pi = 3.14159;
 281   tuple<int&, double&> seventeen_pi = make_tuple(ref(seventeen), ref(pi));
 282   tuple<int&, const double&> seventeen_pi2 =
 283     make_tuple(ref(seventeen), cref(pi));
 284   tuple<int&, double&> seventeen_pi_tied = tie(seventeen, pi);
 285   assert(get<0>(t3a) == 1);
 286   assert(get<1>(t3a) == 3.14159f);
 287   assert(std::strcmp(get<2>(t3a), "Hello, world!") == 0);
 288
 289   assert(t3a == t3b);
 290   assert(!(t3a != t3b));
 291   assert(!(t3a < t3b));
 292   assert(!(t3a > t3b));
 293   assert(t3a <= t3b && t3b <= t3a);
 294   assert(t3a >= t3b && t3b >= t3a);
 295 }