Struct CursorMutKey

pub struct CursorMutKey<'a, K: 'a, V: 'a, A = Global> { pub(in ::collections::btree::map) current: Option<Handle<NodeRef<Mut<'a>, K, V, Leaf>, Edge>>, pub(in ::collections::btree::map) root: DormantMutRef<'a, Option<NodeRef<Owned, K, V, LeafOrInternal>>>, pub(in ::collections::btree::map) length: &'a mut usize, pub(in ::collections::btree::map) alloc: &'a mut A }

A cursor over a BTreeMap with editing operations, and which allows mutating the key of elements.

A Cursor is like an iterator, except that it can freely seek back-and-forth, and can safely mutate the map 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 map, and can operate on the two immediately adjacent elements.

A CursorMutKey is created from a CursorMut with the CursorMut::with_mutable_key method.

Safety

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

Fields

current: Option<Handle<NodeRef<Mut<'a>, K, V, Leaf>, Edge>>
root: DormantMutRef<'a, Option<NodeRef<Owned, K, V, LeafOrInternal>>>
length: &'a mut usize
alloc: &'a mut A

Implementations

impl<'a, K, V, A> CursorMutKey<'a, K, V, A>

fn next(&mut self) -> Option<(&mut K, &mut V)>

Advances the cursor to the next gap, returning the key and value of the element that it moved over.

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

fn prev(&mut self) -> Option<(&mut K, &mut V)>

Advances the cursor to the previous gap, returning the key and value of the element that it moved over.

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

fn peek_next(&mut self) -> Option<(&mut K, &mut V)>

Returns a reference to the key and value of the next element without moving the cursor.

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

fn peek_prev(&mut self) -> Option<(&mut K, &mut V)>

Returns a reference to the key and value of the previous element without moving the cursor.

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

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

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

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

impl<'a, K: Ord, V, A: Allocator + Clone> CursorMutKey<'a, K, V, A>

unsafe fn insert_after_unchecked(&mut self, key: K, value: V)

Inserts a new key-value pair into the map 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 BTreeMap invariants are maintained. Specifically:

  • The key of the newly inserted element must be unique in the tree.
  • All keys in the tree must remain in sorted order.
unsafe fn insert_before_unchecked(&mut self, key: K, value: V)

Inserts a new key-value pair into the map 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 BTreeMap invariants are maintained. Specifically:

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

Inserts a new key-value pair into the map 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 key is not greater than the key before the cursor (if any), or if it not less than the key after the cursor (if any), then an UnorderedKeyError is returned since this would invalidate the Ord invariant between the keys of the map.

fn insert_before(&mut self, key: K, value: V) -> Result<(), UnorderedKeyError>

Inserts a new key-value pair into the map 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 key is not greater than the key before the cursor (if any), or if it not less than the key after the cursor (if any), then an UnorderedKeyError is returned since this would invalidate the Ord invariant between the keys of the map.

fn remove_next(&mut self) -> Option<(K, V)>

Removes the next element from the BTreeMap.

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

fn remove_prev(&mut self) -> Option<(K, V)>

Removes the preceding element from the BTreeMap.

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

Trait Implementations

impl<K: Debug, V: Debug, A> Debug for CursorMutKey<'_, K, V, A>

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

Auto Trait Implementations

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

impl<'a, K, V, A> Freeze for CursorMutKey<'a, K, V, A> where Option<Handle<NodeRef<Mut<'a>, K, V, Leaf>, Edge>>: Freeze, DormantMutRef<'a, Option<NodeRef<Owned, K, V, LeafOrInternal>>>: Freeze, &'a mut A: Freeze,

impl<'a, K, V, A> RefUnwindSafe for CursorMutKey<'a, K, V, A> where Option<Handle<NodeRef<Mut<'a>, K, V, Leaf>, Edge>>: RefUnwindSafe, DormantMutRef<'a, Option<NodeRef<Owned, K, V, LeafOrInternal>>>: RefUnwindSafe, &'a mut A: RefUnwindSafe,

impl<'a, K, V, A> Send for CursorMutKey<'a, K, V, A> where Option<Handle<NodeRef<Mut<'a>, K, V, Leaf>, Edge>>: Send, DormantMutRef<'a, Option<NodeRef<Owned, K, V, LeafOrInternal>>>: Send, &'a mut A: Send,

impl<'a, K, V, A> Sync for CursorMutKey<'a, K, V, A> where Option<Handle<NodeRef<Mut<'a>, K, V, Leaf>, Edge>>: Sync, DormantMutRef<'a, Option<NodeRef<Owned, K, V, LeafOrInternal>>>: Sync, &'a mut A: Sync,

impl<'a, K, V, A> Unpin for CursorMutKey<'a, K, V, A> where Option<Handle<NodeRef<Mut<'a>, K, V, Leaf>, Edge>>: Unpin, DormantMutRef<'a, Option<NodeRef<Owned, K, V, LeafOrInternal>>>: Unpin, &'a mut A: Unpin,

impl<'a, K, V, A> UnsafeUnpin for CursorMutKey<'a, K, V, A> where Option<Handle<NodeRef<Mut<'a>, K, V, Leaf>, Edge>>: UnsafeUnpin, DormantMutRef<'a, Option<NodeRef<Owned, K, V, LeafOrInternal>>>: UnsafeUnpin, &'a mut A: UnsafeUnpin,

Blanket Implementations

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

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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

impl<T> From<T> for CursorMutKey<'a, K, V, A>

fn from(t: T) -> T

Returns the argument unchanged.

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

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

impl<T> SizedTypeProperties for CursorMutKey<'a, K, V, A>

impl<T, U> Into<U> for CursorMutKey<'a, K, V, 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 CursorMutKey<'a, K, V, 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 CursorMutKey<'a, K, V, A> where U: TryFrom<T>,

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