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)         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_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*/