Struct LenderAdapter 

pub struct LenderAdapter<I>(/* private fields */);

Available on crate feature lender only.

An adapter for CursorLendingIterator which implements lender::Lender.

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

Implementations

impl<I> LenderAdapter<I>

pub fn into_inner(self) -> I

Convert the adapter back into the inner iterator.

impl<I: CursorLendingIterator> LenderAdapter<I>

pub fn valid(&self) -> bool

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

See CursorLendingIterator::valid().

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

Get the current value the iterator is at.

See CursorLendingIterator::current().

pub fn prev(&mut self) -> Option<Lend<'_, 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 CursorLendingIterator::prev().

Trait Implementations

impl<I: Clone> Clone for LenderAdapter<I>

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

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Debug> Debug for LenderAdapter<I>

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

Formats the value using the given formatter.

impl<I: CursorLendingIterator> Lender for LenderAdapter<I>

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

Yield the next lend, if any, of the lender.

fn next_chunk(&mut self, chunk_size: usize) -> Chunk<'_, Self>

where Self: Sized,

Take the next len lends of the lender with temporary lender Chunk. This is the quivalent of cloning the lender and calling take(len) on it.

fn size_hint(&self) -> (usize, Option<usize>)

Get the estimated minimum and maximum length of the lender. Use .len() for the exact length if the lender implements ExactSizeLender.

fn count(self) -> usize

where Self: Sized,

Count the number of lends in the lender by consuming it.

fn last<'call>(&'call mut self) -> Option<Self::Lend>

where Self: Sized,

Get the last lend of the lender, if any, by consuming it.

fn advance_by(&mut self, n: usize) -> Result<(), NonZero<usize>>

Advance the lender by n lends. If the lender does not have enough lends, return the number of lends left.

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

Yield the nth lend of the lender, if any, by consuming it. If the lender does not have enough lends, returns None.

fn step_by(self, step: usize) -> StepBy<Self>

where Self: Sized,

Skip step - 1 lends between each lend of the lender.

fn chain<U>(self, other: U) -> Chain<Self, <U as IntoLender>::Lender>

where Self: Sized, U: for<'all> IntoLender + for<'all> Lending<'all, Lend = Self::Lend>,

Chain the lender with another lender of the same type.

fn zip<U>(self, other: U) -> Zip<Self, <U as IntoLender>::Lender>

where U: IntoLender, Self: Sized,

Zip the lender with another lender of the same or different type.

fn intersperse<'call>(self, separator: Self::Lend) -> Intersperse<'call, Self>

where Self: Sized, Self::Lend: for<'all> Clone,

Intersperse each lend of this lender with the given seperator.

fn intersperse_with<'call, G>( self, separator: G, ) -> IntersperseWith<'call, Self, G>

where Self: Sized, G: FnMut() -> Self::Lend,

Intersperse each lend of this lender with the seperator produced by the given function.

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

where Self: Sized, F: for<'all> FnMutHKA<'all, Self::Lend>,

Map each lend of this lender using the given function.

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

where F: FnMut(Self::Lend) -> O, Self: Sized,

Map each lend of this lender into an owned value using the given function.

fn for_each<F>(self, f: F)

where Self: Sized, F: FnMut(Self::Lend),

Call the given function with each lend of this lender.

fn filter<P>(self, predicate: P) -> Filter<Self, P>

where Self: Sized, P: FnMut(&Self::Lend) -> bool,

Filter this lender using the given predicate.

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

where Self: Sized, F: for<'all> FnMutHKAOpt<'all, Self::Lend>,

Filter and map this lender using the given function.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

Enumerate this lender. Each lend is paired with its zero-based index.

fn peekable<'call>(self) -> Peekable<'call, Self>

where Self: Sized,

Make this lender peekable, so that it is possible to peek at the next lend without consuming it.

fn skip_while<P>(self, predicate: P) -> SkipWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Lend) -> bool,

Skip the first contiguous sequence lends of this lender that satisfy the given predicate.

fn take_while<P>(self, predicate: P) -> TakeWhile<Self, P>

where Self: Sized, P: FnMut(&Self::Lend) -> bool,

Take the first contiguous sequence lends of this lender that satisfy the given predicate.

fn map_while<P>(self, predicate: P) -> MapWhile<Self, P>

where Self: Sized, P: for<'all> FnMutHKAOpt<'all, Self::Lend>,

