map/MetaTypeList_8hpp_source.html

// <MetaTypeList.hpp> -*- C++ -*-


#pragma once


#include <type_traits>

#include <memory> // For unique_ptr


namespace MetaTypeList {


    template<typename...>

    class type_list {};


    template<typename...>

    class create;


    template<typename Head, typename... Tail>


    class create<type_list<>, Head, Tail...> :

        public create<type_list<Head>, Tail...> {};


    template<typename Head, typename... Tail, typename... Elements>


    class create<type_list<Elements...>, Head, Tail...> :

        public create<type_list<Elements..., Head>, Tail...> {};


    template<typename... Elements>


    class create<type_list<Elements...>> {

    public:

        using type = type_list<Elements...>;

    };


    template<typename... Elements>

    using create_t = typename create<type_list<Elements...>>::type;


    template<typename>

    class frontT;


    template<typename Head, typename... Tail>


    class frontT<type_list<Head, Tail...>> {

    public:

        using type = Head;

    };


    template<typename List>

    using front = typename frontT<List>::type;


    template<typename>

    class pop_frontT;


    template<typename Head, typename... Tail>


    class pop_frontT<type_list<Head, Tail...>> {

    public:

        using type = type_list<Tail...>;

    };


    template<typename List>

    using pop_front = typename pop_frontT<List>::type;


    template<typename, typename>

    class push_frontT;


    template<typename... Elements, typename NewElement>


    class push_frontT<type_list<Elements...>, NewElement> {

    public:

        using type = type_list<NewElement, Elements...>;

    };


    template<typename List, typename NewElement>

    using push_front = typename push_frontT<List, NewElement>::type;


    template<typename, typename>

    class push_backT;


    template<typename... Elements, typename NewElement>


    class push_backT<type_list<Elements...>, NewElement> {

    public:

        using type = type_list<Elements..., NewElement>;

    };


    template<typename List, typename NewElement>

    using push_back = typename push_backT<List, NewElement>::type;


    template<typename List, unsigned N>

    class nth_elementT : public nth_elementT<pop_front<List>, N-1> {};


    template<typename List>

    class nth_elementT<List, 0> : public frontT<List> {};


    template<typename List, unsigned N>

    using nth_element = typename nth_elementT<List, N>::type;


    template<typename>

    class is_empty : public std::false_type {};


    template<>

    class is_empty<type_list<>> : public std::true_type {};


    template<typename...>

    class get_pack_size;


    template<typename Head, typename... Tail>


    class get_pack_size<type_list<Head, Tail...>> {

    public:

        static constexpr std::size_t value =

            1 + get_pack_size<type_list<Tail...>>::value;

    };


    template<>


    class get_pack_size<type_list<>> {

    public:

        static constexpr std::size_t value = 0;

    };


    template<typename...>

    struct is_meta_typelist : public std::false_type {};


    template<typename... Args>

    struct is_meta_typelist<MetaTypeList::type_list<Args...>> : public std::true_type {};


    template<std::size_t, typename...>

    class get_index;


    template<std::size_t S, typename T, typename Head, typename... Tail>


    class get_index<S, T, type_list<Head, Tail...>,

                    typename std::enable_if<std::is_same<T, Head>::value>::type> {

    public:

        static constexpr std::size_t value = (S - sizeof...(Tail)) - 1;

    };


    template<std::size_t S, typename T, typename Head, typename... Tail>


    class get_index<S, T, type_list<Head, Tail...>,

                    typename std::enable_if<!std::is_same<T, Head>::value>::type> :

        public get_index<S, T, type_list<Tail...>> {};


} // namespace MetaTypeList


MetaTypeList::pop_front
typename pop_frontT< List >::type pop_front
pop_frontT Alias Template.
Definition MetaTypeList.hpp:112

MetaTypeList::nth_element
typename nth_elementT< List, N >::type nth_element
nth_elementT Alias Template.
Definition MetaTypeList.hpp:182

MetaTypeList::push_front
typename push_frontT< List, NewElement >::type push_front
push_frontT Alias Template.
Definition MetaTypeList.hpp:137

MetaTypeList::create_t
typename create< type_list< Elements... > >::type create_t
create Alias Template.
Definition MetaTypeList.hpp:64

MetaTypeList::front
typename frontT< List >::type front
frontT Alias Template.
Definition MetaTypeList.hpp:88

MetaTypeList::push_back
typename push_backT< List, NewElement >::type push_back
push_backT Alias Template.
Definition MetaTypeList.hpp:162

MetaTypeList::create
The Variadic Class Template create takes a variable number of different types and creates a well-form...
Definition MetaTypeList.hpp:32

MetaTypeList::frontT
The class template frontT takes type_list as template param. and typedefs the type of the first templ...
Definition MetaTypeList.hpp:73

MetaTypeList::get_index
Class Template to return the index of a certain type in a certain typelist.
Definition MetaTypeList.hpp:243

MetaTypeList::get_pack_size
Class Template get_pack_size return the current number of types in the type_list.
Definition MetaTypeList.hpp:201

MetaTypeList::is_empty
Class Template is_empty Generic case.
Definition MetaTypeList.hpp:188

MetaTypeList::nth_elementT
This class template gives us the type of Nth element in a type_list by taking advantage of the nested...
Definition MetaTypeList.hpp:170

MetaTypeList::pop_frontT
The class template pop_frontT takes type_list as template param., extracts out the first type in type...
Definition MetaTypeList.hpp:97

MetaTypeList::push_backT
The class template push_backT takes an existing type_list and a new type, inserts that new type at en...
Definition MetaTypeList.hpp:147

MetaTypeList::push_frontT
The class template push_frontT takes an existing type_list and a new type, inserts that new type at f...
Definition MetaTypeList.hpp:122

MetaTypeList::type_list
The variadic class template type_list has no implementation and is empty by itself.
Definition MetaTypeList.hpp:24

MetaTypeList::is_meta_typelist
Variadic Class Template which takes a type and matches it if that is a type_list. Generic case result...
Definition MetaTypeList.hpp:229