Class ForwardEngine<CalculationData>

Type Parameters

CalculationData = any

Hierarchy (View Summary)

BaseEngine<
    CalculationData,
    [
        startingNode: AbstractNode,
        nodeUpdateEvent: INodeUpdateEventData
        | undefined,
    ],
>
- ForwardEngine

Index

Constructors

constructor

new ForwardEngine<CalculationData = any>(
editor: Editor,
): ForwardEngine<CalculationData>
Type Parameters
- CalculationData = any
Parameters
- editor: Editor
Returns ForwardEngine<CalculationData>
Inherited from BaseEngine.constructor
- Defined in engine/src/baseEngine.ts:94

Properties

`Protected`editor

editor: Editor

events

events: {
    afterNodeCalculation: BaklavaEvent<
        AfterNodeCalculationEventData,
        BaseEngine<
            CalculationData,
            [startingNode: AbstractNode, nodeUpdateEvent: INodeUpdateEventData],
        >,
    >;
    afterRun: BaklavaEvent<
        CalculationResult,
        BaseEngine<
            CalculationData,
            [startingNode: AbstractNode, nodeUpdateEvent: INodeUpdateEventData],
        >,
    >;
    beforeNodeCalculation: BaklavaEvent<
        BeforeNodeCalculationEventData,
        BaseEngine<
            CalculationData,
            [startingNode: AbstractNode, nodeUpdateEvent: INodeUpdateEventData],
        >,
    >;
    beforeRun: PreventableBaklavaEvent<
        CalculationData,
        BaseEngine<
            CalculationData,
            [startingNode: AbstractNode, nodeUpdateEvent: INodeUpdateEventData],
        >,
    >;
    statusChange: BaklavaEvent<
        EngineStatus,
        BaseEngine<
            CalculationData,
            [startingNode: AbstractNode, nodeUpdateEvent: INodeUpdateEventData],
        >,
    >;
} = ...

Type Declaration

afterNodeCalculation: BaklavaEvent<
    AfterNodeCalculationEventData,
    BaseEngine<
        CalculationData,
        [startingNode: AbstractNode, nodeUpdateEvent: INodeUpdateEventData],
    >,
>
This event is called after a node has been calculated.
afterRun: BaklavaEvent<
    CalculationResult,
    BaseEngine<
        CalculationData,
        [startingNode: AbstractNode, nodeUpdateEvent: INodeUpdateEventData],
    >,
>
This event is called as soon as a run is completed. The argument is the result of the calculation.
beforeNodeCalculation: BaklavaEvent<
    BeforeNodeCalculationEventData,
    BaseEngine<
        CalculationData,
        [startingNode: AbstractNode, nodeUpdateEvent: INodeUpdateEventData],
    >,
>
This event is called before a node is calculated. It is not preventable since this would break calculation.
beforeRun: PreventableBaklavaEvent<
    CalculationData,
    BaseEngine<
        CalculationData,
        [startingNode: AbstractNode, nodeUpdateEvent: INodeUpdateEventData],
    >,
>
This event will be called before all the nodes calculate functions are called. The argument is the calculationData that the nodes will receive
statusChange: BaklavaEvent<
    EngineStatus,
    BaseEngine<
        CalculationData,
        [startingNode: AbstractNode, nodeUpdateEvent: INodeUpdateEventData],
    >,
>

hooks

hooks: {
    gatherCalculationData: SequentialHook<
        CalculationData
        | undefined,
        BaseEngine<
            CalculationData,
            [startingNode: AbstractNode, nodeUpdateEvent: INodeUpdateEventData],
        >,
        CalculationData,
    >;
    transferData: DynamicSequentialHook<any, IConnection, any>;
} = ...

`Protected`recalculateOrder

recalculateOrder: boolean = true

Accessors

status

get status(): EngineStatus
Returns EngineStatus
Inherited from BaseEngine.status
- Defined in engine/src/baseEngine.ts:81

Methods

calculateOrder

calculateOrder(): void
Force the engine to recalculate the node execution order before the next run. This is normally done automatically. Use this method if the default change detection does not work in your scenario.

Returns void
Inherited from BaseEngine.calculateOrder
- Defined in engine/src/baseEngine.ts:270

`Protected`calculateWithoutData

calculateWithoutData(
    ...args: [
        startingNode: AbstractNode,
        nodeUpdateEvent: INodeUpdateEventData,
    ],
): Promise<CalculationResult | null>
Use the gatherCalculationData hook to get the calculation data
Parameters
- ...args: [startingNode: AbstractNode, nodeUpdateEvent: INodeUpdateEventData]
  The calculation arguments with which the engine's calculate method will be called (in addition to the calculationData)
