diff --git a/src/steam/engine/buffer-provider.hpp b/src/steam/engine/buffer-provider.hpp index 2972f2eef..44fc4bbdb 100644 --- a/src/steam/engine/buffer-provider.hpp +++ b/src/steam/engine/buffer-provider.hpp @@ -50,6 +50,7 @@ #include "steam/engine/buffer-local-key.hpp" #include "lib/nocopy.hpp" +#include #include @@ -58,6 +59,7 @@ namespace engine { using lib::Literal; using std::unique_ptr; + using std::forward; class BufferMetadata; @@ -105,8 +107,8 @@ namespace engine { void emitBuffer (BuffHandle const&); void releaseBuffer (BuffHandle const&); - template - BuffHandle lockBufferFor (); + template + BuffHandle lockBufferFor (ARGS ...args); /** allow for attaching and owing an object within an already created buffer */ void attachTypeHandler (BuffHandle const& target, BufferDescriptor const& reference); @@ -118,8 +120,8 @@ namespace engine { BufferDescriptor getDescriptorFor(size_t storageSize=0); BufferDescriptor getDescriptorFor(size_t storageSize, TypeHandler specialTreatment); - template - BufferDescriptor getDescriptor(); + template + BufferDescriptor getDescriptor (ARGS ...args); @@ -146,11 +148,11 @@ namespace engine { * buffer descriptor. The corresponding buffer * has been allocated and marked for exclusive use */ - template + template BuffHandle - BufferProvider::lockBufferFor() + BufferProvider::lockBufferFor (ARGS ...args) { - BufferDescriptor attach_object_automatically = getDescriptor(); + BufferDescriptor attach_object_automatically = getDescriptor (forward (args)...); return lockBuffer (attach_object_automatically); } @@ -159,11 +161,11 @@ namespace engine { * an instance of the template type embedded into the buffer * and destroying that embedded object when releasing the buffer. */ - template + template BufferDescriptor - BufferProvider::getDescriptor() + BufferProvider::getDescriptor (ARGS ...args) { - return getDescriptorFor (sizeof(BU), TypeHandler::create()); + return getDescriptorFor (sizeof(BU), TypeHandler::create (forward (args)...)); } diff --git a/src/steam/engine/connectivity-obsolete.hpp b/src/steam/engine/connectivity-obsolete.hpp index 7b1ca684b..0a9876a82 100644 --- a/src/steam/engine/connectivity-obsolete.hpp +++ b/src/steam/engine/connectivity-obsolete.hpp @@ -52,7 +52,6 @@ #include "steam/mobject/parameter.hpp" #include "steam/engine/state-closure-obsolete.hpp" /////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation #include "steam/engine/channel-descriptor.hpp" -#include "steam/engine/turnout-system.hpp" #include "lib/frameid.hpp" #include "lib/ref-array.hpp" @@ -71,13 +70,6 @@ namespace engine { typedef ProcNode* PNode; /////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation - class Port - { - public: - virtual ~Port(); ///< this is an interface - - virtual TurnoutSystem enactTurnout() =0; - }; /** * Interface: Description of the input and output ports, diff --git a/src/steam/engine/feed-manifold.hpp b/src/steam/engine/feed-manifold.hpp index 33af4ff4a..8e3f46437 100644 --- a/src/steam/engine/feed-manifold.hpp +++ b/src/steam/engine/feed-manifold.hpp @@ -35,11 +35,10 @@ #include "lib/error.hpp" #include "lib/nocopy.hpp" -#include "steam/engine/channel-descriptor.hpp" #include "steam/engine/proc-node.hpp" +#include "lib/several.hpp" -#include -#include +//#include ////////////////////////////////TICKET #826 will be reworked alltogether @@ -61,134 +60,12 @@ namespace engine { * thus the array of real buffer pointers can be fed directly to the * processing function of the respective node. * - * @todo this whole design is a first attempt and rather clumsy. It should be reworked - * to use a single contiguous memory area and just layer the object structure on top - * (by using placement new). Yet the idea of an stack-like organisation should be retained + * @todo WIP-WIP-WIP 7/24 now reworking the old design in the light of actual render engine requirements... */ struct FeedManifold { - typedef BuffHandle * PHa; - typedef BuffHandle::PBuff * PBu; - typedef pair Chunk; - - PHa outHandle; - PHa inHandle; - PBu outBuff; - PBu inBuff; }; -/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : presumably obsolete - class BufferDescriptor; - - /** Obsolete, to be rewritten /////TICKET #826 */ - class BuffTableStorage - { - /////////////////////////////////////////////////////////////////////////TICKET #826 need to be reworked entirely - /** just a placeholder to decouple the existing code - * from the reworked BuffHandle logic. The existing - * code in turn will be reworked rather fundamentally - */ - struct BuffHaXXXX - : BuffHandle - { - BuffHaXXXX() : BuffHandle(just_satisfy_the_compiler()) { /* wont work ever */ } - static BufferDescriptor const& - just_satisfy_the_compiler() { } - }; - - ////////////////////////////////////TICKET #825 should be backed by mpool and integrated with node invocation - vector hTab_; - vector pTab_; - size_t level_; - - public: - BuffTableStorage (const size_t maxSiz) - : hTab_(maxSiz), - pTab_(maxSiz), - level_(0) - { } - - ~BuffTableStorage() { ASSERT (0==level_, "buffer management logic broken."); } - - protected: - - friend class BuffTableChunk; - - /** allocate the given number of slots - * starting at current level to be used - * by the newly created BuffTableChunk - */ - FeedManifold::Chunk - claim (uint slots) - { - ASSERT (pTab_.size() == hTab_.size()); - REQUIRE (level_+slots <= hTab_.size()); - - size_t prev_level (level_); - level_ += slots; - return std::make_pair (&hTab_[prev_level], - &pTab_[prev_level]); - } - - void - release (uint slots) - { - ASSERT (slots <= level_); - REQUIRE (level_ <= hTab_.size()); - REQUIRE (level_ <= pTab_.size()); - - level_ -= slots; - } - - bool - level_check (FeedManifold::Chunk& prev_level) - { - return prev_level.first == &hTab_[level_] - && prev_level.second == &pTab_[level_]; - } - }; - - - /** Obsolete, to be rewritten /////TICKET #826 - * to be allocated on the stack while evaluating a ProcNode#pull() call. - * The "current" State (StateProxy) maintains a BuffTableStorage (=pool), - * which can be used to crate such chunks. The claiming and releasing of - * slots in the BuffTableStorage is automatically tied to BuffTableChunk - * object's lifecycle. - */ - class BuffTableChunk - : public FeedManifold, - util::NonCopyable - { - const uint siz_; - FeedManifold::Chunk tab_; - BuffTableStorage& sto_; - - public: - BuffTableChunk (Connectivity const& wd, BuffTableStorage& storage) - : siz_(wd.nrI + wd.nrO), - tab_(storage.claim (siz_)), - sto_(storage) - { - const uint nrO(wd.nrO); - - // Setup the publicly visible table locations - this->outHandle = &tab_.first[ 0 ]; - this->inHandle = &tab_.first[nrO]; - this->outBuff = &tab_.second[ 0 ]; - this->inBuff = &tab_.second[nrO]; - } - - ~BuffTableChunk () - { - sto_.release (siz_); - ASSERT ( sto_.level_check (tab_), - "buffer management logic broken."); - } - }; -/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : (End)presumably obsolete - - }} // namespace steam::engine diff --git a/src/steam/engine/node-wiring-builder.hpp b/src/steam/engine/node-wiring-builder.hpp index 319c96d6b..c3bc81b71 100644 --- a/src/steam/engine/node-wiring-builder.hpp +++ b/src/steam/engine/node-wiring-builder.hpp @@ -42,10 +42,7 @@ #define ENGINE_NODE_WIRING_BUILDER_H -//#include "steam/engine/proc-node.hpp" //////////////////////////////////////////////////////////////////TICKET #1367 : switch to new Node Invocation scheme -#include "steam/engine/connectivity-obsolete.hpp" -#include "lib/ref-array.hpp" -#include "lib/util-foreach.hpp" +#include "steam/engine/proc-node.hpp" #include "lib/nocopy.hpp" @@ -53,137 +50,6 @@ namespace steam { namespace engine { - using lib::RefArray; - - - /** - * Finding out about a concrete way of wiring up a - * ProcNode about to be built. Such a (temporary) setup object - * is used while building the low-level model. It is loaded with - * information concerning the intended connections to be made - * and then used to initialise the wiring descriptor, which - * in turn allows us to setup the ProcNode. - * - * \par intended usage pattern - * The goal is to describe the constellation of a new node to be built. - * Thus, we start with one or several existing nodes, specifying which - * output should go to which input pin of the yet-to-be created new node. - * When intending to create a source node, a default WiringSituation - * should be used, without adding any connection information. - * - * @deprecated WIP-WIP-WIP 2024 Node-Invocation is reworked from ground up for the »Playback Vertical Slice« - */ - class WiringSituation - : util::NonCopyable - { - long flags_; - asset::Proc::ProcFunc* function_; - - public: /* === API for querying collected data === */ - RefArray& - makeOutDescriptor() const - { - UNIMPLEMENTED ("build new output descriptors for the node under construction"); //////////TODO: where to get the information about the output channels??? - } - - RefArray& - makeInDescriptor() const - { - UNIMPLEMENTED ("build new input descriptors for the node under construction"); - } - - Connectivity::ProcFunc* - resolveProcessingFunction() const - { - REQUIRE (function_); - return function_; - } - - lumiera::NodeID const& - createNodeID() const - { - UNIMPLEMENTED ("initiate generation of a new unique node-ID"); // see rendergraph.cpp - } - - - - public: /* === API for specifying the desired wiring === */ - - /** A default WiringSituation doesn't specify any connections. - * It can be used as-is for building a source node, or augmented - * with connection information later on. - */ - WiringSituation() - : flags_(0) - , function_(0) - { - UNIMPLEMENTED ("representation of the intended wiring"); - } - - - /** Continue the wiring by hooking directly into the output - * of an existing predecessor node - */ - WiringSituation (PNode predecessor) - : flags_(0) - , function_(0) - { - UNIMPLEMENTED ("wiring representation; hook up connections 1:1"); - REQUIRE (predecessor); - - //////////////////////////TODO: see Ticket 254 - // for_each (predecessor->outputs(), ..... see also Ticket 183 (invoking member fun in for_each) - - } - - - /** set up a connection leading to a specific input pin of the new node */ - WiringSituation& - defineInput (uint inPin, PNode pred, uint outPin) - { - UNIMPLEMENTED ("wiring representation; define new connection"); - return *this; - } - - /** set up the next input connection, - * originating at a specific output pin of the predecessor */ - WiringSituation& - defineInput (PNode pred, uint outPin) - { - UNIMPLEMENTED ("wiring representation; define new connection"); - return *this; - } - - /** set up the next input connection to a specific input pin, - * originating at a the next/sole output pin of the predecessor */ - WiringSituation& - defineInput (uint inPin, PNode pred) - { - UNIMPLEMENTED ("wiring representation; define new connection"); - return *this; - } - - - /** set detail flags regarding the desired node operation mode */ - WiringSituation& - setFlag (long code) - { - flags_ |= code; - return *this; - } - - long getFlags () const { return flags_; } - - - /** trigger resolving of the actual processing function */ - WiringSituation& - resolveProcessor (asset::Proc const& procAsset) - { - function_ = procAsset.resolveProcessor(); - ENSURE (function_); - } - - }; /////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation class NodeWiringBuilder @@ -194,8 +60,7 @@ namespace engine { /****************************************************//** * Terminal: complete the Connectivity defined thus far. */ -// Connectivity - void* /////////////////////////////////////////////////OOO Connectivity no longer needs to be abstract + Connectivity build() { UNIMPLEMENTED("Node-Connectivity Setup"); @@ -211,6 +76,7 @@ namespace engine { buildPatternFor() { UNIMPLEMENTED("instantiate Domain Ontology Facade and outfit the NodeWiringBuilder"); + return NodeWiringBuilder{}; } diff --git a/src/steam/engine/nodewiring-obsolete.hpp b/src/steam/engine/nodewiring-obsolete.hpp index 633782d8a..aade4705b 100644 --- a/src/steam/engine/nodewiring-obsolete.hpp +++ b/src/steam/engine/nodewiring-obsolete.hpp @@ -33,9 +33,7 @@ #define ENGINE_NODEWIRING_OBSOLETE_H -//#include "steam/engine/proc-node.hpp" ///////////////////////////////TODO clarify if required further on #include "steam/engine/connectivity-obsolete.hpp" -#include "steam/engine/node-wiring-builder.hpp" #include "lib/allocation-cluster.hpp" #include "lib/ref-array.hpp" #include "lib/util-foreach.hpp" @@ -53,9 +51,141 @@ namespace engine { namespace config { class WiringFactoryImpl; } +/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : inlined here and then dropped in node-wiring-builder.hpp using lib::RefArray; + /** + * Finding out about a concrete way of wiring up a + * ProcNode about to be built. Such a (temporary) setup object + * is used while building the low-level model. It is loaded with + * information concerning the intended connections to be made + * and then used to initialise the wiring descriptor, which + * in turn allows us to setup the ProcNode. + * + * \par intended usage pattern + * The goal is to describe the constellation of a new node to be built. + * Thus, we start with one or several existing nodes, specifying which + * output should go to which input pin of the yet-to-be created new node. + * When intending to create a source node, a default WiringSituation + * should be used, without adding any connection information. + * + * @deprecated WIP-WIP-WIP 2024 Node-Invocation is reworked from ground up for the »Playback Vertical Slice« + */ + class WiringSituation + : util::NonCopyable + { + long flags_; + asset::Proc::ProcFunc* function_; + + public: /* === API for querying collected data === */ + RefArray& + makeOutDescriptor() const + { + UNIMPLEMENTED ("build new output descriptors for the node under construction"); //////////TODO: where to get the information about the output channels??? + } + + RefArray& + makeInDescriptor() const + { + UNIMPLEMENTED ("build new input descriptors for the node under construction"); + } + + Connectivity::ProcFunc* + resolveProcessingFunction() const + { + REQUIRE (function_); + return function_; + } + + lumiera::NodeID const& + createNodeID() const + { + UNIMPLEMENTED ("initiate generation of a new unique node-ID"); // see rendergraph.cpp + } + + + + public: /* === API for specifying the desired wiring === */ + + /** A default WiringSituation doesn't specify any connections. + * It can be used as-is for building a source node, or augmented + * with connection information later on. + */ + WiringSituation() + : flags_(0) + , function_(0) + { + UNIMPLEMENTED ("representation of the intended wiring"); + } + + + /** Continue the wiring by hooking directly into the output + * of an existing predecessor node + */ + WiringSituation (PNode predecessor) + : flags_(0) + , function_(0) + { + UNIMPLEMENTED ("wiring representation; hook up connections 1:1"); + REQUIRE (predecessor); + + //////////////////////////TODO: see Ticket 254 + // for_each (predecessor->outputs(), ..... see also Ticket 183 (invoking member fun in for_each) + + } + + + /** set up a connection leading to a specific input pin of the new node */ + WiringSituation& + defineInput (uint inPin, PNode pred, uint outPin) + { + UNIMPLEMENTED ("wiring representation; define new connection"); + return *this; + } + + /** set up the next input connection, + * originating at a specific output pin of the predecessor */ + WiringSituation& + defineInput (PNode pred, uint outPin) + { + UNIMPLEMENTED ("wiring representation; define new connection"); + return *this; + } + + /** set up the next input connection to a specific input pin, + * originating at a the next/sole output pin of the predecessor */ + WiringSituation& + defineInput (uint inPin, PNode pred) + { + UNIMPLEMENTED ("wiring representation; define new connection"); + return *this; + } + + + /** set detail flags regarding the desired node operation mode */ + WiringSituation& + setFlag (long code) + { + flags_ |= code; + return *this; + } + + long getFlags () const { return flags_; } + + + /** trigger resolving of the actual processing function */ + WiringSituation& + resolveProcessor (asset::Proc const& procAsset) + { + function_ = procAsset.resolveProcessor(); + ENSURE (function_); + } + + }; +/////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : (END)inlined here and then dropped in node-wiring-builder.hpp + + /** diff --git a/src/steam/engine/proc-node.hpp b/src/steam/engine/proc-node.hpp index b8f1c11a4..c449faaf7 100644 --- a/src/steam/engine/proc-node.hpp +++ b/src/steam/engine/proc-node.hpp @@ -51,7 +51,8 @@ #include "steam/engine/channel-descriptor.hpp" #include "steam/engine/turnout-system.hpp" #include "lib/frameid.hpp" -#include "lib/ref-array.hpp" +#include "lib/ref-array.hpp" /////////////////////OOO phase out +#include "lib/several.hpp" #include diff --git a/src/steam/engine/turnout.hpp b/src/steam/engine/turnout.hpp index 387304a00..8245213e9 100644 --- a/src/steam/engine/turnout.hpp +++ b/src/steam/engine/turnout.hpp @@ -59,11 +59,11 @@ #ifndef STEAM_ENGINE_TURNOUT_H #define STEAM_ENGINE_TURNOUT_H -#include #include "steam/common.hpp" #include "steam/engine/proc-node.hpp" #include "steam/engine/turnout-system.hpp" #include "steam/engine/feed-manifold.hpp" +#include "steam/engine/state-closure.hpp" /////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation #include "steam/engine/channel-descriptor.hpp" //#include "vault/gear/job.h" diff --git a/src/steam/engine/type-handler.hpp b/src/steam/engine/type-handler.hpp index 0eae6666f..1802a32c3 100644 --- a/src/steam/engine/type-handler.hpp +++ b/src/steam/engine/type-handler.hpp @@ -45,6 +45,7 @@ #include "lib/error.hpp" #include "lib/hash-value.h" +#include #include #include @@ -54,6 +55,7 @@ namespace engine { using lib::HashVal; using std::bind; + using std::forward; using std::function; using std::placeholders::_1; @@ -62,18 +64,11 @@ namespace engine { namespace { // (optional) helpers to build an object embedded into a buffer... - template + template inline void - buildIntoBuffer (void* storageBuffer) + buildIntoBuffer (void* storageBuffer, ARGS&& ...args) { - new(storageBuffer) X(); - } - - template - inline void - buildIntoBuffer_A1 (void* storageBuffer, A1 arg1) - { - new(storageBuffer) X(arg1); + new(storageBuffer) X(forward (args)...); } template @@ -145,20 +140,13 @@ namespace engine { { } /** builder function defining a TypeHandler - * to place a default-constructed object - * into the buffer. */ - template + * to place an object into the buffer, + * possibly with given ctor arguments. */ + template static TypeHandler - create () + create (ARGS&& ...args) { - return TypeHandler (buildIntoBuffer, destroyInBuffer); - } - - template - static TypeHandler - create (A1 a1) - { - return TypeHandler ( bind (buildIntoBuffer_A1, _1, a1) + return TypeHandler ( bind (buildIntoBuffer, _1, forward (args)...) , destroyInBuffer); } diff --git a/tests/core/steam/engine/feed-manifold-test.cpp b/tests/core/steam/engine/feed-manifold-test.cpp index 75349d6c6..855c04b02 100644 --- a/tests/core/steam/engine/feed-manifold-test.cpp +++ b/tests/core/steam/engine/feed-manifold-test.cpp @@ -135,25 +135,27 @@ namespace test { */ class FeedManifold_test : public Test { +#if false /////////////////////////////////////////////////////////////////////////////////////////////////////////////UNIMPLEMENTED :: TICKET #852 using PSto = std::unique_ptr; PSto pStorage; +#endif /////////////////////////////////////////////////////////////////////////////////////////////////////////////UNIMPLEMENTED :: TICKET #852 ulong counter; virtual void run(Arg) { counter = 0; +#if false /////////////////////////////////////////////////////////////////////////////////////////////////////////////UNIMPLEMENTED :: TICKET #852 // allocate storage block to be used chunk wise pStorage.reset (new BuffTableStorage (TABLE_SIZ)); -#if false /////////////////////////////////////////////////////////////////////////////////////////////////////////////UNIMPLEMENTED :: TICKET #852 invocation (0, detect_start_level(*pStorage)); -#endif /////////////////////////////////////////////////////////////////////////////////////////////////////////////UNIMPLEMENTED :: TICKET #852 pStorage.reset(0); // dtor throws assertion error if corrupted cout << "BuffTable chunks allocated: "<() + .build(); + UNIMPLEMENTED ("build render nodes linked into a connectivity network"); + } + + + /** @test TODO Use existing node connectivity to generate a TurnoutSystem + * @todo WIP 7/24 🔁 define ⟶ implement + */ + void + generate_turnout_system() + { + UNIMPLEMENTED ("use existing node connectivity to generate a TurnoutSystem"); + } + + + /** @test TODO Invoke some render nodes as linked together + * @todo WIP 7/24 🔁 define ⟶ implement + */ + void + trigger_node_port_invocation() { UNIMPLEMENTED ("operate some render nodes as linked together"); - } + } }; diff --git a/tests/core/steam/engine/test-rand-ontology.hpp b/tests/core/steam/engine/test-rand-ontology.hpp new file mode 100644 index 000000000..fcbfe3f17 --- /dev/null +++ b/tests/core/steam/engine/test-rand-ontology.hpp @@ -0,0 +1,66 @@ +/* + TEST-RAND-ONTOLOGY.hpp - placeholder for a domain-ontology working on dummy data frames + + Copyright (C) Lumiera.org + 2024, Hermann Vosseler + + This program 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. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. + +*/ + +/** @file testframe-rand-ontology.hpp + ** A faked »media calculation« environment to validate the render node network. + */ + + +#ifndef STEAM_ENGINE_TEST_RAND_ONTOLOGY_H +#define STEAM_ENGINE_TEST_RAND_ONTOLOGY_H + + +#include "steam/engine/testframe.hpp" + + +namespace steam { +namespace engine{ +namespace test { + + + /** + * A fake _Domain Ontology_ to describe mocked »render operations« on + * dummy data frames filled with random numbers. + * + * @see TestFrame_test + * @see NodeDevel_test + * @see NodeLinkage_test + * + */ + class TestRandOntology + { + + public: + ~TestRandOntology() = default; + TestRandOntology() = default; + + private: + }; + + + + /** */ + + + +}}} // namespace steam::engine::test +#endif diff --git a/wiki/thinkPad.ichthyo.mm b/wiki/thinkPad.ichthyo.mm index c672ab7fd..39e14e3c9 100644 --- a/wiki/thinkPad.ichthyo.mm +++ b/wiki/thinkPad.ichthyo.mm @@ -80043,9 +80043,7 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
- - - +

