Struct ChannelSystem 

pub struct ChannelSystem { /* private fields */ }

A definition object for a CS. It represents the abstract definition of a CS.

The only way to produce a ChannelSystem is through a ChannelSystemBuilder. This guarantees that there are no type errors involved in the definition of its PGs, and thus the CS will always be in a consistent state.

The only way to execute the ChannelSystem is to generate a new ChannelSystemRun through ChannelSystem::new_instance. The ChannelSystemRun cannot outlive its ChannelSystem, as it holds references to it. This allows to cheaply generate multiple ChannelSystemRuns from the same ChannelSystem.

Example:

// Create and populate a CS builder object
let mut cs_builder = ChannelSystemBuilder::new();
let pg_id = cs_builder.new_program_graph();
let initial = cs_builder.new_initial_location(pg_id).expect("create new location");
cs_builder.add_autonomous_transition(pg_id, initial, initial, None).expect("add transition");

// Build the builder object to get a CS definition object.
let cs_def = cs_builder.build();

// Instantiate a CS with the previously built definition.
let mut cs = cs_def.new_instance();

// Perform the (unique) active transition available.
let (pg_id_trans, e, mut post_locs) = cs.possible_transitions().last().expect("autonomous transition");
assert_eq!(pg_id_trans, pg_id);
let post_loc = post_locs.last().expect("post location").last().expect("post location");
assert_eq!(post_loc, initial);
cs.transition(pg_id, e, &[initial]).expect("transition is active");

Implementations

impl ChannelSystem

pub fn new_instance<'def>(&'def self) -> ChannelSystemRun<'def>

Creates a new ChannelSystemRun which allows to execute the CS as defined.

The new instance borrows the caller to refer to the CS definition without copying its data, so that spawning instances is (relatively) inexpensive.

See also ProgramGraph::new_instance.

pub fn channels(&self) -> &Vec<(Vec<Type>, Option<usize>)>

Returns the list of defined channels, given as the pair of their type and capacity (where None denotes channels with infinite capacity, and Some denotes channels with finite capacity).

Trait Implementations

impl Clone for ChannelSystem

fn clone(&self) -> ChannelSystem

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ChannelSystem

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

Formats the value using the given formatter.