Trait Handler 

pub trait Handler<Op, Exts>
where
    Op: OperationShape,
{
    type Future: Future<Output = Result<Op::Output, Op::Error>>;

    // Required method
    fn call(&mut self, input: Op::Input, exts: Exts) -> Self::Future;
}

A utility trait used to provide an even interface for all operation handlers.

See operation documentation for more info.

Required Associated Types

type Future: Future<Output = Result<Op::Output, Op::Error>>

Required Methods

fn call(&mut self, input: Op::Input, exts: Exts) -> Self::Future

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors

impl<Op, F, Fut, Exts0, Exts1, Exts2, Exts3, Exts4, Exts5, Exts6, Exts7, Exts8> Handler<Op, (Exts0, Exts1, Exts2, Exts3, Exts4, Exts5, Exts6, Exts7, Exts8)> for F

where Op: OperationShape, F: Fn(Op::Input, Exts0, Exts1, Exts2, Exts3, Exts4, Exts5, Exts6, Exts7, Exts8) -> Fut, Fut: Future, Fut::Output: IntoResult<Op::Output, Op::Error>,

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Result<<Op as OperationShape>::Output, <Op as OperationShape>::Error>>

impl<Op, F, Fut, Exts0, Exts1, Exts2, Exts3, Exts4, Exts5, Exts6, Exts7> Handler<Op, (Exts0, Exts1, Exts2, Exts3, Exts4, Exts5, Exts6, Exts7)> for F

where Op: OperationShape, F: Fn(Op::Input, Exts0, Exts1, Exts2, Exts3, Exts4, Exts5, Exts6, Exts7) -> Fut, Fut: Future, Fut::Output: IntoResult<Op::Output, Op::Error>,

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Result<<Op as OperationShape>::Output, <Op as OperationShape>::Error>>

impl<Op, F, Fut, Exts0, Exts1, Exts2, Exts3, Exts4, Exts5, Exts6> Handler<Op, (Exts0, Exts1, Exts2, Exts3, Exts4, Exts5, Exts6)> for F

where Op: OperationShape, F: Fn(Op::Input, Exts0, Exts1, Exts2, Exts3, Exts4, Exts5, Exts6) -> Fut, Fut: Future, Fut::Output: IntoResult<Op::Output, Op::Error>,

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Result<<Op as OperationShape>::Output, <Op as OperationShape>::Error>>

impl<Op, F, Fut, Exts0, Exts1, Exts2, Exts3, Exts4, Exts5> Handler<Op, (Exts0, Exts1, Exts2, Exts3, Exts4, Exts5)> for F

where Op: OperationShape, F: Fn(Op::Input, Exts0, Exts1, Exts2, Exts3, Exts4, Exts5) -> Fut, Fut: Future, Fut::Output: IntoResult<Op::Output, Op::Error>,

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Result<<Op as OperationShape>::Output, <Op as OperationShape>::Error>>

impl<Op, F, Fut, Exts0, Exts1, Exts2, Exts3, Exts4> Handler<Op, (Exts0, Exts1, Exts2, Exts3, Exts4)> for F

where Op: OperationShape, F: Fn(Op::Input, Exts0, Exts1, Exts2, Exts3, Exts4) -> Fut, Fut: Future, Fut::Output: IntoResult<Op::Output, Op::Error>,

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Result<<Op as OperationShape>::Output, <Op as OperationShape>::Error>>

impl<Op, F, Fut, Exts0, Exts1, Exts2, Exts3> Handler<Op, (Exts0, Exts1, Exts2, Exts3)> for F

where Op: OperationShape, F: Fn(Op::Input, Exts0, Exts1, Exts2, Exts3) -> Fut, Fut: Future, Fut::Output: IntoResult<Op::Output, Op::Error>,

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Result<<Op as OperationShape>::Output, <Op as OperationShape>::Error>>

impl<Op, F, Fut, Exts0, Exts1, Exts2> Handler<Op, (Exts0, Exts1, Exts2)> for F

where Op: OperationShape, F: Fn(Op::Input, Exts0, Exts1, Exts2) -> Fut, Fut: Future, Fut::Output: IntoResult<Op::Output, Op::Error>,

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Result<<Op as OperationShape>::Output, <Op as OperationShape>::Error>>

impl<Op, F, Fut, Exts0, Exts1> Handler<Op, (Exts0, Exts1)> for F

where Op: OperationShape, F: Fn(Op::Input, Exts0, Exts1) -> Fut, Fut: Future, Fut::Output: IntoResult<Op::Output, Op::Error>,

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Result<<Op as OperationShape>::Output, <Op as OperationShape>::Error>>

impl<Op, F, Fut, Exts0> Handler<Op, (Exts0,)> for F

where Op: OperationShape, F: Fn(Op::Input, Exts0) -> Fut, Fut: Future, Fut::Output: IntoResult<Op::Output, Op::Error>,

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Result<<Op as OperationShape>::Output, <Op as OperationShape>::Error>>

impl<Op, F, Fut> Handler<Op, ()> for F

where Op: OperationShape, F: Fn(Op::Input) -> Fut, Fut: Future, Fut::Output: IntoResult<Op::Output, Op::Error>,

type Future = Map<Fut, fn(<Fut as Future>::Output) -> Result<<Op as OperationShape>::Output, <Op as OperationShape>::Error>>