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.

Examples found in repository

examples/text_adventure.rs (line 146)

fn main() {
    let adventure = Adventure {
        rooms: vec![
            "You stand at a crossroads.".into(),
            "A dark cave yawns before you.".into(),
            "Sunlight breaks over a quiet meadow.".into(),
        ],
        passages: vec![
            passage("Enter the cave", 0, 1),
            passage("Walk to the meadow", 0, 2),
            passage("Retreat from the cave", 1, 0),
        ],
    };

    let mut simulation = OwnedSimulation::<Adventure>::new(adventure);

    let describe =
        |simulation: &OwnedSimulation<Adventure>| simulation.rooms[*simulation.data()].clone();

    println!("{}", describe(&simulation));
    for choice in simulation.callables() {
        println!("  → {}", simulation.passages[choice.0].text);
    }

    let Some(first) = simulation.callables().next() else {
        panic!("crossroads has choices");
    };
    assert!(simulation.try_call(first));
    assert_eq!(simulation.state.room, 1);
    println!("\n{}", describe(&simulation));

    let Some(back) = simulation.revertables().next() else {
        panic!("cave can be left");
    };
    assert!(simulation.try_revert(back));
    assert_eq!(simulation.state.room, 0);
    println!("\nBack: {}", describe(&simulation));
}

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

Loads a new OwnedSimulation from data using the specified info.

Errors

Returns an error if a valid state cannot be loaded from data.

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 LoadData = <Info as SimulationInfo>::LoadData

The type of data used to load the simulation state.

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

Reloads the simulation state from the provided data.

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

Calls the provided event.

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.

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

type AccessData = <Info as SimulationInfo>::AccessData

The type used to access the current state data.

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 represents the current state.

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

Returns the events that can be called in the current state.

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

Checks if the provided event can be called in the current state.

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

Returns the events that can be reverted in the current state.

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

Checks if the provided event can be reverted in the current state.