Returns Promise<CalculationResult | null>
The calculation result
Inherited from BaseEngine.calculateWithoutData
- Defined in engine/src/baseEngine.ts:279

checkConnection

checkConnection(
from: NodeInterface,
to: NodeInterface,
): { connectionAllowed: boolean; connectionsInDanger: Connection[] }
Check whether a connection can be created. A connection can not be created when it would result in a cyclic graph.
Parameters
- from: NodeInterface
  The interface from which the connection would start
- to: NodeInterface
  The interface where the connection would end
Returns { connectionAllowed: boolean; connectionsInDanger: Connection[] }
Whether the connection can be created
Overrides BaseEngine.checkConnection
- Defined in engine/src/forwardEngine.ts:457

`Protected`execute

execute(
    calculationData: CalculationData,
    startingNode: AbstractNode,
    data: INodeUpdateEventData | undefined,
): Promise<CalculationResult>
Overwrite this method to perform the calculation
Parameters
- calculationData: CalculationData
  The data which is provided to each node's calculate method
- startingNode: AbstractNode
- data: INodeUpdateEventData | undefined
Returns Promise<CalculationResult>
The calculation result
Overrides BaseEngine.execute
- Defined in engine/src/forwardEngine.ts:34

`Protected`findInterfaceByTemplateId

findInterfaceByTemplateId(
nodes: readonly AbstractNode[],
templateId: string,
): NodeInterface<any> | null
Parameters
- nodes: readonly AbstractNode[]
- templateId: string
Returns NodeInterface<any> | null
Inherited from BaseEngine.findInterfaceByTemplateId
- Defined in engine/src/baseEngine.ts:335

getInputValues

getInputValues(graph: Graph): Map<string, any>
Gathers the values of all unconnected input interfaces in the graph
Parameters
- graph: Graph
Returns Map<string, any>
Map nodeInterface.id -> value
Overrides BaseEngine.getInputValues
- Defined in engine/src/forwardEngine.ts:440

`Protected`onChange

onChange(
    recalculateOrder: boolean,
    updatedNode?: AbstractNode,
    data?: INodeUpdateEventData,
): void
This method is called whenever the graph or values of node interfaces have been changed. You can overwrite this method to automatically trigger a calculation on change. Note: This method is only called when the engine is either idle or running.
Parameters
- recalculateOrder: boolean
  Whether the change modified the graph itself, e. g. a connection or a node was added/removed
