Struct RegisterEntries 

pub struct RegisterEntries<'a, 'ctx> { /* private fields */ }

FallibleLender returned by Ledger::register_entries.

Holds the running cumulative Amount and a borrow into the underlying transactions; each call to FallibleLender::next advances to the next matching posting, updates the running total, and lends a borrow. Errors from currency conversion are surfaced as QueryError.

Trait Implementations

impl<'a, 'ctx> FallibleLender for RegisterEntries<'a, 'ctx>

type Error = QueryError

The error type.

fn __check_covariance<'long: 'short, 'short>( proof: CovariantProof<<Self as FallibleLending<'long>>::Lend>, ) -> CovariantProof<<Self as FallibleLending<'short>>::Lend>

Internal method for checking the covariance of the Lend associated type of this fallible lender.

fn next(&mut self) -> Result<Option<FallibleLend<'_, Self>>, Self::Error>

Yields the next lend, if any, of the lender, or Ok(None) when iteration is finished.

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

where Self: Sized,

Takes the next chunk_size lends of the lender with temporary lender Chunk. The returned Chunk borrows this fallible lender mutably and advances it as the chunk is consumed; any elements left unconsumed when the Chunk is dropped remain and are produced by later calls.

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

Gets the estimated minimum and maximum length of the lender. Both bounds assume that all remaining calls to next() succeed. That is, next() could return an Err in fewer calls than specified by the lower bound.

fn count(self) -> Result<usize, Self::Error>

where Self: Sized,

Counts the number of lends in the lender by consuming it until the lender yields Ok(None) or Err(_).

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

where Self: Sized,

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

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

Advances the lender by n lends.

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

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

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

where Self: Sized,

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

fn chain<U>( self, other: U, ) -> Chain<Self, <U as IntoFallibleLender>::FallibleLender>

where Self: Sized, U: IntoFallibleLender<Error = Self::Error> + for<'all> FallibleLending<'all, Lend = Self::Lend>,

Chains the lender with another lender of the same type.

fn zip<U>( self, other: U, ) -> Zip<Self, <U as IntoFallibleLender>::FallibleLender>

where U: IntoFallibleLender, Self: Sized,

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

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

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

Intersperses each lend of this lender with the separator produced by the given function.

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

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

Maps each lend of this lender using the given function.

fn map_err<E, F>(self, f: F) -> MapErr<E, Self, F>

where Self: Sized, F: FnMut(Self::Error) -> E,

Maps the error of this lender using the given function.

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

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

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

fn for_each<F>(self, f: F) -> Result<(), Self::Error>

where Self: Sized, F: FnMut(Self::Lend) -> Result<(), Self::Error>,

Calls 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) -> Result<bool, Self::Error>,

Filters this lender using the given predicate.

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

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

Filters and maps this lender using the given function.

fn enumerate(self) -> Enumerate<Self>

where Self: Sized,

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

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

where Self: Sized,

Makes 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) -> Result<bool, Self::Error>,

Skips the first contiguous sequence of 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) -> Result<bool, Self::Error>,

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

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

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

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

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

where Self: Sized,

Skips the first n lends of this lender.

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

where Self: Sized,

Takes the first n lends of this lender.

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

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

The FallibleLender version of Iterator::scan.

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

where Self: Sized, F: for<'all> FnMutHKARes<'all, Self::Lend, Self::Error>, <F as FnMutHKARes<'all, Self::Lend, Self::Error>>::B: for<'all> IntoFallibleLender<Error = Self::Error>,

The FallibleLender version of Iterator::flat_map.

fn fuse(self) -> Fuse<Self>

where Self: Sized,

The FallibleLender version of Iterator::fuse.

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

where Self: Sized, F: FnMut(&Self::Lend) -> Result<(), Self::Error>,

The FallibleLender version of Iterator::inspect.

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

where Self: Sized, F: FnMut(&mut Self::Lend) -> Result<(), Self::Error>,

Mutates each lend with the given function.

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

where Self: Sized,

The FallibleLender version of Iterator::by_ref.

fn collect<B>(self) -> Result<B, (B, Self::Error)>

where Self: Sized, B: for<'all> FromLender<NonFallibleAdapter<'all, Self>>,

Transforms the fallible lender into a collection. If any invocation of next returns Err, returns the collection built from values yielded successfully, together with the error.

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

where Self: Sized, E: for<'all> ExtendLender<NonFallibleAdapter<'all, Self>>,

Extends an existing collection with lends from this fallible lender.

fn partition<'this, E, F>(self, f: F) -> Result<(E, E), ((E, E), Self::Error)>

