trait.hpp

Go to the documentation of this file.

/*
  TRAIT.hpp  -  type handling and type detection helpers
 
   Copyright (C)
     2009,            Hermann Vosseler <Ichthyostega@web.de>
 
 **Lumiera** is free software; you can redistribute it and/or modify it
 under the terms of the GNU General Public License as published by the
 Free Software Foundation; either version 2 of the License, or (at your
 option) any later version. See the file COPYING for further details.
 
*/
 
 
#ifndef LIB_META_TRAIT_H
#define LIB_META_TRAIT_H
 
 
#include "lib/meta/util.hpp"
#include "lib/meta/duck-detector.hpp"
 
#include <type_traits>
 
 
//Forward declarations for the Unwrap helper....
namespace boost{
  template<class X> class reference_wrapper;
}
namespace std {
  template<class X> class reference_wrapper;
  template<class X> class shared_ptr;
  template<class X, class D> class unique_ptr;
  template<class C, class T> class basic_filebuf;
  template<class C> class char_traits;
}
namespace lib{
  template<class X, class B>  class P;
  
  namespace hash {
    class LuidH;
  }
  namespace time {
    class TimeValue;
    class Duration;
}}
namespace steam {
namespace mobject{
  template<class X, class B>  class Placement;
}}
 
 
namespace lib {
namespace meta {
  
  using std::remove_cv_t;
  using std::remove_pointer_t;
  using std::remove_reference_t;
  using std::conditional_t;
  using std::is_reference_v;
  using std::is_lvalue_reference_v;
  using std::is_rvalue_reference_v;
  using std::is_pointer;
  using std::is_base_of;
  using std::is_convertible;
  using std::is_constructible;
  using std::is_floating_point;
  using std::is_arithmetic;
  using std::is_unsigned;
  using std::is_signed;
  using std::is_class;
  using std::is_same;
  using std::__not_;
  using std::__and_;
  using std::__or_;
  
  template<typename T>
  static constexpr bool isConst_v = std::is_const_v<remove_reference_t<T>>;
  template<typename T>
  static constexpr bool isLRef_v = std::is_lvalue_reference_v<T>;
  template<typename T>
  static constexpr bool isRRef_v = std::is_rvalue_reference_v<T>;
  template<typename T>
  static constexpr bool isRef_v = std::is_reference_v<T>;
  
  
  template<typename X>
  struct Unwrap
    : std::false_type
    {
      using Type = X;
      
      static  X&
      extract (X const& x)
        {
          return const_cast<X&> (x);
        }
    };
  
  template<>
  struct Unwrap<void>   
    : std::false_type
    {
      using Type = void;
    };
  
  template<typename X>
  struct Unwrap<X*>
    : std::true_type
    {
      using Type = remove_cv_t<X>;
      
      static Type&
      extract (const X* ptr)
        {
          ASSERT (ptr);
          return const_cast<Type&> (*ptr);
        }
    };
  
  template<typename X>
  struct Unwrap<boost::reference_wrapper<X>>
    : std::true_type
    {
      using Type = X;
      
      static X&
      extract (boost::reference_wrapper<X> wrapped)
        {
          return wrapped;
        }
    };
  
  template<typename X>
  struct Unwrap<std::reference_wrapper<X>>
    : std::true_type
    {
      using Type = X;
      
      static X&
      extract (std::reference_wrapper<X> wrapped)
        {
          return wrapped;
        }
    };
  
  template<typename X, class D>
  struct Unwrap<std::unique_ptr<X,D>>
    : std::true_type
    {
      using Type = X;
      
      static X&
      extract (std::unique_ptr<X,D> const& ptr)
        {
          ASSERT (ptr);
          return *ptr;
        }
    };
  
  template<typename X>
  struct Unwrap<std::shared_ptr<X>>
    : std::true_type
    {
      using Type = X;
      
      static X&
      extract (std::shared_ptr<X> const& ptr)
        {
          ASSERT (ptr);
          return *ptr;
        }
    };
  
