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)         Lumiera.org
    2016,               Hermann Vosseler <Ichthyostega@web.de>

  This program 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.

  This program is distributed in the hope that it will be useful,
  but WITHOUT ANY WARRANTY; without even the implied warranty of
  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  GNU General Public License for more details.

  You should have received a copy of the GNU General Public License
  along with this program; if not, write to the Free Software
  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

*/


#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"



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 = typename 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 = typename 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*/