FlowLookahead

We assume the Manager is already waiting for another simulation when the request is made. Otherwise virtual time may progress unexpectedly and cause unpredictable behaviour depending on the timing of the Manager messages.

Lookahead.+ for details on the IDfunction itself. As it works through the flow tree, the algorithm does the following:

1. If the current node is a task (i.e. a leaf node), it should be registered by adding itself to the current running lookahead structure. To do this it uses the IDFunction that it received. If no ID function was provided, this means that there are no prior requirements to starting this task and so it is not registered.
2. If the current node is a Then, first the left branch is parsed, and then the right branch is parsed. The preconditions (i.e. the IDFunction) of the left branch is the same as the preconditions of this node, however the preconditions of the right branch are that which is returned by the left branch (as opposed to the preconditions of this Then node). This is because, by our definition, the right branch happens after the left branch, and hence the preconditions of the right branch is that the left branch is completed.
3. If the current node is an And, or Or node, it parses all its child nodes normally, since the child branches are independent. Then, depending on the node type, it returns a function and a lookahead structure. The lookahead structure contains the current lookahead entries, and may be combined with other structures later on. The IDFunction will be used by other nodes to register new lookahead entries, where it will describe the preconditions of that entry; As such, the function should express if this node is "done", as this is necessary in determining if some task in the future may start.
4. If our current node is a task (leaf node), then we create a new function; The function will return None if this task is not in the map which it receives as input, and Some(value) otherwise. The result of this is that when the function will receive a list of completed tasks, if this task is on the list then the function will indicate that the prerequires are met, and hence (when combined with other functions from other nodes) this function can be used to describe the prerequisites of future tasks.
5. If our current node is a Then, we only need to return the IDFunction of the right branch, since the left branch was already considered when parsing the right branch. For example, if you had a flow [A THEN B THEN C], we want to express that A is a prerequisite of B, and B is a prerequisite of C. It is unnecessary to say that A is a prerequisite of C since it is already a prerequisite of B.
6. If our current node is an And, we need to combine the functions of all the child nodes. If all the child nodes are "complete" then this node is complete, hence if any child function returns None, this function should also return None. Otherwise, the maximum value of the child functions is returned, since tasks that come after an And may only begin once all of the previous tasks have finished.
7. If our current node is an Or, the child node functions are also combined in a similar way to Ands, but this time we return the minimum value of the child functions, since any task that comes after an Or may begin as soon as any of the branches in an Or are completed. It might be easier to picture this algorithim when given some examples. Please refer to the wiki for examples and more detailed explanations.