typetraits.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_TYPETRAITS_HH
#define DUNE_TYPETRAITS_HH
 
#if defined HAVE_TYPE_TRAITS
#include <type_traits>
#elif defined HAVE_TR1_TYPE_TRAITS
#include <tr1/type_traits>
#endif
 
#include <dune/common/deprecated.hh>
 
namespace Dune
{
 
  struct Empty {};
 
  template <typename T>
  class TypeTraits
  {
  private:
    template <class U>
    struct PointerTraits {
      enum { result = false };
      typedef Empty PointeeType;
    };
 
    template <class U>
    struct PointerTraits<U*> {
      enum { result = true };
      typedef U PointeeType;
    };
 
    template <class U> struct ReferenceTraits
    {
      enum { result = false };
      typedef U ReferredType;
    };
 
    template <class U> struct ReferenceTraits<U&>
    {
      enum { result = true };
      typedef U ReferredType;
    };
 
  public:
    enum { isPointer = PointerTraits<T>::result };
    typedef typename PointerTraits<T>::PointeeType PointeeType DUNE_DEPRECATED_MSG("Use remove_pointer instead!");
 
    enum { isReference = ReferenceTraits<T>::result };
    typedef typename ReferenceTraits<T>::ReferredType ReferredType DUNE_DEPRECATED_MSG("Use remove_reference instead!");
  };
 
  template<typename T>
  struct ConstantVolatileTraits
  {
    enum {
      isVolatile=false,
      isConst=false
    };
 
    typedef T UnqualifiedType;
    typedef const T ConstType;
    typedef const volatile T ConstVolatileType;
  };
 
  template<typename T>
  struct ConstantVolatileTraits<const T>
  {
    enum {
      isVolatile=false, isConst=true
    };
    typedef T UnqualifiedType;
    typedef const UnqualifiedType ConstType;
    typedef const volatile UnqualifiedType ConstVolatileType;
  };
 
 
  template<typename T>
  struct ConstantVolatileTraits<volatile T>
  {
    enum {
      isVolatile=true, isConst=false
    };
    typedef T UnqualifiedType;
    typedef const UnqualifiedType ConstType;
    typedef const volatile UnqualifiedType ConstVolatileType;
  };
 
  template<typename T>
  struct ConstantVolatileTraits<const volatile T>
  {
    enum {
      isVolatile=true, isConst=true
    };
    typedef T UnqualifiedType;
    typedef const UnqualifiedType ConstType;
    typedef const volatile UnqualifiedType ConstVolatileType;
  };
 
  template<typename T>
  struct IsVolatile
  {
    enum {
      value=ConstantVolatileTraits<T>::isVolatile
    };
  };
 
  template<typename T>
  struct IsConst
  {
    enum {
      value=ConstantVolatileTraits<T>::isConst
    };
  };
 
  template<typename T, bool isVolatile>
  struct RemoveConstHelper
  {
    typedef typename ConstantVolatileTraits<T>::UnqualifiedType Type;
  };
 
  template<typename T>
  struct RemoveConstHelper<T,true>
  {
    typedef volatile typename ConstantVolatileTraits<T>::UnqualifiedType Type;
  };
 
#if defined HAVE_TYPE_TRAITS
  using std::remove_const;
#elif defined HAVE_TR1_TYPE_TRAITS
  using std::tr1::remove_const;
#else
  template<typename T>
  struct remove_const
  {
    typedef typename RemoveConstHelper<T, IsVolatile<T>::value>::Type type;
  };
#endif
 
#if defined HAVE_TYPE_TRAITS
  using std::remove_reference;
#elif defined HAVE_TR1_TYPE_TRAITS
  using std::tr1::remove_reference;
#else
 
  template<typename T> struct remove_reference {
    typedef T type;
  };
#  ifndef DOXYGEN
  template<typename T> struct remove_reference<T&> {
    typedef T type;
  };
#  endif // ! defined(DOXYGEN)
#endif
 
  template<class From, class To>
  class Conversion
  {
    typedef char Small;
    struct Big {char dummy[2];};
    static Small test(To);
    static Big test(...);
    static typename remove_reference< From >::type &makeFrom ();
 
  public:
    enum {
      exists =  sizeof(test(makeFrom())) == sizeof(Small),
      isTwoWay = exists && Conversion<To,From>::exists,
      sameType = false
    };
    Conversion(){}
 
  };
 
  template <class From>
  class Conversion<From, void>
  {
  public:
    enum {
      exists = false,
      isTwoWay = false,
      sameType = false
    };
  };
 
  template <class To>
  class Conversion<void, To>
  {
  public:
    enum {
      exists = false,
      isTwoWay = false,
      sameType = false
    };
  };
 
