175 lines
5.0 KiB
C++
Executable File
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 ());
|
|
}
|
|
|
|
}}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|