templateTools.h

Go to the documentation of this file.

#ifndef TIL_TEMPLATE_TOOLS_H
#define TIL_TEMPLATE_TOOLS_H


// includes from BOOST library
#include "boost/type_traits.hpp"

// includes from TIL library
#include "til/til_common.h"

#define TIL_FOR_ALL_NUMERIC_TYPES(macro)    \
  macro(bool)                               \
  macro(unsigned char)                      \
  macro(char)                               \
  macro(unsigned short)                     \
  macro(short)                              \
  macro(int)                                \
  macro(unsigned int)                       \
  macro(long)                               \
  macro(unsigned long)                      \
  macro(float)                              \
  macro(double)                             \
  macro(long double)                        \


namespace til
{

  //------------------------------------------------------------------------------------------------

    //-------------------------//
   //  true_type, false_type  //
  //-------------------------//
  
  struct true_type  { static bool const value = true; };
  struct false_type { static bool const value = false; };
  
  //------------------------------------------------------------------------------------------------

    //-------------//
   //  bool_type  //
  //-------------//

  template < bool B >
  struct bool_type : public false_type {};
  template < >
  struct bool_type<true> : public true_type {};

  //------------------------------------------------------------------------------------------------
  
    //-----------//
   //  type_if  //
  //-----------//

        template < bool B, typename TypeIfTrue, typename TypeIfFalse >
        struct type_if { typedef TypeIfTrue type; };
        template < typename TypeIfTrue, typename TypeIfFalse >
        struct type_if<false, TypeIfTrue, TypeIfFalse> { typedef TypeIfFalse type; };


  //------------------------------------------------------------------------------------------------

    //-----------//
   //  is_same  //
  //-----------//

  template < typename T1, typename T2 >
  struct is_same : public false_type {};
  template < typename T >
  struct is_same<T,T> : public true_type {};
  

  //------------------------------------------------------------------------------------------------

    //--------------//
   //  naked_type  //
  //--------------//

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

  //------------------------------------------------------------------------------------------------

        template < typename T1, typename T2 >
        struct is_same_rvalue_type
                : public is_same
      <
                          typename naked_type<T1>::type,
                          typename naked_type<T2>::type
                  >                        
        {};

  //------------------------------------------------------------------------------------------------

    //-----------------//
   //  is_same_naked  //
  //-----------------//

  template < typename T1, typename T2 >
  struct is_same_naked : public boost::is_same<typename naked_type<T1>::type, typename naked_type<T2>::type> {};

  //------------------------------------------------------------------------------------------------


    //-------------------------//
   //  enable_if, disable_if  //
  //-------------------------//


        template <bool B, class T = void>
        struct enable_if_c {
                typedef T type;
        };
        template <class T>
        struct enable_if_c<false, T> {};
        template <class Cond, class T = void>
        struct enable_if : public enable_if_c<Cond::value, T> {};

        template <bool B, class T = void>
        struct disable_if_c {
                typedef T type;
        };
        template <class T>
        struct disable_if_c<true, T> {};
        template <class Cond, class T = void>
        struct disable_if : public disable_if_c<Cond::value, T> {};


  //------------------------------------------------------------------------------------------------

  /*
    //---------------//
   //  int_to_type  //
  //---------------//

        template <int N>
        struct int_to_type
        {
                static int const value = N;
        };
  */

  //------------------------------------------------------------------------------------------------

    //--------//
   //  prec  //
  //--------//

  template < typename T >
  struct prec { typedef T type; };

  //------------------------------------------------------------------------------------------------

    //--------//
   // check  //
  //--------//

  
  template < bool b >
  struct check { typedef typename enable_if_c<b>::type type; };

} // namespace til


#endif