Struct Parallelizer 

pub struct Parallelizer<M = ()> { /* private fields */ }

Parallelizer runs all its states at the same time.

Note that at any time you ask it to make a decision it goes through non-active states and tries to run them so instead of starting all possible states at once, it will ensure that at any time of decision making all possible states will run.

Example

use emergent::prelude::*;

struct Memory {
    a: bool,
    b: bool,
}

let mut parallelizer = Parallelizer::new(vec![
    ParallelizerState::new(true, ClosureTask::default().enter(|m: &mut Memory| m.a = true)),
    ParallelizerState::new(true, ClosureTask::default().enter(|m: &mut Memory| m.b = true)),
]);

let mut memory = Memory { a: false, b: false };
assert!(parallelizer.process(&mut memory));
assert_eq!(memory.a, true);
assert_eq!(memory.b, true);

Implementations

impl<M> Parallelizer<M>

pub fn new(states: Vec<ParallelizerState<M>>) -> Self

Constructs new parallelizer with states.

pub fn is_active(&self) -> bool

Tells if any of states is active/running.

pub fn reset(&mut self, memory: &mut M, forced: bool) -> bool

Stops all active/running states.

By default states that are locked won’t stop, but we can force stop them.

pub fn process(&mut self, memory: &mut M) -> bool

Perform decision making.

pub fn update(&mut self, memory: &mut M)

Update active/running states.

Trait Implementations

impl<M> Debug for Parallelizer<M>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<M, K> DecisionMaker<M, K> for Parallelizer<M>

where K: Default,

fn decide(&mut self, memory: &mut M) -> Option<K>

Performs decision making and returns the key of the state it switched into.

fn change_mind(&mut self, _: Option<K>, memory: &mut M) -> bool

Force switch into state (Some activates new state, None deactivates current state).

impl<M> Task<M> for Parallelizer<M>

fn is_locked(&self, memory: &M) -> bool

Tells if task is locked (it’s still running). Used by decision makers to tell if one can change its state (when current task is not locked).

fn on_enter(&mut self, memory: &mut M)

Action performed when task starts its work.

fn on_exit(&mut self, memory: &mut M)

Action performed when task stops its work.

fn on_update(&mut self, memory: &mut M)

Action performed when task is active and gets updated.

fn on_process(&mut self, memory: &mut M) -> bool

Action performed when task is active but decision maker did not changed its state. This one is applicable for making hierarchical decision makers (telling children decision makers to decide on new state, because some if not all decision makers are tasks).