tree-mutator-attribute-binding.hpp

Go to the documentation of this file.

/*
  TREE-MUTATOR-ATTRIBUTE-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_ATTRIBUTE_BINDING_H
#define LIB_DIFF_TREE_MUTATOR_ATTRIBUTE_BINDING_H


#include "lib/error.hpp"
#include "lib/symbol.hpp"
#include "lib/diff/gen-node.hpp"
#include "lib/diff/tree-mutator.hpp"
#include "lib/format-string.hpp"
#include "lib/idi/entry-id.hpp"

#include <utility>


namespace lib {
namespace diff{

  namespace { // Mutator-Builder decorator components...
    
    
    template<class PAR>
    class AttributeBindingBase
      : public PAR
      {
        
        BareEntryID attribID_;
        
      protected:
        AttributeBindingBase (BareEntryID attribID, PAR&& chain)
          : PAR(std::forward<PAR>(chain))
          , attribID_(attribID)
          { }
        
        bool
        isApplicable (GenNode const& spec)
          {
            return spec.isNamed()
               and attribID_ == spec.idi;
          }
        
        void
        __ifApplicable_refuse_to(Literal oper, GenNode const& spec)
          {
            if (this->isApplicable(spec))
              throw error::Logic (_Fmt{"attempt to %s attribute '%s', "
                                       "but this binding for '%s' is linked to a data field and "
                                       "thus does not support any notion of 'order' or 'position', "
                                       "inserting or deletion."}
                                      % oper % spec.idi % this->attribID_);
          }
        
        
        /* ==== re-Implementation of the operation API ==== */
      public:
        virtual bool
        matchSrc (GenNode const& spec)  override
          {
            return isApplicable (spec)
                or PAR::matchSrc (spec);
          }
        
        
        // note: hasSrc() not overridden here --> delegate to parent layer
        
        
        virtual bool
        acceptSrc (GenNode const& spec)  override
          {
            return isApplicable (spec)
                or PAR::acceptSrc (spec);
          }
        
        virtual void
        skipSrc (GenNode const& refSpec)  override
          {
            __ifApplicable_refuse_to ("skip or drop", refSpec);
            PAR::skipSrc (refSpec);
          }
        
        virtual bool
        findSrc (GenNode const& refSpec)  override
          {
            __ifApplicable_refuse_to ("re-order", refSpec);
            return PAR::findSrc (refSpec);
          }
        
        virtual bool
        accept_until (GenNode const& spec)  override
          {
            if (Ref::END == spec or Ref::ATTRIBS == spec)
              return PAR::accept_until(spec);
            else
              {
                __ifApplicable_refuse_to ("navigate to a position behind", spec);
                return PAR::accept_until(spec);
              }
          }
      };
    
    
    
    
    template<class PAR, class CLO>
    class ChangeOperation
      : public AttributeBindingBase<PAR>
      {
        using CloArgs = typename lib::meta::_Fun<CLO>::Args;
        using ValueType = typename lib::meta::Pick<CloArgs, 0>::Type;
        using ID = idi::EntryID<ValueType>;
        
        
        CLO setter_;
        
      public:
        ChangeOperation (Symbol attribKey, CLO clo, PAR&& chain)
          : AttributeBindingBase<PAR>(ID{attribKey}, std::forward<PAR>(chain))
          , setter_(clo)
          { }
        
        
        /* ==== Implementation of value assignment operation ==== */
        
        virtual bool
        injectNew (GenNode const& spec)  override
          {
            if (not this->isApplicable(spec))
              return PAR::injectNew(spec);
            
            setter_(spec.data.get<ValueType>());
            return true;
          }
        
        virtual bool
        assignElm (GenNode const& spec)  override
          {
            if (not this->isApplicable(spec))
              return PAR::assignElm(spec);
            
            setter_(spec.data.get<ValueType>());
            return true;
          }
      };
    
    
    
    template<class PAR, class MUT>
    class MutationOperation
      : public AttributeBindingBase<PAR>
      {
        
        ASSERT_VALID_SIGNATURE (MUT, void(TreeMutator::Handle));

        MUT mutatorBuilder_;
        
        
      public:
        MutationOperation (BareEntryID const& attribID, MUT clo, PAR&& chain)
          : AttributeBindingBase<PAR>(attribID, std::forward<PAR>(chain))
          , mutatorBuilder_(clo)
          { }
        
        
        virtual bool
        mutateChild (GenNode const& spec, TreeMutator::Handle targetBuff)  override
          {
            if (not this->isApplicable(spec))
              return PAR::mutateChild(spec, targetBuff);
            
            mutatorBuilder_(targetBuff);
            return true;
          }
        
        
        virtual bool
        injectNew (GenNode const& spec)  override
          {
            return this->isApplicable(spec)
                or PAR::injectNew(spec);
          }
      };
    
    
    
    template<class PAR>
    template<typename CLO>
    inline auto
    Builder<PAR>::change (Symbol attributeID, CLO setterClosure)
    {
      return chainedBuilder<ChangeOperation<PAR,CLO>> (attributeID, setterClosure);
    }
    
    
    template<class PAR>
    template<typename CLO>
    inline auto
    Builder<PAR>::mutateAttrib (Symbol attributeID, CLO mutatorBuilderClosure)
    {
      idi::EntryID<Rec> key{attributeID};
      return chainedBuilder<MutationOperation<PAR,CLO>> (key, mutatorBuilderClosure);
    }
    
    template<class PAR>
    template<typename CLO>
    inline auto
    Builder<PAR>::mutateAttrib (idi::BareEntryID const& rawID, CLO mutatorBuilderClosure)
    {
      return chainedBuilder<MutationOperation<PAR,CLO>> (rawID, mutatorBuilderClosure);
    }
    
    
    
  }//(END)Mutator-Builder decorator components...
  
}} // namespace lib::diff
#endif /*LIB_DIFF_TREE_MUTATOR_ATTRIBUTE_BINDING_H*/