Enum RestoreKind 

pub enum RestoreKind<'a> {
    Rewind {
        undo_for: Option<&'a str>,
    },
    Undo {
        spending: &'a str,
    },
}

Which direction a restore moves the workspace’s undo history, and whose undo stack it touches.

The destination belongs to the kind because the two are not independent: a rewind files a record under the session it hands the workspace to, and an undo spends the record filed under the session asking for it. Keeping them as separate arguments let a meaningless fourth combination be spelled, and made None at a call site say nothing about which.

Variants

Rewind

Going back in history, leaving an undo behind, filed under the session this hands the workspace to.

undo_for: None is a rewind with no destination session to be reachable from: nothing is recorded and the restore is not undoable. The caller is expected to have said so before running it.

The lock does not reach a destination that is not the performer. A session’s lock serializes it against itself (D18), and the undo record is written under undo_for — so naming a different session writes to a file this lock does not cover. It is safe in the case that motivates it, where a forking host creates that session immediately before the call and nothing else is using it yet. A host that hands undo_for a session already in use is outside what the lock protects, and the two concurrent push_restore read-modify-writes can lose an entry (D26).

Fields

undo_for: Option<&'a str>

Undo

Reversing spending’s most recent rewind and consuming that record, so undoing twice walks back through two rewinds rather than oscillating between the last two states.

Fields

spending: &'a str

Trait Implementations

impl<'a> Clone for RestoreKind<'a>

fn clone(&self) -> RestoreKind<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for RestoreKind<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for RestoreKind<'a>

impl<'a> PartialEq for RestoreKind<'a>

fn eq(&self, other: &RestoreKind<'a>) -> bool

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for RestoreKind<'a>