media-weaving-pattern.hpp

Go to the documentation of this file.

/*
  MEDIA-WEAVING-PATTERN.hpp  -  Base patterns to organise data connections and render processing invocation
 
   Copyright (C)
     2008,            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 STEAM_ENGINE_MEDIA_WEAVING_PATTERN_H
#define STEAM_ENGINE_MEDIA_WEAVING_PATTERN_H
 
#include "steam/common.hpp"
#include "steam/engine/turnout.hpp"
#include "steam/engine/turnout-system.hpp"
#include "steam/engine/feed-manifold.hpp"
//#include "vault/gear/job.h"
//#include "steam/engine/exit-node.hpp"
//#include "lib/time/timevalue.hpp"
//#include "lib/linked-elements.hpp"
#include "lib/several.hpp"
//#include "lib/util-foreach.hpp"
//#include "lib/iter-adapter.hpp"
//#include "lib/meta/function.hpp"
//#include "lib/itertools.hpp"
//#include "lib/util.hpp"      ////////OOO wegen manifoldSiz<FUN>()
 
//#include <stack>
 
 
namespace steam {
namespace engine {
  
  using lib::Several;
  
  
  template<class INVO>
  struct MediaWeavingPattern
    : util::NonCopyable
    {
      using Feed = INVO::Feed;
      
      static_assert (_verify_usable_as_InvocationAdapter<Feed>());
      
      Several<PortRef>   leadPort_;
      Several<BuffDescr> outTypes_;
      
      uint resultSlot_{0};
      
      INVO prototype_;
      
      template<typename...ARGS>
      MediaWeavingPattern (Several<PortRef>&&   pr
                          ,Several<BuffDescr>&& dr
                          ,uint resultIdx
                          ,ARGS&& ...args)
        : leadPort_{move(pr)}
        , outTypes_{move(dr)}
        , resultSlot_{resultIdx}
        , prototype_{forward<ARGS>(args)...}
        { }
      
      
      Feed
      mount (TurnoutSystem& turnoutSys)
        {
          ENSURE (leadPort_.size() <= INVO::FAN_I);
          ENSURE (outTypes_.size() <= INVO::FAN_O);
          return prototype_.buildFeed (turnoutSys);
        }
      
      void
      pull (Feed& feed, TurnoutSystem& turnoutSys)
        {
          if constexpr (Feed::hasInput())
            for (uint i=0; i<leadPort_.size(); ++i)
              {
                BuffHandle inputData = leadPort_[i].get().weave (turnoutSys);
                feed.inBuff.createAt(i, move(inputData));
              }
        }
      
      void
      shed (Feed& feed, TurnoutSystem&, OptionalBuff outBuff)
        {
          for (uint i=0; i<outTypes_.size(); ++i)
              {
                BuffHandle resultData =
                  i == resultSlot_ and outBuff? *outBuff
                                              : outTypes_[i].lockBuffer();
                feed.outBuff.createAt(i, move(resultData));
              }
          feed.connect();
        }
      
      void
      weft (Feed& feed, TurnoutSystem&)
        {
          feed.invoke();                 // process data
        }
      
      BuffHandle
      fix (Feed& feed, TurnoutSystem&)
        {
          if constexpr (Feed::hasInput())
            for (uint i=0; i<leadPort_.size(); ++i)
              {
                feed.inBuff[i].release();
              }
          for (uint i=0; i<outTypes_.size(); ++i)
              {
                feed.outBuff[i].emit();    // state transition: data ready
                if (i != resultSlot_)
                  feed.outBuff[i].release();
              }
          ENSURE (resultSlot_ < INVO::FAN_O, "invalid result buffer configured.");
          return feed.outBuff[resultSlot_];
        }
      
      
      friend auto
      _accessInternal(MediaWeavingPattern& patt)
      {
        return std::tie (patt.leadPort_, patt.outTypes_);
      }
    };
  
  
  
}}// namespace steam::engine
#endif /*STEAM_ENGINE_MEDIA_WEAVING_PATTERN_H*/