Map this lender using the given function while it returns Some.

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

where Self: Sized,

Skip the first n lends of this lender.

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

where Self: Sized,

Take the first n lends of this lender.

fn scan<St, F>(self, initial_state: St, f: F) -> Scan<Self, St, F>

where Self: Sized, F: for<'all> FnMutHKAOpt<'all, (&'all mut St, Self::Lend)>,

Documentation is incomplete. Refer to Iterator::scan for more information.

fn flat_map<'call, F>(self, f: F) -> FlatMap<'call, Self, F>

where Self: Sized, F: for<'all> FnMutHKA<'all, Self::Lend>, <F as FnMutHKA<'all, Self::Lend>>::B: for<'all> IntoLender,

Documentation is incomplete. Refer to Iterator::flat_map for more information

fn flatten<'call>(self) -> Flatten<'call, Self>

where Self: Sized, Self::Lend: for<'all> IntoLender,

Documentation is incomplete. Refer to Iterator::flatten for more information

fn fuse(self) -> Fuse<Self>

where Self: Sized,

Documentation is incomplete. Refer to Iterator::fuse for more information

fn inspect<F>(self, f: F) -> Inspect<Self, F>

where Self: Sized, F: FnMut(&Self::Lend),

Documentation is incomplete. Refer to Iterator::inspect for more information

fn mutate<F>(self, f: F) -> Mutate<Self, F>

where Self: Sized, F: FnMut(&mut Self::Lend),

Mutate each lend with the given function.

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

where Self: Sized,

Documentation is incomplete. Refer to Iterator::by_ref for more information

fn collect<B>(self) -> B

where Self: Sized, B: FromLender<Self>,

Documentation is incomplete. Refer to Iterator::collect for more information

fn try_collect<'a, B>( &'a mut self, ) -> <<Self::Lend as Try>::Residual as Residual<B>>::TryType

where Self: Sized, Self::Lend: for<'all> Try, <Self::Lend as Try>::Residual: for<'all> Residual<B>, B: for<'all> FromLender<TryShunt<'all, &'a mut Self>>,

Documentation is incomplete. Refer to Iterator::try_collect for more information

fn collect_into<E>(self, collection: &mut E) -> &mut E

where Self: Sized, E: ExtendLender<Self>,

Documentation is incomplete. Refer to Iterator::collect_into for more information

fn partition<A, E, F>(self, f: F) -> (E, E)

where Self: Sized, E: Default + ExtendLender<Self>, F: FnMut(&Self::Lend) -> bool,

Documentation is incomplete. Refer to Iterator::partition for more information

fn is_partitioned<P>(self, predicate: P) -> bool

where Self: Sized, P: FnMut(Self::Lend) -> bool,

Documentation is incomplete. Refer to Iterator::is_partitioned for more information

fn try_fold<B, F, R>(&mut self, init: B, f: F) -> R

where Self: Sized, F: FnMut(B, Self::Lend) -> R, R: Try<Output = B>,

Documentation is incomplete. Refer to Iterator::try_fold for more information

fn try_for_each<F, R>(&mut self, f: F) -> R

where Self: Sized, F: FnMut(Self::Lend) -> R, R: Try<Output = ()>,

Documentation is incomplete. Refer to Iterator::try_for_each for more information

fn fold<B, F>(self, init: B, f: F) -> B

where Self: Sized, F: FnMut(B, Self::Lend) -> B,

Documentation is incomplete. Refer to Iterator::fold for more information

fn reduce<T, F>(self, f: F) -> Option<T>

where Self: Sized, Self::Lend: for<'all> ToOwned<Owned = T>, F: FnMut(T, Self::Lend) -> T,

Documentation is incomplete. Refer to Iterator::reduce for more information

fn try_reduce<T, F, R>( self, f: F, ) -> <<R as Try>::Residual as Residual<Option<T>>>::TryType

where Self: Sized, Self::Lend: for<'all> ToOwned<Owned = T>, F: FnMut(T, Self::Lend) -> R, R: Try<Output = T>, <R as Try>::Residual: Residual<Option<T>>,

Documentation is incomplete. Refer to Iterator::try_reduce for more information

fn all<F>(&mut self, f: F) -> bool

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

Documentation is incomplete. Refer to Iterator::all for more information

fn any<F>(&mut self, f: F) -> bool

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

Documentation is incomplete. Refer to Iterator::any for more information

