Files
spark/src/lib/utils/meta_programming.h
T
2017-09-19 14:43:33 +00:00

175 lines
5.0 KiB
C++
Executable File

#pragma once
#include <iostream>
#include <boost/mpl/string.hpp>
#include <algorithm>
#include <utility>
#include <type_traits>
namespace bts {
namespace meta {
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 ());
}
}}