Struct MapAsync 

pub struct MapAsync<F, H> {
    pub handler: H,
    pub f: F,
}

Fields

handler: H

f: F

Trait Implementations

impl<F: Clone, H: Clone> Clone for MapAsync<F, H>

fn clone(&self) -> MapAsync<F, H>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<F: Copy, H: Copy> Copy for MapAsync<F, H>

impl<F: Debug, H: Debug> Debug for MapAsync<F, H>

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

Formats the value using the given formatter.

impl<F: Eq, H: Eq> Eq for MapAsync<F, H>

impl<F, H, T, E> Handler<T, E> for MapAsync<F, H>

where T: Send, F: Send + Sync + Fn1ResultAsync<T, E>, H: Handler<F::Ok, E>,

type Output = <H as Handler<<F as Fn1ResultAsync<T, E>>::Ok, E>>::Output

fn handle<'a>( &'a self, request: T, ) -> impl Future<Output = Result<Self::Output, E>> + Send + Captures<(&'a Self, T)>

fn after<C>(self, current: C) -> Seq<C, Self>

where C: SeqHandler<T, E, Self>, Self: Sized,

Run this handler after specified, specified handler must implement SeqHandler to create something meaningful

fn or<R, EE>(self, rhs: R) -> Or<Self, R>

where Self: Sized + Handler<T, Recoverable<T, EE>>, R: Handler<T, EE>,

Logical or for handlers, refer to Or for documentation

fn serve<X, OTx, SRx>( self, rx: X, options: ServeOptions<OTx, SRx>, ) -> impl Future<Output = Result<(), E>> + Send

where T: Send + 'static, E: Send + 'static, Self::Output: Send, Self: Sized + Clone + 'static, X: RxChan<T, E, Self::Output>, X::Responder: Send + 'static, OTx: OutputTx<Self::Output, E> + 'static, SRx: ShutdownRx<E>,

Launches Server, same as calling Handler::into_server and Server::serve method on it

fn into_server<X>(self, rx: X) -> Server<Self, X>

where Self: Sized, X: RxChan<T, E, Self::Output>,

Creates server from that handler, for more, see docs for Server handler

fn provide<Env, F>(self, env: Env, f: F) -> Provide<Env, F, Self>

where Self: Sized,

Special case of Handler::map_async, refer to Provide documentation for more.

fn map_async<K, F>(self, f: F) -> MapAsync<F, Self>

where Self: Sized, F: Fn1ResultAsync<K, E, Ok = T>,

Same as Handler::map, but provided function is async

fn map<K, F>(self, f: F) -> Map<F, Self>

where Self: Sized, F: Fn1Result<K, E, SOut = T>,

Changes input of the handler into another type, to do that - it accepts function that maps that type to input type of the current handler

fn pipe<Dst>(self, dst: Dst) -> Pipe<Self, Dst>

where Self: Sized, Dst: Handler<Self::Output, E>,

Pipes output from one handler to Dst, refer to docs of Pipe for more.

fn share(self) -> Arc<Self>

where Self: Sized,

Wraps handler in Arc

fn erase(self) -> ErasedHandler<T, Self::Output, E>

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

Erase type of handler, this requires T to be Send + ’static, I am not sure if this is absolute requirement or it ('static) can be lifted, PRs are welcome

impl<F: PartialEq, H: PartialEq> PartialEq for MapAsync<F, H>

fn eq(&self, other: &MapAsync<F, H>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<F, H> StructuralPartialEq for MapAsync<F, H>