MetaUtils.h

Go to the documentation of this file.

#ifndef AMPGEN_METAUTILS_H
#define AMPGEN_METAUTILS_H
 
#include <memory>
#include <tuple>
#include <vector>
#include <string>
#include <cxxabi.h>
#include <algorithm>
 
namespace AmpGen
{
 
  template <class TYPE> std::string type_string()
  {
    int status = 0;
    std::string name = abi::__cxa_demangle( typeid( TYPE ).name(), nullptr, nullptr, &status );
    if( std::is_const<typename std::remove_reference<TYPE>::type>::value ) 
      name = "const " + name;
    if( std::is_reference<TYPE>() ) name = name + "&";
    return name; 
  }
 
  template <class TYPE> std::string type_string( const TYPE& ) { return type_string<TYPE>(); }
 
  namespace detail {
    template<typename T, typename... args> struct zeroType { typedef T type; };
  }
  template<int N, typename... args> using nthType = typename std::tuple_element<N, std::tuple<args...>>::type;
 
  template<typename... args> using zeroType = typename detail::zeroType<args...>::type; 
 
  template <std::size_t I = 0, typename FuncT, typename... Tp>
    typename std::enable_if_t<I == sizeof...( Tp ), void>
    for_each( std::tuple<Tp...>&, FuncT ){}
 
  template <std::size_t I = 0, typename FuncT, typename... Tp> 
    inline typename std::enable_if_t< I<sizeof...( Tp ), void> for_each( std::tuple<Tp...>& t, FuncT f )
    {
      f( std::get<I>( t ) );
      for_each<I + 1, FuncT, Tp...>( t, f );
    }
  template <typename iterator, typename... transform_types> 
    void for_each_sequence( iterator begin, iterator end, transform_types... transforms)
    {
      for_each( std::tuple<transform_types...>(transforms...), [&](auto& transform){ std::for_each( begin, end, transform ); } );
    }
 
  template <std::size_t I = 0, typename FuncT, typename... Tp>
    typename std::enable_if_t<I == sizeof...( Tp ), void>
    for_each( const std::tuple<Tp...>&, FuncT ){}
 
  template <std::size_t I = 0, typename FuncT, typename... Tp> 
    inline typename std::enable_if_t< I<sizeof...( Tp ), void> for_each( const std::tuple<Tp...>& t, FuncT f )
    {
      f( std::get<I>( t ) );
      for_each<I + 1, FuncT, Tp...>( t, f );
    }
  
  template <std::size_t I = 0, typename FuncT, typename... Tp>
    typename std::enable_if_t<I == sizeof...( Tp ), void>
    for_each_with_counter( const std::tuple<Tp...>&, FuncT ){}
 
  template <std::size_t I = 0, typename FuncT, typename... Tp> 
    inline typename std::enable_if_t< I<sizeof...( Tp ), void> for_each_with_counter( const std::tuple<Tp...>& t, FuncT f )
    {
      f( std::get<I>( t ), I);
      for_each_with_counter<I + 1, FuncT, Tp...>( t, f );
    }
 
 
  template <typename R, 
           typename RT, 
           typename ARGS, 
           bool result = std::is_same<decltype( ( ( *(R*)nullptr ) )( ARGS() ) ), RT>::value>
             constexpr bool typeHelper( int )
             {
               return result;
             }
 
  template <typename R, 
            typename RT, 
            typename ARGS> 
             constexpr bool typeHelper( ... )
             {
               return false;
             }
 
  template <typename R, 
           typename RT, 
           typename ARGS> 
             constexpr bool hasReturnType()
             {
               return typeHelper<R, RT, ARGS>( 0 );
             }
  template <typename T, typename... R> constexpr bool hasConstructor()
  {
    return std::is_constructible<T,R...>::value && (false == std::is_same<T, R...>::value);
  }
 
 
  template <typename arg=void, typename... args> std::vector<std::string> typelist()
  {
    std::vector< std::string > rt;
    if( type_string<arg>() != "void" ) {
      rt.emplace_back( type_string<arg>() );
      auto rtp = typelist<args...>(); 
      std::copy( rtp.begin(), rtp.end(), std::back_inserter(rt) );
    }
    return rt;
  }
 
  template <typename> struct isTuple: std::false_type {};
  template <typename ...T> struct isTuple<std::tuple<T...>>: std::true_type {};
  template <typename> struct isVector : std::false_type {};
  template <typename    T> struct isVector<std::vector<T>> : std::true_type {};
  template <typename> struct is_array : std::false_type {};
  template <typename    T, std::size_t N> struct is_array<std::array<T,N>> : std::true_type {};
 
 
#define def_has_function(function_name) \
  template <typename T>      \
  struct has_##function_name { \
    template<typename U> static auto test(int) -> decltype(std::declval<U>().function_name() == 1, std::true_type()); \
    template<typename>   static std::false_type test(...); \
    static constexpr bool value = std::is_same<decltype(test<T>(0)), std::true_type>::value; \
  };
 
  template<typename ...T>
    struct is_functor : std::false_type {};
 
  template<typename T, typename rt, typename... args>
    struct is_functor<T, rt(args...)> {
        template<typename U>
        static constexpr auto test(U*) -> decltype(std::declval<U>().operator()( std::declval<args>()...), std::true_type()); 
        template<typename> static constexpr std::false_type test(...);
        static constexpr bool value = std::is_same<decltype(test<T>(0)), std::true_type>::value ;
    };
 
  template <int A, int B> struct get_power
  {
    static const int value = A * get_power<A, B - 1>::value;
  };
  template <int A> struct get_power<A, 0>
  {
    static const int value = 1;
  };
 
} // namespace AmpGen
 
#endif