Trait CursorLendingIterator

pub trait CursorLendingIterator {
    type Item<'a>
       where Self: 'a;

    // Required methods
    fn valid(&self) -> bool;
    fn next(&mut self) -> Option<Self::Item<'_>>;
    fn current(&self) -> Option<Self::Item<'_>>;
    fn prev(&mut self) -> Option<Self::Item<'_>>;
}

A CursorLendingIterator provides access to the entries of some sorted collection, and can move its current position in either direction.

As a lending iterator, only one entry can be accessed at a time.

Conceptually, it is circular, and its initial position is before the first entry and after the last entry. As such, it is not a FusedIterator, as continuing to call next() at the end of iteration wraps around to the start. (Note that if the collection is empty, then the iterator will remain at that phantom position.)

Implementations may or may not be threadsafe. Even if an implementation is threadsafe, newly-added entries may or may not be seen immediately by other threads.

Forwards iteration should be preferred over backwards iteration.

Required Associated Types

type Item<'a> where Self: 'a

The item of this lending iterator, whose lifetime can force the consumer to drop the item before obtaining a new item (which requires a mutable borrow to the iterator, invalidating the borrow of the previous item).

Required Methods

fn valid(&self) -> bool

Determine whether the iterator is currently at any value in the collection. If the iterator is invalid, then it is conceptually one position before the first entry and one position after the last entry. (Or, there may be no entries.)

current() will be Some if and only if the iterator is valid.

fn next(&mut self) -> Option<Self::Item<'_>>

Move the iterator one position forwards, and return the entry at that position. Returns None if the iterator was at the last entry.

fn current(&self) -> Option<Self::Item<'_>>

Get the current value the iterator is at, if the iterator is valid.

fn prev(&mut self) -> Option<Self::Item<'_>>

Move the iterator one position back, and return the entry at that position. Returns None if the iterator was at the first entry.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors