mutation-message.hpp

Go to the documentation of this file.

/*
  MUTATION-MESSAGE.hpp  -  message to cause changes to generic model elements

  Copyright (C)         Lumiera.org
    2017,               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_MUTATION_MESSAGE_H
#define LIB_DIFF_MUTATION_MESSAGE_H


#include "lib/error.hpp"
#include "lib/iter-source.hpp"
#include "lib/iter-adapter-stl.hpp"
#include "lib/diff/tree-diff.hpp"
#include "lib/diff/gen-node.hpp"
#include "lib/format-util.hpp"
#include "lib/meta/util.hpp"

#include <string>


namespace lib {
namespace diff{
  
  using std::string;
  using std::__and_;
  using std::__not_;
  using lib::meta::enable_if;
  using lib::meta::can_IterForEach;
  using lib::meta::can_STL_ForEach;
  
  using DiffStep = TreeDiffLanguage::DiffStep;
  using DiffSource = IterSource<DiffStep>;
  
  
  
  struct MutationMessage
    : DiffSource::iterator
    {
      using _FrontEnd = DiffSource::iterator;
      
      MutationMessage()                                   = default;
      MutationMessage(MutationMessage&&)                  = default;
      MutationMessage(MutationMessage const&)             = default;
      MutationMessage(MutationMessage& o)  : MutationMessage((MutationMessage const&)o) { }
      MutationMessage& operator= (MutationMessage const&) = default;
      MutationMessage& operator= (MutationMessage &&)     = default;
      
      explicit
      MutationMessage(DiffSource* diffGenerationContext)
        : _FrontEnd{DiffSource::build (diffGenerationContext)}
        { }
      
      MutationMessage(std::initializer_list<DiffStep> const&& ili)
        : MutationMessage{iter_stl::snapshot (move(ili))}
        { }
      
      template<typename...ARGS>
      MutationMessage(ARGS&& ...args)
        : MutationMessage{ {std::forward<ARGS>(args)...} }
        { }
      
      template<class IT>
      MutationMessage(IT&& ii,                        enable_if< can_IterForEach<IT>, void*> =nullptr)
        : _FrontEnd{iter_source::wrapIter (std::forward<IT>(ii))}
        { }
      
      template<class CON>
      MutationMessage(CON& container,                 enable_if< __and_< can_STL_ForEach<CON>
                                                                       ,__not_<can_IterForEach<CON>>>, void*> =nullptr)
        : _FrontEnd{iter_source::eachEntry(container)}
        { }
      
      
      MutationMessage& updateDiagnostics();
    };
  
  
  
  namespace { // Implementation: take snapshot to enable diagnostics
    
    struct DiffSnapshot
      : std::vector<DiffStep>
      {
        DiffSnapshot(MutationMessage& srcMsg)
          {
            for ( ; srcMsg; ++srcMsg )
              push_back (*srcMsg);
          }
      };
    
    using _VecIter = DiffSnapshot::iterator;
    using _RangeIT = RangeIter<_VecIter>;
    using _Wrapped = WrappedLumieraIter<_RangeIT>;
    
    class MaterialisedDiffBuffer
      : private DiffSnapshot
      , public _Wrapped
      {
      public:
        MaterialisedDiffBuffer(MutationMessage& srcMsg)
          : DiffSnapshot{srcMsg}
          , _Wrapped{_RangeIT{DiffSnapshot::begin(), DiffSnapshot::end()}}
          { }
        
        virtual
        operator string()  const override
          {
            return "Diff--{"+util::join (static_cast<DiffSnapshot> (*this))+"}";
          }
      };
  }
  
  inline MutationMessage&
  MutationMessage::updateDiagnostics()
  {
    return *this = MutationMessage{new MaterialisedDiffBuffer(*this)};
  }

  
  
  
  
}} // namespace lib::diff
#endif /*LIB_DIFF_MUTATION_MESSAGE_H*/