Files
spark/src/lib/utils/meta_programming.h
T

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