Struct SimpleExecutor 

pub struct SimpleExecutor<ID: PartialEq> { /* private fields */ }

Simple Executor

This simple executor stores Nodes in a sorted vector where the priority is higher the closer to the current timestamp the Node’s next update is.

Note: The Simple Executor can be interrupted by sending a true value over the mpsc channel whose receiving end is owned by the SimpleExecutor

Addendum: The Simple Executor will also busy wait between node executions so do not expect the SimpleExecutor to yield CPU time to other processes while it is running.

Implementations

impl<ID: PartialEq> SimpleExecutor<ID>

pub fn new(interrupt: Receiver<bool>) -> Self

Create a new Simple Executor without any Nodes

pub fn new_with( interrupt: Receiver<bool>, nodes: Vec<Box<dyn Node<ID>>>, ) -> Self

Creates a new Simple Executor with a number of Nodes

Trait Implementations

impl<ID: PartialEq> Executor<ID> for SimpleExecutor<ID>

type Context = Box<dyn Any>

Context doesn’t really apply to SimpleExecutors

fn start(&mut self)

For each node in the simple executor we should reset their priority to 0 and start the node. We should also set the start_instant to the current time.

Note: this method should not be called individually as it will always be called during the update_for_ms and update_loop methods so running it here is completely redundant.

fn update_for_ms(&mut self, ms: u128)

Start the executor and run the executor for a given number of milliseconds before stopping the executor. An interrupt will also stop the executor early.

Note: if there are no Nodes currently in the executor it will busy wait until the time has passed or an interrupt occurs

fn update_loop(&mut self)

Start the executor and run until an interrupt is received.

Note: if there are no Nodes currently in the executor it will busy wait until it receives an interrupt

fn check_interrupt(&mut self) -> bool

Check the interrupt receiver for an interrupt. If an interrupt signal was sent over the channel then this node should report that it was interrupted.

fn add_node(&mut self, node: Box<dyn Node<ID>>)

Add a node to the Simple Executor.

Note: Nodes can only be added to the executor when it is not running.

Additionally, only 1 node can exist per id so additional nodes added with the same id will replace the previous node of a given id.

fn remove_node(&mut self, id: &ID) -> Option<Box<dyn Node<ID>>>

Remove a node from the Simple Executor.

Note: Nodes can only be removed from the executor when it is not running.

fn add_node_with_context( &mut self, node: Box<dyn Node<ID>>, _ctx: Self::Context, )

Add a node to the executor with some given context.