Struct c2rust_refactor::util::cursor::Cursor

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

A Cursor indicates a position within a sequence of Ts. The position can be anywhere within the sequence, including before the first item and after the last.

Marks

In addition to moving through and manipulating the sequence, Cursors also permit marking the current position so it can be referenced in later operations. These marks remain in place even if items are inserted, removed, or replaced before or after the mark. (But replacing a range of items will invalidate all marks between the replaced items.)

Methods

impl<T> Cursor<T>

pub fn new() -> Cursor<T>

pub fn from_vec(orig: Vec<T>) -> Cursor<T>

pub fn into_vec(self) -> Vec<T>

pub fn retract(&mut self)

Move the cursor back by one position.

pub fn retract_by(&mut self, n: usize)

Move the cursor back by n positions.

pub fn advance(&mut self)

Move the cursor forward by one position.

pub fn advance_by(&mut self, steps: usize)

Move the cursor forward by n positions.

pub fn mark(&mut self) -> Mark

Return a Mark indicating the current position. As long as the mark remains valid, seek can be used to return to this position.

pub fn seek(&mut self, mark: Mark)

Return to a previously marked position. Panics if the mark is invalid.

pub fn eof(&self) -> bool

Checks if the cursor is positioned at the end of the sequence.

pub fn insert(&mut self, x: T)

Insert an element at the current position. Afterward, the cursor will point after the inserted element.

pub fn insert_multi(&mut self, xs: Vec<T>)

Insert several elements at the current position. Afterward, the cursor will point after the inserted elements.

pub fn remove(&mut self) -> T

Remove the element after the current position. Panics if the current position is at the end of the sequence.

pub fn remove_multi(&mut self, n: usize) -> Vec<T>

Remove n elements after the current position.

pub fn next(&self) -> &T

Return a reference to the element immediately after the current position.

pub fn advance_until<F: FnMut(&T) -> bool>(&mut self, pred: F)

Advance until an element matches pred. The cursor is left pointing just before the matching element. If no element matches, the cursor points at the end of the sequence.

pub fn remove_to_mark(&mut self, m: Mark) -> Vec<T>

Remove elements between the current position and the given mark. The mark must not be behind the current position in the buffer.

pub fn replace<F>(&mut self, func: F) where
    F: FnOnce(T) -> T, 

Replace the element after the cursor by transforming it with func. Does not move the cursor.

pub fn replace_range<F>(&mut self, start: Mark, end: Mark, func: F) where
    F: FnOnce(Vec<T>) -> Vec<T>, 

Extract the elements between start and end, transform them using func, and insert the results in their place. Afterward, the cursor points past the end of the replacement sequnece.

pub fn advance_until_match<F, R>(&mut self, func: F) -> Option<R> where
    F: FnMut(&T) -> Option<R>, 

Check items with func until it matches (returns Some). Returns the result of func on the matched item, and leaves the cursor just before the item itself.

pub fn debug(&self)