...für den »Playback Vertical Slice« wird eine Fixture fabriziert, wie sie vermutlich später mal vom Builder produziert werden wird (wenn es ihn dann endlich mal gibt) — tatsächlich sehe ich das als ersten prototypischen Entwurf, den ich hier nebenbei aus einer bottom-up-Bewegung gewinnen kann @@ -80444,16 +80442,13 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
- - - +

beachte: dieser »eine Frame« kann durchaus noch inhärent strukturiert sein, beispielsweise mehrere Planes für ein planares Format enthalten oder ein Interleaved-Zyklus von Einzelframes für zusammengehörige Kanäle sein — entscheidend ist, daß dieses Datenelement jeweils als EInheit verwendet und zusammen produziert oder konsumiert wird.

- - + @@ -80720,6 +80715,22 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
 + + + + +

+ erste Rohentwürfe +

+

+ +Basis-Implementation +

+ + + + + + @@ -81400,22 +81411,17 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
- - - +

aber erwartungsgemäß hat man das eben grade nicht

- - + - - - +

...sondern nur einen lokalen Kontext @@ -81439,23 +81445,18 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
- - - +

...und ich kann mich erinnern, daß ich sie auch damals nicht vestanden habe, sondern mich immer nur von Definition zu Definition hangelte...

- - + - - - +

