tree-mutator-attribute-binding.hpp

Go to the documentation of this file.

/*
  TREE-MUTATOR-ATTRIBUTE-BINDING.hpp  -  diff::TreeMutator implementation building block
 
   Copyright (C)
     2016,            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_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/meta/typeseq-util.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   = lib::meta::_Fun<CLO>::Args;
        using ValueType = 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*/