Compiler Explorer

Source code

struct nil_type {};

template <typename HEAD_T, typename TAIL_T = nil_type>
struct typelist {
    typedef HEAD_T head_type;
    typedef TAIL_T tail_type;
};

template <typename>
struct is_typelist {
    static const bool value = false;
};

template <typename HEAD_T, typename TAIL_T>
struct is_typelist<typelist<HEAD_T, TAIL_T> > {
    static const bool value = true;
};

template <>
struct is_typelist<nil_type> {
    static const bool value = true;
};

#define TYPELIST_1(t1) typelist<t1, nil_type>
#define TYPELIST_2(t1, t2) typelist<t1, TYPELIST_1(t2)>
#define TYPELIST_3(t1, t2, t3) typelist<t1, TYPELIST_2(t2, t3)>
#define TYPELIST_4(t1, t2, t3, t4) typelist<t1, TYPELIST_3(t2, t3, t4)>

template <
    typename T01 = nil_type, typename T02 = nil_type, typename T03 = nil_type,
    typename T04 = nil_type, typename T05 = nil_type, typename T06 = nil_type,
    typename T07 = nil_type, typename T08 = nil_type, typename T09 = nil_type,
    typename T10 = nil_type, typename T11 = nil_type, typename T12 = nil_type,
    typename T13 = nil_type, typename T14 = nil_type, typename T15 = nil_type,
    typename T16 = nil_type, typename T17 = nil_type, typename T18 = nil_type,
    typename T19 = nil_type, typename T20 = nil_type>
struct make_typelist {
   private:
    typedef typename make_typelist<T02, T03, T04, T05, T06, T07, T08, T09, T10,
                                   T11, T12, T13, T14, T15, T16, T17, T18, T19,
                                   T20>::type tail_type;

public:
    typedef typelist<T01, tail_type> type;
};

template <>
struct make_typelist<> {
    typedef nil_type type;
};

template <typename>
struct size;

template <>
struct size<nil_type> {
    static const int value = 0;
};

template <typename HEAD_T, typename TAIL_T>
struct size<typelist<HEAD_T, TAIL_T> > {
    static const int value = 1 + size<TAIL_T>::value;
};

template <typename>
struct empty;

template <>
struct empty<nil_type> {
    static const bool value = true;
};

template <typename HEAD_T, typename TAIL_T>
struct empty<typelist<HEAD_T, TAIL_T> > {
    static const bool value = false;
};

template <typename, int>
struct at;

template <typename HEAD_T, typename TAIL_T>
struct at<typelist<HEAD_T, TAIL_T>, 0> {
    typedef HEAD_T type;
};

template <typename HEAD_T, typename TAIL_T, int INDEX_V>
struct at<typelist<HEAD_T, TAIL_T>, INDEX_V> {
    typedef typename at<TAIL_T, (INDEX_V - 1)>::type type;
};

template <typename, typename>
struct contains;

template <typename HEAD_T, typename TAIL_T, typename T>
struct contains<typelist<HEAD_T, TAIL_T>, T> {
    static const bool value = contains<TAIL_T, T>::value;
};

template <typename TAIL_T, typename T>
struct contains<typelist<T, TAIL_T>, T> {
    static const bool value = true;
};

template <typename T>
struct contains<nil_type, T> {
    static const bool value = false;
};

template <typename, typename>
struct index_of;

template <typename HEAD_T, typename TAIL_T, typename T>
struct index_of<typelist<HEAD_T, TAIL_T>, T> {
    static const int value = 1 + index_of<TAIL_T, T>::value;
};

template <typename TAIL_T, typename T>
struct index_of<typelist<T, TAIL_T>, T> {
    static const bool value = 0;
};

template <typename, typename>
struct push_front;

template <typename HEAD_T, typename TAIL_T, typename T>
struct push_front<typelist<HEAD_T, TAIL_T>, T> {
    typedef typelist<T, typelist<HEAD_T, TAIL_T> > type;
};

template <typename T>
struct push_front<nil_type, T> {
    typedef typelist<T> type;
};

template <typename, typename>
struct push_back;

template <typename HEAD_T, typename TAIL_T, typename T>
struct push_back<typelist<HEAD_T, TAIL_T>, T> {
    typedef typelist<HEAD_T, typename push_back<TAIL_T, T>::type> type;
};

template <typename T>
struct push_back<nil_type, T> {
    typedef typelist<T> type;
};

template <typename, typename>
struct append;

template <typename HEAD_T, typename TAIL_T, typename T>
struct append<typelist<HEAD_T, TAIL_T>, T> {
    typedef typelist<HEAD_T, typename append<TAIL_T, T>::type> type;
};

template <typename T>
struct append<nil_type, T> {
    typedef typelist<T> type;
};