fn find<P>(&mut self, predicate: P) -> Option<Self::Lend>

where Self: Sized, P: FnMut(&Self::Lend) -> bool,

Documentation is incomplete. Refer to Iterator::find for more information

fn find_map<'a, F>( &'a mut self, f: F, ) -> Option<<F as FnMutHKAOpt<'a, Self::Lend>>::B>

where Self: Sized, F: for<'all> FnMutHKAOpt<'all, Self::Lend>,

Documentation is incomplete. Refer to Iterator::find_map for more information

fn try_find<F, R>( &mut self, f: F, ) -> <<R as Try>::Residual as Residual<Option<Self::Lend>>>::TryType

where Self: Sized, F: FnMut(&Self::Lend) -> R, R: Try<Output = bool>, <R as Try>::Residual: for<'all> Residual<Option<Self::Lend>>,

Documentation is incomplete. Refer to Iterator::try_find for more information

fn position<P>(&mut self, predicate: P) -> Option<usize>

where Self: Sized, P: FnMut(Self::Lend) -> bool,

Documentation is incomplete. Refer to Iterator::position for more information

fn max<T>(self) -> Option<T>

where Self: Sized, T: for<'all> PartialOrd<Self::Lend>, Self::Lend: for<'all> ToOwned<Owned = T>,

Documentation is incomplete. Refer to Iterator::max for more information

fn min<T>(self) -> Option<T>

where Self: Sized, T: for<'all> PartialOrd<Self::Lend>, Self::Lend: for<'all> ToOwned<Owned = T>,

Documentation is incomplete. Refer to Iterator::min for more information

fn max_by_key<B, T, F>(self, f: F) -> Option<T>

where B: Ord, Self: Sized, Self::Lend: for<'all> ToOwned<Owned = T>, F: FnMut(&T) -> B,

Documentation is incomplete. Refer to Iterator::max_by_key for more information

fn max_by<T, F>(self, compare: F) -> Option<T>

where Self: Sized, Self::Lend: for<'all> ToOwned<Owned = T>, F: FnMut(&T, &Self::Lend) -> Ordering,

Documentation is incomplete. Refer to Iterator::max_by for more information

fn min_by_key<B, T, F>(self, f: F) -> Option<T>

where B: Ord, Self: Sized, Self::Lend: for<'all> ToOwned<Owned = T>, F: FnMut(&T) -> B,

Documentation is incomplete. Refer to Iterator::min_by_key for more information

fn min_by<T, F>(self, compare: F) -> Option<T>

where Self: Sized, Self::Lend: for<'all> ToOwned<Owned = T>, F: FnMut(&T, &Self::Lend) -> Ordering,

Documentation is incomplete. Refer to Iterator::min_by for more information

fn unzip<ExtA, ExtB>(self) -> (ExtA, ExtB)

where Self: Sized, Self::Lend: for<'all> TupleLend<'all>, ExtA: Default + ExtendLender<FirstShunt<Self>>, ExtB: Default + ExtendLender<SecondShunt<Self>>,

Documentation is incomplete. Refer to Iterator::unzip for more information

fn copied<T>(self) -> Copied<Self>

where Self: Sized + for<'all> Lending<'all, Lend = &'all T>, T: Copy,

Documentation is incomplete. Refer to Iterator::copied for more information.

fn cloned<T>(self) -> Cloned<Self>

where Self: Sized + for<'all> Lending<'all, Lend = &'all T>, T: Clone,

Documentation is incomplete. Refer to Iterator::cloned for more information.

fn owned(self) -> Owned<Self>

where Self: Sized, Self::Lend: for<'all> ToOwned,

Turn this Lender into an Iterator.

fn cycle(self) -> Cycle<Self>

where Self: Sized + Clone,

Documentation is incomplete. Refer to Iterator::cycle for more information

fn sum<S>(self) -> S

where Self: Sized, S: SumLender<Self>,

Documentation is incomplete. Refer to Iterator::sum for more information

fn product<P>(self) -> P

where Self: Sized, P: ProductLender<Self>,

Documentation is incomplete. Refer to Iterator::product for more information

fn cmp<L>(self, other: L) -> Ordering

where L: IntoLender, <L as IntoLender>::Lender: for<'all> Lending<'all, Lend = Self::Lend>, Self::Lend: for<'all> Ord, Self: Sized,

Documentation is incomplete. Refer to Iterator::cmp for more information

