node-builder.hpp

Go to the documentation of this file.

/*
  NODE-BUILDER.hpp  -  Setup of render nodes connectivity
 
   Copyright (C)
     2009,            Hermann Vosseler <Ichthyostega@web.de>
     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 ENGINE_NODE_BUILDER_H
#define ENGINE_NODE_BUILDER_H
 
 
#include "lib/error.hpp"
#include "lib/nocopy.hpp"
#include "steam/engine/weaving-pattern-builder.hpp"
#include "steam/engine/media-weaving-pattern.hpp"
#include "steam/engine/param-weaving-pattern.hpp"
#include "steam/engine/proc-node.hpp"
#include "steam/engine/turnout.hpp"
#include "lib/several-builder.hpp"
#include "lib/format-string.hpp"
#include "lib/index-iter.hpp"
 
#include <utility>
#include <vector>
 
 
namespace steam {
namespace engine {
  namespace err = lumiera::error;
  
  using util::_Fmt;
  using std::forward;
  using std::move;
  using std::ref;
  
  
  namespace { // default policy configuration to use heap allocator
    
    struct UseHeapAlloc
      {
        template<class I, class E=I>
        using Policy = lib::allo::HeapOwn<I,E>;
      };
    //
  }//(End) policy
  
  
  
  template<class POL, class I, class E=I>
  using DataBuilder = lib::SeveralBuilder<I,E, POL::template Policy>;
  
  
  
  template<class POL, class DAT>
  class NodeBuilder;
  
  template<class POL, class DAT>
  class PortBuilderRoot;
  
  
  
  
  template<class POL, class DAT = PatternDataAnchor>
  class NodeBuilder
    : util::MoveOnly
    {
      using PortData = DataBuilder<POL, Port>;
      using LeadRefs = DataBuilder<POL, ProcNodeRef>;
      
    protected:
      StrView symbol_;
      LeadRefs leads_;
      DAT patternData_;
      
    public:
      template<typename...INIT>
      NodeBuilder (StrView nodeSymbol, INIT&& ...alloInit)
        : symbol_{nodeSymbol}
        , leads_{forward<INIT> (alloInit)...}
        { }
      
      template<class BUILD, uint siz, class D0>
      NodeBuilder (NodeBuilder<POL,D0>&& pred, SizMark<siz>, BUILD&& entryBuilder)
        : symbol_{pred.symbol_}
        , leads_{move (pred.leads_)}
        , patternData_{move (pred.patternData_), forward<BUILD> (entryBuilder)}
        { }
      
      template<class P, class D0>
      friend class NodeBuilder;
      
      
      NodeBuilder&&
      addLead (ProcNode const& lead)
        {
          leads_.append (ref(lead));
          return move(*this);
        }
      
      
      PortBuilderRoot<POL,DAT> preparePort();
      
      
      template<template<typename> class ALO =std::void_t, typename...INIT>
      auto
      withAllocator (INIT&& ...alloInit)
        {
          using AllocatorPolicy = lib::allo::SetupSeveral<ALO,INIT...>;
          return NodeBuilder<AllocatorPolicy>{symbol_, forward<INIT>(alloInit)...};
        }
      
      
      /************************************************************/
      Connectivity
      build()
        {
          PortData ports;
          patternData_.collectEntries(ports);
          return Connectivity{ports.build()
                             ,leads_.build()
                             };
        }
    };
  
  template<class POL, class D0, uint siz, class BUILD>
  NodeBuilder (NodeBuilder<POL,D0>&&, SizMark<siz>, BUILD&&) -> NodeBuilder<POL, PatternData<D0,BUILD,siz>>;
  
  
  
  
  template<class POL, class DAT>
  class PortBuilderRoot
    : protected NodeBuilder<POL,DAT>
    {
    public:
      NodeBuilder<POL,DAT>
      completePort()
        {
          static_assert(not sizeof(POL),
            "can not build a port without specifying a processing function");
        }
      
      template<typename FUN>
      auto invoke (StrView portSpec, FUN fun);
      
      template<class SPEC>
      auto computeParam(SPEC&&);
      
      
    private:
      PortBuilderRoot(NodeBuilder<POL,DAT>&& anchor)
        : NodeBuilder<POL,DAT>{move(anchor)}
        { }
      
      friend PortBuilderRoot NodeBuilder<POL,DAT>::preparePort();
    };
  
  template<class POL, class DAT>
  inline PortBuilderRoot<POL, DAT>
  NodeBuilder<POL,DAT>::preparePort ()
  {
    return PortBuilderRoot<POL,DAT>{move(*this)};
  }
  
  
  
  template<class POL, class DAT, class WAB>
  class PortBuilder
    : public PortBuilderRoot<POL,DAT>
    {
      using _Par = PortBuilderRoot<POL,DAT>;
      
      WAB weavingBuilder_;
      uint defaultPort_;
      
    public:
      
      template<class ILA, typename...ARGS>
      PortBuilder&&
      createBuffers (ARGS&& ...args)
        {
          UNIMPLEMENTED ("define builder for all buffers to use");
          return move(*this);
        }
      
      
      PortBuilder&&
      asResultSlot (uint r)
        {
          weavingBuilder_.selectResultSlot(r);
          return move(*this);
        }
      
      PortBuilder&&
      connectLead (uint idx)
        {
          return connectLeadPort (idx, this->defaultPort_);
        }
      
      PortBuilder&&
      connectLead (ProcNode& leadNode)
        {
          return connectLeadPort (leadNode, this->defaultPort_);
        }
      
      PortBuilder&&
      connectLeadPort (uint idx, uint port)
        {
          if (idx >= _Par::leads_.size())
            throw err::Logic{_Fmt{"Builder refers to lead-node #%d, yet only %d are currently defined."}
                                 % idx % _Par::leads_.size()
                            ,LERR_(INDEX_BOUNDS)
                            };
          weavingBuilder_.attachToLeadPort (_Par::leads_[idx], port);
          return move(*this);
        }
      
      PortBuilder&&
      connectLeadPort (ProcNode& leadNode, uint port)
        {
          uint knownEntry{0};
          for (auto& lead : lib::IndexIter{_Par::leads_})  // leads_ holds ref-wrappers
            if (util::isSameObject (leadNode, lead.get()))
              break;
            else
              ++knownEntry;
          if (knownEntry == _Par::leads_.size())
            _Par::addLead (leadNode);
          
          ENSURE (knownEntry < _Par::leads_.size());
          return connectLeadPort (knownEntry, port);
        }
      
      PortBuilder&&
      useLeadPort (uint defaultPort)
        {
          this->defaultPort_ = defaultPort;
          return move(*this);
        }
      
      template<class PFX>
      auto
      attachParamFun (PFX paramFunctor)
        {
          using AdaptedWeavingBuilder = WAB::template Adapted<PFX>;
          using AdaptedPortBuilder    = PortBuilder<POL,DAT,AdaptedWeavingBuilder>;
          //
          return AdaptedPortBuilder{move(*this)
                                   ,weavingBuilder_.adaptParam (move (paramFunctor))
                                   };
        }
      
      template<class AUTO>
      auto
      attachAutomation (AUTO&& aFun)
        {
          return attachParamFun ([automation = forward<AUTO>(aFun)]
                                 (TurnoutSystem& turnoutSys)
                                    {
                                      return automation (turnoutSys.getNomTime());
                                    });
        }
      
      template<typename PAR>
      auto
      setParam (PAR paramVal)
        {
          return attachParamFun ([=](TurnoutSystem&) -> PAR
                                    {
                                      return paramVal;
                                    });
        }
      
      template<typename PAR, typename...PARS>
      auto
      setParam (PAR v1, PARS ...vs)
        {
          return attachParamFun ([=](TurnoutSystem&) -> tuple<PAR,PARS...>
                                    {
                                      return std::make_tuple (v1,vs...);
                                    });
        }
      
      template<typename GET>
      auto
      retrieveParam (GET&& getter)
        {
          return attachParamFun ([accessor=forward<GET>(getter)]
                                 (TurnoutSystem& turnoutSys)
                                    {
                                      return turnoutSys.get(accessor);
                                    });
        }
      
      template<typename ADA>
      auto
      adaptParam (ADA&& paramAdaptor)
        {
          using DecoratedPrototype = WAB::template Decorated<ADA>;
          using AdaptedPortBuilder = PortBuilder<POL,DAT,DecoratedPrototype>;
          //
          return AdaptedPortBuilder{move(*this)
                                   ,weavingBuilder_.adaptProcFunParam (move (paramAdaptor))
                                   };
        }
      
      template<typename PAR, typename...PARS>
      auto
      closeParamFront (PAR v1, PARS ...vs)
        {
          return adaptParam(
                    WAB::ParamClosure::template closeFront (forward<PAR> (v1)
                                                           ,forward<PARS>(vs)...));
        }
      
      template<typename PAR, typename...PARS>
      auto
      closeParamBack (PAR v1, PARS ...vs)
        {
          return adaptParam(
                    WAB::ParamClosure::template closeBack  (forward<PAR> (v1)
                                                           ,forward<PARS>(vs)...));
        }
      
      template<size_t idx, typename PAR>
      auto
      closeParam (PAR val)
        {
          return adaptParam(
                    WAB::ParamClosure::template close<idx> (forward<PAR> (val)));
        }
      
      
      
      /*************************************************************/
      auto
      completePort()
        {
          weavingBuilder_.connectRemainingInputs (_Par::leads_, this->defaultPort_);
          return NodeBuilder{static_cast<NodeBuilder<POL,DAT>&&> (*this) // slice away PortBulder subclass data
                            ,weavingBuilder_.sizMark
                            ,weavingBuilder_.build()};
        }                 // chain to builder with extended patternData
      
    private:
      template<typename FUN>
      PortBuilder(_Par&& base, FUN&& fun, StrView portSpec)
        : _Par{move(base)}
        , weavingBuilder_{forward<FUN> (fun), _Par::symbol_, portSpec, _Par::leads_.policyConnect()}
        , defaultPort_{_Par::patternData_.size()}
        { }               // ^^^ by default use next free port
      
      friend class PortBuilderRoot<POL,DAT>;
      
      template<class WABO>
      PortBuilder (PortBuilder<POL,DAT,WABO>&& prevBuilder, WAB&& adaptedWeavingBuilder)
        : _Par{move(prevBuilder)}
        , weavingBuilder_{move (adaptedWeavingBuilder)}
        , defaultPort_{prevBuilder.defaultPort_}
        { }
      
      template<class PX, class DX, class WX>
      friend class PortBuilder;
    };
  
  
  template<class POL, class DAT>
  template<typename FUN>
  auto
  PortBuilderRoot<POL,DAT>::invoke (StrView portSpec, FUN fun)
    {
      using Prototype          = FeedManifold<FUN>::Prototype;
      using WeavingBuilder_FUN = WeavingBuilder<POL, Prototype>;
      return PortBuilder<POL,DAT, WeavingBuilder_FUN>{move(*this), move(fun), portSpec};
    }
  
  
  
  
  
  template<class POL, class DAT, class SPEC>
  class ParamAgentBuilder
    : public PortBuilderRoot<POL,DAT>
    {
      using _Par = PortBuilderRoot<POL,DAT>;
      
      using BlockBuilder  = SPEC::BlockBuilder;
      using PostProcessor = function<void(TurnoutSystem&)>;
 
      BlockBuilder blockBuilder_;
      PostProcessor postProcessor_;
      Port* delegatePort_;
      uint defaultPortNr_;
 
    public:
      ParamAgentBuilder&&
      delegateLead (uint idx)
        {
          return delegateLeadPort (idx, defaultPortNr_);
        }
      
      ParamAgentBuilder&&
      delegateLead (ProcNode& leadNode)
        {
          return delegateLeadPort (leadNode, defaultPortNr_);
        }
      
      ParamAgentBuilder&&
      delegateLeadPort (uint idx, uint port)
        {
          if (idx >= _Par::leads_.size())
            throw err::Logic{_Fmt{"Builder refers to lead-node #%d, yet only %d are currently defined."}
                                 % idx % _Par::leads_.size()
                            ,LERR_(INDEX_BOUNDS)
                            };
          ProcNode& leadNode = _Par::leads_[idx];
          delegatePort_ = & leadNode.getPort (port);
          return move(*this);
        }
      
      ParamAgentBuilder&&
      delegateLeadPort (ProcNode& leadNode, uint port)
        {
          uint knownEntry{0};
          for (auto& lead : lib::IndexIter{_Par::leads_})
            if (util::isSameObject (leadNode, lead))
              break;
            else
              ++knownEntry;
          if (knownEntry == _Par::leads_.size())
            _Par::addLead (leadNode);
          
          ENSURE (knownEntry < _Par::leads_.size());
          return delegateLeadPort (knownEntry, port);
        }
      
      
      ParamAgentBuilder&&
      installPostProcessor(PostProcessor pp)
        {
          postProcessor_ = move(pp);
        }
      
      
      /*********************************************************************/
      auto
      completePort()
        {
          if (not delegatePort_)
            throw err::Logic{"Building a ParamAgentNode requires a delegate node "
                             "to perform within the scope with extended parameters"
                            ,LERR_(BOTTOM_VALUE)};
          string portSpec = "Par+"+delegatePort_->procID.genProcSpec();
          ProcAttrib flags;
          flags.isProxy = true;
          flags.manifold = false;
          
          using WeavingPattern  = ParamWeavingPattern<SPEC>;
          using TurnoutWeaving  = Turnout<WeavingPattern>;
          using PortDataBuilder = DataBuilder<POL, Port>;
          
          return NodeBuilder ( static_cast<NodeBuilder<POL,DAT>&&> (*this) // slice away PortBulder subclass data
                             , SizMark<sizeof(TurnoutWeaving)>{}
                             ,// prepare a builder-λ to construct the actual Turnout-object
                              [&procID = ProcID::describe(_Par::symbol_,portSpec,flags)
                              ,builder = move(blockBuilder_)
                              ,postProc = move(postProcessor_)
                              ,delegate = delegatePort_
                              ]
                              (PortDataBuilder& portData) mutable -> void
                                {
                                  portData.template emplace<TurnoutWeaving> (procID
                                                                            ,move(builder)
                                                                            ,move(postProc)
                                                                            ,*delegate
                                                                            );
                                });
        }                     // chain back up to Node-Builder with extended patternData
      
    private:
      ParamAgentBuilder(_Par&& base, BlockBuilder&& builder)
        : _Par{move(base)}
        , blockBuilder_{move(builder)}
        , delegatePort_{nullptr}
        , defaultPortNr_{_Par::patternData_.size()}
        { }                 // ^^^ by default use next free port
      
      friend class PortBuilderRoot<POL,DAT>;
    };
  
  
  template<class POL, class DAT>
  template<class SPEC>
  auto
  PortBuilderRoot<POL,DAT>::computeParam(SPEC&& ref)
    {
      using ParamBuildSpec = std::decay_t<SPEC>;
      ParamBuildSpec spec {forward<SPEC>(ref)};                      // consumes the spec
      return ParamAgentBuilder<POL,DAT,ParamBuildSpec>{move(*this), spec.makeBlockBuilder()};
    }
  
  
  
  
  inline auto
  prepareNode (StrView nodeSymbol)
  {
    return NodeBuilder<UseHeapAlloc>{nodeSymbol};
  }
  
  
  
  
  
  class ProcBuilder
    : util::MoveOnly
    {
    public:
      
      void 
      requiredSources ()
        {
          UNIMPLEMENTED ("enumerate all source feeds required");
//        return move(*this);
        }
      
      void 
      retrieve (void* streamType)
        {
          (void)streamType;
          UNIMPLEMENTED ("recursively define a predecessor feed");
//        return move(*this);
        }
      
      /****************************************************/
      void 
      build()
        {
          UNIMPLEMENTED("Level-3 build-walk");
        }
    };
  
  
  class LinkBuilder
    : util::MoveOnly
    {
    public:
      
      void 
      from (void* procAsset)
        {
          (void)procAsset;
          UNIMPLEMENTED ("recursively enter definition of processor node to produce this feed link");
//        return move(*this);
        }
    };
  
  
  
  inline auto
  retrieve(void* streamType)
  {
    (void)streamType;
    UNIMPLEMENTED("start a connectivity definition at Level-3");
    return LinkBuilder{};  
  }
  
  
}} // namespace steam::engine
#endif /*ENGINE_NODE_BUILDER_H*/