clang/test/CXX/temp/temp.decls/temp.variadic/metafunctions.cpp

   1 // RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
   2
   3 // This is a collection of various template metafunctions involving
   4 // variadic templates, which are meant to exercise common use cases.
   5 template<typename T, typename U>
   6 struct is_same {
   7   static const bool value = false;
   8 };
   9
  10 template<typename T>
  11 struct is_same<T, T> {
  12   static const bool value = true;
  13 };
  14
  15 template<typename...> struct tuple { };
  16 template<int ...> struct int_tuple { };
  17 template<typename T, typename U> struct pair { };
  18
  19 namespace Count {
  20   template<typename Head, typename ...Tail>
  21   struct count {
  22     static const unsigned value = 1 + count<Tail...>::value;
  23   };
  24
  25   template<typename T>
  26   struct count<T> {
  27     static const unsigned value = 1;
  28   };
  29
  30   int check1[count<int>::value == 1? 1 : -1];
  31   int check2[count<float, double>::value == 2? 1 : -1];
  32   int check3[count<char, signed char, unsigned char>::value == 3? 1 : -1];
  33 }
  34
  35 namespace CountWithPackExpansion {
  36   template<typename ...> struct count;
  37
  38   template<typename Head, typename ...Tail>
  39   struct count<Head, Tail...> {
  40     static const unsigned value = 1 + count<Tail...>::value;
  41   };
  42
  43   template<>
  44   struct count<> {
  45     static const unsigned value = 0;
  46   };
  47
  48   int check0[count<>::value == 0? 1 : -1];
  49   int check1[count<int>::value == 1? 1 : -1];
  50   int check2[count<float, double>::value == 2? 1 : -1];
  51   int check3[count<char, signed char, unsigned char>::value == 3? 1 : -1];
  52 }
  53
  54 namespace Replace {
  55   // Simple metafunction that replaces the template arguments of
  56   // template template parameters with 'int'.
  57   template<typename T>
  58   struct EverythingToInt;
  59
  60   template<template<typename ...> class TT, typename T1, typename T2>
  61   struct EverythingToInt<TT<T1, T2> > {
  62     typedef TT<int, int> type;
  63   };
  64
  65   int check0[is_same<EverythingToInt<tuple<double, float>>::type,
  66              tuple<int, int>>::value? 1 : -1];
  67 }
  68
  69 namespace Math {
  70   template<int ...Values>
  71   struct double_values {
  72     typedef int_tuple<Values*2 ...> type;
  73   };
  74
  75   int check0[is_same<double_values<1, 2, -3>::type,
  76                      int_tuple<2, 4, -6>>::value? 1 : -1];
  77
  78   template<int ...Values>
  79   struct square {
  80     typedef int_tuple<(Values*Values)...> type;
  81   };
  82
  83   int check1[is_same<square<1, 2, -3>::type,
  84                      int_tuple<1, 4, 9>>::value? 1 : -1];
  85
  86   template<typename IntTuple> struct square_tuple;
  87
  88   template<int ...Values>
  89   struct square_tuple<int_tuple<Values...>> {
  90     typedef int_tuple<(Values*Values)...> type;
  91   };
  92
  93   int check2[is_same<square_tuple<int_tuple<1, 2, -3> >::type,
  94                      int_tuple<1, 4, 9>>::value? 1 : -1];
  95
  96   template<int ...Values> struct sum;
  97
  98   template<int First, int ...Rest>
  99   struct sum<First, Rest...> {
 100     static const int value = First + sum<Rest...>::value;
 101   };
 102
 103   template<>
 104   struct sum<> {
 105     static const int value = 0;
 106   };
 107
 108   int check3[sum<1, 2, 3, 4, 5>::value == 15? 1 : -1];
 109
 110   template<int ... Values>
 111   struct lazy_sum {
 112     int operator()() {
 113       return sum<Values...>::value;
 114     }
 115   };
 116
 117   void f() {
 118     lazy_sum<1, 2, 3, 4, 5>()();
 119   }
 120 }
 121
 122 namespace ListMath {
 123   template<typename T, T ... V> struct add;
 124
 125   template<typename T, T i, T ... V>
 126   struct add<T, i, V...> {
 127     static const T value = i + add<T, V...>::value;
 128   };
 129
 130   template<typename T>
 131   struct add<T> {
 132     static const T value = T();
 133   };
 134
 135   template<typename T, T ... V>
 136   struct List {
 137     struct sum {
 138       static const T value = add<T, V...>::value;
 139     };
 140   };
 141
 142   template<int ... V>
 143   struct ListI : public List<int, V...> {
 144   };
 145
 146   int check0[ListI<1, 2, 3>::sum::value == 6? 1 : -1];
 147 }
 148
 149 namespace Indices {
 150   template<unsigned I, unsigned N, typename IntTuple>
 151   struct build_indices_impl;
 152
 153   template<unsigned I, unsigned N, int ...Indices>
 154   struct build_indices_impl<I, N, int_tuple<Indices...> >
 155     : build_indices_impl<I+1, N, int_tuple<Indices..., I> > {
 156   };
 157
 158   template<unsigned N, int ...Indices>
 159   struct build_indices_impl<N, N, int_tuple<Indices...> > {
 160     typedef int_tuple<Indices...> type;
 161   };
 162
 163   template<unsigned N>
 164   struct build_indices : build_indices_impl<0, N, int_tuple<> > { };
 165
 166   int check0[is_same<build_indices<5>::type,
 167                      int_tuple<0, 1, 2, 3, 4>>::value? 1 : -1];
 168 }
 169
 170 namespace TemplateTemplateApply {
 171   template<typename T, template<class> class ...Meta>
 172   struct apply_each {
 173     typedef tuple<typename Meta<T>::type...> type;
 174   };
 175
 176   template<typename T>
 177   struct add_reference {
 178     typedef T& type;
 179   };
 180
 181   template<typename T>
 182   struct add_pointer {
 183     typedef T* type;
 184   };
 185
 186   template<typename T>
 187   struct add_const {
 188     typedef const T type;
 189   };
 190
 191   int check0[is_same<apply_each<int,
 192                                 add_reference, add_pointer, add_const>::type,
 193                      tuple<int&, int*, int const>>::value? 1 : -1];
 194
 195   template<typename T, template<class> class ...Meta>
 196   struct apply_each_indirect {
 197     typedef typename apply_each<T, Meta...>::type type;
 198   };
 199
 200   int check1[is_same<apply_each_indirect<int, add_reference, add_pointer,
 201                                          add_const>::type,
 202                      tuple<int&, int*, int const>>::value? 1 : -1];
 203
 204   template<typename T, typename ...Meta>
 205   struct apply_each_nested {
 206     typedef typename apply_each<T, Meta::template apply...>::type type;
 207   };
 208
 209   struct add_reference_meta {
 210     template<typename T>
 211     struct apply {
 212       typedef T& type;
 213     };
 214   };
 215
 216   struct add_pointer_meta {
 217     template<typename T>
 218     struct apply {
 219       typedef T* type;
 220     };
 221   };
 222
 223   struct add_const_meta {
 224     template<typename T>
 225     struct apply {
 226       typedef const T type;
 227     };
 228   };
 229
 230   int check2[is_same<apply_each_nested<int, add_reference_meta,
 231                                        add_pointer_meta, add_const_meta>::type,
 232                      tuple<int&, int*, int const>>::value? 1 : -1];
 233
 234 }
 235
 236 namespace FunctionTypes {
 237   template<typename FunctionType>
 238   struct Arity;
 239
 240   template<typename R, typename ...Types>
 241   struct Arity<R(Types...)> {
 242     static const unsigned value = sizeof...(Types);
 243   };
 244
 245   template<typename R, typename ...Types>
 246   struct Arity<R(Types......)> { // expected-warning {{varargs}} expected-note {{pack}} expected-note {{insert ','}}
 247     static const unsigned value = sizeof...(Types);
 248   };
 249
 250   template<typename R, typename T1, typename T2, typename T3, typename T4>
 251   struct Arity<R(T1, T2, T3, T4)>; // expected-note{{template is declared here}}
 252
 253   int check0[Arity<int()>::value == 0? 1 : -1];
 254   int check1[Arity<int(float, double)>::value == 2? 1 : -1];
 255   int check2[Arity<int(float...)>::value == 1? 1 : -1];
 256   int check3[Arity<int(float, double, long double...)>::value == 3? 1 : -1];
 257   Arity<int(float, double, long double, char)> check4; // expected-error{{implicit instantiation of undefined template 'FunctionTypes::Arity<int (float, double, long double, char)>'}}
 258 }
 259
 260 namespace SuperReplace {
 261   template<typename T>
 262   struct replace_with_int {
 263     typedef int type;
 264   };
 265
 266   template<template<typename ...> class TT, typename ...Types>
 267   struct replace_with_int<TT<Types...>> {
 268     typedef TT<typename replace_with_int<Types>::type...> type;
 269   };
 270
 271   int check0[is_same<replace_with_int<pair<tuple<float, double, short>,
 272                                            pair<char, unsigned char>>>::type,
 273                      pair<tuple<int, int, int>, pair<int, int>>>::value? 1 : -1];
 274 }