Struct PooledLendingIteratorAdapter 

pub struct PooledLendingIteratorAdapter<I: PooledIterator> { /* private fields */ }

Available on crate feature lending-iterator only.

An adapter for PooledIterator which implements lending_iterator::LendingIterator.

To avoid conflicts between LendingIterator::next and PooledIterator::next, the PooledIterator is not implemented for the adapter; however, the other cursor methods (valid, current, prev) are implemented if I: CursorPooledIterator, and Seekable is implemented if I: Seekable.

Implementations

impl<I: PooledIterator> PooledLendingIteratorAdapter<I>

pub fn into_inner(self) -> I

Convert the adapter back into the inner iterator.

impl<I: CursorPooledIterator> PooledLendingIteratorAdapter<I>

pub fn valid(&self) -> bool

Determine whether the iterator is currently at any value in the collection.

See CursorPooledIterator::valid().

pub const fn current(&self) -> Option<Item<'_, Self>>

Get the current value the iterator is at.

This is cheap, and does not require getting a new buffer.

See CursorPooledIterator::current().

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

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

See CursorPooledIterator::prev().

Trait Implementations

impl<I: Clone + PooledIterator> Clone for PooledLendingIteratorAdapter<I>

where I::Item: Clone,

fn clone(&self) -> PooledLendingIteratorAdapter<I>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<I: Debug + PooledIterator> Debug for PooledLendingIteratorAdapter<I>

where I::Item: Debug,

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

Formats the value using the given formatter.

impl<'next, I: PooledIterator> LendingIteratorඞItem<'next> for PooledLendingIteratorAdapter<I>

type T = &'next <I as PooledIterator>::Item

impl<I: PooledIterator> LendingIterator for PooledLendingIteratorAdapter<I>

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

Query the next() Item of this Self iterator.

fn filter<F>(self, should_yield: F) -> Filter<Self, F>

where Self: Sized, F: FnMut(&Self::T) -> bool,

LendingIterator counterpart of Iterator::filter().

fn for_each(self, f: impl FnMut(Self::T))

where Self: Sized,

LendingIterator counterpart of Iterator::for_each().

fn fold<Acc>(self, acc: Acc, f: impl FnMut(Acc, Self::T) -> Acc) -> Acc

where Self: Sized,

LendingIterator counterpart of Iterator::fold().

fn try_for_each<Err>( &mut self, f: impl FnMut(Self::T) -> Result<(), Err>, ) -> Result<(), Err>

LendingIterator counterpart of Iterator::try_for_each().

fn try_fold<Acc, Err>( &mut self, acc: Acc, f: impl FnMut(Acc, Self::T) -> Result<Acc, Err>, ) -> Result<Acc, Err>

LendingIterator counterpart of Iterator::try_fold().

fn all(&mut self, predicate: impl FnMut(Self::T) -> bool) -> bool

where Self: Sized,

LendingIterator counterpart of Iterator::all().

fn any(&mut self, predicate: impl FnMut(Self::T) -> bool) -> bool

where Self: Sized,

LendingIterator counterpart of Iterator::any().

fn by_ref(&mut self) -> &mut Self

where Self: Sized,

LendingIterator counterpart of Iterator::by_ref().

fn count(self) -> usize

where Self: Sized,

LendingIterator counterpart of Iterator::count().

fn find<'find>( &'find mut self, predicate: impl FnMut(&Self::T) -> bool + 'find, ) -> Option<Self::T>

where Self: Sized,

LendingIterator counterpart of Iterator::find().

fn fuse(self) -> Fuse<Self>

where Self: Sized,

LendingIterator counterpart of Iterator::fuse().

fn nth(&mut self, n: usize) -> Option<Self::T>

LendingIterator counterpart of Iterator::nth().

fn position<F>( &mut self, predicate: impl FnMut(Self::T) -> bool, ) -> Option<usize>

where Self: Sized,

LendingIterator counterpart of Iterator::position().

fn skip(self, count: usize) -> Skip<Self>

where Self: Sized,

LendingIterator counterpart of Iterator::skip().

fn take(self, count: usize) -> Take<Self>

where Self: Sized,

LendingIterator counterpart of Iterator::take().

fn map<NewItemType, F>(self, f: F) -> Map<Self, F, NewItemType>

