FControlFlow

Navigation

API > API/Plugins > API/Plugins/ControlFlows

Inheritance Hierarchy

• FSharedFromThisBase
• TSharedFromThis
• FControlFlow

References

Syntax

class FControlFlow : public TSharedFromThis< FControlFlow >  
Copy full snippet

class FControlFlow : public TSharedFromThis< FControlFlow >

Remarks

System/Tool to queue (asynchronous or synchronous) functions for modularity implemented via delegates. Allows code to be more easily read so there fewer 'Alt+G'-ing around to figure out what and where a class does it's thing

This system only supports non-const functions currently.

'QueueFunction': Queues a 'void (...)' function. The Flow will execute this function and continue on with the next function in queue.

'QueueWait': Queues a 'void (FControlFlowNodeRef FlowHandle, ...)' function. The flow will stop until 'FlowHandle->ContinueFlow()' is called. BE RESPONSIBLE and make sure all code paths call to continue xOR cancel, otherwise the flow will hang.

'QueueControlFlow': Queues a 'void (TSharedRef Subflow, ...)' function.

'QueueControlFlowBranch': Queues a 'int32(TSharedRef Branch, ...)' function. TODO: Allow any return-type for branch selection, and not restricted to only int32. Lambda-Syntax: '.BranchFlow(this { })'

'QueueConcurrentFlows': Queues a 'void(TSharedRef ForkedFlow, ...)' function Lambda-Syntax: '.ForkFlow(this { })'

'QueueConditionalLoop': Queues a 'EConditionalLoopResult(TSharedRef Loop, ...)' function The public functions of 'FConditionalLoop' forces the caller to define the loop as as a 'while (CONDITION) {}' or a 'do {} while(CONDITION);' The return is a FControlFlow& and queue your flow as normal Lambda-Syntax: '.Loop(this { })'

'QueueStep': Usable in UObject's or classes that derive from TSharedFromThis. The Control Flow will automatically deduce if this is a 'QueueFunction', 'QueueWait', 'QueueControlFlow', 'QueueControlFlowBranch', 'QueueConcurrentFlows', 'EConditionalLoopResult' based on the function signature. Returns a ref to the ControlFlow - enables chained step queueing.

Using the auto-deduction of 'QueueStep', you can change the queue from a synchronous function (QueueFunction) to an asynchronous one (QueueWait) or vice-versa by adding/removing the 'FControlFlowNodeRef FlowHandle' as your first parameter. And you can change it to (QueueControlFlow) if need be as well!

Syntax:

void MyFunction(...); void MyFunction(FControlFlowNodeRef FlowHandle, ...); void MyFunction(TSharedRef Subflow, ...); void MyFunction(int32(TSharedRef Branch, ...);

ControlFlowInstance->QueueStep(this, &UserClass:MyFunction1, ...) .QueueStep(this, &UserClass:MyFunction2, ...) .QueueStep(this, &UserClass:MyFunction3, ...);

This allow ease of going from Synchronous Functionality to Asynchronously Functionality to Subflows as you build out your Flow.

Full Example Class

struct FMyFlowClass : public TSharedFromThis { typedef FMyFlowClass ThisClass; FMyFlowClass() : MyPurpose(MakeShared()) {}

void RunMyPurpose() { MyPurpose .QueueStep(this, &ThisClass::Construct) .Loop(this { Outerloop->RunLoopFirst() .SetCancelledNodeAsComplete(true) .QueueStep(this, &ThisClass::Foo) .QueueStep(this, &ThisClass::Foo) .Loop(this { InnerLoop->CheckConditionFirst() .BranchFlow([this], TSharedRef Branch) { Branch->AddOrGetBranch(0) .QueueStep(this, &ThisClass::Foo) .QueueStep(this, &ThisClass::Foo);

Branch->AddOrGetBranch(1) .QueueStep(this, &ThisClass::Foo) .ForkFlow([this], TSharedRef ConcurrentFlows) { ConcurrentFlows->AddOrGetFlow(0) .QueueStep(this, &ThisClass::Foo) .QueueStep(this, &ThisClass::Foo);

ConcurrentFlows->AddOrGetFlow(1) .QueueStep(this, &ThisClass::Foo); });

return FMath::RandBool() ? EConditionalLoopResult::RunLoop : EConditionalLoopResult::LoopFinished; }) .QueueStep(this, &ThisClass::Foo);

return FMath::RandBool() ? EConditionalLoopResult::RunLoop : EConditionalLoopResult::LoopFinished; }) .QueueStep(this, &ThisClass::Foo);

return EConditionalLoopResult::RunLoop; // OuterLoop will never end in this example }) .QueueStep(this, &ThisClass::Destruct) .ExecuteFlow(); }

private: void Foo(); void Construct(); // Equivalent to Init void Destruct(); // Equivalent to Uninit

TSharedRef MyPurpose; };

The implementation details of a flow can be fully disjointed from the Flow logic itself!

Constructors

Functions

Constants