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

   1 // { dg-do run { target c++11 } }
   2 // A basic implementation of TR1's bind using variadic teplates
   3 // Contributed by Douglas Gregor <doug.gregor@gmail.com>
   4 #include <cassert>
   5
   6 // Trivial reference_wrapper
   7 template<typename T>
   8 struct reference_wrapper
   9 {
  10   reference_wrapper(T& x) : ptr(&x) { }
  11
  12   operator T&() const { return *ptr; }
  13
  14   T& get() const { return *ptr; }
  15
  16   T* ptr;
  17 };
  18
  19 template<typename T> reference_wrapper<T> ref(T& x) { return x; }
  20 template<typename T> reference_wrapper<const T> cref(const T& x) { return x; }
  21
  22 // Simple type-traits we'll need
  23 template<typename T>
  24 struct add_reference
  25 {
  26   typedef T& type;
  27 };
  28
  29 template<typename T>
  30 struct add_reference<T&>
  31 {
  32   typedef T& type;
  33 };
  34
  35 template<typename T, typename U>
  36 struct is_same
  37 {
  38   static const bool value = false;
  39 };
  40
  41 template<typename T>
  42 struct is_same<T, T>
  43 {
  44   static const bool value = true;
  45 };
  46
  47 // For creating the constructor parameters of tuple<>
  48 template<typename T>
  49 struct add_const_reference
  50 {
  51   typedef const T& type;
  52 };
  53
  54 template<typename T>
  55 struct add_const_reference<T&>
  56 {
  57   typedef T& type;
  58 };
  59
  60 // 6.1.3 Class template tuple: Needed for bind() implementation
  61 template<typename... Values>
  62 class tuple;
  63
  64 template<> class tuple<> { };
  65
  66 template<typename Head, typename... Tail>
  67 class tuple<Head, Tail...>
  68   : private tuple<Tail...>
  69 {
  70   typedef tuple<Tail...> inherited;
  71
  72  public:
  73   tuple() { }
  74
  75   // implicit copy-constructor is okay
  76
  77   tuple(typename add_const_reference<Head>::type v,
  78         typename add_const_reference<Tail>::type... vtail)
  79     : m_head(v), inherited(vtail...) { }
  80
  81   template<typename... VValues>
  82   tuple(const tuple<VValues...>& other)
  83     : m_head(other.head()), inherited(other.tail()) { }
  84
  85   template<typename... VValues>
  86   tuple& operator=(const tuple<VValues...>& other)
  87   {
  88     m_head = other.head();
  89     tail() = other.tail();
  90     return *this;
  91   }
  92
  93   typename add_reference<Head>::type       head()       { return m_head; }
  94   typename add_reference<const Head>::type head() const { return m_head; }
  95   inherited&                               tail()       { return *this; }
  96   const inherited&                         tail() const { return *this; }
  97
  98  protected:
  99   Head m_head;
 100 };
 101
 102 template<typename T>
 103 struct make_tuple_result
 104 {
 105   typedef T type;
 106 };
 107
 108 template<typename T>
 109 struct make_tuple_result<reference_wrapper<T> >
 110 {
 111   typedef T& type;
 112 };
 113
 114 // 6.1.3.2 Tuple creation functions
 115 struct ignore_t {
 116   template<typename T> ignore_t& operator=(const T&) { return *this; }
 117 } ignore;
 118
 119 template<typename... Values>
 120 tuple<typename make_tuple_result<Values>::type...>
 121 make_tuple(const Values&... values)
 122 {
 123   return tuple<typename make_tuple_result<Values>::type...>(values...);
 124 }
 125
 126 template<typename... Values>
 127 tuple<Values&...> tie(Values&... values)
 128 {
 129   return tuple<Values&...>(values...);
 130 }
 131
 132 // 6.1.3.3 Tuple helper classes
 133 template<typename Tuple>
 134 struct tuple_size;
 135
 136 template<>
 137 struct tuple_size<tuple<> >
 138 {
 139   static const __SIZE_TYPE__ value = 0;
 140 };
 141
 142 template<typename Head, typename... Tail>
 143 struct tuple_size<tuple<Head, Tail...> >
 144 {
 145   static const __SIZE_TYPE__ value = 1 + tuple_size<tuple<Tail...> >::value;
 146 };
 147
 148 template<int I, typename Tuple>
 149 struct tuple_element;
 150
 151 template<int I, typename Head, typename... Tail>
 152 struct tuple_element<I, tuple<Head, Tail...> >
 153 {
 154   typedef typename tuple_element<I-1, tuple<Tail...> >::type type;
 155 };
 156
 157 template<typename Head, typename... Tail>
 158 struct tuple_element<0, tuple<Head, Tail...> >
 159 {
 160   typedef Head type;
 161 };
 162
 163 // 6.1.3.4 Element access
 164 template<int I, typename Tuple>
 165 class get_impl;
 166
 167 template<int I, typename Head, typename... Values>
 168 class get_impl<I, tuple<Head, Values...> >
 169 {
 170   typedef typename tuple_element<I-1, tuple<Values...> >::type Element;
 171   typedef typename add_reference<Element>::type RJ;
 172   typedef typename add_const_reference<Element>::type PJ;
 173   typedef get_impl<I-1, tuple<Values...> > Next;
 174
 175  public:
 176   static RJ get(tuple<Head, Values...>& t)
 177   { return Next::get(t.tail()); }
 178
 179   static PJ get(const tuple<Head, Values...>& t)
 180   { return Next::get(t.tail()); }
 181 };
 182
 183 template<typename Head, typename... Values>
 184 class get_impl<0, tuple<Head, Values...> >
 185 {
 186   typedef typename add_reference<Head>::type RJ;
 187   typedef typename add_const_reference<Head>::type PJ;
 188
 189  public:
 190   static RJ get(tuple<Head, Values...>& t)       { return t.head(); }
 191   static PJ get(const tuple<Head, Values...>& t) { return t.head(); }
 192 };
 193
 194 template<int I, typename... Values>
 195 typename add_reference<
 196            typename tuple_element<I, tuple<Values...> >::type
 197          >::type
 198 get(tuple<Values...>& t)
 199 {
 200   return get_impl<I, tuple<Values...> >::get(t);
 201 }
 202
 203 template<int I, typename... Values>
 204 typename add_const_reference<
 205            typename tuple_element<I, tuple<Values...> >::type
 206          >::type
 207 get(const tuple<Values...>& t)
 208 {
 209   return get_impl<I, tuple<Values...> >::get(t);
 210 }
 211
 212 // 6.1.3.5 Relational operators
 213 inline bool operator==(const tuple<>&, const tuple<>&) { return true; }
 214
 215 template<typename T, typename... TTail, typename U, typename... UTail>
 216 bool operator==(const tuple<T, TTail...>& t, const tuple<U, UTail...>& u)
 217 {
 218   return t.head() == u.head() && t.tail() == u.tail();
 219 }
 220
 221 template<typename... TValues, typename... UValues>
 222 bool operator!=(const tuple<TValues...>& t, const tuple<UValues...>& u)
 223 {
 224   return !(t == u);
 225 }
 226
 227 inline bool operator<(const tuple<>&, const tuple<>&) { return false; }
 228
 229 template<typename T, typename... TTail, typename U, typename... UTail>
 230 bool operator<(const tuple<T, TTail...>& t, const tuple<U, UTail...>& u)
 231 {
 232   return (t.head() < u.head() ||
 233           (!(t.head() < u.head()) && t.tail() < u.tail()));
 234 }
 235
 236 template<typename... TValues, typename... UValues>
 237 bool operator>(const tuple<TValues...>& t, const tuple<UValues...>& u)
 238 {
 239   return u < t;
 240 }
 241
 242 template<typename... TValues, typename... UValues>
 243 bool operator<=(const tuple<TValues...>& t, const tuple<UValues...>& u)
 244 {
 245   return !(u < t);
 246 }
 247
 248 template<typename... TValues, typename... UValues>
 249 bool operator>=(const tuple<TValues...>& t, const tuple<UValues...>& u)
 250 {
 251   return !(t < u);
 252 }
 253
 254 // enable_if, the breakfast of champions
 255 template<bool Cond, typename Type = void>
 256 struct enable_if {
 257   typedef Type type;
 258 };
 259
 260 template<typename Type>
 261 struct enable_if<false, Type> { };
 262
 263 // 3.6 Function object binders
 264
 265 // 3.6.1 Class template is_bind_expression
 266 template<typename T>
 267 struct is_bind_expression {
 268   static const bool value = false;
 269 };
 270
 271 // 3.6.2 Class template is_placeholder
 272 template<typename T>
 273 struct is_placeholder {
 274   static const int value = 0;
 275 };
 276
 277 // 3.6.3 Function template bind
 278 template<int I> struct placeholder {} ;
 279
 280 template<int N> struct int_c { };
 281
 282 // A tuple of integer values
 283 template<int...> struct int_tuple {};
 284
 285 // make_indexes_impl is a helper for make_indexes
 286 template<int I, typename IntTuple, typename... Types>
 287 struct make_indexes_impl;
 288
 289
 290 template<int I, int... Indexes, typename T, typename... Types>
 291 struct make_indexes_impl<I, int_tuple<Indexes...>, T, Types...>
 292 {
 293   typedef typename make_indexes_impl<I+1,
 294                                      int_tuple<Indexes..., I>,
 295                                      Types...>::type type;
 296 };
 297
 298 template<int I, int... Indexes>
 299 struct make_indexes_impl<I, int_tuple<Indexes...> > {
 300   typedef int_tuple<Indexes...> type;
 301 };
 302
 303 // make_indexes takes a variable-length number of N types and
 304 // generates an int_tuple that contains <0, 1, 2, ..., N-1>. These can
 305 // be used as indexes for tuple's get or tuple_element operation.
 306 template<typename... Types>
 307 struct make_indexes : make_indexes_impl<0, int_tuple<>, Types...> { };
 308
 309 // Get the Ith tuple element, but only if I is in bounds.
 310 template<int I, typename Tuple, typename = void>
 311 struct safe_tuple_element{ };
 312
 313 template<int I, typename... Values>
 314 struct safe_tuple_element<I, tuple<Values...>,
 315          typename enable_if<(I >= 0 &&
 316                              I < tuple_size<tuple<Values...> >::value)
 317                             >::type>
 318 {
 319   typedef typename tuple_element<I, tuple<Values...> >::type type;
 320 };
 321
 322 // mu maps a bound argument to an actual argument, given a tuple of
 323 // the arguments passed to the function object returned by bind().
 324
 325 // Return the stored reference from reference_wrapper
 326 template<typename T, typename... Args>
 327 inline T& mu(reference_wrapper<T>& bound_arg, const tuple<Args&...>&)
 328 {
 329   return bound_arg.get();
 330 }
 331
 332 // Unwrap a tuple into separate arguments and forward to the function
 333 // object f.
 334 template<typename F, int... Indexes, typename... Args>
 335 inline typename F::result_type
 336 unwrap_and_forward(F& f, int_tuple<Indexes...>, const tuple<Args&...>& args)
 337 {
 338   return f(get<Indexes>(args)...);
 339 }
 340
 341 // Evaluate the inner bind expression
 342 template<typename Bound, typename... Args>
 343 inline typename enable_if<is_bind_expression<Bound>::value,
 344                           typename Bound::result_type>::type
 345 mu(Bound& bound_arg, const tuple<Args&...>& args)
 346 {
 347   typedef typename make_indexes<Args...>::type Indexes;
 348   return unwrap_and_forward(bound_arg, Indexes(), args);
 349 }
 350
 351 // Retrieve the Ith argument from args
 352 template<typename Bound, typename... Args>
 353 inline typename safe_tuple_element<is_placeholder<Bound>::value - 1,
 354                                    tuple<Args...> >::type
 355 mu(Bound& bound_arg, const tuple<Args&...>& args)
 356 {
 357   return get<is_placeholder<Bound>::value-1>(args);
 358 }
 359
 360 // Return the stored value.
 361 template<typename T>
 362 struct is_reference_wrapper {
 363   static const bool value = false;
 364 };
 365
 366 template<typename T>
 367 struct is_reference_wrapper<reference_wrapper<T> > {
 368   static const bool value = true;
 369 };
 370
 371 template<typename Bound, typename... Args>
 372 inline typename enable_if<(!is_bind_expression<Bound>::value
 373                            && !is_placeholder<Bound>::value
 374                            && !is_reference_wrapper<Bound>::value),
 375                           Bound&>::type
 376 mu(Bound& bound_arg, const tuple<Args&...>&)
 377 {
 378   return bound_arg;
 379 }
 380
 381 //
 382 template<typename F, typename... BoundArgs, int... Indexes, typename... Args>
 383 typename F::result_type
 384 apply_functor(F& f, tuple<BoundArgs...>& bound_args, int_tuple<Indexes...>,
 385               const tuple<Args&...>& args)
 386 {
 387   return f(mu(get<Indexes>(bound_args), args)...);
 388 }
 389
 390 template<typename F, typename... BoundArgs>
 391 class bound_functor
 392 {
 393   typedef typename make_indexes<BoundArgs...>::type indexes;
 394
 395  public:
 396   typedef typename F::result_type result_type;
 397
 398   explicit bound_functor(const F& f, const BoundArgs&... bound_args)
 399     : f(f), bound_args(bound_args...) { }
 400
 401   template<typename... Args>
 402   typename F::result_type operator()(Args&... args) {
 403     return apply_functor(f, bound_args, indexes(), tie(args...));
 404   }
 405
 406  private:
 407   F f;
 408   tuple<BoundArgs...> bound_args;
 409 };
 410
 411 template<typename F, typename... BoundArgs>
 412 struct is_bind_expression<bound_functor<F, BoundArgs...> > {
 413   static const bool value = true;
 414 };
 415
 416 template<typename F, typename... BoundArgs>
 417 inline bound_functor<F, BoundArgs...>
 418 bind(const F& f, const BoundArgs&... bound_args)
 419 {
 420   return bound_functor<F, BoundArgs...>(f, bound_args...);
 421 }
 422
 423
 424 // 3.6.4 Placeholders
 425 template<int I>
 426 struct is_placeholder<placeholder<I> > {
 427   static const int value = I;
 428 };
 429
 430 placeholder<1> _1;
 431 placeholder<2> _2;
 432 placeholder<3> _3;
 433 placeholder<4> _4;
 434 placeholder<5> _5;
 435 placeholder<6> _6;
 436 placeholder<7> _7;
 437 placeholder<8> _8;
 438 placeholder<9> _9;
 439
 440 // Test code
 441 template<typename T>
 442 struct plus {
 443   typedef T result_type;
 444
 445   T operator()(T x, T y) { return x + y; }
 446 };
 447
 448 template<typename T>
 449 struct multiplies {
 450   typedef T result_type;
 451
 452   T operator()(T x, T y) { return x * y; }
 453 };
 454
 455 template<typename T>
 456 struct negate {
 457   typedef T result_type;
 458
 459   T operator()(T x) { return -x; }
 460 };
 461
 462 int main()
 463 {
 464   int seventeen = 17;
 465   int forty_two = 42;
 466
 467   assert(bind(plus<int>(), _1, _2)(seventeen, forty_two) == 59);
 468   assert(bind(plus<int>(), _1, _1)(seventeen, forty_two) == 34);
 469   assert(bind(plus<int>(), _2, _1)(seventeen, forty_two) == 59);
 470   assert(bind(plus<int>(), 5, _1)(seventeen, forty_two) == 22);
 471   assert(bind(plus<int>(), ref(seventeen), _2)(seventeen, forty_two) == 59);
 472   assert(bind(plus<int>(), bind(multiplies<int>(), 3, _1), _2)(seventeen, forty_two)
 473          == 93);
 474   return 0;
 475 }