Struct retry_error::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 copy 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: Display> Display for RetryError<E>

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

Formats the value using the given formatter.

impl<E: Debug + Display> Error for RetryError<E>

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

The lower-level source of this error, if any.

fn backtrace(&self) -> Option<&Backtrace>

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

Returns a stack backtrace, if available, of where this error occurred.

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

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, Global>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.