param-weaving-pattern.hpp

Go to the documentation of this file.

/*
  PARAM-WEAVING-PATTERN.hpp  -  Pattern to carry out special parameter computations
 
   Copyright (C)
     2024,            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 STEAM_ENGINE_PARAM_WEAVING_PATTERN_H
#define STEAM_ENGINE_PARAM_WEAVING_PATTERN_H
 
#include "steam/common.hpp"
#include "steam/engine/turnout.hpp"
#include "steam/engine/turnout-system.hpp"
#include "lib/uninitialised-storage.hpp"
#include "lib/meta/variadic-rebind.hpp"
#include "lib/meta/tuple-helper.hpp"
#include "lib/meta/function.hpp"
 
#include <tuple>
#include <utility>
 
 
namespace steam {
namespace engine {
  
  using std::move;
  using std::forward;
  using std::function;
  using std::make_tuple;
  using std::tuple;
  using lib::meta::Tuple;
  using lib::meta::ElmTypes;
  
  
  template<class ANCH, typename...FUNZ>
  struct ParamBuildSpec
    {
      using Functors = tuple<FUNZ...>;
      
      using ResTypes = ElmTypes<Functors>::template Apply<lib::meta::_FunRet>;
      using ParamTup = Tuple<ResTypes>;
      
      Functors functors_;
      
      ParamBuildSpec (Functors&& funz)
        : functors_{move (funz)}
        { }
      
      ParamBuildSpec clone() { return *this; }
      
      
      template<typename FUN>
      auto
      addSlot (FUN&& paramFun)
        {
          using FunN = std::decay_t<FUN>;
          return ParamBuildSpec<ANCH,FUNZ...,FunN>{std::tuple_cat (move(functors_)
                                                                  ,make_tuple (forward<FUN>(paramFun)))};
        }
      
      template<typename PAR>
      auto
      addValSlot (PAR paramVal)
        {
          return addSlot ([paramVal](TurnoutSystem&){ return paramVal; });
        }
      
      
      template<size_t slot>
      auto
      invokeParamFun (TurnoutSystem& turnoutSys)
        {
          return std::get<slot> (functors_) (turnoutSys);
        }
      
      using ChainCons = lib::meta::RebindVariadic<ANCH::template Chain, ParamTup>::Type;
      
      
      template<size_t slot>
      struct Accessor
        {
          static auto&
          getParamVal (TurnoutSystem& turnoutSys)
            {
              using StorageAccessor = ChainCons::template Accessor<slot>;
              return turnoutSys.retrieveData (StorageAccessor());
            }
        };
      
      template<size_t idx>
      Accessor<idx>
      makeAccessor()
        {
          return Accessor<idx>{};
        }
      
      class BlockBuilder
        : util::MoveOnly
        {
          Functors functors_;
          
        public:
          ChainCons::NewFrame
          buildParamDataBlock (TurnoutSystem& turnoutSys)
            {
              return std::apply ([&](auto&&... paramFun)
                                      {  //    invoke parameter-functors and build NewFrame from results
                                        return ChainCons::build (paramFun (turnoutSys) ...);
                                      }
                                ,functors_);
            }
          
          void
          emplaceParamDataBlock (void* storage, TurnoutSystem& turnoutSys)
            {
              std::apply ([&](auto&&... paramFun)
                              {  //    invoke parameter-functors and build NewFrame from results
                                ChainCons::emplace (storage, paramFun (turnoutSys) ...);
                              }
                        ,functors_);
            }
          
        private:
          BlockBuilder (Functors&& funz)
            : functors_{move (funz)}
            { }
          
          friend class ParamBuildSpec;
        };
      
      BlockBuilder
      makeBlockBuilder()
        {
          return BlockBuilder (move (functors_));
        }
    };
  
  inline auto
  buildParamSpec()
    {
      return ParamBuildSpec<TurnoutSystem::FrontBlock>{tuple<>{}};
    }
  
  
  
  
  
  template<class SPEC>
  struct ParamWeavingPattern
    : util::MoveOnly
    {
      using Functors = SPEC::Functors;
      using DataBlock = SPEC::ChainCons::NewFrame;
      using BlockBuilder = SPEC::BlockBuilder;
      using PostProcessor = function<void(TurnoutSystem&)>;
      
      BlockBuilder blockBuilder_;
      PostProcessor postProcess_;
      Port&        delegatePort_;
      
      struct Feed
        : util::NonCopyable
        {
          lib::UninitialisedStorage<DataBlock> buffer;
          OptionalBuff outBuff;
          
          DataBlock& block() { return buffer[0]; }
          
          void
          emplaceParamDataBlock (BlockBuilder& builder, TurnoutSystem& turnoutSys)
            {
              builder.emplaceParamDataBlock (&block(), turnoutSys);
            }
        };
      
      
      ParamWeavingPattern (BlockBuilder builder, PostProcessor postProc, Port& delegate)
        : blockBuilder_{move (builder)}
        , postProcess_{move (postProc)}
        , delegatePort_{delegate}
        { }
      
      
      Feed
      mount (TurnoutSystem&)
        {
          return Feed();
        }
      
      void
      pull (Feed& feed, TurnoutSystem& turnoutSys)
        {
          feed.emplaceParamDataBlock (blockBuilder_, turnoutSys);
        }
      
      void
      shed (Feed& feed, TurnoutSystem& turnoutSys, OptionalBuff outBuff)
        {
          turnoutSys.attachChainBlock(feed.block());
          feed.outBuff = outBuff;
          if (postProcess_)
            postProcess_(turnoutSys);
        }
      
      void
      weft (Feed& feed, TurnoutSystem& turnoutSys)
        {
          feed.outBuff = delegatePort_.weave (turnoutSys, feed.outBuff);
          ENSURE (feed.outBuff);
        }
      
      BuffHandle
      fix (Feed& feed, TurnoutSystem& turnoutSys)
        {
          turnoutSys.detachChainBlock(feed.block());
          return *feed.outBuff;
        }
      
      
      friend auto
      _accessInternal(ParamWeavingPattern& patt)
      {
        return std::tie (patt.delegatePort_);
      }
    };
  
  
}}// namespace steam::engine
#endif /*STEAM_ENGINE_PARAM_WEAVING_PATTERN_H*/