fn cmp_by<L, F>(self, other: L, cmp: F) -> Ordering

where Self: Sized, L: IntoLender, F: for<'all> FnMut(Self::Lend, <<L as IntoLender>::Lender as Lending<'all>>::Lend) -> Ordering,

Documentation is incomplete. Refer to Iterator::cmp_by for more information

fn partial_cmp<L>(self, other: L) -> Option<Ordering>

where L: IntoLender, Self::Lend: for<'all> PartialOrd<<<L as IntoLender>::Lender as Lending<'all>>::Lend>, Self: Sized,

Documentation is incomplete. Refer to Iterator::partial_cmp for more information

fn partial_cmp_by<L, F>(self, other: L, partial_cmp: F) -> Option<Ordering>

where Self: Sized, L: IntoLender, F: for<'all> FnMut(Self::Lend, <<L as IntoLender>::Lender as Lending<'all>>::Lend) -> Option<Ordering>,

Documentation is incomplete. Refer to Iterator::partial_cmp_by for more information

fn eq<L>(self, other: L) -> bool

where L: IntoLender, Self::Lend: for<'all> PartialEq<<<L as IntoLender>::Lender as Lending<'all>>::Lend>, Self: Sized,

Documentation is incomplete. Refer to Iterator::eq for more information

fn eq_by<L, F>(self, other: L, eq: F) -> bool

where Self: Sized, L: IntoLender, F: for<'all> FnMut(Self::Lend, <<L as IntoLender>::Lender as Lending<'all>>::Lend) -> bool,

Documentation is incomplete. Refer to Iterator::eq_by for more information

fn ne<L>(self, other: L) -> bool

where L: IntoLender, Self::Lend: for<'all> PartialEq<<<L as IntoLender>::Lender as Lending<'all>>::Lend>, Self: Sized,

Documentation is incomplete. Refer to Iterator::ne for more information

fn lt<L>(self, other: L) -> bool

where L: IntoLender, Self::Lend: for<'all> PartialOrd<<<L as IntoLender>::Lender as Lending<'all>>::Lend>, Self: Sized,

Documentation is incomplete. Refer to Iterator::lt for more information

fn le<L>(self, other: L) -> bool

where L: IntoLender, Self::Lend: for<'all> PartialOrd<<<L as IntoLender>::Lender as Lending<'all>>::Lend>, Self: Sized,

Documentation is incomplete. Refer to Iterator::le for more information

fn gt<L>(self, other: L) -> bool

where L: IntoLender, Self::Lend: for<'all> PartialOrd<<<L as IntoLender>::Lender as Lending<'all>>::Lend>, Self: Sized,

Documentation is incomplete. Refer to Iterator::gt for more information

fn ge<L>(self, other: L) -> bool

where L: IntoLender, Self::Lend: for<'all> PartialOrd<<<L as IntoLender>::Lender as Lending<'all>>::Lend>, Self: Sized,

Documentation is incomplete. Refer to Iterator::ge for more information

fn is_sorted<T>(self) -> bool

where Self: Sized, Self::Lend: for<'all> ToOwned<Owned = T>, T: PartialOrd,

Documentation is incomplete. Refer to Iterator::is_sorted for more information

fn is_sorted_by<T, F>(self, compare: F) -> bool

where Self: Sized, Self::Lend: for<'all> ToOwned<Owned = T>, F: FnMut(&T, &T) -> Option<Ordering>,

Documentation is incomplete. Refer to Iterator::is_sorted_by for more information

fn is_sorted_by_key<F, K>(self, f: F) -> bool

where Self: Sized, F: FnMut(Self::Lend) -> K, K: PartialOrd,

Documentation is incomplete. Refer to Iterator::is_sorted_by_key for more information

fn iter<'this>(self) -> Iter<'this, Self>

where Self: Sized + 'this, Self::Lend: 'this,

Turn this lender into an Iterator where it has already fulfilled the requirements of the Iterator trait.

impl<'lend, I: CursorLendingIterator> Lending<'lend> for LenderAdapter<I>

type Lend = <I as LendItem<'lend>>::Item

The type being lent.

impl<I: PartialEq> PartialEq for LenderAdapter<I>

fn eq(&self, other: &LenderAdapter<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 LenderAdapter<I>

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

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> Eq for LenderAdapter<I>

impl<I> StructuralPartialEq for LenderAdapter<I>