value-type-binding.hpp

Go to the documentation of this file.

/*
  VALUE-TYPE-BINDING.hpp  -  control type variations for custom containers
 
   Copyright (C)
     2010,2024        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_VALUE_TYPE_BINDING_H
#define LIB_META_VALUE_TYPE_BINDING_H
 
 
#include "lib/error.hpp"
#include "lib/meta/trait.hpp"
 
 
 
 
namespace lib {
namespace meta {
  
  namespace { // Helper trait to detect nested value_type binding definitions
    
    template<typename TY>
    class has_nested_ValueTypeBindings
      {
        template<typename X, typename XX = typename X::value_type
                           , typename XY = typename X::reference
                           , typename XZ = typename X::pointer
                >
        struct Probe
          { };
        
        template<class X>
        static Yes_t check(Probe<X> * );
        template<class>
        static No_t  check(...);
        
      public:
        static const bool value = (sizeof(Yes_t)==sizeof(check<TY>(0)));
      };
    
    template<class X>
    struct use_ValueTypebindings
      : __and_<has_nested_ValueTypeBindings< remove_reference_t<X> >
              ,__not_<is_StringLike< remove_reference_t<X> >
                     >
              >
      { };
  }
  
  
  template<typename TY, typename SEL =void>
  struct ValueTypeBinding
    {
      using value_type = RefTraits<TY>::Value;
      using reference  = RefTraits<TY>::Reference;
      using pointer    = RefTraits<TY>::Pointer;
    };
  
  template<typename TY>
  struct ValueTypeBinding<TY,      enable_if<use_ValueTypebindings<TY>> >
    {
      using _SrcType   = RefTraits<TY>::Value;
      
      using value_type = _SrcType::value_type;
      using reference  = _SrcType::reference;
      using pointer    = _SrcType::pointer;
    };
  
  
  
  
  template<typename T1, typename T2,  bool = has_TypeResult<std::common_type<T1,T2>>()>
  struct CommonResultYield
    : std::false_type
    { };
  
  template<typename T1, typename T2>
  struct CommonResultYield<T1, T2, true >
    : std::true_type
    {
      using _Common = std::common_type_t<T1,T2>;
      // NOTE: unfortunately std::common_type decays (strips cv and reference)
      static constexpr bool isConst = isConst_v<T1> or isConst_v<T2>;
      static constexpr bool isRef   = isLRef_v<T1> and isLRef_v<T2>;
      
      using _ConstT = std::conditional_t<isConst
                                        , const _Common
                                        ,       _Common
                                        >;
      using _ValRef = std::conditional_t<isRef
                                        , std::add_lvalue_reference_t<_ConstT>
                                        , std::remove_reference_t<_ConstT>
                                        >;
      
      using ResType    = _ValRef;
      using value_type = RefTraits<ResType>::Value;
      using reference  = RefTraits<ResType>::Reference;
      using pointer    = RefTraits<ResType>::Pointer;
    };
  
  
  
}} // namespace lib::meta
#endif /*LIB_META_VALUE_TYPE_BINDING_H*/