diff --git a/src/steam/engine/buffer-metadata.hpp b/src/steam/engine/buffer-metadata.hpp index 67819a6cd..b42097e63 100644 --- a/src/steam/engine/buffer-metadata.hpp +++ b/src/steam/engine/buffer-metadata.hpp @@ -40,10 +40,10 @@ ** just accesses yet another buffer to place the results of calculations. ** ** These additional distinctions and properties are associated with the help of the - ** BufferDescriptor, embedded into each BuffHandle. While the engine just uses these - ** handles in the way of a pointer, the buffer descriptor acts as an additional tag - ** attached to the buffer access, allowing to re-access a context within the - ** buffer provider implementation. + ** [Buffer Descriptor](\ref BuffDescr), embedded into each BuffHandle. While the engine + ** mostly uses these handles in the way of a pointer, the buffer descriptor acts as a + ** configuration tag attached to the buffer access, allowing to re-access a context + ** within the buffer provider implementation. ** ** @see buffer-provider.hpp ** @see BufferMetadata_test @@ -140,7 +140,7 @@ namespace engine { /** * Description of a Buffer-"type". * Key elements will be used to generate hash IDs, - * to be embedded into a BufferDescriptor. + * to be embedded into a [Buffer Descriptor](\ref BuffDescr). * Keys are chained hierarchically. */ class Key diff --git a/src/steam/engine/buffer-provider.cpp b/src/steam/engine/buffer-provider.cpp index bc09c9151..b714f903d 100644 --- a/src/steam/engine/buffer-provider.cpp +++ b/src/steam/engine/buffer-provider.cpp @@ -63,23 +63,23 @@ namespace engine { * currently locked and usable by client code */ bool - BufferProvider::verifyValidity (BufferDescriptor const& bufferID) const + BufferProvider::verifyValidity (BuffDescr const& bufferID) const { return meta_->isLocked (bufferID); } - BufferDescriptor + BuffDescr BufferProvider::getDescriptorFor (size_t storageSize) { - return BufferDescriptor (*this, meta_->key (storageSize)); + return BuffDescr (*this, meta_->key (storageSize)); } - BufferDescriptor + BuffDescr BufferProvider::getDescriptorFor(size_t storageSize, TypeHandler specialTreatment) { - return BufferDescriptor (*this, meta_->key (storageSize, specialTreatment)); + return BuffDescr (*this, meta_->key (storageSize, specialTreatment)); } @@ -103,7 +103,7 @@ namespace engine { metadata::Key& typeKey = meta_->get (typeID); metadata::Entry& entry = meta_->markLocked(typeKey, storage, implID); - return BuffHandle (BufferDescriptor(*this, entry), storage); + return BuffHandle (BuffDescr(*this, entry), storage); } @@ -113,14 +113,14 @@ namespace engine { * client may reasonably assume to get the actual number of buffers, as * indicated by the return value. A provider may be able to handle * various kinds of buffers (e.g. of differing size), which are - * distinguished by the \em type embodied into the BufferDescriptor. + * distinguished by _the type embodied into_ the BuffDescr. * @return maximum number of simultaneously usable buffers of this type, * to be retrieved later through calls to #lockBuffer. * @throw error::State when no buffer of this kind can be provided * @note the returned count may differ from the requested count. */ uint - BufferProvider::announce (uint count, BufferDescriptor const& type) + BufferProvider::announce (uint count, BuffDescr const& type) { uint actually_possible = prepareBuffers (count, type); if (!actually_possible) @@ -143,7 +143,7 @@ namespace engine { * to establish a reliably available baseline. */ BuffHandle - BufferProvider::lockBuffer (BufferDescriptor const& type) + BufferProvider::lockBuffer (BuffDescr const& type) { REQUIRE (was_created_by_this_provider (type)); @@ -203,7 +203,7 @@ namespace engine { * @note EX_STRONG */ void - BufferProvider::attachTypeHandler (BuffHandle const& target, BufferDescriptor const& reference) + BufferProvider::attachTypeHandler (BuffHandle const& target, BuffDescr const& reference) { metadata::Entry& metaEntry = meta_->get (target.entryID()); metadata::Entry& refEntry = meta_->get (reference); @@ -237,7 +237,7 @@ namespace engine { bool - BufferProvider::was_created_by_this_provider (BufferDescriptor const& descr) const + BufferProvider::was_created_by_this_provider (BuffDescr const& descr) const { return isSameObject (*this, *descr.provider_); } @@ -246,10 +246,10 @@ namespace engine { - /* === BufferDescriptor and BuffHandle === */ + /* === BuffDescr and BuffHandle === */ bool - BufferDescriptor::verifyValidity() const + BuffDescr::verifyValidity() const { ENSURE (provider_); return provider_->verifyValidity(*this); @@ -257,7 +257,7 @@ namespace engine { size_t - BufferDescriptor::determineBufferSize() const + BuffDescr::determineBufferSize() const { ENSURE (provider_); return provider_->getBufferSize (*this); @@ -265,7 +265,7 @@ namespace engine { uint - BufferDescriptor::announce (uint count) + BuffDescr::announce (uint count) { ENSURE (provider_); return provider_->announce(count, *this); @@ -273,7 +273,7 @@ namespace engine { BuffHandle - BufferDescriptor::lockBuffer() + BuffDescr::lockBuffer() { ENSURE (provider_); return provider_->lockBuffer(*this); @@ -313,7 +313,7 @@ namespace engine { * This causes the dtor function to be invoked when releasing this buffer. * The assumption is that client code will placement-construct an object * into this buffer right away, and thus we're taking ownership on that object. - * @param type a reference BufferDescriptor defining an embedded TypeHandler to use + * @param type a reference BuffDescr defining an embedded TypeHandler to use * A copy of this TypeHandler will be stored into the local metadata for * this buffer only, not altering the basic buffer type in any way * @throw lifecycle error when attempting to treat an buffer not in locked state @@ -322,7 +322,7 @@ namespace engine { * @note EX_STRONG */ void - BuffHandle::takeOwnershipFor(BufferDescriptor const& type) + BuffHandle::takeOwnershipFor(BuffDescr const& type) { if (!this->isValid()) throw error::Logic ("attaching an object requires an buffer in locked state", LERR_(LIFECYCLE)); diff --git a/src/steam/engine/buffer-provider.hpp b/src/steam/engine/buffer-provider.hpp index 44fc4bbdb..d365b9819 100644 --- a/src/steam/engine/buffer-provider.hpp +++ b/src/steam/engine/buffer-provider.hpp @@ -101,9 +101,9 @@ namespace engine { virtual ~BufferProvider(); ///< this is an ABC - uint announce (uint count, BufferDescriptor const&); + uint announce (uint count, BuffDescr const&); - BuffHandle lockBuffer (BufferDescriptor const&); + BuffHandle lockBuffer (BuffDescr const&); void emitBuffer (BuffHandle const&); void releaseBuffer (BuffHandle const&); @@ -111,29 +111,29 @@ namespace engine { BuffHandle lockBufferFor (ARGS ...args); /** allow for attaching and owing an object within an already created buffer */ - void attachTypeHandler (BuffHandle const& target, BufferDescriptor const& reference); + void attachTypeHandler (BuffHandle const& target, BuffDescr const& reference); void emergencyCleanup (BuffHandle const& target, bool invokeDtor =false); /** describe the kind of buffer managed by this provider */ - BufferDescriptor getDescriptorFor(size_t storageSize=0); - BufferDescriptor getDescriptorFor(size_t storageSize, TypeHandler specialTreatment); + BuffDescr getDescriptorFor(size_t storageSize=0); + BuffDescr getDescriptorFor(size_t storageSize, TypeHandler specialTreatment); template - BufferDescriptor getDescriptor (ARGS ...args); + BuffDescr getDescriptor (ARGS ...args); /* === API for BuffHandle internal access === */ - bool verifyValidity (BufferDescriptor const&) const; - size_t getBufferSize (HashVal typeID) const; + bool verifyValidity (BuffDescr const&) const; + size_t getBufferSize (HashVal typeID) const; protected: BuffHandle buildHandle (HashVal typeID, void* storage, LocalKey const&); - bool was_created_by_this_provider (BufferDescriptor const&) const; + bool was_created_by_this_provider (BuffDescr const&) const; }; @@ -152,7 +152,7 @@ namespace engine { BuffHandle BufferProvider::lockBufferFor (ARGS ...args) { - BufferDescriptor attach_object_automatically = getDescriptor (forward (args)...); + BuffDescr attach_object_automatically = getDescriptor (forward (args)...); return lockBuffer (attach_object_automatically); } @@ -162,7 +162,7 @@ namespace engine { * and destroying that embedded object when releasing the buffer. */ template - BufferDescriptor + BuffDescr BufferProvider::getDescriptor (ARGS ...args) { return getDescriptorFor (sizeof(BU), TypeHandler::create (forward (args)...)); diff --git a/src/steam/engine/buffhandle-attach.hpp b/src/steam/engine/buffhandle-attach.hpp index adb757ad9..805eda284 100644 --- a/src/steam/engine/buffhandle-attach.hpp +++ b/src/steam/engine/buffhandle-attach.hpp @@ -103,7 +103,7 @@ namespace engine { inline void BuffHandle::takeOwnershipFor() { - BufferDescriptor howto_attach_object_automatically + BuffDescr howto_attach_object_automatically = descriptor_.provider_->getDescriptor(); takeOwnershipFor (howto_attach_object_automatically); // EX_STRONG } diff --git a/src/steam/engine/buffhandle.hpp b/src/steam/engine/buffhandle.hpp index 06a374615..cae55fb9a 100644 --- a/src/steam/engine/buffhandle.hpp +++ b/src/steam/engine/buffhandle.hpp @@ -32,18 +32,19 @@ ** buffers, and for accessing those buffers, the node needs to keep a table of buffer ** pointers, and for releasing the buffers later on, we utilise the buffer handles. ** - ** These buffer handles are based on a buffer descriptor record, which is opaque as far - ** as the client is concerned. BufferDescriptor acts as a representation of the type or - ** kind of buffer. The only way to obtain such a BufferDescriptor is from a concrete - ** BufferProvider implementation. A back-link to this owning and managing provider is - ** embedded into the BufferDescriptor, allowing to retrieve an buffer handle, corresponding - ** to an actual buffer provided and managed behind the scenes. There is no automatic - ** resource management; clients are responsible to invoke BuffHandle#release when done. + ** These buffer handles are based on a [Buffer Descriptor record](\ref BuffDescr), + ** which is opaque as far as the client is concerned. BuffDescr acts as a representation + ** of the type or kind of buffer. The only way to obtain such a BuffDescr is from a concrete + ** BufferProvider implementation. A back-link to this owning and managing provider is embedded + ** into the BuffDescr, which thus may be used as a _configuration tag,_ allowing to retrieve a + ** concrete buffer handle when needed, corresponding to an actual buffer provided and managed + ** behind the scenes. There is no automatic resource management; clients are responsible to + ** invoke BuffHandle#release when done. ** - ** @warning buffer management via BuffHandle and BufferDescriptor does _not automatically - ** maintain proper alignment._ Rather, it relies on the storage allocator to provide - ** a buffer suitably aligned for the target type to hold. In most cases, this target - ** location will actually be storage maintained on heap through some STL collection; + ** @warning buffer management via BuffHandle and BuffDescr does _not automatically maintain + ** proper alignment._ Rather, it relies on the storage allocator to provide a buffer + ** suitably aligned for the target type to hold. In most cases, this target location + ** will actually be storage maintained on heap through some STL collection; ** this topic is a possible subtle pitfall non the less. ** ** @see BufferProvider @@ -82,13 +83,13 @@ namespace engine { * by the BufferProvider, which may use (and even change) the opaque contents * to organise the internal buffer management. */ - class BufferDescriptor + class BuffDescr { protected: BufferProvider* provider_; HashVal subClassification_; - BufferDescriptor(BufferProvider& manager, HashVal detail) + BuffDescr(BufferProvider& manager, HashVal detail) : provider_(&manager) , subClassification_(detail) { } @@ -120,8 +121,8 @@ namespace engine { { typedef StreamType::ImplFacade::DataBuffer Buff; - BufferDescriptor descriptor_; - Buff* pBuffer_; + BuffDescr descriptor_; + Buff* pBuffer_; public: @@ -129,7 +130,7 @@ namespace engine { /** @internal a buffer handle may be obtained by "locking" * a buffer from the corresponding BufferProvider */ - BuffHandle(BufferDescriptor const& typeInfo, void* storage = 0) + BuffHandle(BuffDescr const& typeInfo, void* storage = 0) : descriptor_(typeInfo) , pBuffer_(static_cast(storage)) { } @@ -181,7 +182,7 @@ namespace engine { private: template void takeOwnershipFor(); - void takeOwnershipFor(BufferDescriptor const& type); + void takeOwnershipFor(BuffDescr const& type); void emergencyCleanup(); }; diff --git a/src/steam/engine/bufftable.hpp b/src/steam/engine/bufftable.hpp index 2ec5400ac..8de8504a4 100644 --- a/src/steam/engine/bufftable.hpp +++ b/src/steam/engine/bufftable.hpp @@ -80,7 +80,7 @@ namespace engine { class Builder { public: - Builder& announce (uint count, BufferDescriptor const& type); + Builder& announce (uint count, BuffDescr const& type); BuffTable& build(); }; @@ -110,7 +110,7 @@ namespace engine { inline BuffTable::Builder& - BuffTable::Builder::announce (uint count, BufferDescriptor const& type) + BuffTable::Builder::announce (uint count, BuffDescr const& type) { UNIMPLEMENTED ("accept announcement of additional buffer table entries required"); } diff --git a/src/steam/engine/channel-descriptor.hpp b/src/steam/engine/channel-descriptor.hpp index 11e50b14e..343421d43 100644 --- a/src/steam/engine/channel-descriptor.hpp +++ b/src/steam/engine/channel-descriptor.hpp @@ -49,9 +49,9 @@ namespace engine { using lib::HashVal; + class BuffDescr; class BuffHandle; class BufferProvider; - class BufferDescriptor; diff --git a/src/steam/engine/feed-manifold-obsolete.hpp b/src/steam/engine/feed-manifold-obsolete.hpp index 569816856..1a4e9f12f 100644 --- a/src/steam/engine/feed-manifold-obsolete.hpp +++ b/src/steam/engine/feed-manifold-obsolete.hpp @@ -78,7 +78,7 @@ namespace engine { PBu inBuff; }; - class BufferDescriptor; + class BuffDescr; /** Obsolete, to be rewritten /////TICKET #826 */ class BuffTableStorage @@ -92,7 +92,7 @@ namespace engine { : BuffHandle { BuffHaXXXX() : BuffHandle(just_satisfy_the_compiler()) { /* wont work ever */ } - static BufferDescriptor const& + static BuffDescr const& just_satisfy_the_compiler() { } }; diff --git a/src/steam/engine/state-closure-obsolete.hpp b/src/steam/engine/state-closure-obsolete.hpp index 59263e4cc..40e0b8f21 100644 --- a/src/steam/engine/state-closure-obsolete.hpp +++ b/src/steam/engine/state-closure-obsolete.hpp @@ -64,7 +64,7 @@ namespace engine { ////////////////////////////////////////////////TICKET #826 expected to be reworked to quite some extent (9/2011) public: /** allocate a new writable buffer with type and size according to - * the BufferDescriptor. The actual provider of this buffer depends + * the BuffDescr. The actual provider of this buffer depends * on the StateClosure implementation; it could be a temporary, located in * the cache, used for feeding calculated frames over a network, etc. * @return a BuffHandle encapsulating the information necessary to get diff --git a/src/steam/engine/state-closure.hpp b/src/steam/engine/state-closure.hpp index cdcdf8a6a..f303dd177 100644 --- a/src/steam/engine/state-closure.hpp +++ b/src/steam/engine/state-closure.hpp @@ -64,7 +64,7 @@ namespace engine { /////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : to be Reworked for »Playback Vertical Slice« public: /** allocate a new writable buffer with type and size according to - * the BufferDescriptor. The actual provider of this buffer depends + * the BuffDescr. The actual provider of this buffer depends * on the StateClosure implementation; it could be a temporary, located in * the cache, used for feeding calculated frames over a network, etc. * @return a BuffHandle encapsulating the information necessary to get diff --git a/src/steam/engine/turnout.hpp b/src/steam/engine/turnout.hpp index 3bf6a9b91..a0e2f31d5 100644 --- a/src/steam/engine/turnout.hpp +++ b/src/steam/engine/turnout.hpp @@ -70,6 +70,8 @@ //#include "steam/engine/exit-node.hpp" //#include "lib/time/timevalue.hpp" //#include "lib/linked-elements.hpp" +#include "lib/several.hpp" +#include "lib/several-builder.hpp"/////////////////TODO extract with a WeavingPattern builder //#include "lib/util-foreach.hpp" //#include "lib/iter-adapter.hpp" #include "lib/meta/function.hpp" @@ -85,6 +87,7 @@ namespace steam { namespace engine { using std::forward; + using lib::Several; /////////////////////////////////////////////////////////////////////////////////////////////////////////////TICKET #1367 : Rebuild the Node Invocation /** @@ -394,7 +397,7 @@ namespace engine { */ template struct Conf_DirectFunctionInvocation - //////////////////////////////OOO non-copyable? move-only?? + : util::MoveOnly { using Manifold = FeedManifold; using Feed = SimpleFunctionInvocationAdapter; @@ -413,12 +416,8 @@ namespace engine { uint fanIn{0}; uint fanOut{0}; - template - using Storage = lib::UninitialisedStorage; - - - Storage leadPort; - Storage outDescr; + Several leadPort; + Several outDescr; //////////////////////////////////////////OOO builder must set-up those descriptors @@ -433,7 +432,7 @@ namespace engine { { for (uint i=0; i struct SimpleWeavingBuilder - : Turnout> + : Turnout> /////////////////////////////////OOO can no longer directly inherit from the product(Turnout), due to SeveralBuilder!!! { SimpleWeavingBuilder attachToLeadPort(ProcNode& lead, uint portNr) @@ -526,6 +525,7 @@ namespace engine { Turnout> build() { + ///////////////////////////////OOO need a way to prepare SeveralBuilder-instances for leadPort and outDescr --> see NodeBuilder return move(*this); } }; diff --git a/src/steam/engine/type-handler.hpp b/src/steam/engine/type-handler.hpp index 1802a32c3..455e288d5 100644 --- a/src/steam/engine/type-handler.hpp +++ b/src/steam/engine/type-handler.hpp @@ -30,7 +30,7 @@ ** Within the Lumiera Engine, the BufferProvider default implementation utilises instances ** of TypeHandler to _describe specific buffer types_ capable of managing an attached object, ** or requiring some other kind of special treatment of the memory area used for the buffer. - ** This BufferDescriptor is embodied into the BufferMetadata::Key and used later on to invoke + ** This BuffDescr is embodied into the BufferMetadata::Key and used later on to invoke ** the contained ctor / dtor functors, passing a concrete buffer (memory area). ** ** @see buffer-metadata.hpp diff --git a/tests/core/steam/engine/buffer-metadata-test.cpp b/tests/core/steam/engine/buffer-metadata-test.cpp index ec69ae067..5ff7ffff7 100644 --- a/tests/core/steam/engine/buffer-metadata-test.cpp +++ b/tests/core/steam/engine/buffer-metadata-test.cpp @@ -211,7 +211,7 @@ namespace test { bufferType1 = meta_->key(bufferType1, transaction1); rawBuffType = meta_->key(rawBuffType, transaction2); // these type keys are now handed over to the client, - // embedded into a BufferDescriptor... + // embedded into a Buffer Descriptor... // later, when it comes to actually *locking* those buffers... typedef char RawBuffer[SIZE_B]; diff --git a/tests/core/steam/engine/buffer-provider-protocol-test.cpp b/tests/core/steam/engine/buffer-provider-protocol-test.cpp index ac6dee9b9..5d9b825f2 100644 --- a/tests/core/steam/engine/buffer-provider-protocol-test.cpp +++ b/tests/core/steam/engine/buffer-provider-protocol-test.cpp @@ -126,8 +126,8 @@ namespace test { // will be preconfigured, depending on the usage context BufferProvider& provider = DiagnosticBufferProvider::build(); - BufferDescriptor desc1 = provider.getDescriptor(); // note: implies also sizeof(TestFrame) - BufferDescriptor desc2 = provider.getDescriptorFor(TEST_SIZE); + BuffDescr desc1 = provider.getDescriptor(); // note: implies also sizeof(TestFrame) + BuffDescr desc2 = provider.getDescriptorFor(TEST_SIZE); CHECK (desc1.verifyValidity()); CHECK (desc2.verifyValidity()); @@ -158,9 +158,9 @@ namespace test { verifyObjectAttachment() { BufferProvider& provider = DiagnosticBufferProvider::build(); - BufferDescriptor type_A = provider.getDescriptorFor(sizeof(TestFrame)); - BufferDescriptor type_B = provider.getDescriptorFor(sizeof(int)); - BufferDescriptor type_C = provider.getDescriptor(); + BuffDescr type_A = provider.getDescriptorFor(sizeof(TestFrame)); + BuffDescr type_B = provider.getDescriptorFor(sizeof(int)); + BuffDescr type_C = provider.getDescriptor(); BuffHandle handle_A = provider.lockBuffer(type_A); BuffHandle handle_B = provider.lockBuffer(type_B); @@ -195,7 +195,7 @@ namespace test { verifyObjectAttachmentFailure() { BufferProvider& provider = DiagnosticBufferProvider::build(); - BufferDescriptor type_D = provider.getDescriptorFor(sizeof(Dummy)); + BuffDescr type_D = provider.getDescriptorFor(sizeof(Dummy)); Dummy::checksum() = 0; BuffHandle handle_D = provider.lockBuffer(type_D); diff --git a/tests/core/steam/engine/tracking-heap-block-provider-test.cpp b/tests/core/steam/engine/tracking-heap-block-provider-test.cpp index 9879f4bb5..511fa4d18 100644 --- a/tests/core/steam/engine/tracking-heap-block-provider-test.cpp +++ b/tests/core/steam/engine/tracking-heap-block-provider-test.cpp @@ -113,7 +113,7 @@ namespace test { { TrackingHeapBlockProvider provider; - BufferDescriptor buffType = provider.getDescriptorFor(TEST_ELM_SIZE); + BuffDescr buffType = provider.getDescriptorFor(TEST_ELM_SIZE); uint numElms = provider.announce(MAX_ELMS, buffType); CHECK (0 < numElms); CHECK (numElms <= MAX_ELMS); @@ -138,7 +138,7 @@ namespace test { { TrackingHeapBlockProvider provider; - BufferDescriptor buffType = provider.getDescriptorFor(TEST_ELM_SIZE); + BuffDescr buffType = provider.getDescriptorFor(TEST_ELM_SIZE); BuffHandle bu1 = provider.lockBuffer (buffType); BuffHandle bu2 = provider.lockBuffer (buffType); diff --git a/tests/core/steam/play/diagnostic-output-slot.hpp b/tests/core/steam/play/diagnostic-output-slot.hpp index 1e24ce5e5..bfe6a40b4 100644 --- a/tests/core/steam/play/diagnostic-output-slot.hpp +++ b/tests/core/steam/play/diagnostic-output-slot.hpp @@ -64,7 +64,7 @@ namespace play { using lib::time::FrameRate; using steam::asset::meta::PGrid; using steam::asset::meta::TimeGrid; - using steam::engine::BufferDescriptor; + using steam::engine::BuffDescr; using steam::engine::test::TestFrame; using steam::engine::TrackingHeapBlockProvider; namespace diagn = steam::engine::diagn; @@ -104,7 +104,7 @@ namespace play { TrackingHeapBlockProvider buffProvider_; - BufferDescriptor bufferType_; + BuffDescr bufferType_; FrameTrackingInfo frameTrackingIndex_; PGrid frameGrid_; diff --git a/wiki/thinkPad.ichthyo.mm b/wiki/thinkPad.ichthyo.mm index ffa432f12..104772f74 100644 --- a/wiki/thinkPad.ichthyo.mm +++ b/wiki/thinkPad.ichthyo.mm @@ -2049,9 +2049,7 @@ - - - +

...um den Umstand zu dokumentieren, @@ -2085,9 +2083,7 @@ - - - +

erscheint definitiv nicht als CSS-Node @@ -2168,9 +2164,7 @@ - - - +

...dann Einfügestelle davor platzieren @@ -2309,9 +2303,7 @@ - - - +

...welches ich zusammen mit meinem @@ -2364,9 +2356,7 @@ - - - +

denn dieses Design gibt die beste Balance zwischen den Belangen @@ -2896,9 +2886,7 @@ - - - +

Lösung: delegiere über zwei Stufen... @@ -3580,9 +3568,7 @@ - - - +

..damit ~GtkLumiera() garantiert vorher aufgerufen wird @@ -4642,9 +4628,7 @@ - - - +

1/2017 Review durchgeführt und Logik überarbeitet. @@ -6330,9 +6314,7 @@ - - - +

Aufgabe: docking panels global @@ -8496,9 +8478,7 @@ - - - +

monadische Lösung @@ -11741,9 +11721,7 @@ - - - +

es werden jetzt keine weiteren Features für TreeExplorer gebaut.... @@ -52971,9 +52949,7 @@ - - - +

...und kaum erkennbarer Nutzen. @@ -52989,9 +52965,7 @@ - - - +

hier müßte der InvocationTrail die aufgesammelten Argumente transportieren. @@ -53273,9 +53247,7 @@ - - - +

...wir versuchen gar nicht erst, »etwas Bestehendes zu nutzen« ― sondern wir machen unser eigenes Ding. @@ -53522,9 +53494,7 @@ - - - +

...implementiert "für die Zukunft", @@ -67976,6 +67946,14 @@ + + + + + + + + @@ -71265,7 +71243,10 @@ - + + + + @@ -82189,16 +82170,49 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
 + + + + + + + + + + - + + + + + + + + + + + +

+ Aufbau erfolgt aus dem Scope der DomainOntology +

+ + + + + + + + + + @@ -86670,6 +86684,57 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
 + + + + +

+ ein Zwischending: BufferDescriptor +

+ + + + + + + + + + + + + + +
    +
  • + das bedeutet: dies ist die Quintessenz der Buffer-Konfiguration und damit die Minimal-Information, die wir für jeden Slot fest vorbelegen müssen. +
    • +
  • + allerdings könnte man noch über eine kompaktere Repräsentation im Speicher nachdenken... +
    • +
+ + + + + + + + + + + +

+ ...im Gegensatz zum Baumuster des Node-Graphen, der stets abwärts gerichtet ist: eine Node kennt nur ihre Vorläufer, aber der BufferDescriptor verweist aufwärts auf einen globalen Service +

+ + + + + + + + @@ -86764,12 +86829,21 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
- + + + + + + + + + + @@ -88100,7 +88174,7 @@ Date:   Thu Apr 20 18:53:17 2023 +0200

- + @@ -88131,7 +88205,25 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
 + + + + + + + + + +

+ und all dies muß in einen verständliche Builder-DSL  verpackt werden +

+ + + + + + @@ -88141,6 +88233,29 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
 + + + + + + + + + + + + + + + + + + + + + + + @@ -88150,11 +88265,39 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
- + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -88180,8 +88323,7 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
aber festgelegt wird sie beim Bauen des Turnout

- - + @@ -88205,6 +88347,24 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
 + + + + + + + +

+ ...denn wir verweisen darauf per Referenz oder Pointer +

+ + + + + + + + @@ -89306,6 +89466,20 @@ Date:   Thu Apr 20 18:53:17 2023 +0200
 + + + + + + + + + + + + + + @@ -127593,7 +127767,7 @@ std::cout << tmpl.render({"what", "World"}) << s - +