template <typename HEAD_T, typename TAIL_T>
struct append<nil_type, typelist<HEAD_T, TAIL_T> > {
    typedef typelist<HEAD_T, TAIL_T> type;
};

template <typename, typename>
struct remove_first;

template <typename HEAD_T, typename TAIL_T, typename T>
struct remove_first<typelist<HEAD_T, TAIL_T>, T> {
    typedef typelist<HEAD_T, typename remove_first<TAIL_T, T>::type> type;
};

template <typename T>
struct remove_first<nil_type, T> {
    typedef nil_type type;
};

template <typename T, typename TAIL_T>
struct remove_first<typelist<T, TAIL_T>, T> {
    typedef TAIL_T type;
};

template <typename, typename>
struct remove;

template <typename HEAD_T, typename TAIL_T, typename T>
struct remove<typelist<HEAD_T, TAIL_T>, T> {
    typedef typelist<HEAD_T, typename remove<TAIL_T, T>::type> type;
};

template <typename T>
struct remove<nil_type, T> {
    typedef nil_type type;
};

template <typename T, typename TAIL_T>
struct remove<typelist<T, TAIL_T>, T> {
    typedef typename remove<TAIL_T, T>::type type;
};

template <typename, typename, typename>
struct replace_first;

template <typename HEAD_T, typename TAIL_T, typename T, typename U>
struct replace_first<typelist<HEAD_T, TAIL_T>, T, U> {
    typedef typelist<HEAD_T, typename replace_first<TAIL_T, T, U>::type> type;
};

template <typename T, typename U>
struct replace_first<nil_type, T, U> {
    typedef nil_type type;
};

template <typename T, typename TAIL_T, typename U>
struct replace_first<typelist<T, TAIL_T>, T, U> {
    typedef typelist<U, TAIL_T> type;
};

template <typename, typename, typename>
struct replace;

template <typename HEAD_T, typename TAIL_T, typename T, typename U>
struct replace<typelist<HEAD_T, TAIL_T>, T, U> {
    typedef typelist<HEAD_T, typename replace<TAIL_T, T, U>::type> type;
};

template <typename T, typename U>
struct replace<nil_type, T, U> {
    typedef nil_type type;
};

template <typename T, typename TAIL_T, typename U>
struct replace<typelist<T, TAIL_T>, T, U> {
    typedef typelist<U, typename replace<TAIL_T, T, U>::type> type;
};

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;
};

#include <cassert>

int main() {
    {
        typedef typelist<int, typelist<char, typelist<float> > >
            manual_list_type;
        typedef TYPELIST_3(int, char, float) macro_list_type;
        assert((is_same<manual_list_type, macro_list_type>::value));

typedef typename make_typelist<int, char, float>::type maker_list_type;
        assert((is_same<manual_list_type, maker_list_type>::value));
    }
    {
        typedef typename make_typelist<int, char, float, long, short>::type
            list_type;
        assert((size<list_type>::value == 5));
        assert(!(empty<list_type>::value));
        assert((is_same<typename at<list_type, 2>::type, float>::value));

assert((contains<list_type, long>::value));
        assert(!(contains<list_type, unsigned>::value));
        assert((index_of<list_type, float>::value == 2));
    }
    {
        typedef typelist<char> start_list;
        typedef typename push_front<start_list, int>::type type_list;
        assert((is_same<type_list, TYPELIST_2(int, char)>::value));
        assert((is_same<typename push_front<nil_type, int>::type,
                        typelist<int> >::value));
    }
    {
        typedef typelist<char> start_list;
        typedef typename push_back<start_list, int>::type type_list;
        assert((is_same<type_list, TYPELIST_2(char, int)>::value));
        assert((is_same<typename push_back<nil_type, int>::type,
                        typelist<int> >::value));
    }
    {
        typedef TYPELIST_2(char, int) front_list;
        typedef TYPELIST_2(short, long) back_list;
        typedef typename append<front_list, back_list>::type type_list;
        assert((is_same<type_list, TYPELIST_4(char, int, short, long)>::value));
    }
    {
        typedef TYPELIST_4(char, int, char, char) start_list;
        typedef typename remove_first<start_list, char>::type type_list;
        assert((is_same<type_list, TYPELIST_3(int, char, char)>::value));
    }
    {
        typedef TYPELIST_4(char, int, char, char) start_list;
        typedef typename remove<start_list, char>::type type_list;
        assert((is_same<type_list, TYPELIST_1(int)>::value));
    }
    {
        typedef TYPELIST_4(char, int, char, char) start_list;
        typedef typename replace_first<start_list, char, short>::type type_list;
        assert((is_same<type_list, TYPELIST_4(short, int, char, char)>::value));
    }
    {
        typedef TYPELIST_4(char, int, char, char) start_list;
        typedef typename replace<start_list, char, short>::type type_list;
        assert(
            (is_same<type_list, TYPELIST_4(short, int, short, short)>::value));
    }
}