- OptionalupdatedNode: AbstractNode
  If a node was updated (which means the value a node's interface has been changed): the node that was updated; undefined otherwise
- Optionaldata: INodeUpdateEventData
  If a node was updated: The update event payload to determine, which interface exactly has been changed; undefined otherwise
Returns void
Overrides BaseEngine.onChange
- Defined in engine/src/forwardEngine.ts:511

pause

pause(): void
Temporarily pause the engine. Use this method when you want to update the graph with the calculation results.

Returns void
Inherited from BaseEngine.pause
- Defined in engine/src/baseEngine.ts:144

resume

resume(): void
Resume the engine from the paused state

Returns void
Inherited from BaseEngine.resume
- Defined in engine/src/baseEngine.ts:152

runGraph

runGraph(
    graph: Graph,
    inputs: Map<string, any>,
    calculationData: CalculationData,
): Promise<CalculationResult>
Run a non-root graph. This method can be used by nodes to calculate internal graphs (e. g. GraphNode). DO NOT use this method for calculation of the root graph! It won't emit any events.
Parameters
- graph: Graph
  The graph to execute
- inputs: Map<string, any>
  Map<NodeInterfaceId, value>
- calculationData: CalculationData
  The data which is provided to each node's calculate method
Returns Promise<CalculationResult>
A promise that resolves to a map that maps rootNodes to their calculated value (what the calculation function of the node returned)
Overrides BaseEngine.runGraph
- Defined in engine/src/forwardEngine.ts:308

runOnce

runOnce(
    calculationData: CalculationData,
    ...args: [
        startingNode: AbstractNode,
        nodeUpdateEvent: INodeUpdateEventData,
    ],
): Promise<CalculationResult | null>
Calculate all nodes once. This will automatically calculate the node calculation order if necessary and transfer values between connected node interfaces.
Parameters
- calculationData: CalculationData
  The data which is provided to each node's calculate method
- ...args: [startingNode: AbstractNode, nodeUpdateEvent: INodeUpdateEventData]
Returns Promise<CalculationResult | null>
A promise that resolves to either
- a map from each node's id to its calculated value (what the calculation function of the node returned)
- null if the calculation was prevented from the beforeRun event
Inherited from BaseEngine.runOnce
- Defined in engine/src/baseEngine.ts:177

start

start(): void
Start the engine. After started, it will run everytime the graph is changed.

Returns void
Inherited from BaseEngine.start
- Defined in engine/src/baseEngine.ts:133

stop

stop(): void
Stop the engine

Returns void
Inherited from BaseEngine.stop
- Defined in engine/src/baseEngine.ts:160

`Protected`validateNodeCalculationOutput

validateNodeCalculationOutput(node: AbstractNode, output: any): void
Validate the result of a node's calculate method. A result is valid if:
- is has the correct format (it must be an object, where the key is the interface key and the value is the output value for that interface)
- every output interface has a value assigned to it (null and undefined are also valid, but the key must exist in the object)
Parameters
- node: AbstractNode
  The node which produced the output data
- output: any
  The result of the node's calculate method
Returns void
Inherited from BaseEngine.validateNodeCalculationOutput
- Defined in engine/src/baseEngine.ts:291

Class ForwardEngine<CalculationData>

Type Parameters

Hierarchy (View Summary)

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Type Parameters

Parameters

Returns ForwardEngine<CalculationData>

Properties

Protectededitor

events

Type Declaration

afterNodeCalculation: BaklavaEvent< AfterNodeCalculationEventData, BaseEngine< CalculationData, [startingNode: AbstractNode, nodeUpdateEvent: INodeUpdateEventData], >,>

afterRun: BaklavaEvent< CalculationResult, BaseEngine< CalculationData, [startingNode: AbstractNode, nodeUpdateEvent: INodeUpdateEventData], >,>

beforeNodeCalculation: BaklavaEvent< BeforeNodeCalculationEventData, BaseEngine< CalculationData, [startingNode: AbstractNode, nodeUpdateEvent: INodeUpdateEventData], >,>

beforeRun: PreventableBaklavaEvent< CalculationData, BaseEngine< CalculationData, [startingNode: AbstractNode, nodeUpdateEvent: INodeUpdateEventData], >,>

statusChange: BaklavaEvent< EngineStatus, BaseEngine< CalculationData, [startingNode: AbstractNode, nodeUpdateEvent: INodeUpdateEventData], >,>

hooks

ProtectedrecalculateOrder

Accessors

status

Returns EngineStatus

Methods

calculateOrder

Returns void

ProtectedcalculateWithoutData

Parameters

Returns Promise<CalculationResult | null>

checkConnection

Parameters

Returns { connectionAllowed: boolean; connectionsInDanger: Connection[] }

Protectedexecute

Parameters

Returns Promise<CalculationResult>

ProtectedfindInterfaceByTemplateId

Parameters

Returns NodeInterface<any> | null

getInputValues

Parameters

Returns Map<string, any>

ProtectedonChange

Parameters

Returns void

pause

Returns void

resume

Returns void

runGraph

Parameters

Returns Promise<CalculationResult>

runOnce

Parameters

Returns Promise<CalculationResult | null>

start

Returns void

stop

Returns void

ProtectedvalidateNodeCalculationOutput

Parameters

Returns void

Settings

On This Page

`Protected`editor

afterNodeCalculation: BaklavaEvent<
AfterNodeCalculationEventData,
BaseEngine<
CalculationData,
[startingNode: AbstractNode, nodeUpdateEvent: INodeUpdateEventData],
>,
>

afterRun: BaklavaEvent<
CalculationResult,
BaseEngine<
CalculationData,
[startingNode: AbstractNode, nodeUpdateEvent: INodeUpdateEventData],
>,
>

beforeNodeCalculation: BaklavaEvent<
BeforeNodeCalculationEventData,
BaseEngine<
CalculationData,
[startingNode: AbstractNode, nodeUpdateEvent: INodeUpdateEventData],
>,
>

beforeRun: PreventableBaklavaEvent<
CalculationData,
BaseEngine<
CalculationData,
[startingNode: AbstractNode, nodeUpdateEvent: INodeUpdateEventData],
>,
>

statusChange: BaklavaEvent<
EngineStatus,
BaseEngine<
CalculationData,
[startingNode: AbstractNode, nodeUpdateEvent: INodeUpdateEventData],
>,
>

`Protected`recalculateOrder

`Protected`calculateWithoutData

`Protected`execute

`Protected`findInterfaceByTemplateId

`Protected`onChange

`Protected`validateNodeCalculationOutput