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