  template<typename X, class B>
  struct Unwrap<P<X, B>>
    : std::true_type
    {
      using Type = X;
      
      static X&
      extract (P<X,B> ptr)
        {
          ASSERT (ptr);
          return *ptr;
        }
    };
  
  
  template<typename X>
  Unwrap<X>::Type&
  unwrap (X const& wrapped)
  {
    return Unwrap<X>::extract(wrapped);
  }
  
  
  
  
  template<typename X>
  struct Strip
    {
      using TypeUnconst  = conditional_t<is_reference_v<X>
                                        ,  conditional_t<is_rvalue_reference_v<X>
                                                        ,  remove_cv_t<remove_reference_t<X>> &&
                                                        ,  remove_cv_t<remove_reference_t<X>> & >
                                        ,  remove_cv_t<X>>;
      using TypeReferred = remove_reference_t<TypeUnconst>;
      using TypePointee  = remove_pointer_t<TypeReferred>;
      using TypePlain    = remove_cv_t<TypePointee>;
      
      using Type         = Unwrap<TypePlain>::Type;
    };
  
  
  
  
  template<typename TY>
  struct RefTraits
    {
      typedef TY  Value;
      typedef TY* Pointer;
      typedef TY& Reference;
    };
  
  template<typename TY>
  struct RefTraits<TY *>
    {
      typedef TY*  Value;
      typedef TY** Pointer;
      typedef TY*& Reference;
    };
  
  template<typename TY>
  struct RefTraits<TY &>
    {
      typedef TY  Value;
      typedef TY* Pointer;
      typedef TY& Reference;
    };
  
  template<typename TY>
  struct RefTraits<TY &&>
    {
      typedef TY  Value;
      typedef TY* Pointer;
      typedef TY& Reference;
    };
  
  
  
  
  
  
  
  /* ==== Traits ==== */
  
  template<typename T, typename U>
  struct is_basicallySame
    : is_same <typename Strip<T>::TypeReferred
              ,typename Strip<U>::TypeReferred>
    { };
  
  template<typename S, typename I>
  struct is_Subclass
    : __or_< __and_< is_class<I>
                   , is_class<S>
                   , is_base_of<I,S>
                   >
           , is_same<I,S>
           >
    { };
    
  template<typename S, typename I>
  struct is_basically
    : is_Subclass <typename Strip<S>::TypeReferred
                  ,typename Strip<I>::TypeReferred>
    { };
  
  template<typename S, typename G>
  struct can_StandIn
    : std::is_convertible<typename RefTraits<S>::Reference
                         ,typename RefTraits<G>::Reference
                         >
    { };
  
  template<typename X>
  struct is_StringLike
    : __or_< is_basically<X, std::string>
           , is_basically<X, std::string_view>
           , is_convertible<X, const char*>
           >
    { };
  
  template<typename X>
  struct can_lexical2string
    : __or_< is_arithmetic<X>
           , is_StringLike<X>
           >
    { };
  
  template<typename X>
  struct use_LexicalConversion
    : __and_<can_lexical2string<X>
            ,__not_<can_convertToString<X>>
            >
    { };
  
  // need to exclude files and input streams from automatic string conversion
  template<typename X>
  struct is_StreamSource
    : is_same<X, std::basic_filebuf<char, std::char_traits<char> > >
    { };
  
  template<typename X>
  struct use_StringConversion4Stream
    : __and_<is_class<typename Strip<X>::TypePlain>
            ,__not_<is_pointer<X>>
            ,__not_<can_lexical2string<X>>
            ,__not_<is_StreamSource<X>>
            >
    { };
  
  
  template<typename X>
  struct is_smart_ptr
    : std::false_type
    { };
  
  template<typename T>
  struct is_smart_ptr<std::shared_ptr<T>>
    : std::true_type
    { };
  
