texp_tests.hpp

Go to the documentation of this file.

#ifndef realroot_BASE_TYPE_TESTS_H
#define realroot_BASE_TYPE_TESTS_H

#include <realroot/texp_bool.hpp>

namespace mmx {

namespace texp 
{
  
  template <class X, class Y> 
  struct equal      
  { 
    enum { V = 1 };
    typedef false_t T;
  };

  template<class X>           
  struct equal<X,X> 
  {
    enum { V = 1 };
    typedef true_t T;
  };
  
  template<class X, class A, class B> 
  struct tselect                { typedef A T; };
  template<class A, class B>
  struct tselect<false_t, A, B> { typedef B T; };
  template<class A, class B>
  struct tselect<null_t,A, B> { typedef B T; };
  
  template<int k, class A, class B>
  struct vselect                { typedef A T; };
  template<class A, class B>
  struct vselect<0,A,B>         { typedef B T; };
  
  template< typename X >  
  struct tnot 
  { 
    typedef false_t T;
  };
  
  template<> 
  struct tnot< false_t > { typedef true_t T; };
  template<>
  struct tnot< null_t > { typedef true_t T; };
  template<class X>
  struct is_ptr{ typedef typename equal<X,typename ptr<X>::T >::T T; };

  template<bool test, class A, class B>
  struct If 
  { 
    typedef A result_t;  
  };
  
  template<class A,class B>
  struct If<false,A,B> 
  { 
    typedef B result_t; 
  };
  
  template<class A,class B>
  struct Eq 
  { 
    enum { result = 0 }; 
    typedef false_t result_t; 
  };
  
  template<class A>
  struct Eq<A,A> 
  { 
    enum { result = 1 }; 
    typedef true_t result_t; 
  };
  
  template<class A>
  struct ValueType
  { 
    typedef typename A::value_type result_t; 
  };
  
  template<class A, int n >
  struct ValueType< A[n] >
  {
    typedef A result_t;
  };
  template<class A>
  struct ValueType<A*>
  { 
    typedef  A result_t; 
  };
  
  template<int n>
  struct Int {};
  
  template<bool b> struct BoolType { typedef false_t result_t; };
  template<> struct BoolType<true> { typedef true_t result_t; };

  template<class X>
  struct deconst{
    typedef X result_t;
  };

  template<class X>
  struct deconst< const X> { typedef X result_t; };

  template<class A,class B>
  struct Sup
  {
    typedef typename deconst<A>::result_t result_t;
  };
  
  template<class el, class nx>
  struct Pair
  {
    typedef el element_t;
    typedef nx next_t;
  };

}// namespace texp
  
#define typelist1(a)     Type::Pair< a, Type::null_t >
#define typelist2(a,b)   Type::Pair< a, typelist1(b) >
#define typelist3(a,b,c) Type::Pair< a, typelist2(b,c) >
#define typelist4(a,b,c) Type::Pair< a, typelist3(b,c,d) >







}// end namespace mmx
  
#endif