Struct RetryError 

pub struct RetryError<E> { /* private fields */ }

An error type for use when we’re going to do something a few times, and they might all fail.

To use this error type, initialize a new RetryError before you start trying to do whatever it is. Then, every time the operation fails, use RetryError::push() to add a new error to the list of errors. If the operation fails too many times, you can use RetryError as an Error itself.

Implementations

impl<E> RetryError<E>

pub fn in_attempt_to<T: Into<String>>(doing: T) -> Self

Create a new RetryError, with no failed attempts.

The provided doing argument is a short string that describes what we were trying to do when we failed too many times. It will be used to format the final error message; it should be a phrase that can go after “while trying to”.

This RetryError should not be used as-is, since when no Errors have been pushed into it, it doesn’t represent an actual failure.

pub fn push<T>(&mut self, err: T)

where T: Into<E>,

Add an error to this RetryError.

You should call this method when an attempt at the underlying operation has failed.

pub fn sources(&self) -> impl Iterator<Item = &E>

Return an iterator over all of the reasons that the attempt behind this RetryError has failed.

pub fn len(&self) -> usize

Return the number of underlying errors.

pub fn is_empty(&self) -> bool

Return true if no underlying errors have been added.

pub fn dedup_by<F>(&mut self, same_err: F)

where F: Fn(&E, &E) -> bool,

Group up consecutive errors of the same kind, for easier display.

Two errors have “the same kind” if they return true when passed to the provided dedup function.

impl<E: PartialEq<E>> RetryError<E>

pub fn dedup(&mut self)

Group up consecutive errors of the same kind, according to the PartialEq implementation.

Trait Implementations

impl<E: Clone> Clone for RetryError<E>

fn clone(&self) -> RetryError<E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E: Debug> Debug for RetryError<E>

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

Formats the value using the given formatter.

impl<E: AsRef<dyn Error>> Display for RetryError<E>

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

Formats the value using the given formatter.

impl<E: Debug + AsRef<dyn Error>> Error for RetryError<E>

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0: use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0: replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl<E, T> Extend<T> for RetryError<E>

where T: Into<E>,

fn extend<C>(&mut self, iter: C)

where C: IntoIterator<Item = T>,

Extends a collection with the contents of an iterator.

fn extend_one(&mut self, item: A)

🔬This is a nightly-only experimental API. (extend_one)

Extends a collection with exactly one element.

fn extend_reserve(&mut self, additional: usize)

🔬This is a nightly-only experimental API. (extend_one)

Reserves capacity in a collection for the given number of additional elements.

impl<E> IntoIterator for RetryError<E>

type Item = E

The type of the elements being iterated over.

type IntoIter = IntoIter<E>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 56 bytes