where NewItemType: HKT, F: for<'next> FnMut([&'next Self; 0], Self::T) -> <NewItemType as WithLifetime<'next>>::T, Self: Sized,

LendingIterator counterpart of Iterator::map().

fn map_to_ref<R, F>( self, f: F, ) -> Map<Self, F, HKT<dyn for<'ඞ> WithLifetime<'ඞ, T = &'ඞ R>>>

where F: for<'any> FnMut([&'any Self; 0], Self::T) -> &'any R, Self: Sized, R: ?Sized,

Convenience method: same as .map(), but for hard-coding the HKT parameter to HKTRef<R> = HKT!(&R).

fn map_to_mut<R, F>( self, f: F, ) -> Map<Self, F, HKT<dyn for<'ඞ> WithLifetime<'ඞ, T = &'ඞ mut R>>>

where F: for<'any> FnMut([&'any Self; 0], Self::T) -> &'any mut R, Self: Sized, R: ?Sized,

Convenience method: same as .map(), but for hard-coding the HKT parameter to HKTRefMut<R> = HKT!(&mut R).

fn map_into_iter<F, NonLendingItem>(self, f: F) -> MapIntoIter<Self, F>

where F: FnMut(Self::T) -> NonLendingItem, Self: Sized,

Convenience shorthand for .map…(…).into_iter().

fn filter_map<NewItemType, F>(self, f: F) -> FilterMap<Self, F, NewItemType>

where NewItemType: HKT, F: for<'next> FnMut([&'next Self; 0], Self::T) -> Option<<NewItemType as WithLifetime<'next>>::T>, Self: Sized,

LendingIterator counterpart of Iterator::filter_map().

fn filter_map_to_ref<R, F>( self, f: F, ) -> FilterMap<Self, F, HKT<dyn for<'ඞ> WithLifetime<'ඞ, T = &'ඞ R>>>

where F: for<'any> FnMut([&'any Self; 0], Self::T) -> Option<&'any R>, Self: Sized, R: ?Sized,

Convenience method: same as .filter_map(), but for hard-coding the HKT parameter to HKTRef<R> = HKT!(&R).

fn filter_map_to_mut<R, F>( self, f: F, ) -> FilterMap<Self, F, HKT<dyn for<'ඞ> WithLifetime<'ඞ, T = &'ඞ mut R>>>

where F: for<'any> FnMut([&'any Self; 0], Self::T) -> Option<&'any mut R>, Self: Sized, R: ?Sized,

Convenience method: same as .filter_map(), but for hard-coding the HKT parameter to HKTRefMut<R> = HKT!(&mut R).

fn filter_map_into_iter<F, NonLendingItem>( self, f: F, ) -> FilterMapIntoIter<Self, F>

where F: FnMut(Self::T) -> Option<NonLendingItem>, Self: Sized,

Convenience shorthand for .filter_map…(…).into_iter().

fn into_iter<Item>(self) -> IntoIter<Self>

where Self: for<'any> LendingIteratorඞItem<'any, T = Item> + Sized,

Convert a Self : LendingIterator into an Iterator, provided Self::Item<'_> does not depend on '_.

impl<I: PartialEq + PooledIterator> PartialEq for PooledLendingIteratorAdapter<I>

where I::Item: PartialEq,

fn eq(&self, other: &PooledLendingIteratorAdapter<I>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<Key, Cmp, I> Seekable<Key, Cmp> for PooledLendingIteratorAdapter<I>

where Key: ?Sized, Cmp: ?Sized + Comparator<Key>, I: Seekable<Key, Cmp> + PooledIterator,

fn reset(&mut self)

Reset the iterator to its initial position, before the first entry and after the last entry (if there are any entries in the collection).

fn seek(&mut self, min_bound: &Key)

Move the iterator to the smallest key which is greater or equal than the provided min_bound.

fn seek_before(&mut self, strict_upper_bound: &Key)

Move the iterator to the greatest key which is strictly less than the provided strict_upper_bound.

fn seek_to_first(&mut self)

Move the iterator to the smallest key in the collection.

fn seek_to_last(&mut self)

Move the iterator to the greatest key in the collection.

impl<I: Eq + PooledIterator> Eq for PooledLendingIteratorAdapter<I>

where I::Item: Eq,

impl<I: PooledIterator> StructuralPartialEq for PooledLendingIteratorAdapter<I>