201 lines
6.3 KiB
C++
201 lines
6.3 KiB
C++
#pragma once
|
|
|
|
#include <algorithm>
|
|
#include <boost/mpl/string.hpp>
|
|
#include <iostream>
|
|
#include <type_traits>
|
|
#include <utility>
|
|
|
|
namespace bts {
|
|
namespace meta {
|
|
|
|
// Instantiate a template with a list of types
|
|
template <class... Ts> struct meta_type_pack {
|
|
template <template <typename...> class T, class... T2s>
|
|
using type = T<T2s..., Ts...>;
|
|
};
|
|
|
|
// Type List Support
|
|
template <class... T> struct list;
|
|
|
|
template <typename Elem, typename List> struct cons;
|
|
|
|
template <typename Elem, typename... Ts> struct cons<Elem, list<Ts...>> {
|
|
using type = list<Elem, Ts...>;
|
|
};
|
|
|
|
template <template <typename> class Pred, typename List> struct filter;
|
|
|
|
template <template <typename> class Pred> struct filter<Pred, list<>> {
|
|
using type = list<>;
|
|
};
|
|
|
|
template <template <typename> class Pred, typename Head, typename... TailTs>
|
|
struct filter<Pred, list<Head, TailTs...>> {
|
|
using Tail = filter<Pred, list<TailTs...>>;
|
|
using type = typename std::conditional<
|
|
Pred<Head>::value,
|
|
cons<Head, typename Tail::type>,
|
|
Tail>::type::type;
|
|
};
|
|
|
|
template <template <typename...> class Elem, class List> struct with_type_list;
|
|
|
|
template <template <typename...> class T, typename... Ts>
|
|
struct with_type_list<T, list<Ts...>> {
|
|
using type = T<Ts...>;
|
|
};
|
|
// End Type List Support
|
|
|
|
template <typename T> constexpr size_t max(T v) { return v; }
|
|
|
|
template <typename T0, typename T1, typename... Ts>
|
|
constexpr size_t max(T0 val1, T1 val2, Ts... vs) {
|
|
return max(std::max(val1, val2), vs...);
|
|
}
|
|
|
|
template <
|
|
class R,
|
|
class C,
|
|
class A1 = void,
|
|
class A2 = void,
|
|
class A3 = void,
|
|
class A4 = void,
|
|
class A5 = void>
|
|
struct member_signature {
|
|
typedef R result;
|
|
typedef C functor;
|
|
typedef A1 arg1;
|
|
typedef A2 arg2;
|
|
typedef A3 arg3;
|
|
typedef A4 arg4;
|
|
typedef A5 arg5;
|
|
|
|
// needed to keep GCC warnings at bay, even though no instances of
|
|
// this class are ever created.
|
|
virtual ~member_signature();
|
|
};
|
|
|
|
template <class R, class C>
|
|
member_signature<R, C> deduce_member_signature(R (C::*)());
|
|
|
|
template <class R, class C, class A1>
|
|
member_signature<R, C, A1> deduce_member_signature(R (C::*)(A1));
|
|
|
|
template <class R, class C, class A1, class A2>
|
|
member_signature<R, C, A1, A2> deduce_member_signature(R (C::*)(A1, A2));
|
|
|
|
template <class R, class C, class A1, class A2, class A3>
|
|
member_signature<R, C, A1, A2, A3>
|
|
deduce_member_signature(R (C::*)(A1, A2, A3));
|
|
|
|
template <class R, class C, class A1, class A2, class A3, class A4>
|
|
member_signature<R, C, A1, A2, A3, A4>
|
|
deduce_member_signature(R (C::*)(A1, A2, A3, A4));
|
|
|
|
template <class R, class C, class A1, class A2, class A3, class A4, class A5>
|
|
member_signature<R, C, A1, A2, A3, A4, A5>
|
|
deduce_member_signature(R (C::*)(A1, A2, A3, A4, A5));
|
|
|
|
template <class R, class C>
|
|
member_signature<R, C> deduce_member_signature(R (C::*)() const);
|
|
|
|
template <class R, class C, class A1>
|
|
member_signature<R, C, A1> deduce_member_signature(R (C::*)(A1) const);
|
|
|
|
template <class R, class C, class A1, class A2>
|
|
member_signature<R, C, A1, A2> deduce_member_signature(R (C::*)(A1, A2) const);
|
|
|
|
template <class R, class C, class A1, class A2, class A3>
|
|
member_signature<R, C, A1, A2, A3> deduce_member_signature(R (C::*)(A1, A2, A3)
|
|
const);
|
|
|
|
template <class R, class C, class A1, class A2, class A3, class A4>
|
|
member_signature<R, C, A1, A2, A3, A4>
|
|
deduce_member_signature(R (C::*)(A1, A2, A3, A4) const);
|
|
|
|
template <class R, class C, class A1, class A2, class A3, class A4, class A5>
|
|
member_signature<R, C, A1, A2, A3, A4, A5>
|
|
deduce_member_signature(R (C::*)(A1, A2, A3, A4, A5) const);
|
|
|
|
template <class F> struct functor_signature {
|
|
typedef decltype(deduce_member_signature(&F::operator())) type;
|
|
};
|
|
|
|
// INT TO STRING
|
|
|
|
// Recursive case
|
|
template <bool b, unsigned N> struct int_to_string2 {
|
|
typedef typename boost::mpl::push_back <
|
|
typename int_to_string2<
|
|
N<10, N / 10>::type,
|
|
boost::mpl::char_<'0' + N % 10>>::type type;
|
|
};
|
|
|
|
// Base case
|
|
template <> struct int_to_string2<true, 0> {
|
|
typedef boost::mpl::string<> type;
|
|
};
|
|
|
|
template <unsigned N> struct int_to_string {
|
|
typedef typename boost::mpl::c_str <
|
|
typename int_to_string2<N<10, N>::type>::type type;
|
|
const static auto size =
|
|
boost::mpl::size < typename int_to_string2<N<10, N>::type>::value;
|
|
};
|
|
|
|
// FIND THE FIRST OCCURRENCE OF A TYPE IN A TYPE LIST
|
|
template <int N, typename Target, typename...> struct GetTypeIdxImp {};
|
|
template <int N, typename Target> struct GetTypeIdxImp<N, Target> {};
|
|
template <int N, typename Target, typename First, typename... Rest>
|
|
struct GetTypeIdxImp<N, Target, First, Rest...> {
|
|
static constexpr int value = std::conditional<
|
|
std::is_same<Target, First>::value,
|
|
std::integral_constant<int, N>,
|
|
GetTypeIdxImp<N + 1, Target, Rest...>>::type::value;
|
|
};
|
|
|
|
template <typename Target, typename... TypeList> struct GetTypeIdx {
|
|
static constexpr int value = GetTypeIdxImp<0, Target, TypeList...>::value;
|
|
};
|
|
|
|
static_assert(
|
|
GetTypeIdx<int, double, int, std::string>::value == 1, "Should be one");
|
|
|
|
// FIND THE FIRST OCCURRENCE OF A TYPE IN A TUPLE TYPE
|
|
|
|
template <typename Target, class... Types> struct GetTypeIdxInTuple {};
|
|
template <typename Target, class... TypeList>
|
|
struct GetTypeIdxInTuple<Target, std::tuple<TypeList...>> {
|
|
static constexpr int value = GetTypeIdxImp<0, Target, TypeList...>::value;
|
|
};
|
|
|
|
static_assert(
|
|
GetTypeIdxInTuple<int, std::tuple<double, int, std::string>>::value == 1,
|
|
"Should be one");
|
|
|
|
template <int N, int SZ, typename Collection, typename Tuple>
|
|
struct CollectTupleItemsImp
|
|
: CollectTupleItemsImp<N + 1, SZ - 1, Collection, Tuple> {
|
|
CollectTupleItemsImp(Tuple &t, Collection *out_col)
|
|
: CollectTupleItemsImp<N + 1, SZ - 1, Collection, Tuple>(t, out_col) {
|
|
out_col->push_back(&std::get<N>(t));
|
|
}
|
|
};
|
|
|
|
template <int N, typename Collection, typename Tuple>
|
|
struct CollectTupleItemsImp<N, 0, Collection, Tuple> {
|
|
CollectTupleItemsImp(Tuple &, Collection *) {}
|
|
virtual ~CollectTupleItemsImp() {}
|
|
};
|
|
|
|
template <typename Collection, typename Tuple>
|
|
void collect_tuple_items(Tuple &tuple, Collection *out_col) {
|
|
CollectTupleItemsImp<0, std::tuple_size<Tuple>::value, Collection, Tuple>(
|
|
tuple, out_col);
|
|
std::reverse(out_col->begin(), out_col->end());
|
|
}
|
|
|
|
} // namespace meta
|
|
} // namespace bts
|