Struct CursorMut

pub struct CursorMut<'a, K: 'a, A = Global> { pub(in ::collections::btree::set) inner: CursorMut<'a, K, SetValZST, A> }

A cursor over a BTreeSet with editing operations.

A Cursor is like an iterator, except that it can freely seek back-and-forth, and can safely mutate the set during iteration. This is because the lifetime of its yielded references is tied to its own lifetime, instead of just the underlying map. This means cursors cannot yield multiple elements at once.

Cursors always point to a gap between two elements in the set, and can operate on the two immediately adjacent elements.

A CursorMut is created with the BTreeSet::lower_bound_mut and BTreeSet::upper_bound_mut methods.

Fields

inner: CursorMut<'a, K, SetValZST, A>

Implementations

impl<'a, T, A> CursorMut<'a, T, A>

fn next(&mut self) -> Option<&T>

Advances the cursor to the next gap, returning the element that it moved over.

If the cursor is already at the end of the set then None is returned and the cursor is not moved.

fn prev(&mut self) -> Option<&T>

Advances the cursor to the previous gap, returning the element that it moved over.

If the cursor is already at the start of the set then None is returned and the cursor is not moved.

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

Returns a reference to the next element without moving the cursor.

If the cursor is at the end of the set then None is returned.

fn peek_prev(&mut self) -> Option<&T>

Returns a reference to the previous element without moving the cursor.

If the cursor is at the start of the set then None is returned.

fn as_cursor(&self) -> Cursor<'_, T>

Returns a read-only cursor pointing to the same location as the CursorMut.

The lifetime of the returned Cursor is bound to that of the CursorMut, which means it cannot outlive the CursorMut and that the CursorMut is frozen for the lifetime of the Cursor.

unsafe fn with_mutable_key(self) -> CursorMutKey<'a, T, A>

Converts the cursor into a CursorMutKey, which allows mutating elements in the tree.

Safety

Since this cursor allows mutating elements, you must ensure that the BTreeSet invariants are maintained. Specifically:

  • The newly inserted element must be unique in the tree.
  • All elements in the tree must remain in sorted order.

impl<'a, T: Ord, A: Allocator + Clone> CursorMut<'a, T, A>

unsafe fn insert_after_unchecked(&mut self, value: T)

Inserts a new element into the set in the gap that the cursor is currently pointing to.

After the insertion the cursor will be pointing at the gap before the newly inserted element.

Safety

You must ensure that the BTreeSet invariants are maintained. Specifically:

  • The newly inserted element must be unique in the tree.
  • All elements in the tree must remain in sorted order.
unsafe fn insert_before_unchecked(&mut self, value: T)

Inserts a new element into the set in the gap that the cursor is currently pointing to.

After the insertion the cursor will be pointing at the gap after the newly inserted element.

Safety

You must ensure that the BTreeSet invariants are maintained. Specifically:

  • The newly inserted element must be unique in the tree.
  • All elements in the tree must remain in sorted order.
fn insert_after(&mut self, value: T) -> Result<(), UnorderedKeyError>

Inserts a new element into the set in the gap that the cursor is currently pointing to.

After the insertion the cursor will be pointing at the gap before the newly inserted element.

If the inserted element is not greater than the element before the cursor (if any), or if it not less than the element after the cursor (if any), then an UnorderedKeyError is returned since this would invalidate the Ord invariant between the elements of the set.

fn insert_before(&mut self, value: T) -> Result<(), UnorderedKeyError>

Inserts a new element into the set in the gap that the cursor is currently pointing to.

After the insertion the cursor will be pointing at the gap after the newly inserted element.

If the inserted element is not greater than the element before the cursor (if any), or if it not less than the element after the cursor (if any), then an UnorderedKeyError is returned since this would invalidate the Ord invariant between the elements of the set.

fn remove_next(&mut self) -> Option<T>

Removes the next element from the BTreeSet.

The element that was removed is returned. The cursor position is unchanged (before the removed element).

fn remove_prev(&mut self) -> Option<T>

Removes the preceding element from the BTreeSet.

The element that was removed is returned. The cursor position is unchanged (after the removed element).

Trait Implementations

impl<K: Debug, A> Debug for CursorMut<'_, K, A>

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

Auto Trait Implementations

impl<'a, K, A = Global> !UnwindSafe for CursorMut<'a, K, A>

impl<'a, K, A> Freeze for CursorMut<'a, K, A> where CursorMut<'a, K, SetValZST, A>: Freeze,

impl<'a, K, A> RefUnwindSafe for CursorMut<'a, K, A> where CursorMut<'a, K, SetValZST, A>: RefUnwindSafe,

impl<'a, K, A> Send for CursorMut<'a, K, A> where CursorMut<'a, K, SetValZST, A>: Send,

impl<'a, K, A> Sync for CursorMut<'a, K, A> where CursorMut<'a, K, SetValZST, A>: Sync,

impl<'a, K, A> Unpin for CursorMut<'a, K, A> where CursorMut<'a, K, SetValZST, A>: Unpin,

impl<'a, K, A> UnsafeUnpin for CursorMut<'a, K, A> where CursorMut<'a, K, SetValZST, A>: UnsafeUnpin,

Blanket Implementations

impl<T> Any for CursorMut<'a, K, A> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for CursorMut<'a, K, A> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for CursorMut<'a, K, A> where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> From<T> for CursorMut<'a, K, A>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> SizeHint for CursorMut<'a, K, A> where T: ?Sized,

fn lower_bound(&self) -> usize
fn upper_bound(&self) -> Option<usize>

impl<T> SizedTypeProperties for CursorMut<'a, K, A>

impl<T, U> Into<U> for CursorMut<'a, K, A> where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom<U> for CursorMut<'a, K, A> where U: Into<T>,

type Error = Infallible;
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for CursorMut<'a, K, A> where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>