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 program_graphs(&self) -> &[ProgramGraph]

Returns an immutable reference to the list of ProgramGraphs of the Channel System.

pub fn program_graph_ids(&self) -> impl Iterator<Item = PgId>

Returns the list of PgIds associated to the Program Graphs of the Channel System.

pub fn channels(&self) -> &[(Vec<Type>, ChannelCapacity)]

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).

pub fn channel( &self, channel: Channel, ) -> Result<(&[Type], ChannelCapacity), CsError>

Returns the type and capacity of the given channel (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.

impl GetSize for ChannelSystem

fn get_heap_size(&self) -> usize

Determines how many bytes this object occupies inside the heap.

fn get_heap_size_with_tracker<TRACKER: GetSizeTracker>( &self, tracker: TRACKER, ) -> (usize, TRACKER)

Determines how many bytes this object occupies inside the heap while using a tracker.

fn get_stack_size() -> usize

Determines how may bytes this object occupies inside the stack.

fn get_size(&self) -> usize

Determines the total size of the object.

fn get_size_with_tracker<T>(&self, tracker: T) -> (usize, T)

where T: GetSizeTracker,

Determines the total size of the object while using a tracker.