Struct rustc_ap_rustc_data_structures::undo_log::VecLog

pub struct VecLog<T> { /* fields omitted */ }

A basic undo log.

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: &<VecLog<T> as Snapshots<T>>::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 rolleod 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
    I: IntoIterator<Item = T>, 

Extends the undo log with many undos.