Struct Model 

pub struct Model<State> { /* private fields */ }

Actor model

Implementations

impl Model<Ready>

pub fn run(self) -> Model<Running>

Spawns each actor task

impl Model<Running>

pub async fn wait(self) -> Result<Model<Completed>, ModelError>

Waits for the task of each actor to finish

impl Model<Unknown>

pub fn new(actors: Vec<Box<dyn Task>>) -> Self

Returns a new model

pub fn name<S: Into<String>>(self, name: S) -> Self

Sets the model name

pub fn quiet(self) -> Self

Quiet mode

pub fn check(self) -> Result<Model<Ready>, ModelError>

Validates actors inputs and outputs

pub fn skip_check(self) -> Model<Ready>

impl<S> Model<S>

pub fn inspect(self) -> Self

Prints some informations about the model and the actors within

pub fn n_io(&self) -> (usize, usize)

Returns the total number of inputs and the total number of outputs

Both numbers should be the same

pub fn n_actors(&self) -> usize

Returns the number of actors

pub fn get_name(&self) -> String

pub fn elapsed_time(&self) -> Duration

Trait Implementations

impl<C, const NI: usize, const NO: usize> Add<Actor<C, NI, NO>> for Model<Unknown>

where C: Update + 'static,

Aggregation of a model and an actor into a new model

type Output = Model<Unknown>

The resulting type after applying the + operator.

fn add(self, rhs: Actor<C, NI, NO>) -> Self::Output

Performs the + operation.

impl<C, const NI: usize, const NO: usize> Add<Model<Unknown>> for Actor<C, NI, NO>

where C: Update + 'static,

Aggregation of an actor and a model into a new model

type Output = Model<Unknown>

The resulting type after applying the + operator.

fn add(self, rhs: Model<Unknown>) -> Self::Output

Performs the + operation.

impl Add for Model<Unknown>

Aggregation of models into a new model

type Output = Model<Unknown>

The resulting type after applying the + operator.

fn add(self, rhs: Self) -> Self::Output

Performs the + operation.

impl<C, const NI: usize, const NO: usize> AddAssign<Actor<C, NI, NO>> for Model<Unknown>

where C: Update + 'static,

fn add_assign(&mut self, rhs: Actor<C, NI, NO>)

Performs the += operation.

impl Default for Model<Unknown>

fn default() -> Self

Returns the “default value” for a type.

impl<S> Display for Model<S>

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

Formats the value using the given formatter.

impl<S: UnknownOrReady> FlowChart for Model<S>

fn graph(&self) -> Option<Graph>

Returns the actors network graph

fn to_html(&self) -> Result<PathBuf, FlowChartError>

Writes the flowchart to an HTML file

fn flowchart(self) -> Self

where Self: Sized,

Writes the actors flowchart to an HTML file

fn flowchart_open(self) -> Self

where Self: Sized,

Writes the actors flowchart to an HTML file and open it in the default browser

impl FromIterator<Box<dyn Task>> for Model<Unknown>

fn from_iter<T: IntoIterator<Item = Box<dyn Task>>>(iter: T) -> Self

Creates a value from an iterator.

impl<State> GetName for Model<State>

where State: UnknownOrReady,

fn get_name(&self) -> String

Returns the flowchart name

impl IntoFuture for Model<Running>

type IntoFuture = Pin<Box<dyn Future<Output = Result<Model<Completed>, ModelError>> + Send>>

Which kind of future are we turning this into?

type Output = <Pin<Box<dyn Future<Output = Result<Model<Completed>, ModelError>> + Send>> as Future>::Output

The output that the future will produce on completion.

fn into_future(self) -> Self::IntoFuture

Creates a future from a value.

impl<State> IntoIterator for &Model<State>

where State: UnknownOrReady,

type Item = PlainActor

The type of the elements being iterated over.

type IntoIter = IntoIter<<&Model<State> as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.