Struct adventure::retry::Retrying

pub struct Retrying<R, T, B = ExponentialBackoff, F = ()> { /* fields omitted */ }

Request for retry combinator.

Trait Implementations

impl<R, T, B, F> BaseRequest for Retrying<R, T, B, F> where
    R: BaseRequest, 

type Ok = R::Ok

The type of successful values from the corresponding response.

type Error = RetryError<R::Error>

The type of failures from the corresponding response.

impl<R: Clone, T: Clone, B: Clone, F: Clone> Clone for Retrying<R, T, B, F>

fn clone(&self) -> Retrying<R, T, B, F>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R, T, B, F, C> OneshotRequest<C> for Retrying<R, T, B, F> where
    Self: RetryMethod<C, Response = R::Response> + Unpin,
    R: Request<C>,
    R::Response: Unpin,
    C: Clone, 

type Response = Retrial<Self, C>

The type of corresponding responses of this request.

fn send_once(self, client: C) -> Self::Response

Send this request to the given client, by consuming itself.

fn repeat(self) -> Repeat<Self> where
    Self: Clone, 

impl<R, T, B, F> PagedRequest for Retrying<R, T, B, F> where
    R: PagedRequest, 

fn advance(&mut self, response: &Self::Ok) -> bool

Modify itself to retrive the next response, of return false if the given response was the last one.

fn paginate<C>(self, client: C) -> Paginator<C, Self> where
    Self: Request<C> + Sized, 

impl<R, T, B, F, C> Request<C> for Retrying<R, T, B, F> where
    Self: RetryMethod<C, Response = R::Response> + Clone + Unpin,
    R: Request<C>,
    R::Response: Unpin,
    C: Clone, 

type Response = Retrial<Self, C>

The type of corresponding responses of this request.

fn send(self: Pin<&mut Self>, client: C) -> Self::Response

fn oneshot(self) -> Oneshot<Self> where
    Self: Sized, 

fn retry_if<F>(self, pred: F) -> RetryingTokio<Self, ExponentialBackoff, F> where
    Self: Sized,
    F: RetrialPredicate<Self>, 

Wrap this request to retry if the given predicate returns true.

fn retry_with_config<T, B, F>(
    self,
    timer: T,
    pred: F,
    backoff: B
) -> Retrying<Self, T, B, F> where
    Self: Sized,
    T: Timer + Unpin,
    B: Backoff,
    F: RetrialPredicate<Self>, 

Wrap this request to retry with customizable options, including the timer implementation.

impl<R, T, B, F> Unpin for Retrying<R, T, B, F> where
    R: Unpin,
    F: Unpin,
    B: Unpin,