Struct ProgramGraphRun 

pub struct ProgramGraphRun<'def> { /* private fields */ }

Representation of a PG that can be executed transition-by-transition.

The structure of the PG cannot be changed, meaning that it is not possible to introduce new locations, actions, variables, etc. Though, this restriction makes it so that cloning the ProgramGraphRun is cheap, because only the internal state needs to be duplicated.

Implementations

impl<'def> ProgramGraphRun<'def>

pub fn current_states(&self) -> &SmallVec<[Location; 8]>

Returns the current location.

// Create a new PG builder
let mut pg_builder = ProgramGraphBuilder::new();

// The builder is initialized with an initial location
let initial_loc = pg_builder.new_initial_location();

// Build the PG from its builder
// The builder is always guaranteed to build a well-defined PG and building cannot fail
let pg = pg_builder.build();
let instance = pg.new_instance();

// Execution starts in the initial location
assert_eq!(instance.current_states().as_slice(), &[initial_loc]);

pub fn possible_transitions( &self, ) -> impl Iterator<Item = (Action, impl Iterator<Item = impl Iterator<Item = Location>>)>

Iterates over all transitions that can be admitted in the current state.

An admissible transition is characterized by the required action and the post-state (the pre-state being necessarily the current state of the machine). The guard (if any) is guaranteed to be satisfied.

pub fn transition<R: Rng>( &mut self, action: Action, post_states: &[Location], rng: &mut R, ) -> Result<(), PgError>

Executes a transition characterized by the argument action and post-state.

Fails if the requested transition is not admissible, or if the post-location time invariants are violated.

pub fn can_wait(&self, delta: Time) -> bool

Checks if it is possible to wait a given amount of time-units without violating the time invariants.

pub fn wait(&mut self, delta: Time) -> Result<(), PgError>

Waits a given amount of time-units.

Returns error if the waiting would violate the current location’s time invariant (if any).

Trait Implementations

impl<'def> Clone for ProgramGraphRun<'def>

fn clone(&self) -> ProgramGraphRun<'def>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'def> Debug for ProgramGraphRun<'def>

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

Formats the value using the given formatter.