Struct History 

pub struct History<R: TurnRules> { /* private fields */ }

A game’s first state and the commands applied since, oldest first.

Implementations

impl<R: TurnRules> History<R>

pub fn new(initial: R) -> Self

A history starting at initial, with no command yet.

pub fn from_parts(initial: R, commands: Vec<R::Command>) -> Self

A history from its first state and the commands applied since, oldest first (as a save holds them).

pub fn into_parts(self) -> (R, Vec<R::Command>)

Its first state and its commands, oldest first.

pub fn initial(&self) -> &R

The state the game started in (point 0).

pub fn initial_mut(&mut self) -> &mut R

The state the game started in, to change: for putting back what a save leaves out of it. A change to how its commands apply changes every later point.

pub fn push(&mut self, command: R::Command)

Records command, which was just applied to the game successfully.

pub fn commands(&self) -> &[R::Command]

The commands applied so far, oldest first.

pub fn len(&self) -> usize

How many commands were applied (the latest point).

pub fn is_empty(&self) -> bool

Whether no command was applied yet.

impl<R: TurnRules + Clone> History<R>

pub fn state_at(&self, n: usize) -> R

The game after its first n commands (all of them if n is past the end).

pub fn replay(&self) -> Vec<Replayed<R>>

where R::Command: Clone,

Every command replayed in order, with the game just before it and its events: one replay for the whole list.

pub fn rewind_to(&mut self, n: usize) -> Result<R, NoSuchPoint>

Goes back to point n (before command n), forgetting that command and every later one, and returns the game at that point.

Trait Implementations

impl<R: Clone + TurnRules> Clone for History<R>

where R::Command: Clone,

fn clone(&self) -> History<R>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<R: Debug + TurnRules> Debug for History<R>

where R::Command: Debug,

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

Formats the value using the given formatter.

impl<'de, R> Deserialize<'de> for History<R>

where R: Deserialize<'de> + TurnRules, R::Command: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<R: Eq + TurnRules> Eq for History<R>

where R::Command: Eq,

impl<R: PartialEq + TurnRules> PartialEq for History<R>

where R::Command: PartialEq,

fn eq(&self, other: &History<R>) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<R> Serialize for History<R>

where R: Serialize + TurnRules, R::Command: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<R: PartialEq + TurnRules> StructuralPartialEq for History<R>

where R::Command: PartialEq,