turnout.hpp

Go to the documentation of this file.

/*
  TURNOUT.hpp  -  Fixed standard scheme to generate data within a Render Node
 
   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_TURNOUT_H
#define STEAM_ENGINE_TURNOUT_H
 
#include "steam/common.hpp"
#include "steam/engine/proc-node.hpp"
#include "steam/engine/turnout-system.hpp"
 
#include <utility>
 
 
namespace steam {
namespace engine {
  
  using std::forward;
  
  
  template<class ADA>
  constexpr bool
  _verify_usable_as_InvocationAdapter()
  {
    // also: array-like outBuff
    // optionally array-like inBuff
    ASSERT_MEMBER_FUNCTOR (&ADA::connect, void());
    ASSERT_MEMBER_FUNCTOR (&ADA::invoke, void());
    return sizeof(ADA);
  }
  
  
  template<class PAT>
  constexpr bool
  _verify_usable_as_WeavingPattern()
  {
    using Feed = PAT::Feed;
    ASSERT_MEMBER_FUNCTOR (&PAT::mount, Feed(TurnoutSystem&));
    ASSERT_MEMBER_FUNCTOR (&PAT::pull, void(Feed&, TurnoutSystem&));
    ASSERT_MEMBER_FUNCTOR (&PAT::shed, void(Feed&, TurnoutSystem&, OptionalBuff));
    ASSERT_MEMBER_FUNCTOR (&PAT::weft, void(Feed&, TurnoutSystem&));
    ASSERT_MEMBER_FUNCTOR (&PAT::fix,  BuffHandle(Feed&, TurnoutSystem&));
    return sizeof(PAT);
  }
  
  
  
  template<class PAT>
  class Turnout
    : public Port
    , public PAT
    {
      static_assert (_verify_usable_as_WeavingPattern<PAT>());
      
      using Feed = PAT::Feed;
      
    public:
      template<typename...INIT>
      Turnout (ProcID& id, INIT&& ...init)
        : Port{id}
        , PAT{forward<INIT> (init)...}
        { }
      
      BuffHandle
      weave (TurnoutSystem& turnoutSys, OptionalBuff outBuff =std::nullopt)  override
        {
          Feed feed = PAT::mount (turnoutSys);
          PAT::pull (feed, turnoutSys);
          PAT::shed (feed, turnoutSys, outBuff);
          PAT::weft (feed, turnoutSys);
          return PAT::fix (feed, turnoutSys);
        }
    };
  
  
  
  
  
  template<class PAT>
  class _TurnoutDiagnostic
    : public Port
    , public PAT
    {
      BuffHandle
      weave (TurnoutSystem&, OptionalBuff =std::nullopt)  override
        {
          throw err::Fatal{"Diagnostic class -- must not be invoked"};
        }
      
    public:
      static auto
      accessInternal (Port& port)
        {                                // Note: deliberately static, not dynamic-cast
          auto& internalView = static_cast<_TurnoutDiagnostic&> (port);
          auto& weavingPattern = static_cast<PAT&> (internalView);
          return _accessInternal(weavingPattern);
        }
    };
  
  
  
}}// namespace steam::engine
#endif /*STEAM_ENGINE_TURNOUT_H*/