tuple-record-init.hpp

Go to the documentation of this file.

/*
  TUPLE-RECORD-INIT.hpp  -  adapter to construct tuple components from GenNode entries
 
   Copyright (C)
     2016,            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_TUPLE_RECORD_INIT_H
#define LIB_META_TUPLE_RECORD_INIT_H
 
#include "lib/meta/tuple-helper.hpp"
#include "lib/meta/typelist-manip.hpp"
#include "lib/meta/typeseq-util.hpp"
#include "lib/meta/generator.hpp"
#include "lib/diff/gen-node.hpp"
#include "lib/meta/trait.hpp"
 
 
// GCC > 13 warns at class definition when a new overload shadows an inherited virtual function.
// While theoretically correct, in practice any call will be dispatched through the base interface,
// which in turn is also generated by metaprogramming from a type list.
// See https://gcc.gnu.org/bugzilla/show_bug.cgi?id=109740
_Pragma("GCC diagnostic push") \
_Pragma("GCC diagnostic ignored \"-Woverloaded-virtual\"")
 
 
namespace lib {
namespace meta {
  namespace error = lumiera::error;
  
  namespace { // implementation details...
    
    using lib::Variant;
    using lib::diff::Rec;
    using lib::diff::GenNode;
    using lib::diff::DataValues;
    
    
    using DataCapPredicate = Variant<DataValues>::Predicate;
    
    
    template<typename TAR>
    struct GenNodeAccessor
      : util::NonCopyable
      {
        
        template<typename TY>
        struct allow_Conversion
          : __and_<is_constructible<TAR, TY const&>
                  ,__not_<is_narrowingInit<typename Strip<TY>::TypePlain
                                          ,typename Strip<TAR>::TypePlain>>
                  >
          { };
        
        using SupportedSourceTypes = Filter<DataValues::List, allow_Conversion>::List;
        
        
        
        struct ConverterBase
          : DataCapPredicate
          {
            char buffer[sizeof(TAR)];
          };
        
        template<typename TY, class BA>
        class Converter
          : public BA
          {
            virtual bool
            handle(TY const& srcElm)
              {
                new(&(BA::buffer)) TAR{srcElm};
                return true;
              };
          };
        
        
        using ConversionBuffer = InstantiateChained< SupportedSourceTypes  // for each of those types...
                                                   , Converter            //  instantiate the Converter template
                                                   , ConverterBase       //   and use this as common base class.
                                                   >;                   //    RESULT: for each type we get a handle(TY)
        
        ConversionBuffer converter_;
        
        TAR&
        accessTargetElement()
          {
            return *reinterpret_cast<TAR*> (&converter_.buffer);
          }
        
        
      public:
        GenNodeAccessor (GenNode const& node)
          : converter_()
          {
            if (not node.data.accept (converter_))
                throw error::Invalid ("Unable to build «" + util::typeStr<TAR>()
                                     +"» element from " + string(node)
                                     ,error::LUMIERA_ERROR_WRONG_TYPE);
          }
        
       ~GenNodeAccessor()
          {
            accessTargetElement().~TAR();
          }
        
        
        operator TAR ()
          {
            return accessTargetElement();
          }
      };
    
  }//(End)implementation details
  
  
  
  
  template<typename...TYPES>
  struct ElementExtractor<lib::diff::Rec, std::tuple<TYPES...>>
    {
      template<size_t i>
      using TargetType = Pick<Types<TYPES...>, i>::Type;
      
      
      template<size_t i>
      struct Access
        {
          Rec const& values;
          
          operator TargetType<i> ()
            {
              using util::toString;
              
              if (values.childSize() <= i)
                throw error::Logic ("Attempt to init the " + toString(sizeof...(TYPES))
                                   +" element " + util::typeStr<std::tuple<TYPES...>>()
                                   +" from an Rec<GenNode> with only " + toString(values.childSize())
                                   +" child elements: " + toString(values)
                                   ,error::LUMIERA_ERROR_WRONG_TYPE);
              
              return GenNodeAccessor<TargetType<i>> (values.child(i));
            }
        };
    };
  
  
  
}} // namespace lib::meta
#endif /*LIB_META_TUPLE_RECORD_INIT_H*/