Struct RestrictedCursor

pub struct RestrictedCursor<'a, T> {
    pub preceding: Option<Preceding<NonNull<Node<T>>>>,
    pub current: Option<NonNull<Node<T>>>,
    pub root: &'a mut Option<NonNull<Node<T>>>,
    pub guarded_nodes: Vec<NonNull<Node<T>>>,
}

A cursor which can be used to mutate element, but only in such a way that it does not remove elements in self.guarded_nodes. This allows for a semi-mutable cursor on the upper portion of a syntax tree while maintaining a mutable cursor on the lower portion.

Fields

preceding: Option<Preceding<NonNull<Node<T>>>>

The preceding element, mutably accessing this is unsafe.

current: Option<NonNull<Node<T>>>

The current element, mutably accessing this is unsafe.

root: &'a mut Option<NonNull<Node<T>>>

The current root element, mutably accessing this is unsafe.

guarded_nodes: Vec<NonNull<Node<T>>>

The set of nodes which cannot be removed, mutably accessing this is unsafe.

Implementations

impl<'a, T> RestrictedCursor<'a, T>

pub fn current(&self) -> Option<&T>

Get the current element.

Returns None if the current element is None or if the current element is the lower bound.

pub fn peek_move_preceding(&mut self) -> Option<&T>

Moves the cursor to the preceding element returning a reference to the new element if one is present, otherwise returning None.

pub fn move_preceding(&mut self) -> bool

Moves the cursor to the preceding element.

If there is no preceding element the cursor is not moved.

pub fn move_next(&mut self)

Moves the cursor to the next element if there is some current element and the next element is within the bounds of the cursor (when splitting a mutable cursor, an immutable cursor is produced where its bound restrict it to element above the mutable cursor).

pub fn move_child(&mut self)

Moves the cursor to the child element if there is some current element and the child element is within the bounds of the cursor (when splitting a mutable cursor, an immutable cursor is produced where its bound restrict it to element above the mutable cursor).

pub fn move_parent(&mut self) -> bool

Moves the cursor through preceding elements until reaching a parent, if no parent is found, the cursor is reset to its original position.

Returns true if the cursor was moved to a parent, or false if not.

pub fn move_successor(&mut self) -> bool

Moves the cursor to the successor element if one can be found. If there is no successor element the cursor is reset to its original position and is not moved.

Returns true if the cursor was moved to a successor, or false if not.

pub fn move_predecessor(&mut self) -> bool

Moves the cursor to the predecessor element if one can be found. If there is no predecessor element the cursor is reset to its original position and is not moved.

Returns true if the cursor was moved to a predecessor, or false if not.

pub fn peek_next(&self) -> Option<&T>

Returns a reference to the next element.

pub fn peek_parent(&self) -> Option<&T>

Returns a reference to the parent element.

Wrapper around self.peek_preceding().and_then(Preceding::parent).

pub fn peek_previous(&self) -> Option<&T>

Returns a reference to the previous element.

Wrapper around self.peek_preceding().and_then(Preceding::previous) .

pub fn peek_preceding(&self) -> Option<Preceding<&T>>

Returns a reference to the preceding element.

pub fn peek_child(&self) -> Option<&T>

Returns a reference to the child element.

pub fn current_mut(&self) -> Option<&mut T>

Get the current element.

pub fn remove_current(&mut self)

Removes the current node if it is not a guarded node.

When removing a node with a child node, the child node is removed.

Returns if the node was removed.

Trait Implementations

impl<'a, T: Debug> Debug for RestrictedCursor<'a, T>

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

Formats the value using the given formatter.

impl<'a, T> From<RestrictedCursor<'a, T>> for Cursor<'a, T>

fn from(cursor: RestrictedCursor<'a, T>) -> Cursor<'a, T>

Converts to this type from the input type.