tree-mutator.hpp

Go to the documentation of this file.

/*
  TREE-MUTATOR.hpp  -  flexible binding to map generic tree changing operations

  Copyright (C)         Lumiera.org
    2015,               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_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*/