tree-mutator-diffmutable-binding.hpp

Go to the documentation of this file.

/*
  TREE-MUTATOR-DIFFMUTABLE-BINDING.hpp  -  default configuration to attach a collection of DiffMutable objects

   Copyright (C)
     2021,            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_DIFFMUTABLE_BINDING_H
#define LIB_DIFF_TREE_MUTATOR_DIFFMUTABLE_BINDING_H


#include "lib/error.hpp"
#include "lib/meta/trait.hpp"
#include "lib/diff/gen-node.hpp"
#include "lib/diff/tree-mutator.hpp"
#include "lib/diff/tree-mutator-collection-binding.hpp"
#include "lib/diff/diff-mutable.hpp"

namespace lib {
namespace diff{
  
  namespace { // Mutator-Builder decorator components...
    
    using lib::meta::enable_if;
    using lib::meta::Yes_t;
    using lib::meta::No_t;
    using std::__and_;
    using std::__or_;
    
    template<typename TY>
    class Can_retrieve_and_compare_ID
      {
        template<typename X,
                 typename SEL = decltype(std::declval<GenNode::ID>() == std::declval<X>().getID())>
        struct Probe
          { };
        
        template<class X>
        static Yes_t check(Probe<X> * );
        template<class>
        static No_t  check(...);
        
      public:
        static const bool value = (sizeof(Yes_t)==sizeof(check<TY>(0)));
      };
    
    template<typename T>
    struct Can_access_ID
      : Can_retrieve_and_compare_ID<typename meta::Strip<T>::Type>
      { };
    
    template<typename T>
    struct Is_DiffMutable          
      : meta::is_Subclass<T,DiffMutable>
      { };
    
    template<typename T>
    struct Is_wrapped_DiffMutable  
      : __and_< meta::Unwrap<T>
              , Is_DiffMutable<typename meta::Unwrap<T>::Type>>
      { };
    
    template<typename T>
    struct can_recursively_bind_DiffMutable
      : __or_< Is_DiffMutable<T>
             , Is_wrapped_DiffMutable<T>>
      { } ;
    
    
    template<class TAR, typename SEL =void>
    struct _AccessID
      {
        static idi::BareEntryID const&
        getID (TAR const&)
          {
            throw error::Logic ("TreeMutator::build() .attach(collection...) : Unable to access the target element's object ID. "
                                "Please define a »Matcher« explicitly by invoking the builder function \"matchElement\".");
          }
      };
    template<class ELM>
    struct _AccessID<ELM, enable_if<Can_access_ID<ELM>>>
      {
        static idi::BareEntryID const&
        getID (ELM const& target)
          {
            return meta::unwrap(target).getID();
          }
      };

    
    
    template<class ELM>
    struct _DefaultBinding<ELM, enable_if<can_recursively_bind_DiffMutable<ELM>>>
      {
        template<class COLL>
        static auto
        attachTo (COLL& coll)
          {
            return _EmptyBinding<ELM>::attachTo(coll)
                      .matchElement([](GenNode const& spec, ELM const& elm)
                         {
                           return spec.idi == _AccessID<ELM>::getID(elm);
                         })
                      .buildChildMutator ([&](ELM& target, GenNode::ID const&, TreeMutator::Handle buff) -> bool
                         {
                           DiffMutable& child = meta::unwrap(target);
                           child.buildMutator (buff);
                           return true;
                         });
          }
      };
    
    
    
    
    
  }//(END)Mutator-Builder decorator components...
  
}} // namespace lib::diff
#endif /*LIB_DIFF_TREE_MUTATOR_DIFFMUTABLE_BINDING_H*/