TMP_Tools.h

Go to the documentation of this file.

// Copyright András Vukics 2006–2014. Distributed under the Boost Software License, Version 1.0. (See accompanying file LICENSE.txt)
// -*- C++ -*-
#ifndef CPPQEDCORE_UTILS_TMP_TOOLS_H_INCLUDED
#define CPPQEDCORE_UTILS_TMP_TOOLS_H_INCLUDED


#ifndef BLITZ_ARRAY_LARGEST_RANK
#define BLITZ_ARRAY_LARGEST_RANK 11
#endif // BLITZ_ARRAY_LARGEST_RANK


#ifndef FUSION_MAX_VECTOR_SIZE
#define FUSION_MAX_VECTOR_SIZE 20
#endif // FUSION_MAX_VECTOR_SIZE


#ifndef FUSION_MAX_LIST_SIZE
#define FUSION_MAX_LIST_SIZE FUSION_MAX_VECTOR_SIZE
#endif // FUSION_MAX_LIST_SIZE

#include <boost/type_traits/add_const.hpp>
#include <boost/type_traits/remove_reference.hpp>
#include <boost/type_traits/remove_const.hpp>


#include <boost/mpl/range_c.hpp>
#include <boost/mpl/vector_c.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/eval_if.hpp>
#include <boost/mpl/identity.hpp>
#include <boost/mpl/int.hpp>
#include <boost/mpl/find_if.hpp>
#include <boost/mpl/equal.hpp>

#define DEFINE_TYPED_STATIC_CONST(typeDescription,typeName,variableName) typedef typeDescription typeName; static const typeName variableName;

#define DEFINE_INITIALIZE_TYPED_STATIC_CONST(typeDescription,typeName,variableName) typedef typeDescription typeName; static const typeName variableName=typeName();


namespace tmptools {


template<typename T>
struct RemoveConstReference : boost::remove_const<typename boost::remove_reference<T>::type>
{};


template<typename T, bool ADD_CONST>
struct ConditionalAddConst 
  : boost::mpl::eval_if_c<ADD_CONST,boost::add_const<T>,boost::mpl::identity<T> > {};


template<unsigned N, int Nbeg> struct Range : boost::mpl::range_c<int,Nbeg,Nbeg+N> {};


template<int N> struct Ordinals : Range<N,0> {};


template<unsigned N1, unsigned N2> struct Power       : boost::mpl::int_<N1*Power<N1,N2-1>::value> {};

template<unsigned N1>              struct Power<N1,0> : boost::mpl::int_<1>                        {};

template<typename Seq, typename ICW>
struct numerical_contains : boost::mpl::not_<boost::is_same<typename boost::mpl::find_if<Seq,
                                                                                         boost::mpl::equal_to<boost::mpl::_,ICW> 
                                                                                         >::type,
                                                            typename boost::mpl::end<Seq>::type
                                                            >
                                             > {};

template<typename Seq, typename T, T VALUE>
struct numerical_contains_c : numerical_contains<Seq,boost::mpl::integral_c<T,VALUE> > {};


namespace details {

template<typename T1, typename T2>
struct value_equal : boost::mpl::bool_<T1::value==T2::value>
{};

} // details



template<typename Seq1, typename Seq2>
struct numerical_equal : boost::mpl::equal<Seq1,Seq2,details::value_equal<boost::mpl::_1,boost::mpl::_2> >
{};


template<int N>
struct AssertEvenAndDivideBy2 : boost::mpl::int_<N/2>
{
  static_assert( 2*(N/2)==N , "Argument not even" );
};



template<int N1, int N2, bool IS_EXCLUSIVE=true>
struct pair_c;

template<int N1, int N2>
struct pair_c<N1,N2,false>
{
  //  enum { first=N1, second=N2 };

  static const int first =N1;
  static const int second=N2;
  
  template<int MIN, int MAX>
  struct SanityCheck
  {
    static_assert( N1>=MIN && N2>=MIN && N1<=MAX && N2<=MAX , "pair_c sanity check failed" );
  };
};

// Apparently, in the above, the static const is DECLARED only. Some compilers (including gcc in some circumstances) need to have them DEFINED as well, which is done below. Cf EffC++ 3rd Edition, item 2.

template<int N1, int N2>
const int pair_c<N1,N2,false>::first;

template<int N1, int N2>
const int pair_c<N1,N2,false>::second;


template<int N1, int N2>
struct pair_c<N1,N2,true> : pair_c<N1,N2,false> 
{
  static_assert( N1!=N2 , "pair_c with equal elements" );
};


//
// A nonnegative compile-time integer vector
//


namespace details {

template<int V>
struct ArgumentDispatcher : boost::mpl::integral_c<int,V>
{
  static_assert( V>=0 , "Negative element in nonnegative vector" );
};

} // details


template<int... V> 
struct Vector : boost::mpl::vector_c<int,details::ArgumentDispatcher<V>::value...> {};


typedef Vector<> V_Empty;


} // tmptools



#endif // CPPQEDCORE_UTILS_TMP_TOOLS_H_INCLUDED