Class BaseEngine<CalculationData, CalculationArgs>`Abstract`

Type Parameters

CalculationData
CalculationArgs extends any[]

Hierarchy (View Summary)

BaseEngine
- DependencyEngine

Implements

IEngine<CalculationData>

Index

Constructors

constructor

new BaseEngine<CalculationData, CalculationArgs extends any[]>(
editor: Editor,
): BaseEngine<CalculationData, CalculationArgs>
Type Parameters
- CalculationData
- CalculationArgs extends any[]
Parameters
- editor: Editor
Returns BaseEngine<CalculationData, CalculationArgs>
- Defined in engine/src/baseEngine.ts:93

Properties

`Protected`editor

editor: Editor

events

events: {
    afterNodeCalculation: BaklavaEvent<
        AfterNodeCalculationEventData,
        BaseEngine<CalculationData, CalculationArgs>,
    >;
    afterRun: BaklavaEvent<
        CalculationResult,
        BaseEngine<CalculationData, CalculationArgs>,
    >;
    beforeNodeCalculation: BaklavaEvent<
        BeforeNodeCalculationEventData,
        BaseEngine<CalculationData, CalculationArgs>,
    >;
    beforeRun: PreventableBaklavaEvent<
        CalculationData,
        BaseEngine<CalculationData, CalculationArgs>,
    >;
    statusChange: BaklavaEvent<
        EngineStatus,
        BaseEngine<CalculationData, CalculationArgs>,
    >;
} = ...

Type declaration

afterNodeCalculation: BaklavaEvent<
AfterNodeCalculationEventData,
BaseEngine<CalculationData, CalculationArgs>,
>
This event is called after a node has been calculated.
afterRun: BaklavaEvent<CalculationResult, BaseEngine<CalculationData, CalculationArgs>>
This event is called as soon as a run is completed. The argument is the result of the calculation.
beforeNodeCalculation: BaklavaEvent<
BeforeNodeCalculationEventData,
BaseEngine<CalculationData, CalculationArgs>,
>
This event is called before a node is calculated. It is not preventable since this would break calculation.
beforeRun: PreventableBaklavaEvent<
CalculationData,
BaseEngine<CalculationData, CalculationArgs>,
>
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, CalculationArgs>>

hooks

hooks: {
    gatherCalculationData: SequentialHook<
        undefined
        | CalculationData,
        BaseEngine<CalculationData, CalculationArgs>,
        CalculationData,
    >;
    transferData: DynamicSequentialHook<any, IConnection, any>;
} = ...

`Protected`recalculateOrder

recalculateOrder: boolean = true

Accessors

status

get status(): EngineStatus
Returns EngineStatus
- Defined in engine/src/baseEngine.ts:80

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
- Defined in engine/src/baseEngine.ts:269

`Protected`calculateWithoutData

calculateWithoutData(
...args: CalculationArgs,
): Promise<null | CalculationResult>
Use the gatherCalculationData hook to get the calculation data
Parameters
- ...args: CalculationArgs
  The calculation arguments with which the engine's calculate method will be called (in addition to the calculationData)
Returns Promise<null | CalculationResult>
The calculation result
- Defined in engine/src/baseEngine.ts:278

checkConnection

checkConnection(
from: NodeInterface,
to: NodeInterface,
): CheckConnectionHookResult
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 CheckConnectionHookResult
Whether the connection can be created
- Defined in engine/src/baseEngine.ts:227

`Protected` `Abstract`execute

execute(
calculationData: CalculationData,
...calculationArgs: CalculationArgs,
): Promise<CalculationResult>
Overwrite this method to perform the calculation
Parameters
- calculationData: CalculationData
  The data which is provided to each node's calculate method
- ...calculationArgs: CalculationArgs
  Additional data which is only provided to the engine
Returns Promise<CalculationResult>
The calculation result
- Defined in engine/src/baseEngine.ts:309

`Abstract`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
Implementation of IEngine.getInputValues
- Defined in engine/src/baseEngine.ts:219

`Protected` `Abstract`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
- Defined in engine/src/baseEngine.ts:322

pause

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

Returns void
- Defined in engine/src/baseEngine.ts:143

resume

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

Returns void
- Defined in engine/src/baseEngine.ts:151

`Abstract`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)
Implementation of IEngine.runGraph
- Defined in engine/src/baseEngine.ts:209

runOnce

runOnce(
calculationData: CalculationData,
...args: CalculationArgs,
): Promise<null | CalculationResult>
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: CalculationArgs
Returns Promise<null | CalculationResult>
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
- Defined in engine/src/baseEngine.ts:176

start

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

Returns void
- Defined in engine/src/baseEngine.ts:132

stop

stop(): void
Stop the engine

Returns void
- Defined in engine/src/baseEngine.ts:159

`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
- Defined in engine/src/baseEngine.ts:290

Class BaseEngine<CalculationData, CalculationArgs>Abstract

Type Parameters

Hierarchy (View Summary)

Implements

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Type Parameters

Parameters

Returns BaseEngine<CalculationData, CalculationArgs>

Properties

Protectededitor

events

Type declaration

afterNodeCalculation: BaklavaEvent< AfterNodeCalculationEventData, BaseEngine<CalculationData, CalculationArgs>,>

afterRun: BaklavaEvent<CalculationResult, BaseEngine<CalculationData, CalculationArgs>>

beforeNodeCalculation: BaklavaEvent< BeforeNodeCalculationEventData, BaseEngine<CalculationData, CalculationArgs>,>

beforeRun: PreventableBaklavaEvent< CalculationData, BaseEngine<CalculationData, CalculationArgs>,>

statusChange: BaklavaEvent<EngineStatus, BaseEngine<CalculationData, CalculationArgs>>

hooks

ProtectedrecalculateOrder

Accessors

status

Returns EngineStatus

Methods

calculateOrder

Returns void

ProtectedcalculateWithoutData

Parameters

Returns Promise<null | CalculationResult>

checkConnection

Parameters

Returns CheckConnectionHookResult

Protected Abstractexecute

Parameters

Returns Promise<CalculationResult>

AbstractgetInputValues

Parameters

Returns Map<string, any>

Protected AbstractonChange

Parameters

Returns void

pause

Returns void

resume

Returns void

AbstractrunGraph

Parameters

Returns Promise<CalculationResult>

runOnce

Parameters

Returns Promise<null | CalculationResult>

start

Returns void

stop

Returns void

ProtectedvalidateNodeCalculationOutput

Parameters

Returns void

Settings

On This Page

Class BaseEngine<CalculationData, CalculationArgs>`Abstract`

`Protected`editor

afterNodeCalculation: BaklavaEvent<
AfterNodeCalculationEventData,
BaseEngine<CalculationData, CalculationArgs>,
>

beforeNodeCalculation: BaklavaEvent<
BeforeNodeCalculationEventData,
BaseEngine<CalculationData, CalculationArgs>,
>

beforeRun: PreventableBaklavaEvent<
CalculationData,
BaseEngine<CalculationData, CalculationArgs>,
>

`Protected`recalculateOrder

`Protected`calculateWithoutData

`Protected` `Abstract`execute

`Abstract`getInputValues

`Protected` `Abstract`onChange

`Abstract`runGraph

`Protected`validateNodeCalculationOutput