Struct rustc_data_structures::undo_log::VecLog

pub struct VecLog<T> {
    log: Vec<T>,
    num_open_snapshots: usize,
}

A basic undo log.

Fields

log: Vec<T>

num_open_snapshots: usize

Trait Implementations

impl<T> Clone for VecLog<T>

where T: Clone,

fn clone(&self) -> VecLog<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for VecLog<T>

where T: Debug,

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

Formats the value using the given formatter.

impl<T> Default for VecLog<T>

fn default() -> VecLog<T>

Returns the “default value” for a type.

impl<T> Index<usize> for VecLog<T>

type Output = T

The returned type after indexing.

fn index(&self, key: usize) -> &T

Performs the indexing (container[index]) operation.

impl<T> Snapshots<T> for VecLog<T>

type Snapshot = Snapshot

fn has_changes(&self, snapshot: &Snapshot) -> bool

Returns true if self has made any changes since snapshot started.

fn actions_since_snapshot(&self, snapshot: &Snapshot) -> &[T]

Returns the slice of actions that were taken since the snapshot began.

fn start_snapshot(&mut self) -> Snapshot

Starts a new snapshot. That snapshot must eventually either be committed via a call to commit or rollback via rollback_to. Snapshots can be nested (i.e., you can start a snapshot whilst another snapshot is in progress) but you must then commit or rollback the inner snapshot before attempting to commit or rollback the outer snapshot.

fn rollback_to<R>(&mut self, values: impl FnOnce() -> R, snapshot: Snapshot)

where R: Rollback<T>,

Rollback (undo) the changes made to storage since the snapshot.

fn commit(&mut self, snapshot: Snapshot)

Commit: keep the changes that have been made since the snapshot began

impl<T> UndoLogs<T> for VecLog<T>

fn num_open_snapshots(&self) -> usize

How many open snapshots this undo log currently has

fn push(&mut self, undo: T)

Pushes a new “undo item” onto the undo log. This method is invoked when some action is taken (e.g., a variable is unified). It records the info needed to reverse that action should an enclosing snapshot be rolled back.

fn clear(&mut self)

Removes all items from the undo log.

fn in_snapshot(&self) -> bool

True if a snapshot has started, false otherwise

fn extend<I>(&mut self, undos: I)

where Self: Sized, I: IntoIterator<Item = T>,

Extends the undo log with many undos.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 32 bytes