275 lines
7.2 KiB
C++
275 lines
7.2 KiB
C++
// RUN: %clang_cc1 -std=c++11 -fsyntax-only -verify %s
|
|
|
|
// This is a collection of various template metafunctions involving
|
|
// variadic templates, which are meant to exercise common use cases.
|
|
template<typename T, typename U>
|
|
struct is_same {
|
|
static const bool value = false;
|
|
};
|
|
|
|
template<typename T>
|
|
struct is_same<T, T> {
|
|
static const bool value = true;
|
|
};
|
|
|
|
template<typename...> struct tuple { };
|
|
template<int ...> struct int_tuple { };
|
|
template<typename T, typename U> struct pair { };
|
|
|
|
namespace Count {
|
|
template<typename Head, typename ...Tail>
|
|
struct count {
|
|
static const unsigned value = 1 + count<Tail...>::value;
|
|
};
|
|
|
|
template<typename T>
|
|
struct count<T> {
|
|
static const unsigned value = 1;
|
|
};
|
|
|
|
int check1[count<int>::value == 1? 1 : -1];
|
|
int check2[count<float, double>::value == 2? 1 : -1];
|
|
int check3[count<char, signed char, unsigned char>::value == 3? 1 : -1];
|
|
}
|
|
|
|
namespace CountWithPackExpansion {
|
|
template<typename ...> struct count;
|
|
|
|
template<typename Head, typename ...Tail>
|
|
struct count<Head, Tail...> {
|
|
static const unsigned value = 1 + count<Tail...>::value;
|
|
};
|
|
|
|
template<>
|
|
struct count<> {
|
|
static const unsigned value = 0;
|
|
};
|
|
|
|
int check0[count<>::value == 0? 1 : -1];
|
|
int check1[count<int>::value == 1? 1 : -1];
|
|
int check2[count<float, double>::value == 2? 1 : -1];
|
|
int check3[count<char, signed char, unsigned char>::value == 3? 1 : -1];
|
|
}
|
|
|
|
namespace Replace {
|
|
// Simple metafunction that replaces the template arguments of
|
|
// template template parameters with 'int'.
|
|
template<typename T>
|
|
struct EverythingToInt;
|
|
|
|
template<template<typename ...> class TT, typename T1, typename T2>
|
|
struct EverythingToInt<TT<T1, T2> > {
|
|
typedef TT<int, int> type;
|
|
};
|
|
|
|
int check0[is_same<EverythingToInt<tuple<double, float>>::type,
|
|
tuple<int, int>>::value? 1 : -1];
|
|
}
|
|
|
|
namespace Math {
|
|
template<int ...Values>
|
|
struct double_values {
|
|
typedef int_tuple<Values*2 ...> type;
|
|
};
|
|
|
|
int check0[is_same<double_values<1, 2, -3>::type,
|
|
int_tuple<2, 4, -6>>::value? 1 : -1];
|
|
|
|
template<int ...Values>
|
|
struct square {
|
|
typedef int_tuple<(Values*Values)...> type;
|
|
};
|
|
|
|
int check1[is_same<square<1, 2, -3>::type,
|
|
int_tuple<1, 4, 9>>::value? 1 : -1];
|
|
|
|
template<typename IntTuple> struct square_tuple;
|
|
|
|
template<int ...Values>
|
|
struct square_tuple<int_tuple<Values...>> {
|
|
typedef int_tuple<(Values*Values)...> type;
|
|
};
|
|
|
|
int check2[is_same<square_tuple<int_tuple<1, 2, -3> >::type,
|
|
int_tuple<1, 4, 9>>::value? 1 : -1];
|
|
|
|
template<int ...Values> struct sum;
|
|
|
|
template<int First, int ...Rest>
|
|
struct sum<First, Rest...> {
|
|
static const int value = First + sum<Rest...>::value;
|
|
};
|
|
|
|
template<>
|
|
struct sum<> {
|
|
static const int value = 0;
|
|
};
|
|
|
|
int check3[sum<1, 2, 3, 4, 5>::value == 15? 1 : -1];
|
|
|
|
template<int ... Values>
|
|
struct lazy_sum {
|
|
int operator()() {
|
|
return sum<Values...>::value;
|
|
}
|
|
};
|
|
|
|
void f() {
|
|
lazy_sum<1, 2, 3, 4, 5>()();
|
|
}
|
|
}
|
|
|
|
namespace ListMath {
|
|
template<typename T, T ... V> struct add;
|
|
|
|
template<typename T, T i, T ... V>
|
|
struct add<T, i, V...> {
|
|
static const T value = i + add<T, V...>::value;
|
|
};
|
|
|
|
template<typename T>
|
|
struct add<T> {
|
|
static const T value = T();
|
|
};
|
|
|
|
template<typename T, T ... V>
|
|
struct List {
|
|
struct sum {
|
|
static const T value = add<T, V...>::value;
|
|
};
|
|
};
|
|
|
|
template<int ... V>
|
|
struct ListI : public List<int, V...> {
|
|
};
|
|
|
|
int check0[ListI<1, 2, 3>::sum::value == 6? 1 : -1];
|
|
}
|
|
|
|
namespace Indices {
|
|
template<unsigned I, unsigned N, typename IntTuple>
|
|
struct build_indices_impl;
|
|
|
|
template<unsigned I, unsigned N, int ...Indices>
|
|
struct build_indices_impl<I, N, int_tuple<Indices...> >
|
|
: build_indices_impl<I+1, N, int_tuple<Indices..., I> > {
|
|
};
|
|
|
|
template<unsigned N, int ...Indices>
|
|
struct build_indices_impl<N, N, int_tuple<Indices...> > {
|
|
typedef int_tuple<Indices...> type;
|
|
};
|
|
|
|
template<unsigned N>
|
|
struct build_indices : build_indices_impl<0, N, int_tuple<> > { };
|
|
|
|
int check0[is_same<build_indices<5>::type,
|
|
int_tuple<0, 1, 2, 3, 4>>::value? 1 : -1];
|
|
}
|
|
|
|
namespace TemplateTemplateApply {
|
|
template<typename T, template<class> class ...Meta>
|
|
struct apply_each {
|
|
typedef tuple<typename Meta<T>::type...> type;
|
|
};
|
|
|
|
template<typename T>
|
|
struct add_reference {
|
|
typedef T& type;
|
|
};
|
|
|
|
template<typename T>
|
|
struct add_pointer {
|
|
typedef T* type;
|
|
};
|
|
|
|
template<typename T>
|
|
struct add_const {
|
|
typedef const T type;
|
|
};
|
|
|
|
int check0[is_same<apply_each<int,
|
|
add_reference, add_pointer, add_const>::type,
|
|
tuple<int&, int*, int const>>::value? 1 : -1];
|
|
|
|
template<typename T, template<class> class ...Meta>
|
|
struct apply_each_indirect {
|
|
typedef typename apply_each<T, Meta...>::type type;
|
|
};
|
|
|
|
int check1[is_same<apply_each_indirect<int, add_reference, add_pointer,
|
|
add_const>::type,
|
|
tuple<int&, int*, int const>>::value? 1 : -1];
|
|
|
|
template<typename T, typename ...Meta>
|
|
struct apply_each_nested {
|
|
typedef typename apply_each<T, Meta::template apply...>::type type;
|
|
};
|
|
|
|
struct add_reference_meta {
|
|
template<typename T>
|
|
struct apply {
|
|
typedef T& type;
|
|
};
|
|
};
|
|
|
|
struct add_pointer_meta {
|
|
template<typename T>
|
|
struct apply {
|
|
typedef T* type;
|
|
};
|
|
};
|
|
|
|
struct add_const_meta {
|
|
template<typename T>
|
|
struct apply {
|
|
typedef const T type;
|
|
};
|
|
};
|
|
|
|
int check2[is_same<apply_each_nested<int, add_reference_meta,
|
|
add_pointer_meta, add_const_meta>::type,
|
|
tuple<int&, int*, int const>>::value? 1 : -1];
|
|
|
|
}
|
|
|
|
namespace FunctionTypes {
|
|
template<typename FunctionType>
|
|
struct Arity;
|
|
|
|
template<typename R, typename ...Types>
|
|
struct Arity<R(Types...)> {
|
|
static const unsigned value = sizeof...(Types);
|
|
};
|
|
|
|
template<typename R, typename ...Types>
|
|
struct Arity<R(Types......)> { // expected-warning {{varargs}} expected-note {{pack}} expected-note {{insert ','}}
|
|
static const unsigned value = sizeof...(Types);
|
|
};
|
|
|
|
template<typename R, typename T1, typename T2, typename T3, typename T4>
|
|
struct Arity<R(T1, T2, T3, T4)>; // expected-note{{template is declared here}}
|
|
|
|
int check0[Arity<int()>::value == 0? 1 : -1];
|
|
int check1[Arity<int(float, double)>::value == 2? 1 : -1];
|
|
int check2[Arity<int(float...)>::value == 1? 1 : -1];
|
|
int check3[Arity<int(float, double, long double...)>::value == 3? 1 : -1];
|
|
Arity<int(float, double, long double, char)> check4; // expected-error{{implicit instantiation of undefined template 'FunctionTypes::Arity<int (float, double, long double, char)>'}}
|
|
}
|
|
|
|
namespace SuperReplace {
|
|
template<typename T>
|
|
struct replace_with_int {
|
|
typedef int type;
|
|
};
|
|
|
|
template<template<typename ...> class TT, typename ...Types>
|
|
struct replace_with_int<TT<Types...>> {
|
|
typedef TT<typename replace_with_int<Types>::type...> type;
|
|
};
|
|
|
|
int check0[is_same<replace_with_int<pair<tuple<float, double, short>,
|
|
pair<char, unsigned char>>>::type,
|
|
pair<tuple<int, int, int>, pair<int, int>>>::value? 1 : -1];
|
|
}
|