tree-mutator-gen-node-binding.hpp

Go to the documentation of this file.

/*
  TREE-MUTATOR-GEN-NODE-BINDING.hpp  -  diff::TreeMutator implementation building block
 
   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_DIFF_TREE_MUTATOR_GEN_NODE_BINDING_H
#define LIB_DIFF_TREE_MUTATOR_GEN_NODE_BINDING_H
 
 
#include "lib/diff/gen-node.hpp"
#include "lib/diff/tree-mutator.hpp"
#include "lib/diff/tree-mutator-collection-binding.hpp"
 
#include <tuple>
 
 
namespace lib {
namespace diff{
 
  namespace { // Mutator-Builder decorator components...
    
    template<class PAR>
    class ObjectTypeHandler
      : public PAR
      {
        Rec::Mutator& targetObj_;
        
      public:
        ObjectTypeHandler(Rec::Mutator& targetObj, PAR&& chain)
          : PAR(std::forward<PAR>(chain))
          , targetObj_(targetObj)
          { }
        
        virtual bool
        injectNew (GenNode const& spec)  override
          {
            if (spec.isNamed() and spec.isTypeID())
              {
                targetObj_.setType(spec.data.get<string>());
                return true;
              }
            else
              return PAR::injectNew (spec);
          }
        
        virtual bool
        assignElm (GenNode const& spec)  override
          {
            if (spec.isNamed() and spec.isTypeID())
              {
                targetObj_.setType(spec.data.get<string>());
                return true;
              }
            else
              return PAR::assignElm (spec);
          }
      };
    
    template<class MUT>
    inline Builder<ObjectTypeHandler<MUT>>
    filterObjectTypeAttribute (Rec::Mutator& targetTree, Builder<MUT>&& chain)
    {
      using ObTyHa = ObjectTypeHandler<MUT>;
      return Builder<ObTyHa>{ObTyHa {targetTree, move(chain)}};
    }
    
    
    
    using Storage = RecordSetup<GenNode>::Storage;
    
    inline Storage&
    accessAttribs (Rec::Mutator& targetTree)
    {
      return std::get<0> (targetTree.exposeToDiff());
    }
    
    inline Storage&
    accessChildren (Rec::Mutator& targetTree)
    {
      return std::get<1> (targetTree.exposeToDiff());
    }
    
    
    template<class PAR>
    inline auto
    Builder<PAR>::attach (Rec::Mutator& targetTree)
    {
      auto rawBinding = this->attach (collection (accessChildren(targetTree)))
                             .attach (collection (accessAttribs(targetTree))
                                     .isApplicableIf ([](GenNode const& spec) -> bool
                                        {     // »Selector« : treat key-value elements here
                                          return spec.isNamed();
                                        }));
      
      return filterObjectTypeAttribute(targetTree, move(rawBinding));
    }
    
  }//(END)Mutator-Builder decorator components...
  
  
}} // namespace lib::diff
#endif /*LIB_DIFF_TREE_MUTATOR_GEN_NODE_BINDING_H*/