tree-mutator-collection-binding.hpp

Go to the documentation of this file.

/*
  TREE-MUTATOR-COLLECTION-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_COLLECTION_BINDING_H
#define LIB_DIFF_TREE_MUTATOR_COLLECTION_BINDING_H


#include "lib/error.hpp"
#include "lib/nocopy.hpp"
#include "lib/meta/trait.hpp"
#include "lib/diff/gen-node.hpp"
#include "lib/diff/tree-mutator.hpp"
#include "lib/iter-adapter-stl.hpp"

#include <utility>
#include <vector>
#include <map>


namespace lib {
namespace diff{

  namespace { // Mutator-Builder decorator components...
    
    
    using std::forward;
    using lib::meta::Strip;
    using lib::diff::GenNode;
    using lib::iter_stl::eachElm;
    
    
    /* === Technicalities of container access === */
    
    template<class C>
    using _AsVector = std::vector<typename C::value_type>;
    template<class C>
    using _AsMap    = std::map<typename C::key_type, typename C::mapped_type>;
    
    template<class C>
    using IF_is_vector = lib::meta::enable_if< std::is_base_of<_AsVector<C>, C>>;
    template<class C>
    using IF_is_map    = lib::meta::enable_if< std::is_base_of<_AsMap<C>, C>>;
    
    
    template<class C,  typename SEL =void>
    struct ContainerTraits
      {
        static_assert (not sizeof(C), "unable to determine any supported container type for C");
      };
    
    template<typename V>
    struct ContainerTraits<V,  IF_is_vector<V> >
      {
        using Vec = _AsVector<V>;
        using Elm = typename Vec::value_type;
        using Itr = typename Vec::iterator;
        
        static Itr
        recentElmRawIter (Vec& vec)
          {
            return Itr{&vec.back()};
          }
        
        static void
        append (Vec& vec, Elm&& elm)
          {
            vec.emplace_back (forward<Elm> (elm));
          }
      };
    
    template<typename M>
    struct ContainerTraits<M,  IF_is_map<M> >
      {
        using Map = _AsMap<M>;
        using Key = typename Map::key_type;
        using Val = typename Map::mapped_type;
        using Elm = std::pair<const Key, Val>;
        
        static auto
        recentElmRawIter (Map& map)
          {
            auto& recentPos = ++map.rend();
            return map.find (recentPos->first);
          }
        
        static void
        append (Map& map, Elm&& elm)
          {
            map.emplace (forward<Elm> (elm));
          }
      };
    
    
    
    template<class COLL, class MAT, class CTR, class SEL, class ASS, class MUT>
    struct CollectionBinding
      : util::MoveOnly
      {
        using Coll = typename Strip<COLL>::TypeReferred;
        using Elm  = typename Coll::value_type;
        using Trait = ContainerTraits<Coll>;
        
        using iterator       = typename lib::iter_stl::_SeqT<Coll>::Range;
        using const_iterator = typename lib::iter_stl::_SeqT<const Coll>::Range;
        
        
        ASSERT_VALID_SIGNATURE (MAT, bool(GenNode const& spec, Elm const& elm))
        ASSERT_VALID_SIGNATURE (CTR, Elm (GenNode const&))
        ASSERT_VALID_SIGNATURE (SEL, bool(GenNode const&))
        ASSERT_VALID_SIGNATURE (ASS, bool(Elm&, GenNode const&))
        ASSERT_VALID_SIGNATURE (MUT, bool(Elm&, GenNode::ID const&, TreeMutator::Handle))
        
        
        Coll& collection;
        
        MAT matches;
        CTR construct;
        SEL isApplicable;
        ASS assign;
        MUT openSub;
        
        CollectionBinding(Coll& coll, MAT m, CTR c, SEL s, ASS a, MUT u)
          : collection(coll)
          , matches(m)
          , construct(c)
          , isApplicable(s)
          , assign(a)
          , openSub(u)
          { }
        
        // only move construction allowed,
        // to enable use of unique_ptr in collections
        
        
        
        /* === content manipulation API === */
        
        Coll contentBuffer;
        
        iterator
        initMutation ()
          {
            contentBuffer.clear();
            swap (collection, contentBuffer);
            return eachElm (contentBuffer);
          }
        
        void
        inject (Elm&& elm)
          {
            Trait::append (collection, forward<Elm>(elm));
          }
        
        iterator
        search (GenNode const& targetSpec, iterator pos)
          {
            while (pos and not matches(targetSpec, *pos))
              ++pos;
            return pos;
          }
        
        iterator
        locate (GenNode const& targetSpec)
          {
            if (not collection.empty()
                and matches (targetSpec, recentElm()))
              return recentElmIter();
            else
              return search (targetSpec, eachElm(collection));
          }
        
        
      private: /* === Technicalities of container access === */
        
        iterator
        recentElmIter()
          {
            return iterator{Trait::recentElmRawIter (collection), std::end (collection)};
          }
        
        Elm&
        recentElm()
          {
            return *Trait::recentElmRawIter (collection);
          }
      };
    
    
    
    template<class PAR, class BIN>
    class ChildCollectionMutator
      : public PAR
      {
        using Iter = typename BIN::iterator;
        
        BIN binding_;
        Iter pos_;
        
        
      public:
        ChildCollectionMutator(BIN&& wiringClosures, PAR&& chain)
          : PAR(std::forward<PAR>(chain))
          , binding_(forward<BIN>(wiringClosures))
          , pos_()
          { }
        
        
        
        
        /* ==== Implementation of TreeNode operation API ==== */
        
        virtual void
        init()  override
          {
            pos_ = binding_.initMutation();
            PAR::init();
          }
        
        virtual bool
        injectNew (GenNode const& n)  override
          {
            if (binding_.isApplicable(n))
              {
                binding_.inject (std::move (binding_.construct(n)));
                return true;
              }
            else
              return PAR::injectNew (n);
          }
        
        virtual bool
        hasSrc ()  override
          {
            return bool(pos_) or PAR::hasSrc();
          }
        
        virtual bool
        matchSrc (GenNode const& spec)  override
          {
            if (binding_.isApplicable(spec))
              return pos_ and binding_.matches (spec, *pos_);
            else
              return PAR::matchSrc (spec);
          }
        
        virtual void
        skipSrc (GenNode const& n)  override
          {
            if (binding_.isApplicable(n))
              {
                if (pos_)
                    ++pos_;
              }
            else
              PAR::skipSrc (n);
          }
        
        virtual bool
        acceptSrc (GenNode const& n)  override
          {
            if (binding_.isApplicable(n))
              {
                bool isSrcMatch = pos_ and binding_.matches (n, *pos_);
                if (isSrcMatch)  //NOTE: crucial to perform only our own match check here
                  {
                    binding_.inject (move(*pos_));
                    ++pos_;
                  }
                return isSrcMatch;
              }
            else
              return PAR::acceptSrc (n);
          }
        
        virtual bool
        findSrc (GenNode const& refSpec)  override
          {
            if (binding_.isApplicable(refSpec))
              {
                Iter found = binding_.search (refSpec, pos_);
                if (found)
                  {
                    binding_.inject (move(*found));
                  }
                return bool(found);
              }
            else
              return PAR::findSrc (refSpec);
          }
        
        virtual bool
        accept_until (GenNode const& spec)  override
          {
            if (spec.matches (Ref::END)
               or
               (spec.matches (Ref::ATTRIBS)
                and binding_.isApplicable (Ref::ATTRIBS)))
              {
                for ( ; pos_; ++pos_)
                  binding_.inject (move(*pos_));
                return PAR::accept_until (spec);
              }
            else
              if (binding_.isApplicable(spec))
                {
                  bool foundTarget = false;
                  while (pos_ and not binding_.matches (spec, *pos_))
                    {
                      binding_.inject (move(*pos_));
                      ++pos_;
                    }
                  if (pos_ and binding_.matches (spec, *pos_))
                    {
                      binding_.inject (move(*pos_));
                      ++pos_;
                      foundTarget = true;
                    }
                  return foundTarget;
                }
              else
                return PAR::accept_until (spec);
          }
        
        virtual bool
        assignElm (GenNode const& spec)  override
          {
            if (binding_.isApplicable(spec))
              {
                Iter target_found = binding_.locate (spec);
                return target_found and binding_.assign (*target_found, spec);
              }
            else
              return PAR::assignElm (spec);
          }
        
        virtual bool
        mutateChild (GenNode const& spec, TreeMutator::Handle targetBuff)  override
          {
            if (binding_.isApplicable(spec))
              {
                Iter target_found = binding_.locate (spec);
                return target_found and binding_.openSub (*target_found, spec.idi, targetBuff);
              }
            else
              return PAR::mutateChild (spec, targetBuff);
          }
        
        virtual bool
        completeScope()  override
          {
            return PAR::completeScope()
               and isnil(this->pos_);
          }
      };
    
    
    
    
    template<class COLL, class MAT, class CTR, class SEL, class ASS, class MUT>
    struct CollectionBindingBuilder
      : CollectionBinding<COLL,MAT,CTR,SEL,ASS,MUT>
      {
        using CollectionBinding<COLL,MAT,CTR,SEL,ASS,MUT>::CollectionBinding;
        
        template<class FUN>
        CollectionBindingBuilder<COLL, FUN ,CTR,SEL,ASS,MUT>
        matchElement (FUN matcher)                               
          {
            return { this->collection
                   , matcher
                   , this->construct
                   , this->isApplicable
                   , this->assign
                   , this->openSub
                   };
          }
        
        template<class FUN>
        CollectionBindingBuilder<COLL,MAT, FUN ,SEL,ASS,MUT>
        constructFrom (FUN constructor)                          
          {
            return { this->collection
                   , this->matches
                   , constructor
                   , this->isApplicable
                   , this->assign
                   , this->openSub
                   };
          }
        
        template<class FUN>
        CollectionBindingBuilder<COLL,MAT,CTR, FUN ,ASS,MUT>
        isApplicableIf (FUN selector)                            
          {
            return { this->collection
                   , this->matches
                   , this->construct
                   , selector
                   , this->assign
                   , this->openSub
                   };
          }
        
        template<class FUN>
        CollectionBindingBuilder<COLL,MAT,CTR,SEL, FUN ,MUT>
        assignElement (FUN setter)                               
          {
            return { this->collection
                   , this->matches
                   , this->construct
                   , this->isApplicable
                   , setter
                   , this->openSub
                   };
          }
        
        template<class FUN>
        CollectionBindingBuilder<COLL,MAT,CTR,SEL,ASS, FUN >
        buildChildMutator (FUN childMutationBuilder)             
          {
            return { this->collection
                   , this->matches
                   , this->construct
                   , this->isApplicable
                   , this->assign
                   , childMutationBuilder
                   };
          }
      };                                                                           
    
    
    template<class COLL, class MAT, class CTR, class SEL, class ASS, class MUT>
    inline auto
    createCollectionBindingBuilder (COLL& coll, MAT m, CTR c, SEL s, ASS a, MUT u)
    {
      using Coll = typename Strip<COLL>::TypeReferred;

      return CollectionBindingBuilder<Coll, MAT,CTR,SEL,ASS,MUT> {coll, m,c,s,a,u};
    }
    
    
    
    template<class ELM>
    struct _EmptyBinding
      {
        static bool
        __ERROR_missing_matcher (GenNode const&, ELM const&)
          {
            throw error::Logic ("unable to build a sensible default matching predicate");
          }
        
        static ELM
        __ERROR_missing_constructor (GenNode const&)
          {
            throw error::Logic ("unable to build a sensible default for creating new elements");
          }
        
        static bool
        ignore_selector (GenNode const& spec)
          {
            return spec != Ref::ATTRIBS;
            // by default apply diff unconditionally,
            // but don't respond to after(ATTRIBS)
          }
        
        static bool
        disable_assignment (ELM&, GenNode const&)
          {
            return false;
          }
        
        static bool
        disable_childMutation (ELM&, GenNode::ID const&, TreeMutator::Handle)
          {
            return false;
          }
        
        
        template<class COLL>
        static auto
        attachTo (COLL& coll)
          {
            return createCollectionBindingBuilder (coll
                                                  ,__ERROR_missing_matcher
                                                  ,__ERROR_missing_constructor
                                                  ,ignore_selector
                                                  ,disable_assignment
                                                  ,disable_childMutation
                                                  );
          }
      };
    
    
    
    using lib::meta::enable_if;
    using lib::diff::can_wrap_in_GenNode;
    
    template<class ELM, typename SEL =void>
    struct _DefaultBinding
      : _EmptyBinding<ELM>
      { };
    
    template<class ELM>
    struct _DefaultBinding<ELM, enable_if<can_wrap_in_GenNode<ELM>>>
      {
        template<class COLL>
        static auto
        attachTo (COLL& coll)
          {
            return _EmptyBinding<ELM>::attachTo(coll)
                      .matchElement([](GenNode const& spec, ELM const& elm)
                         {
                           return spec.matches(elm);
                         })
                      .constructFrom([](GenNode const& spec) -> ELM
                         {
                           return spec.data.get<ELM>();
                         });
          }
      };
    
    
    template<>
    struct _DefaultBinding<GenNode>
      {
        template<class COLL>
        static auto
        attachTo (COLL& coll)
          {
            return _EmptyBinding<GenNode>::attachTo(coll)
                      .matchElement([](GenNode const& spec, GenNode const& elm)
                         {
                           return spec.matches(elm);
                         })
                      .constructFrom([](GenNode const& spec) -> GenNode
                         {
                           return GenNode{spec};
                         })
                      .assignElement ([](GenNode& target, GenNode const& spec) -> bool
                         {
                           target.data = spec.data;
                           return true;
                         })
                      .buildChildMutator ([](GenNode& target, GenNode::ID const& subID, TreeMutator::Handle buff) -> bool
                         {
                           if (target.idi == subID     // require match on already existing child object
                               and target.data.isNested())
                             {
                               mutateInPlace (target.data.get<Rec>())
                                   .buildMutator(buff);
                               buff.get()->init();
                               return true;
                             }
                           else
                             return false;
                         });
          }
      };
    
    
    
    
    
    template<class COLL>
    inline auto
    collection (COLL& coll)
    {
      using Elm  = typename COLL::value_type;
      
      return _DefaultBinding<Elm>::attachTo(coll);
    }
    
    
    
    template<class PAR>
    template<class BIN>
    inline auto
    Builder<PAR>::attach (BIN&& collectionBindingSetup)
    {
      return chainedBuilder<ChildCollectionMutator<PAR,BIN>> (forward<BIN>(collectionBindingSetup));
    }
    
    
  }//(END)Mutator-Builder decorator components...
  
}} // namespace lib::diff
#endif /*LIB_DIFF_TREE_MUTATOR_COLLECTION_BINDING_H*/