typelist.hpp

Go to the documentation of this file.

#pragma once
 
#include <type_traits>
#include <functional>
 
namespace fc {
 
namespace typelist {
 
// Forward declare the list so impl can see it
template<typename...> struct list;
 
namespace impl {
using typelist::list;
 
template<typename, template<typename...> class> struct apply;
template<typename... Ts, template<typename...> class Delegate>
struct apply<list<Ts...>, Delegate> { using type = Delegate<Ts...>; };
 
template<typename... Ts>
struct length;
template<> struct length<> { constexpr static std::size_t value = 0; };
template<typename T, typename... Ts>
struct length<T, Ts...> { constexpr static std::size_t value = length<Ts...>::value+1; };
 
template<typename...> struct concat;
template<typename... OldTypes, typename... NewTypes>
struct concat<list<OldTypes...>, list<NewTypes...>> {
   using type = list<OldTypes..., NewTypes...>;
};
template<typename... OldTypes, typename... NewTypes, typename NextList, typename... Lists>
struct concat<list<OldTypes...>, list<NewTypes...>, NextList, Lists...> {
   using type = typename concat<list<OldTypes..., NewTypes...>, NextList, Lists...>::type;
};
 
template<std::size_t count> struct make_sequence;
template<> struct make_sequence<0> { using type = list<>; };
template<> struct make_sequence<1> { using type = list<std::integral_constant<std::size_t, 0>>; };
template<std::size_t count>
struct make_sequence {
   using type = typename concat<typename make_sequence<count-1>::type,
                                list<std::integral_constant<std::size_t, count-1>>>::type;
};
 
template<typename, typename> struct transform;
template<typename... List, typename Transformer>
struct transform<list<List...>, Transformer> {
   using type = list<typename Transformer::template transform<List>::type...>;
};
 
template<typename Search, typename List> struct index_of;
template<typename Search> struct index_of<Search, list<>> { constexpr static int value = -1; };
template<typename Search, typename T, typename... Ts>
struct index_of<Search, list<T, Ts...>> {
    constexpr static int deeper = index_of<Search, list<Ts...>>::value;
    constexpr static int value = std::is_same<Search, T>::value? 0 : (deeper == -1? -1 : deeper + 1);
};
 
template<typename...> struct concat_unique;
template<typename... Uniques>
struct concat_unique<list<Uniques...>, list<>> {
   using type = list<Uniques...>;
};
template<typename... Uniques, typename T>
struct concat_unique<list<Uniques...>, list<T>> {
   using type = std::conditional_t<index_of<T, list<Uniques...>>::value >= 0,
                                   list<Uniques...>, list<Uniques..., T>>;
};
template<typename... Uniques, typename T1, typename T2, typename... Types>
struct concat_unique<list<Uniques...>, list<T1, T2, Types...>> {
   using type = typename concat_unique<
      typename concat_unique<list<Uniques...>, list<T1>>::type, list<T2, Types...>>::type;
};
template<typename... Uniques, typename... Lists>
struct concat_unique<list<Uniques...>, list<>, Lists...> {
   using type = typename concat_unique<list<Uniques...>, Lists...>::type;
};
template<typename Uniques, typename L1a, typename... L1s, typename L2, typename... Lists>
struct concat_unique<Uniques, list<L1a, L1s...>, L2, Lists...> {
   using type = typename concat_unique<typename concat_unique<Uniques, list<L1a, L1s...>>::type, L2, Lists...>::type;
};
 
template<typename, std::size_t> struct at;
template<typename T, typename... Types>
struct at<list<T, Types...>, 0> { using type = T; };
template<typename T, typename... Types, std::size_t index>
struct at<list<T, Types...>, index> : at<list<Types...>, index-1> {};
 
template<typename, typename, std::size_t> struct remove_at;
template<typename... Left, typename T, typename... Right>
struct remove_at<list<Left...>, list<T, Right...>, 0> { using type = list<Left..., Right...>; };
template<typename... Left, typename T, typename... Right, std::size_t index>
struct remove_at<list<Left...>, list<T, Right...>, index> {
   using type = typename remove_at<list<Left..., T>, list<Right...>, index-1>::type;
};
 
template<template<typename> class Filter, typename Filtered, typename List> struct filter;
template<template<typename> class Filter, typename... Filtered>
struct filter<Filter, list<Filtered...>, list<>> { using type = list<Filtered...>; };
template<template<typename> class Filter, typename... Filtered, typename T1, typename... Types>
struct filter<Filter, list<Filtered...>, list<T1, Types...>> {
   using type = typename std::conditional_t<Filter<T1>::value,
                                           filter<Filter, list<Filtered..., T1>, list<Types...>>,
                                           filter<Filter, list<Filtered...>, list<Types...>>>::type;
};
 
template<typename, typename, std::size_t, std::size_t, typename = void> struct slice;
template<typename... Results, typename... Types, std::size_t index>
struct slice<list<Results...>, list<Types...>, index, index, void> { using type = list<Results...>; };
template<typename... Results, typename T, typename... Types, std::size_t end>
struct slice<list<Results...>, list<T, Types...>, 0, end, std::enable_if_t<end != 0>>
        : slice<list<Results..., T>, list<Types...>, 0, end-1> {};
template<typename T, typename... Types, std::size_t start, std::size_t end>
struct slice<list<>, list<T, Types...>, start, end, std::enable_if_t<start != 0>>
        : slice<list<>, list<Types...>, start-1, end-1> {};
 
template<typename, typename> struct zip;
template<>
struct zip<list<>, list<>> { using type = list<>; };
template<typename A, typename... As, typename B, typename... Bs>
struct zip<list<A, As...>, list<B, Bs...>> {
   using type = typename concat<list<list<A, B>>, typename zip<list<As...>, list<Bs...>>::type>::type;
};
 
template<typename Callable, typename Ret, typename T>
Ret dispatch_helper(Callable& c) { return c(T()); }
 
} // namespace impl
 
template<typename... Types>
struct list { using type = list; };
 
template<typename List, template<typename...> class Delegate>
using apply = typename impl::apply<List, Delegate>::type;
 
template<typename List>
constexpr static std::size_t length() { return apply<List, impl::length>::value; }
 
template<typename... Lists>
using concat = typename impl::concat<Lists...>::type;
 
template<std::size_t count>
using make_sequence = typename impl::make_sequence<count>::type;
 
template<typename List = list<>>
struct builder {
   template<typename NewType> using add = typename builder<typename impl::concat<List, list<NewType>>::type>::type;
   template<typename NewList> using add_list = typename builder<typename impl::concat<List, NewList>::type>::type;
   using type = builder;
   using finalize = List;
};
 
template<typename List, typename Transformer>
using transform = typename impl::transform<List, Transformer>::type;
 
template<typename List, typename T>
constexpr static int index_of() { return impl::index_of<T, List>::value; }
 
template<typename List, typename T>
constexpr static bool contains() { return impl::index_of<T, List>::value != -1; }
 
template<typename... TypeLists>
using concat_unique = typename impl::concat_unique<list<>, TypeLists...>::type;
 
template<typename List, std::size_t index>
using at = typename impl::at<List, index>::type;
 
template<typename List>
using first = at<List, 0>;
template<typename List>
using last = at<List, length<List>()-1>;
 
template<typename List, std::size_t index>
using remove_at = typename impl::remove_at<list<>, List, index>::type;
 
template<typename List, typename Remove>
using remove_element = remove_at<List, index_of<List, Remove>()>;
 
template<typename List, template<typename> class Filter>
using filter = typename impl::filter<Filter, list<>, List>::type;
 
template<template<typename> class Filter>
struct invert_filter {
   template<typename T>
   struct type { constexpr static bool value = !Filter<T>::value; };
};
 
template<typename List, std::size_t start, std::size_t end = length<List>()>
using slice = typename impl::slice<list<>, List, start, end>::type;
 
template<typename ListA, typename ListB>
using zip = typename impl::zip<ListA, ListB>::type;
 
template<typename List>
using index = typename impl::zip<typename impl::make_sequence<length<List>()>::type, List>::type;
 
namespace runtime {
template<typename T> struct wrapper { using type = T; };
 
template<typename... Types, typename Callable, typename = std::enable_if_t<impl::length<Types...>::value != 0>,
         typename Return = decltype(std::declval<Callable>()(wrapper<at<list<Types...>, 0>>()))>
Return dispatch(list<Types...>, std::size_t index, Callable c) {
   static std::function<Return(Callable&)> call_table[] =
      { impl::dispatch_helper<Callable, Return, wrapper<Types>>... };
   if (index < impl::length<Types...>::value) return call_table[index](c);
   throw std::out_of_range("Invalid index to fc::typelist::runtime::dispatch()");
}
template<typename List, typename Callable>
auto dispatch(List l, int64_t index, Callable c) {
   if (index < 0) throw std::out_of_range("Negative index to fc::typelist::runtime::dispatch()");
   return dispatch(l, std::size_t(index), std::move(c));
}
 
template<typename... Types, typename Callable>
void for_each(list<Types...>, Callable c) {
   bool trues[] = { [](Callable& c, auto t) { c(t); return true; }(c, wrapper<Types>())... };
   (void)(trues);
}
 
} } } // namespace fc::typelist::runtime