Differences

This shows you the differences between two versions of the page.

--- en:toolworks:docs:apparatus:operating [2021/12/16 20:42] – [Argument Delivery] vladius
+++ en:toolworks:docs:apparatus:operating [2023/01/14 13:13] (current) – vladius
@@ Line 7: / Line 7: @@
 ==== Using a Lambda ====
-You can easily operate on your chain via a C++ lambda and this is how you do it:
+You can easily operate on your chain via a [[cpp>language/lambda|C++ lambda]] and this is how you do it:
 <code cpp>
 Chain->Operate([](FMyTrait Trait)
@@ Line 44: / Line 44: @@
 available, excessive tasks not needed for that quantity won't be queued at all.
-==== Argument Delivery ====
+==== Dependency Injection ====
 One great thing about operating is that the function arguments are actually resolved
@@ Line 63: / Line 63: @@
 You can actually ask for different contextual information within the loop. For example:<code cpp>
-Chain->Operate([](const FChain* Chain, Cursor& Cursor, ISubjective* Subjective, FMyTrait Trait, UMyDetail* Detail)
+Chain->Operate([](const FChain* Chain, const FChainCursor& Cursor, ISubjective* Subjective, FMyTrait Trait, UMyDetail* Detail)
 {
     ...
+});
+</code>
+==== Current Iteration Index ====
+Just in case you need to know the number of the current iterated Slot (i.e. Subject's place within the chain), use the dedicated [[appi>struct_t_chain_1_1_f_cursor.html#a18005eddb3a624bdabb76475c3863751|GetChainSlotIndex()]] method of the corresponding Cursor type, which can also be delivered using the [[#argument_delivery|aforementioned means]]:<code cpp>
+SolidChain->Operate([](FPlacementTrait& Placement, const FSolidChainCursor& Cursor)
+{
+	Placement.Number = Cursor.GetChainSlotIndex();
 });
 </code>
@@ Line 72: / Line 81: @@
 While conceptually not very clean it is sometime useful to stop the actual processing (iterating) of the chain
-in a manual, premature way. This can be easily accomplished with a dedicated [[appi>struct_t_chain.html#aec97fe73be3d6d9f4c279c7427ed99d6|method]].
+prematurely, manually. This can be easily accomplished with a dedicated [[appi>struct_t_chain.html#aec97fe73be3d6d9f4c279c7427ed99d6|method]].
 For example:<code cpp>
@@ Line 86: / Line 95: @@
     Counter += Trait.Value;
 });
+</code>
+==== Direct Mechanism Operating ====
+The Operating simplification goes as far as actually Operating on a Mechanism directly, like so:<code cpp>
+Mechanism->Operate([](FGlowing Glowing, FHelmet Helmet)
+{
+    ...
+});
+</code>
+This way the [[en:toolworks:docs:apparatus:filter|Filtering]] and the [[en:toolworks:docs:apparatus:enchaining|Enchaining]] is done automatically under the hood, deriving the necessary Components from the lambda arguments.
+You can of course supply the Filter specification explicitly, overriding it.
+So for example, if you want to specify an additional [[en:toolworks:docs:apparatus:trait|Trait]] and a [[en:toolworks:docs:apparatus:flag|Flagmark]] condition, do it like so:<code cpp>
+Mechanism->Operate(FFilter::Make<FGlowing, FHelmet, FHero>(FM_Z), [](FGlowing Glowing, FHelmet Helmet)
+{
+    ...
+});
+</code>
+The direct Operating mode is smart enough to deduce the type of the Chain used within the Operating process, so if you specify a reference to a Trait and/or a Solid Subject handle in your arguments list, the technique will essentially produce a [[en:toolworks:docs:apparatus:solidity|Solid]] iterating:<code cpp>
+Mechanism->Operate([](FSolidSubjectHandle Subject, FGlowing& Glowing, FHelmet& Helmet)
+{
+    ...
+});
+</code>
+You can still specify the Chain type explicitly as a first template argument to a method:<code cpp>
+Mechanism->Operate<FSolidChain>([](FGlowing Glowing, FHelmet Helmet)
+{
+    // You logic within Solid semantics:
+    ...
+});
+</code>
+Concurrency variants are also provided by the direct interface:<code cpp>
+Mechanism->OperateConcurrently([](FSolidSubjectHandle Subject, FGlowing& Glowing, FHelmet& Helmet)
+{
+    ...
+}, /*Maximum number of threads=*/4, /*Minimum number of Subjects=*/16);
 </code>