das ist die gradezu klassische »Top-down«-Falle: @@ -81472,8 +81473,7 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
- - + @@ -81485,13 +81485,15 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
 - + + + @@ -81500,18 +81502,22 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
- + - + + - + + - + + + @@ -81519,8 +81525,179 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ dieser speichert einen HashVal subClassification_ +

+ + + + + + + + + + + + + + + + +

+ siehe type-handler.hpp +

+ + + + + + + + +

+ dieser zielt darauf ab, Strukturen in den Buffer zu pflanzen +

+ + + + + + + + + + + + + + + + + + + + + + + +

+ und dieser gehört zu einer DomainOntology +

+ + + + + + + + + + + + + + + + + + + + + + + + + + + + +

+ Konsequenz ⟹ die Spec legt fest was in den Buffer gelegt wird +

+ + + + + + + + + + + + + + +

+ leider setzt das bereits die Domain-Ontology vorraus +

+ + + + + + + + + + + + + + + + + + + +

+ ...und zur Laufzeit wird nur noch ein Stück von diesem »was« angefordert +

+ + + + + + + + + + + + @@ -81530,8 +81707,9 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
- - + + + @@ -85215,12 +85393,12 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
- +

- man geht von ProcNode durch Connectivity, dann NodeWiring ... und wenn man Glück hat, fällt einem der Header nodeoperaton.hpp auf...  ⚠ denn sonst ist der tatsächliche Einstiegspunkt mit üblichen Methoden der Code-Suche praktisch nicht zu finden: Er steckt in nodewiring.hpp in der konkreten Definition der virtuellen Funktion callDown()  — und von dort in eine dependent Method thisStep.retrieve(), die tatsächlich im Template ActualInvocationProcess an STRATEGY::step()  weitergereicht wird — und vermutlich ist nur mir klar, daß damit die verketteten step()-Methoden in nodeoperation.hpp gemeint sind... + man geht von ProcNode durch Connectivity, dann NodeWiring ... und wenn man Glück hat, fällt einem der Header nodeoperation.hpp  auf...  ⚠ denn sonst ist der tatsächliche Einstiegspunkt mit üblichen Methoden der Code-Suche praktisch nicht zu finden: Er steckt in nodewiring.hpp in der konkreten Definition der virtuellen Funktion callDown()  — und von dort in eine dependent Method thisStep.retrieve(), die tatsächlich im Template ActualInvocationProcess an STRATEGY::step()  weitergereicht wird — und vermutlich ist nur mir klar, daß damit die verketteten step()-Methoden in nodeoperation.hpp  gemeint sind...