  template<>
  class Conversion< int, double >
  {
  public:
    enum {
      exists = true,
      isTwoWay = false,
      sameType = false
    };
  };
 
  template<class T>
  class Conversion<T,T>{
  public:
    enum { exists=true, isTwoWay=true, sameType=true};
  };
 
  template <class Base, class Derived>
  class IsBaseOf
  {
    typedef typename ConstantVolatileTraits< typename remove_reference< Base >::type >::UnqualifiedType RawBase;
    typedef typename ConstantVolatileTraits< typename remove_reference< Derived >::type >::UnqualifiedType RawDerived;
    typedef char Small;
    struct Big {char dummy[2];};
    static Small test(RawBase*);
    static Big test(...);
    static RawDerived* &makePtr ();
  public:
    enum {
      value = sizeof(test(makePtr())) == sizeof(Small)
    };
    IsBaseOf(){}
 
  };
 
  template<class T1, class T2>
  struct IsInteroperable
  {
    enum {
      value = Conversion<T1,T2>::exists || Conversion<T2,T1>::exists
    };
  };
 
#ifdef HAVE_TYPE_TRAITS
  using std::enable_if;
#else
  template<bool b, typename T=void>
  struct enable_if
  {
    typedef T type;
  };
 
  template<typename T>
  struct enable_if<false,T>
  {};
#endif
 
 
  template<class T1, class T2, class Type>
  struct EnableIfInterOperable
    : public enable_if<IsInteroperable<T1,T2>::value, Type>
  {};
 
#if defined HAVE_TYPE_TRAITS
  using std::is_same;
#elif defined HAVE_TR1_TYPE_TRAITS
  using std::tr1::is_same;
#else
  template<typename T1, typename T2>
  struct is_same
  {
    enum {
      /* @brief Whether T1 is the same type as T2. */
      value=false
    };
  };
 
 
  template<typename T>
  struct is_same<T,T>
  {
    enum { value=true};
  };
#endif
 
  template<bool first, class T1, class T2>
  struct SelectType
  {
    typedef T1 Type DUNE_DEPRECATED_MSG("Use Dune::conditional::type instead");
  } DUNE_DEPRECATED;
 
  template<class T1, class T2>
  struct SelectType<false,T1,T2>
  {
    typedef T2 Type DUNE_DEPRECATED_MSG("Use Dune::conditional::type instead");
  };
 
#if DOXYGEN || !HAVE_STD_CONDITIONAL
 
  template<bool first, class T1, class T2>
  struct conditional
  {
    typedef T1 type;
  };
 
  template<class T1, class T2>
  struct conditional<false,T1,T2>
  {
    typedef T2 type;
  };
 
#else // DOXYGEN || !HAVE_STD_CONDITIONAL
 
  // pull in default implementation
  using std::conditional;
 
#endif // DOXYGEN || !HAVE_STD_CONDITIONAL
 
  //
  // integral_constant (C++0x 20.7.3 "Helper classes")
  //
#if HAVE_INTEGRAL_CONSTANT
  using std::integral_constant;
  using std::true_type;
  using std::false_type;
#else // #if HAVE_INTEGRAL_CONSTANT
 
  template <class T, T v>
  struct integral_constant {
    static const T value = v;
    typedef T value_type;
    typedef integral_constant<T,v> type;
    operator value_type() { return value; }
  };
 
  typedef integral_constant<bool, true> true_type;
  typedef integral_constant<bool, false> false_type;
#endif // #else // #if HAVE_INTEGRAL_CONSTANT
 
  template<typename>
  struct __is_pointer_helper
  : public false_type { };
 
  template<typename T>
  struct __is_pointer_helper<T*>
  : public true_type { };
 
  template<typename T>
  struct is_pointer
  : public integral_constant<bool, (__is_pointer_helper<T>::value)>
    { };
 
  // Helper class for is_lvalue_reference
  template<typename>
  struct __is_lvalue_reference_helper
  : public false_type { };
 
  template<typename T>
  struct __is_lvalue_reference_helper<T&>
  : public true_type { };
 
  template<typename T>
  struct is_lvalue_reference
  : public integral_constant<bool, (__is_lvalue_reference_helper<T>::value)>
    { };
 
  template<typename _Tp>
    struct __remove_pointer_helper
    { typedef _Tp     type; };
 
  template<typename _Tp>
    struct __remove_pointer_helper<_Tp*>
    { typedef _Tp     type; };
 
  template<typename _Tp>
    struct remove_pointer
    : public __remove_pointer_helper<typename remove_const<_Tp>::type >
    { };
 
}
#endif