weaving-pattern-builder.hpp

Go to the documentation of this file.

/*
  WEAVING-PATTERN-BUILDER.hpp  -  build an invocation pattern for media calculations
 
   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_WEAVING_PATTERN_BUILDER_H
#define STEAM_ENGINE_WEAVING_PATTERN_BUILDER_H
 
#include "lib/error.hpp"
#include "lib/several-builder.hpp"
#include "steam/engine/proc-id.hpp"
#include "steam/engine/engine-ctx.hpp"
#include "steam/engine/buffer-provider.hpp"
#include "steam/engine/buffhandle-attach.hpp"  
#include "steam/engine/media-weaving-pattern.hpp"
#include "lib/meta/tuple-closure.hpp"
#include "lib/meta/tuple-helper.hpp"
//#include "lib/test/test-helper.hpp" ////////////////////////////OOO TODO added for test
#include "lib/format-string.hpp"
#include "lib/iter-zip.hpp"
#include "lib/util.hpp"
 
#include <functional>
#include <utility>
#include <vector>
#include <string>
 
 
namespace steam {
namespace engine {
  namespace err = lumiera::error;
  
  using StrView = std::string_view;
  using std::forward;
  using lib::Depend;
  using lib::izip;
  using util::_Fmt;
  using util::max;
  
  
  
  template<class POL, class I, class E=I>
  using DataBuilder = lib::SeveralBuilder<I,E, POL::template Policy>;
  
  template<uint siz>
  using SizMark = std::integral_constant<uint,siz>;
  
  
  
  template<class PAR, class BUILD, uint siz>
  struct PatternData
    : PAR
    {
      BUILD buildEntry;
      
      uint size() { return 1 + PAR::size(); }
      
      template<class DAB>
      void
      collectEntries (DAB& dataBuilder, uint cntElm =0, uint maxSiz =0)
        {
          PAR::collectEntries (dataBuilder, cntElm+1, max (siz,maxSiz));
          buildEntry (dataBuilder);
        }
      
      
      PatternData(PAR&& predecessor, BUILD&& entryBuilder)
        : PAR{move (predecessor)}
        , buildEntry{move (entryBuilder)}
        { }
    };
  
  struct PatternDataAnchor
    {
      uint size() { return 0; }
      
      template<class DAB>
      void
      collectEntries (DAB& dataBuilder, uint cntElm, uint maxSiz)
        {
          dataBuilder.reserve (cntElm, maxSiz);
        }
    };
  
  
  
  
  
  
  template<class POL, class PROT>
  struct WeavingBuilder
    : util::MoveOnly
    {
      using WeavingPattern = MediaWeavingPattern<PROT>;
      using TurnoutWeaving = Turnout<WeavingPattern>;
      static constexpr SizMark<sizeof(TurnoutWeaving)> sizMark{};
      static constexpr uint FAN_I = PROT::FAN_I;
      static constexpr uint FAN_O = PROT::FAN_O;
      
      using TypeMarker = std::function<BuffDescr(BufferProvider&)>;
      using ProviderRef = std::reference_wrapper<BufferProvider>;
      using ParamClosure = lib::meta::TupleClosureBuilder<typename PROT::Param>;
      
      DataBuilder<POL, PortRef> leadPorts;
      std::vector<TypeMarker>   buffTypes;
      std::vector<ProviderRef>  providers;
      
      uint resultSlot{0};
      
      Depend<EngineCtx> ctx;
      
      StrView nodeSymb_;
      StrView portSpec_;
      PROT prototype_;
      
      template<typename...INIT>
      WeavingBuilder (PROT&& prototype, StrView nodeSymb, StrView portSpec, INIT&& ...alloInit)
        : leadPorts{forward<INIT> (alloInit)...}
        , buffTypes{fillDefaultBufferTypes()}
        , nodeSymb_{nodeSymb}
        , portSpec_{portSpec}
        , prototype_{move(prototype)}
        { }
      
      template<class PREV>
      WeavingBuilder (WeavingBuilder<POL,PREV>&& prevBuilder, PROT&& adaptedPrototype)
        : leadPorts {move (prevBuilder.leadPorts)}
        , buffTypes {move (prevBuilder.buffTypes)}
        , providers {move (prevBuilder.providers)}
        , resultSlot{move (prevBuilder.resultSlot)}
        , nodeSymb_ {move (prevBuilder.nodeSymb_)}
        , portSpec_ {move (prevBuilder.portSpec_)}
        , prototype_{move (adaptedPrototype)}
        { }
      
      
      template<class PFX>
      using AdaptedPrototype = PROT::template Adapted<PFX>;
      template<class PFX>
      using Adapted = WeavingBuilder<POL, AdaptedPrototype<PFX>>;
      
      template<class PFX>
      auto
      adaptParam (PFX paramFunctor)
        {
          static_assert (PROT::template isSuitableParamFun<PFX>()
                        ,"suitable as param-functor for given processing-functor");
          //
          using AdaptedWeavingBuilder = Adapted<PFX>;
          //
          return AdaptedWeavingBuilder{move(*this)
                                      ,prototype_.moveAdaptedParam (move (paramFunctor))
                                      };
        }
      
      
      template<class DEC>
      using DecoratedPrototype = PROT::template Decorated<DEC>;
      template<class DEC>
      using Decorated = WeavingBuilder<POL, DecoratedPrototype<DEC>>;
      
      template<class DEC>
      auto
      adaptProcFunParam (DEC decorator)
        {
          static_assert (PROT::template isSuitableParamAdaptor<DEC>()
                        ,"suitable to adapt the processing-functor's param argument");
          //
          using AdaptedWeavingBuilder = Decorated<DEC>;
          //
          return AdaptedWeavingBuilder{move(*this)
                                      ,prototype_.moveTransformedParam (move (decorator))
                                      };
        }
      
      WeavingBuilder&&
      attachToLeadPort (ProcNode& lead, uint portNr)
        {
          if (leadPorts.size() >= FAN_I)
            throw err::Logic{_Fmt{"Builder: attempt to add further input, "
                                  "but all %d »input slots« of the processing function are already connected."}
                                 % FAN_I
                            };
          PortRef portRef{lead.getPort (portNr)};
          leadPorts.append (portRef);
          return move(*this);
        }
      
      
      WeavingBuilder&&
      connectRemainingInputs (DataBuilder<POL, ProcNodeRef>& knownLeads, uint defaultPort)
        {
          REQUIRE (leadPorts.size() <= FAN_I);
          uint cnt = FAN_I - leadPorts.size();
          if (FAN_I > knownLeads.size())
            throw err::Logic{_Fmt{"Builder: attempt to auto-connect %d further »input slots«, "
                                  "but this ProcNode has only %d predecessor nodes, while the "
                                  "given processing function expects %d inputs."}
                                 % cnt % knownLeads.size() % FAN_I
                            };
          while (cnt--)
            attachToLeadPort (knownLeads[leadPorts.size()], defaultPort);
          return move(*this);
        }
      
      WeavingBuilder&&
      selectResultSlot (uint idx)
        {
          this->resultSlot = idx;
          return move(*this);
        }
      
      
      auto
      build()
        {
          // discard excess storage prior to allocating the output types sequence
          leadPorts.shrinkFit();
          
          maybeFillDefaultProviders (buffTypes.size());
          REQUIRE (providers.size() == buffTypes.size());
          auto outTypes = DataBuilder<POL, BuffDescr>{leadPorts.policyConnect()}
                                     .reserve (buffTypes.size());
          
          for (auto& [i,typeConstructor] : izip(buffTypes))
            outTypes.append (
              typeConstructor (providers[i]));
          
          ENSURE (leadPorts.size() == FAN_I);
          ENSURE (outTypes.size()  == FAN_O);
          
          using PortDataBuilder = DataBuilder<POL, Port>;
          // provide a free-standing functor to build a suitable Port impl (≙Turnout)
          return [leads = move(leadPorts.build())
                 ,types = move(outTypes.build())
                 ,prototype = move(prototype_)
                 ,resultIdx = resultSlot
                 ,&procID = ProcID::describe (nodeSymb_,portSpec_)
                 ]
                 (PortDataBuilder& portData) mutable -> void
                   {
                     portData.template emplace<TurnoutWeaving> (procID
                                                               ,move(leads)
                                                               ,move(types)
                                                               ,resultIdx
                                                               ,move(prototype)
                                                               );
                   };
        }
      
      
      
    private: /* ====== WeavingBuilder implementation details ====== */
      void
      maybeFillDefaultProviders (size_t maxSlots)
        {
          for (uint i=providers.size(); i < maxSlots; ++i)
            providers.emplace_back (ctx().mem);
        }
      
      template<typename BU>
      struct BufferDescriptor
        {
          TypeMarker
          makeBufferDescriptor()  const
            {
              return [](BufferProvider& provider)
                        { return provider.getDescriptor<BU>(); };
            }
        };
      
      using OutTypesDescriptors = PROT::template OutTypesApply<BufferDescriptor>;
      using OutDescriptorTup  = lib::meta::Tuple<OutTypesDescriptors>;
      
      static constexpr OutDescriptorTup outDescriptors{};
      
      static auto
      fillDefaultBufferTypes()
        {
          std::vector<TypeMarker> defaultBufferTypes;
          defaultBufferTypes.reserve (std::tuple_size_v<OutDescriptorTup>);
          lib::meta::forEach(outDescriptors
                            ,[&](auto& desc)
                                {
                                  defaultBufferTypes.emplace_back(
                                      desc.makeBufferDescriptor());
                                });
          return defaultBufferTypes;
        }
    };
  
  
}}// namespace steam::engine
#endif /*STEAM_ENGINE_WEAVING_PATTERN_BUILDER_H*/