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/symbol.hpp"//////////////////////////////TODO RLY?
#include "lib/nocopy.hpp"
#include "steam/engine/weaving-pattern-builder.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 "lib/test/test-helper.hpp"

#include <utility>
#include <vector>


namespace steam {
namespace engine {
  namespace err = lumiera::error;
  
//  using lib::Literal;
  using util::_Fmt;
  using std::forward;
  using std::move;
  
  
  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 (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 ADA, typename...ARGS>
      auto adaptInvocation(ARGS&& ...args);
      
      
    private:
      PortBuilderRoot(NodeBuilder<POL>&& anchor)
        : NodeBuilder<POL>{move(anchor)}
        { }
      
      friend PortBuilderRoot NodeBuilder<POL>::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
      conectLead (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_})
            if (util::isSameObject (leadNode, lead))
              break;
            else
              ++knownEntry;
          if (knownEntry == _Par::leads_.size())
            _Par::addLead (leadNode);
          
          ENSURE (knownEntry < _Par::leads_.size());
          weavingBuilder_.attachToLeadPort (knownEntry, port);
          return move(*this);
        }
      
      PortBuilder
      useLeadPort (uint defaultPort)
        {
          this->defaultPort_ = defaultPort;
          return move(*this);
        }
      
      
      /*************************************************************/
      auto
      completePort()
        {
          weavingBuilder_.connectRemainingInputs (_Par::leads_, this->defaultPort_);
          weavingBuilder_.fillRemainingBufferTypes();
          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()}
        { }
      
      friend class PortBuilderRoot<POL,DAT>;
    };
  
  
  template<class POL, class DAT>
  template<typename FUN>
  auto
  PortBuilderRoot<POL,DAT>::invoke (StrView portSpec, FUN fun)
    {
      using WeavingBuilder_FUN = WeavingBuilder<POL, manifoldSiz<FUN>(), FUN>;
      return PortBuilder<POL,DAT, WeavingBuilder_FUN>{move(*this), move(fun), portSpec};
    }
/*
  template<class POL>
  template<class ADA, typename...ARGS>
  auto
  PortBuilderRoot<POL>::adaptInvocation(ARGS&& ...args)
    {
      return move(*this);
    }
  */
  
  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)
        {
          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)
        {
          UNIMPLEMENTED ("recursively enter definition of processor node to produce this feed link");
//        return move(*this);
        }
    };
  
  
  
  inline auto
  retrieve(void* streamType)
  {
    UNIMPLEMENTED("start a connectivity definition at Level-3");
    return LinkBuilder{};  
  }
  
  
}} // namespace steam::engine
#endif /*ENGINE_NODE_BUILDER_H*/