tree-mutator.hpp

Go to the documentation of this file.

/*
  TREE-MUTATOR.hpp  -  flexible binding to map generic tree changing operations
 
   Copyright (C)
     2015,            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_H
#define LIB_DIFF_TREE_MUTATOR_H
 
 
#include "lib/error.hpp"
#include "lib/nocopy.hpp"
#include "lib/symbol.hpp"
#include "lib/meta/trait.hpp"
#include "lib/diff/gen-node.hpp"
#include "lib/opaque-holder.hpp"
#include "lib/iter-adapter-stl.hpp"
#include "lib/format-string.hpp"
#include "lib/idi/entry-id.hpp"
 
#include <utility>
#include <string>
 
 
namespace lib {
namespace diff{
  
  namespace error = lumiera::error;
  
  using lib::Symbol;
  using std::string;
  using util::_Fmt;
  using lib::idi::BareEntryID;
  
  
  
  
  class TestMutationTarget; // for unit testing
  
  
  namespace {
    template<class PAR>
    struct Builder;
  }
  
  
  class TreeMutator
    : util::MoveOnly
    {
      
    public:
      virtual ~TreeMutator(); 
      
      // only default and move construction allowed
      TreeMutator ()                    =default;
      TreeMutator (TreeMutator&&)       =default;
      
      
      
      /* ==== operation API ==== */
      
      virtual void
      init() { }
      
      virtual bool
      hasSrc () 
        {
          return false;
          // do nothing by default
        }
      
      virtual bool
      injectNew (GenNode const&)
        {
          // do nothing by default
          return false;
        }
      
      virtual bool
      matchSrc (GenNode const&)
        {
          // do nothing by default
          return false;
        }
      
      virtual void
      skipSrc (GenNode const&)
        {
          // do nothing by default
        }
      
      virtual bool
      acceptSrc (GenNode const&)
        {
          // do nothing by default
          return false;
        }
      
      virtual bool
      accept_until (GenNode const& spec)
        {
          return (Ref::END == spec or Ref::ATTRIBS == spec);
              // contents are exhausted by default,
             //  yet we're unable to find something specific
        }
      
      virtual bool
      findSrc (GenNode const&)
        {
          // do nothing by default
          return false;
        }
      
      virtual bool
      assignElm (GenNode const&)
        {
          // do nothing by default
          return false;
        }
      
      
      using Handle = PlantingHandle<TreeMutator>;
      
      virtual bool
      mutateChild (GenNode const&, Handle)
        {
          // do nothing by default
          return false;
        }
      
      virtual bool
      completeScope()
        {
          // nothing to clean-up or verify by default
          return true;
        }
      
      
      
      static Builder<TreeMutator> build();
    };
  
  
  
  
  
  namespace { // Mutator-Builder decorator components...
    
    using std::forward;
    using std::move;
    
    
    template<class PAR>
    struct Builder
      : PAR
      {
        explicit
        Builder(PAR&& par)
          : PAR{forward<PAR> (par)}
          { }
        
        template<typename BIN, typename...ARGS>
        Builder<BIN>
        chainedBuilder (ARGS&&...args)
          {
            return Builder<BIN> (BIN{forward<ARGS>(args)..., move(*this)});
          }
        
        
        
        /* ==== binding API ==== */
        
        template<typename CLO>
        auto change (Symbol attributeID, CLO setterClosure);
        
        
        template<typename CLO>
        auto mutateAttrib (Symbol attributeID, CLO mutatorBuilderClosure);
        
        template<typename CLO>
        auto mutateAttrib (idi::BareEntryID const& rawID, CLO mutatorBuilderClosure);
        
        
        template<typename BIN>
        auto attach (BIN&& collectionBindingSetup);
        
        
        auto attach (Rec::Mutator& targetTree);
        
        
        auto attachDummy (TestMutationTarget& dummy);
        
        
        auto ignoreAllChanges();
        
        
        template<typename LIS>
        auto onSeqChange (LIS changeListener);
        
        template<typename LIS>
        auto onLocalChange (LIS changeListener);
      };
    
  }//(END) Mutator-Builder...
  
  
  inline Builder<TreeMutator>
  TreeMutator::build ()
  {
    return Builder<TreeMutator>{TreeMutator()};
  }
  
  
}} // namespace lib::diff
 
 
         /* == implementation detail headers == */
 
#include "lib/diff/tree-mutator-gen-node-binding.hpp"
#include "lib/diff/tree-mutator-attribute-binding.hpp"
#include "lib/diff/tree-mutator-collection-binding.hpp"
#include "lib/diff/tree-mutator-listener-binding.hpp"
#include "lib/diff/tree-mutator-noop-binding.hpp"
 
 
 
#endif /*LIB_DIFF_TREE_MUTATOR_H*/