What is <Processor> - the computer

[rayk]

Processor

A statement piece of code that is executed at each vertex in a logically effective manner until some termination condition is met (e.g. a number of iterations have occurred, all vertex in the graph have been consumed, or some other conditions.)

Constructor

(Graph) => Graph

The passed in <Graph> here is NOT the target graph on which the processor is to be run. Rather it's a graph that contains the processor's configuration and initial state.

Execution

(Stream<Node>) => Processor

Execution of the processor entails passing it a Stream<Node> that the processor shall subscribe and listen to. Handling any arriving <Node>. The runner or one of its controlled subprocesses then adds <Node> to the sink of the stream in topological order. The processor completes its work when the sink is closed, which the runner is notified about via the close event on the <Stream<Node>> to which it has subscribed.

By calling result a <Graph> containing the result is returned.

Processor Assumptions

Each implementation of <Processor> make the following assumptions:

1. Each node from its source graph is passed once and only once during an execution cycle.
2. It could receive subtypes of Node which it's not interested in.
3. That all the properties within the Node are available & assessable when the node is received on the stream.
4. That no information about the remaining number or type of nodes that could arrive on the stream is available.
   5

Processor Guarantees

Each implementation of <Processor> provides the following guarantees.

1. Any state the processor has maintained after receiving Stream<Node> is destroyed after calling .result.
2. That calling .result before closing the sink associated with the stream will throw <StateError>
3. That calling .reset on the process returns it to the state before it received the stream.
4. That calling .reset on a process a second time or before it receives a stream will result in a NOOP.
5. The processor in terms of its state before it receives a Stream and after the Stream/sink has been closed is serializable. (Allowing it to be passed different isolates or execution environments.)