@@ -85313,11 +85491,22 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
- + + - - - + + + + + + + + + + + + + @@ -85487,6 +85676,7 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
 + @@ -85494,9 +85684,10 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
+ - + @@ -85522,9 +85713,7 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
- - - +

...und zwar mit einer Gruppierung der Buffer nach Größe, und vermutlich auch pro Thread @@ -85543,16 +85732,13 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
- - - +

Es kann durchaus sein, daß das jeweilige Output-System einzelne Teil-Kanäle in einem planaren Format haben möchte, also als einzelne, zusammenhängende Datenblöcke für jeden Kanal (Hue, Sat, Lum, bzw. Sound-L/R oder WXYZ...)

- - + @@ -85566,12 +85752,13 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
- + + - + @@ -85583,23 +85770,25 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
- - - +

warum? weil es die BufferManager-Abstraktion unterläuft

- - + - + + + + + + @@ -85633,10 +85822,34 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
+ + + + + + + +

+ Auf der Ebene der Implementierung ist die Domain-Ontology so etwas wie eine Typklasse — wie bildet man das in C++17 ab — und wie in C++20 ? +

+ + + + + + + + + + + + + + - + @@ -85659,8 +85872,14 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
- - + + + + + + + + @@ -85685,7 +85904,12 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
 - + + + + + + @@ -85779,16 +86003,13 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
 - - - +

...weiterhin bleibt es dabei, daß der Zugang zum Buffer-Management über das Turnout-System (früher StateAdapter) läuft; aber dafür ist kein klassisches OO-Interface notwendig, sofern das Buffer-Handling seinerseits auf einem Interface aufbaut. Die Aufgabe, an der sich das entscheidet ist, wie der konkrete Turnout eine konkrete FeedManifold bauen kann (und ob er das überhaupt tut)

- - + @@ -124838,6 +125059,10 @@ std::cout << tmpl.render({"what", "World"}) << s + + + +