Struct tor_hsservice::internal_prelude::RetryError

pub(crate) struct RetryError<E> {
    pub(crate) doing: String,
    pub(crate) errors: Vec<(Attempt, E)>,
    pub(crate) n_errors: usize,
}

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.

Fields

doing: String

errors: Vec<(Attempt, E)>

n_errors: usize

Implementations

impl<E> RetryError<E>

pub fn in_attempt_to<T>(doing: T) -> RetryError<E>

where T: Into<String>,

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> RetryError<E>

where E: PartialEq,

pub fn dedup(&mut self)

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

Trait Implementations

impl<E> Clone for RetryError<E>

where E: Clone,

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 for RetryError<E>

where E: Debug,

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

Formats the value using the given formatter.

impl<E> Display for RetryError<E>

where E: AsRef<dyn Error>,

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

Formats the value using the given formatter.

impl<E> Error for RetryError<E>

where E: Debug + AsRef<dyn Error>,

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

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> From<BackoffError<E>> for RetryError<E>

fn from(e: BackoffError<E>) -> Self

Converts to this type from the input type.

impl From<RetryError<UploadError>> for Problem

fn from(original: RetryError<DescUploadError>) -> Problem

Converts to this type from the input type.

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) -> <RetryError<E> as IntoIterator>::IntoIter

Creates an iterator from a value.