Class DependencyEngine<CalculationData>

Type Parameters

CalculationData = any

Hierarchy (view full)

BaseEngine<CalculationData, []>
- DependencyEngine

Index

Constructors

constructor

new DependencyEngine<CalculationData>(editor): DependencyEngine<CalculationData>
Type Parameters
- CalculationData = any
Parameters
- editor: Editor
Returns DependencyEngine<CalculationData>
Overrides BaseEngine.constructor
- Defined in engine/src/dependencyEngine.ts:12

Properties

`Protected` editor

editor: Editor

events

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

Type declaration

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

hooks

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

Type declaration

gatherCalculationData: SequentialHook<undefined | CalculationData, BaseEngine<CalculationData, []>, 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: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
Inherited from BaseEngine.calculateOrder
- Defined in engine/src/baseEngine.ts:269

`Protected` calculateWithoutData

calculateWithoutData(...args): Promise<null | CalculationResult>
Use the gatherCalculationData hook to get the calculation data
Parameters
- Rest ...args: []
  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
Inherited from BaseEngine.calculateWithoutData
- Defined in engine/src/baseEngine.ts:278

checkConnection

checkConnection(from, to): 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<any>
  The interface from which the connection would start
- to: NodeInterface<any>
  The interface where the connection would end
Returns CheckConnectionHookResult
Whether the connection can be created
Inherited from BaseEngine.checkConnection
- Defined in engine/src/baseEngine.ts:227

`Protected` execute

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

getInputValues

getInputValues(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/dependencyEngine.ts:91

`Protected` onChange

onChange(recalculateOrder): 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
Returns void
Overrides BaseEngine.onChange
- Defined in engine/src/dependencyEngine.ts:113

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:143

resume

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

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

runGraph

runGraph(graph, inputs, 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/dependencyEngine.ts:22

runOnce

runOnce(calculationData, ...args): 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
- Rest ...args: []
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
Inherited from BaseEngine.runOnce
- 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
Overrides BaseEngine.start
- Defined in engine/src/dependencyEngine.ts:16

stop

stop(): void
Stop the engine

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

`Protected` validateNodeCalculationOutput

validateNodeCalculationOutput(node, output): 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:290

Class DependencyEngine<CalculationData>

Type Parameters

Hierarchy (view full)

Index

Constructors

Properties

Accessors

Methods

Constructors

constructor

Type Parameters

Parameters

Returns DependencyEngine<CalculationData>

Properties

Protected editor

events

Type declaration

afterNodeCalculation: BaklavaEvent<AfterNodeCalculationEventData, BaseEngine<CalculationData, []>>

afterRun: BaklavaEvent<CalculationResult, BaseEngine<CalculationData, []>>

beforeNodeCalculation: BaklavaEvent<BeforeNodeCalculationEventData, BaseEngine<CalculationData, []>>

beforeRun: PreventableBaklavaEvent<CalculationData, BaseEngine<CalculationData, []>>

statusChange: BaklavaEvent<EngineStatus, BaseEngine<CalculationData, []>>

hooks

Type declaration

gatherCalculationData: SequentialHook<undefined | CalculationData, BaseEngine<CalculationData, []>, CalculationData>

transferData: DynamicSequentialHook<any, IConnection, any>

Protected recalculateOrder

Accessors

status

Returns EngineStatus

Methods

calculateOrder

Returns void

Protected calculateWithoutData

Parameters

Returns Promise<null | CalculationResult>

checkConnection

Parameters

Returns CheckConnectionHookResult

Protected execute

Parameters

Returns Promise<CalculationResult>

getInputValues

Parameters

Returns Map<string, any>

Protected onChange

Parameters

Returns void

pause

Returns void

resume

Returns void

runGraph

Parameters

Returns Promise<CalculationResult>

runOnce

Parameters

Returns Promise<null | CalculationResult>

start

Returns void

stop

Returns void

Protected validateNodeCalculationOutput

Parameters

Returns void

Settings

Member Visibility

Theme

On This Page

`Protected` editor

`Protected` recalculateOrder

`Protected` calculateWithoutData

`Protected` execute

`Protected` onChange

`Protected` validateNodeCalculationOutput