where Self: Sized + 'this, E: Default + ExtendLender<NonFallibleAdapter<'this, Self>>, F: FnMut(&Self::Lend) -> Result<bool, Self::Error>,

The FallibleLender version of Iterator::partition.

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

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

The FallibleLender version of Iterator::is_partitioned.

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

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

The FallibleLender version of Iterator::try_fold.

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

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

The FallibleLender version of Iterator::try_for_each.

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

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

The FallibleLender version of Iterator::fold.

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

where F: FnMut(Self::Lend) -> Result<bool, Self::Error>,

The FallibleLender version of Iterator::all.

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

where F: FnMut(Self::Lend) -> Result<bool, Self::Error>,

The FallibleLender version of Iterator::any.

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

where P: FnMut(&Self::Lend) -> Result<bool, Self::Error>,

The FallibleLender version of Iterator::find.

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

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

The FallibleLender version of Iterator::find_map.

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

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

The FallibleLender version of Iterator::try_find.

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

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

The FallibleLender version of Iterator::position.

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

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

The FallibleLender version of Iterator::copied.

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

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

The FallibleLender version of Iterator::cloned.

fn sum<S>(self) -> Result<S, Self::Error>

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

The FallibleLender version of Iterator::sum.

fn product<P>(self) -> Result<P, Self::Error>

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

The FallibleLender version of Iterator::product.

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

where Self: Sized, L: IntoFallibleLender<Error = Self::Error>, F: for<'all> FnMut(Self::Lend, <<L as IntoFallibleLender>::FallibleLender as FallibleLending<'all>>::Lend) -> Result<Ordering, Self::Error>,

The FallibleLender version of Iterator::cmp_by.

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

where L: IntoFallibleLender<Error = Self::Error>, Self::Lend: for<'all> PartialOrd<<<L as IntoFallibleLender>::FallibleLender as FallibleLending<'all>>::Lend>, Self: Sized,

The FallibleLender version of Iterator::partial_cmp.

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

where Self: Sized, L: IntoFallibleLender<Error = Self::Error>, F: for<'all> FnMut(Self::Lend, <<L as IntoFallibleLender>::FallibleLender as FallibleLending<'all>>::Lend) -> Result<Option<Ordering>, Self::Error>,

The FallibleLender version of Iterator::partial_cmp_by.

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

where L: IntoFallibleLender<Error = Self::Error>, Self::Lend: for<'all> PartialEq<<<L as IntoFallibleLender>::FallibleLender as FallibleLending<'all>>::Lend>, Self: Sized,

The FallibleLender version of Iterator::eq.

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

where Self: Sized, L: IntoFallibleLender<Error = Self::Error>, F: for<'all> FnMut(Self::Lend, <<L as IntoFallibleLender>::FallibleLender as FallibleLending<'all>>::Lend) -> Result<bool, Self::Error>,

The FallibleLender version of Iterator::eq_by.

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

where L: IntoFallibleLender<Error = Self::Error>, Self::Lend: for<'all> PartialEq<<<L as IntoFallibleLender>::FallibleLender as FallibleLending<'all>>::Lend>, Self: Sized,

The FallibleLender version of Iterator::ne.

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

where L: IntoFallibleLender<Error = Self::Error>, Self::Lend: for<'all> PartialOrd<<<L as IntoFallibleLender>::FallibleLender as FallibleLending<'all>>::Lend>, Self: Sized,

The FallibleLender version of Iterator::lt.

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

where L: IntoFallibleLender<Error = Self::Error>, Self::Lend: for<'all> PartialOrd<<<L as IntoFallibleLender>::FallibleLender as FallibleLending<'all>>::Lend>, Self: Sized,

The FallibleLender version of Iterator::le.

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

where L: IntoFallibleLender<Error = Self::Error>, Self::Lend: for<'all> PartialOrd<<<L as IntoFallibleLender>::FallibleLender as FallibleLending<'all>>::Lend>, Self: Sized,

The FallibleLender version of Iterator::gt.

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

where L: IntoFallibleLender<Error = Self::Error>, Self::Lend: for<'all> PartialOrd<<<L as IntoFallibleLender>::FallibleLender as FallibleLending<'all>>::Lend>, Self: Sized,

The FallibleLender version of Iterator::ge.

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

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

The FallibleLender version of Iterator::is_sorted_by_key.

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

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

Turns this FallibleLender into a FallibleIterator where it has already fulfilled the requirements of the FallibleIterator trait.

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

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

Turns this FallibleLender into a new FallibleLender that lends references to the items of the original lender.

impl<'a, 'ctx, 'lend> FallibleLending<'lend> for RegisterEntries<'a, 'ctx>

type Lend = RegisterEntry<'lend, 'ctx>

The type being lent.