tree-mutator-listener-binding.hpp

Go to the documentation of this file.

/*
  TREE-MUTATOR-LISTENER-BINDING.hpp  -  decorator for TreeMutator to attach change listeners

  Copyright (C)         Lumiera.org
    2019,               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_LISTENER_BINDING_H
#define LIB_DIFF_TREE_MUTATOR_LISTENER_BINDING_H


#include "lib/error.hpp"
#include "lib/diff/gen-node.hpp"
#include "lib/diff/tree-mutator.hpp"

namespace lib {
namespace diff{

  namespace { // Mutator-Builder decorator components...
    
    
    template<class PAR, typename LIS, bool assign =false>
    class Detector4StructuralChanges
      : public PAR
      {
        LIS changeListener_;
        bool triggered_ = false;
        
        void
        trigger(bool relevant =true)
          {
            if (relevant)
              triggered_ = true;
          }
        
      public:
        Detector4StructuralChanges (LIS functor, PAR&& chain)
          : PAR(std::forward<PAR>(chain))
          , changeListener_{functor}
          { }
        
        // move construction allowed and expected to happen
        Detector4StructuralChanges (Detector4StructuralChanges&&) =default;
        
       ~Detector4StructuralChanges()
          {
            if (triggered_)
              changeListener_();
          }
        
        /* ==== TreeMutator API ==== */
        
        using Elm  = GenNode const&;
        
        bool injectNew (Elm elm) override { trigger();       return PAR::injectNew (elm); }
        bool findSrc   (Elm elm) override { trigger();       return PAR::findSrc   (elm); }
        void skipSrc   (Elm elm) override { trigger();              PAR::skipSrc   (elm); }
        bool assignElm (Elm elm) override { trigger(assign); return PAR::assignElm (elm); }
      };
    
    
    
    template<class PAR>
    template<typename LIS>
    inline auto
    Builder<PAR>::onSeqChange (LIS changeListener)
    {
      ASSERT_VALID_SIGNATURE (LIS, void(void))
      
      return chainedBuilder<Detector4StructuralChanges<PAR,LIS>> (changeListener);
    }
    
    template<class PAR>
    template<typename LIS>
    inline auto
    Builder<PAR>::onLocalChange (LIS changeListener)
    {
      ASSERT_VALID_SIGNATURE (LIS, void(void))
                                                            //  vvvv---note: including assignments
      return chainedBuilder<Detector4StructuralChanges<PAR,LIS, true>> (changeListener);
    }
    
  }//(END)Mutator-Builder decorator components...
  
}} // namespace lib::diff
#endif /*LIB_DIFF_TREE_MUTATOR_LISTENER_BINDING_H*/