Struct OwnedSimulation

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

An owned simulation that holds the simulation info and the simulation state.

Fields

state: Info::State

The simulation state.

Implementations

impl<Info: SimulationInfo> OwnedSimulation<Info>

pub fn new<T: Into<Info>>(info: T) -> Self

Creates a new OwnedSimulation using the specified info.

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

Loads a new OwnedSimulation from data using the specified info.

pub fn release(self) -> Info

Release the info from the simulation again and destroys all states.

Trait Implementations

impl<Info: SimulationInfo + Clone> Clone for OwnedSimulation<Info>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Info: SimulationInfo> Deref for OwnedSimulation<Info>

type Target = Info

The resulting type after dereferencing.

fn deref(&self) -> &Info

Dereferences the value.

impl<Info: EditableSimulationInfo> Editable for OwnedSimulation<Info>

type Edit<'a> = OwnedSimulationEdit<'a, Info> where Self: 'a

The type used for safe edits and refreshing the state.

fn edit(&mut self) -> OwnedSimulationEdit<'_, Info>

Creates a type which allows safe edits to the info without invalidating the states, and automatically refreshes the states when the edit type goes out of scope.

impl<Info: SimulationInfo> Simulation for OwnedSimulation<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.