Struct PollService 

pub struct PollService<E, S, F>
where
    F: Fn(usize) -> Result<(), RetryError<E>>,
{ /* private fields */ }

A Service, MutService, or AsyncService, which encapsulates a Service<(), Output = Option<T>>, MutService<(), Output = Option<T>>, or AsyncService<(), Output = Option<T>>, blocking with the given idle function until a value is returned or the idle function returns an error.

When the underlying Service<()> returns None, the given idle function will be called. The idle function will be called repeatedly, given the attempt number as input, until Some(T) is returned by the underlying service. The idle function may return Err(RetryError::Interrupted) to return an error and avoid blocking forever.

See the idle module for some provided idle functions.

Implementations

impl<E, S, F> PollService<E, S, F>

where F: Fn(usize) -> Result<(), RetryError<E>>,

pub fn new(service: S, idle: F) -> Self

Trait Implementations

impl<O, E, S, F> AsyncService for PollService<E, S, F>

where O: Send + 'static, E: Send + 'static, S: AsyncService<Input = (), Output = Option<O>, Error = E> + Send + Sync, F: Fn(usize) -> Result<(), RetryError<E>> + Send + Sync,

type Input = ()

type Output = O

type Error = RetryError<<S as AsyncService>::Error>

fn process<'life0, 'async_trait>( &'life0 self, __arg1: (), ) -> Pin<Box<dyn Future<Output = Result<Self::Output, Self::Error>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

impl<O, E, S, F> MutService for PollService<E, S, F>

where S: MutService<Input = (), Output = Option<O>, Error = E>, F: Fn(usize) -> Result<(), RetryError<E>>,

type Input = ()

type Output = O

type Error = RetryError<<S as MutService>::Error>

fn process(&mut self, _: ()) -> Result<Self::Output, Self::Error>

fn into_dyn<'a>( self, ) -> DynMutService<'a, Self::Input, Self::Output, Self::Error>

where Self: Sized + 'static,

Convert this Service into a DynMutService

impl<O, E, S, F> Service for PollService<E, S, F>

where S: Service<Input = (), Output = Option<O>, Error = E>, F: Fn(usize) -> Result<(), RetryError<E>>,

type Input = ()

type Output = O

type Error = RetryError<<S as Service>::Error>

fn process(&self, _: ()) -> Result<Self::Output, Self::Error>

Process an input, producing a Result<Self::Output, Self::Error>

fn into_mut(self) -> ServiceMut<Self>

where Self: Sized,

Convert this Service into a ServiceMut which impls MutService

fn into_async(self) -> ServiceAsync<Self>

where Self: Sized + Send + Sync + 'static,

Convert this Service into a ServiceAsync which impls AsyncService

fn into_dyn<'a>(self) -> DynService<'a, Self::Input, Self::Output, Self::Error>

where Self: Sized + 'static,

Convert this Service into a DynService