Struct BorrowedSimulation

pub struct BorrowedSimulation<'a, Info: SimulationInfo> {
    pub state: Info::State,
    /* private fields */
}

A borrowed simulation that holds an immutable reference to the simulation info and owns the simulation state.

Fields

state: Info::State

The simulation state.

Implementations

impl<'a, Info: SimulationInfo> BorrowedSimulation<'a, Info>

pub fn new(info: &'a Info) -> Self

Creates a new BorrowedSimulation which belongs to the specified info.

pub fn from_data( info: &'a Info, data: Info::LoadData, ) -> Result<Self, Info::StateLoadingError>

Loads a new BorrowedSimulation from data which belongs to the specified info.

Trait Implementations

impl<Info: SimulationInfo + Clone> Clone for BorrowedSimulation<'_, Info>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Info: SimulationInfo> Deref for BorrowedSimulation<'_, Info>

type Target = Info

The resulting type after dereferencing.

fn deref(&self) -> &Info

Dereferences the value.

impl<Info: SimulationInfo> Simulation for BorrowedSimulation<'_, Info>

type StateLoadingError = <Info as SimulationInfo>::StateLoadingError

The error type returned when loading the simulation state fails.

type AccessData = <Info as SimulationInfo>::AccessData

The type used to access the current state.

type LoadData = <Info as SimulationInfo>::LoadData

The type of data used to load the simulation state.

type Event = <Info as SimulationInfo>::Event

The type of events that can be called or reverted in the simulation.

type EventContainer<'a> = <Info as SimulationInfo>::EventContainer<'a> where Self: 'a

The type of container used to access the available events.

fn data(&self) -> &Info::AccessData

Returns a reference to the data which repsesents the current state.

fn reload( &mut self, data: Info::LoadData, ) -> Result<(), Info::StateLoadingError>

Reloads the simulation state from the provided data.

fn callables(&self) -> Info::EventContainer<'_>

Returns the events that can currently be called.

fn callable(&self, event: Info::Event) -> bool

Checks if the provided event can be called.

unsafe fn call(&mut self, event: Info::Event)

Calls the provided event.

fn revertables(&self) -> Info::EventContainer<'_>

Returns the events that can currently be reverted.

fn revertable(&self, event: Info::Event) -> bool

Checks if the provided event can be reverted.

unsafe fn revert(&mut self, event: Info::Event)

Reverts the provided event.

fn try_call(&mut self, event: Self::Event) -> bool

Tries to call the provided event and returns if it was successful.

fn try_revert(&mut self, event: Self::Event) -> bool

Tries to revert the provided event and returns if it was successful.

fn prepare_call(&mut self) -> CallState<'_, Self, Call>

Prepares a safe helper to list callable elements and choose one to call.

fn prepare_revert(&mut self) -> CallState<'_, Self, Revert>

Prepares a safe helper to list revertable elements and choose one to revert.