Struct adventure::repeat::Repeat

pub struct Repeat<R> { /* fields omitted */ }

An Request adaptor for types that implements OneshotRequest, by cloning itself.

Trait Implementations

impl<R> BaseRequest for Repeat<R> where
    R: BaseRequest, 

type Ok = R::Ok

The type of successful values from the corresponding response.

type Error = R::Error

The type of failures from the corresponding response.

impl<R: Clone> Clone for Repeat<R>

fn clone(&self) -> Repeat<R>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<R> From<R> for Repeat<R> where
    R: Clone, 

fn from(req: R) -> Self

Performs the conversion.

impl<R, C> OneshotRequest<C> for Repeat<R> where
    R: OneshotRequest<C> + Clone, 

type Response = R::Response

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> PagedRequest for Repeat<R> 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, C> Request<C> for Repeat<R> where
    R: OneshotRequest<C> + Clone, 

type Response = R::Response

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> RetriableRequest for Repeat<R> where
    R: RetriableRequest, 

fn should_retry(&self, error: &Self::Error, next_interval: Duration) -> bool

fn retry(self) -> RetryingTokio<Self> where
    Self: Sized, 

Wrap this request to retry itself on failure, with a default ExponentialBackoff strategy.

fn retry_with_backoff<B>(self, backoff: B) -> RetryingTokio<Self, B> where
    Self: BaseRequest + Sized,
    B: Backoff, 

Wrap this request to retry itself on failure, with a given backoff strategy.