  template <typename T, typename D>
  struct is_smart_ptr<std::unique_ptr<T,D>>
    : std::true_type
    { };
  
  
  
  
  
  
  template<typename NUM>
  struct is_nonFloat
    : __and_<is_arithmetic<NUM>
            ,__not_<is_floating_point<NUM>>
            >
    { };
  
  template<typename SRC, typename TAR>
  struct is_narrowingInit
    : __or_<__and_<is_unsigned<SRC>, is_signed<TAR>>
           ,__and_<is_signed<SRC>, is_unsigned<TAR>>
           ,__and_<is_nonFloat<SRC>, is_floating_point<TAR>>
           ,__and_<is_floating_point<SRC>, is_nonFloat<TAR>>
           ,__not_<is_constructible<TAR, SRC>>
           >
    { };
  
  template<typename TAR>
  struct is_narrowingInit<lib::hash::LuidH, TAR>
    : __or_<is_arithmetic<TAR>
           ,is_floating_point<TAR>
           >
    { };
  
#define TRAIT_IS_NARROWING(_SRC_, _TAR_) \
  template<>                              \
  struct is_narrowingInit<_SRC_, _TAR_>    \
    : std::true_type                        \
    { };
  
  TRAIT_IS_NARROWING (int64_t, int32_t)
  TRAIT_IS_NARROWING (int64_t, int16_t)
  TRAIT_IS_NARROWING (int64_t, int8_t)
  TRAIT_IS_NARROWING (int64_t, char)
  TRAIT_IS_NARROWING (int32_t, int16_t)
  TRAIT_IS_NARROWING (int32_t, int8_t)
  TRAIT_IS_NARROWING (int32_t, char)
  TRAIT_IS_NARROWING (int16_t, int8_t)
  TRAIT_IS_NARROWING (int16_t, short)
  TRAIT_IS_NARROWING (int16_t, char)
  
  TRAIT_IS_NARROWING (uint64_t, uint32_t)
  TRAIT_IS_NARROWING (uint64_t, uint16_t)
  TRAIT_IS_NARROWING (uint64_t, uint8_t)
  TRAIT_IS_NARROWING (uint32_t, uint16_t)
  TRAIT_IS_NARROWING (uint32_t, uint8_t)
  TRAIT_IS_NARROWING (uint16_t, uint8_t)
  TRAIT_IS_NARROWING (uint16_t, ushort)
  
  TRAIT_IS_NARROWING (double, float)
  
  TRAIT_IS_NARROWING (double, lib::time::TimeValue)
  TRAIT_IS_NARROWING (double, lib::time::Duration)
  
#undef TRAIT_IS_NARROWING
  
  
  
  
  
  
  /* ====== generic iteration support ====== */
  
  template<typename T>
  class can_IterForEach
    {
      using  Type = Strip<T>::Type;
       
      META_DETECT_NESTED(value_type);
      META_DETECT_OPERATOR_DEREF();
      META_DETECT_OPERATOR_INC();
      
    public:
      enum{ value = std::is_constructible<bool, Type>::value
                and HasNested_value_type<Type>::value
                and HasOperator_deref<Type>::value
                and HasOperator_inc<Type>::value
          };
    };
  
  
  
  template<typename T>
  class is_StateCore
    {
      using  Type = Strip<T>::Type;
     
      META_DETECT_FUNCTION_ARGLESS(checkPoint);
      META_DETECT_FUNCTION_ARGLESS(iterNext);
      META_DETECT_FUNCTION_ARGLESS(yield);
      
    public:
      enum{ value = HasArglessFun_checkPoint<Type>::value
                and HasArglessFun_iterNext<Type>::value
                and HasArglessFun_yield<Type>::value
          };
    };
  
  
  
  template<typename T>
  class can_STL_ForEach
    {
      using Type = Strip<T>::Type;
      
      struct is_iterable
        {
          META_DETECT_NESTED(iterator);
          META_DETECT_FUNCTION(typename X::iterator, begin,(void));
          META_DETECT_FUNCTION(typename X::iterator, end  ,(void));
          
          enum { value = HasNested_iterator<Type>::value
                     and HasFunSig_begin<Type>::value
                     and HasFunSig_end<Type>::value
           };
        };
      
      struct is_noexcept_iterable
        {
          META_DETECT_NESTED(iterator);
          META_DETECT_FUNCTION(typename X::iterator, begin,(void) noexcept);
          META_DETECT_FUNCTION(typename X::iterator, end  ,(void) noexcept);
          
          enum { value = HasNested_iterator<Type>::value
                     and HasFunSig_begin<Type>::value
                     and HasFunSig_end<Type>::value
           };
        };
      
      struct is_const_iterable
        {
          META_DETECT_NESTED(const_iterator);
          META_DETECT_FUNCTION(typename X::const_iterator, begin,(void) const);
          META_DETECT_FUNCTION(typename X::const_iterator, end  ,(void) const);
          
          enum { value = HasNested_const_iterator<Type>::value
                     and HasFunSig_begin<Type>::value
                     and HasFunSig_end<Type>::value
           };
        };
      
      struct is_const_noexcept_iterable
        {
          META_DETECT_NESTED(const_iterator);
          META_DETECT_FUNCTION(typename X::const_iterator, begin,(void) const noexcept);
          META_DETECT_FUNCTION(typename X::const_iterator, end  ,(void) const noexcept);
          
          enum { value = HasNested_const_iterator<Type>::value
                     and HasFunSig_begin<Type>::value
                     and HasFunSig_end<Type>::value
           };
        };
      
      
    public:
      enum { value = is_iterable::value
                  or is_const_iterable::value
                  or is_noexcept_iterable::value
                  or is_const_noexcept_iterable::value
           };
    };
  
  
  template<typename T>
  class can_STL_backIteration
    {
      using Type = Strip<T>::Type;
      
      struct is_backIterable
        {
          META_DETECT_NESTED(reverse_iterator);
          META_DETECT_FUNCTION(typename X::reverse_iterator, rbegin,(void));
          META_DETECT_FUNCTION(typename X::reverse_iterator, rend  ,(void));
          
          enum { value = HasNested_reverse_iterator<Type>::value
                     and HasFunSig_rbegin<Type>::value
                     and HasFunSig_rend<Type>::value
           };
        };
      
      struct is_noexcept_backIterable
        {
          META_DETECT_NESTED(reverse_iterator);
          META_DETECT_FUNCTION(typename X::reverse_iterator, rbegin,(void) noexcept);
          META_DETECT_FUNCTION(typename X::reverse_iterator, rend  ,(void) noexcept);
          
          enum { value = HasNested_reverse_iterator<Type>::value
                     and HasFunSig_rbegin<Type>::value
                     and HasFunSig_rend<Type>::value
           };
        };
      
      struct is_const_backIterable
        {
          META_DETECT_NESTED(const_reverse_iterator);
          META_DETECT_FUNCTION(typename X::const_reverse_iterator, rbegin,(void) const);
          META_DETECT_FUNCTION(typename X::const_reverse_iterator, rend  ,(void) const);
          
          enum { value = HasNested_const_reverse_iterator<Type>::value
                     and HasFunSig_rbegin<Type>::value
                     and HasFunSig_rend<Type>::value
           };
        };
      
      struct is_const_noexcept_backIterable
        {
          META_DETECT_NESTED(const_reverse_iterator);
          META_DETECT_FUNCTION(typename X::const_reverse_iterator, rbegin,(void) const noexcept);
          META_DETECT_FUNCTION(typename X::const_reverse_iterator, rend  ,(void) const noexcept);
          
          enum { value = HasNested_const_reverse_iterator<Type>::value
                     and HasFunSig_rbegin<Type>::value
                     and HasFunSig_rend<Type>::value
           };
        };
      
      
    public:
      enum { value = is_backIterable::value
                  or is_const_backIterable::value
                  or is_noexcept_backIterable::value
                  or is_const_noexcept_backIterable::value
           };
    };
  
  
  
}} // namespace lib::meta
#endif