Trait Handler 

pub trait Handler<I, O, Args>:
    Send
    + Sync
    + 'static {
    // Required method
    fn call(&self, ctx: Context<I>) -> impl Future<Output = O> + Send;
}

A trait for functions that can be used as pipeline steps.

Required Methods

fn call(&self, ctx: Context<I>) -> impl Future<Output = O> + Send

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<F, I, O, Fut, I1> Handler<I, O, (I1,)> for F

where I: Clone + Send + Sync + 'static, O: Send + 'static, F: Fn(I1) -> Fut + Send + Sync + 'static, Fut: Future<Output = O> + Send, I1: FromContext<I>,

impl<F, I, O, Fut, I1, I2> Handler<I, O, (I1, I2)> for F

where I: Clone + Send + Sync + 'static, O: Send + 'static, F: Fn(I1, I2) -> Fut + Send + Sync + 'static, Fut: Future<Output = O> + Send, I1: FromContext<I>, I2: FromContext<I>,

impl<F, I, O, Fut, I1, I2, I3> Handler<I, O, (I1, I2, I3)> for F

where I: Clone + Send + Sync + 'static, O: Send + 'static, F: Fn(I1, I2, I3) -> Fut + Send + Sync + 'static, Fut: Future<Output = O> + Send, I1: FromContext<I>, I2: FromContext<I>, I3: FromContext<I>,

impl<F, I, O, Fut, I1, I2, I3, I4> Handler<I, O, (I1, I2, I3, I4)> for F

where I: Clone + Send + Sync + 'static, O: Send + 'static, F: Fn(I1, I2, I3, I4) -> Fut + Send + Sync + 'static, Fut: Future<Output = O> + Send, I1: FromContext<I>, I2: FromContext<I>, I3: FromContext<I>, I4: FromContext<I>,

impl<F, I, O, Fut, I1, I2, I3, I4, I5> Handler<I, O, (I1, I2, I3, I4, I5)> for F

where I: Clone + Send + Sync + 'static, O: Send + 'static, F: Fn(I1, I2, I3, I4, I5) -> Fut + Send + Sync + 'static, Fut: Future<Output = O> + Send, I1: FromContext<I>, I2: FromContext<I>, I3: FromContext<I>, I4: FromContext<I>, I5: FromContext<I>,

impl<F, I, O, Fut, I1, I2, I3, I4, I5, I6> Handler<I, O, (I1, I2, I3, I4, I5, I6)> for F

where I: Clone + Send + Sync + 'static, O: Send + 'static, F: Fn(I1, I2, I3, I4, I5, I6) -> Fut + Send + Sync + 'static, Fut: Future<Output = O> + Send, I1: FromContext<I>, I2: FromContext<I>, I3: FromContext<I>, I4: FromContext<I>, I5: FromContext<I>, I6: FromContext<I>,

impl<F, I, O, Fut, I1, I2, I3, I4, I5, I6, I7> Handler<I, O, (I1, I2, I3, I4, I5, I6, I7)> for F

where I: Clone + Send + Sync + 'static, O: Send + 'static, F: Fn(I1, I2, I3, I4, I5, I6, I7) -> Fut + Send + Sync + 'static, Fut: Future<Output = O> + Send, I1: FromContext<I>, I2: FromContext<I>, I3: FromContext<I>, I4: FromContext<I>, I5: FromContext<I>, I6: FromContext<I>, I7: FromContext<I>,

impl<F, I, O, Fut, I1, I2, I3, I4, I5, I6, I7, I8> Handler<I, O, (I1, I2, I3, I4, I5, I6, I7, I8)> for F

where I: Clone + Send + Sync + 'static, O: Send + 'static, F: Fn(I1, I2, I3, I4, I5, I6, I7, I8) -> Fut + Send + Sync + 'static, Fut: Future<Output = O> + Send, I1: FromContext<I>, I2: FromContext<I>, I3: FromContext<I>, I4: FromContext<I>, I5: FromContext<I>, I6: FromContext<I>, I7: FromContext<I>, I8: FromContext<I>,

impl<F, I, O, Fut, I1, I2, I3, I4, I5, I6, I7, I8, I9> Handler<I, O, (I1, I2, I3, I4, I5, I6, I7, I8, I9)> for F

where I: Clone + Send + Sync + 'static, O: Send + 'static, F: Fn(I1, I2, I3, I4, I5, I6, I7, I8, I9) -> Fut + Send + Sync + 'static, Fut: Future<Output = O> + Send, I1: FromContext<I>, I2: FromContext<I>, I3: FromContext<I>, I4: FromContext<I>, I5: FromContext<I>, I6: FromContext<I>, I7: FromContext<I>, I8: FromContext<I>, I9: FromContext<I>,

impl<F, I, O, Fut, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10> Handler<I, O, (I1, I2, I3, I4, I5, I6, I7, I8, I9, I10)> for F

where I: Clone + Send + Sync + 'static, O: Send + 'static, F: Fn(I1, I2, I3, I4, I5, I6, I7, I8, I9, I10) -> Fut + Send + Sync + 'static, Fut: Future<Output = O> + Send, I1: FromContext<I>, I2: FromContext<I>, I3: FromContext<I>, I4: FromContext<I>, I5: FromContext<I>, I6: FromContext<I>, I7: FromContext<I>, I8: FromContext<I>, I9: FromContext<I>, I10: FromContext<I>,

impl<F, I, O, Fut, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11> Handler<I, O, (I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11)> for F

where I: Clone + Send + Sync + 'static, O: Send + 'static, F: Fn(I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11) -> Fut + Send + Sync + 'static, Fut: Future<Output = O> + Send, I1: FromContext<I>, I2: FromContext<I>, I3: FromContext<I>, I4: FromContext<I>, I5: FromContext<I>, I6: FromContext<I>, I7: FromContext<I>, I8: FromContext<I>, I9: FromContext<I>, I10: FromContext<I>, I11: FromContext<I>,

impl<F, I, O, Fut, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12> Handler<I, O, (I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12)> for F

where I: Clone + Send + Sync + 'static, O: Send + 'static, F: Fn(I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12) -> Fut + Send + Sync + 'static, Fut: Future<Output = O> + Send, I1: FromContext<I>, I2: FromContext<I>, I3: FromContext<I>, I4: FromContext<I>, I5: FromContext<I>, I6: FromContext<I>, I7: FromContext<I>, I8: FromContext<I>, I9: FromContext<I>, I10: FromContext<I>, I11: FromContext<I>, I12: FromContext<I>,

impl<F, I, O, Fut, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13> Handler<I, O, (I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13)> for F

where I: Clone + Send + Sync + 'static, O: Send + 'static, F: Fn(I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13) -> Fut + Send + Sync + 'static, Fut: Future<Output = O> + Send, I1: FromContext<I>, I2: FromContext<I>, I3: FromContext<I>, I4: FromContext<I>, I5: FromContext<I>, I6: FromContext<I>, I7: FromContext<I>, I8: FromContext<I>, I9: FromContext<I>, I10: FromContext<I>, I11: FromContext<I>, I12: FromContext<I>, I13: FromContext<I>,

impl<F, I, O, Fut, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14> Handler<I, O, (I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14)> for F

where I: Clone + Send + Sync + 'static, O: Send + 'static, F: Fn(I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14) -> Fut + Send + Sync + 'static, Fut: Future<Output = O> + Send, I1: FromContext<I>, I2: FromContext<I>, I3: FromContext<I>, I4: FromContext<I>, I5: FromContext<I>, I6: FromContext<I>, I7: FromContext<I>, I8: FromContext<I>, I9: FromContext<I>, I10: FromContext<I>, I11: FromContext<I>, I12: FromContext<I>, I13: FromContext<I>, I14: FromContext<I>,

impl<F, I, O, Fut, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15> Handler<I, O, (I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15)> for F

where I: Clone + Send + Sync + 'static, O: Send + 'static, F: Fn(I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15) -> Fut + Send + Sync + 'static, Fut: Future<Output = O> + Send, I1: FromContext<I>, I2: FromContext<I>, I3: FromContext<I>, I4: FromContext<I>, I5: FromContext<I>, I6: FromContext<I>, I7: FromContext<I>, I8: FromContext<I>, I9: FromContext<I>, I10: FromContext<I>, I11: FromContext<I>, I12: FromContext<I>, I13: FromContext<I>, I14: FromContext<I>, I15: FromContext<I>,

impl<F, I, O, Fut, I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16> Handler<I, O, (I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16)> for F

where I: Clone + Send + Sync + 'static, O: Send + 'static, F: Fn(I1, I2, I3, I4, I5, I6, I7, I8, I9, I10, I11, I12, I13, I14, I15, I16) -> Fut + Send + Sync + 'static, Fut: Future<Output = O> + Send, I1: FromContext<I>, I2: FromContext<I>, I3: FromContext<I>, I4: FromContext<I>, I5: FromContext<I>, I6: FromContext<I>, I7: FromContext<I>, I8: FromContext<I>, I9: FromContext<I>, I10: FromContext<I>, I11: FromContext<I>, I12: FromContext<I>, I13: FromContext<I>, I14: FromContext<I>, I15: FromContext<I>, I16: FromContext<I>,

impl<I, H1, O1, A1> Handler<I, (O1,), (A1,)> for Sink<(H1,)>

where I: Clone + Send + Sync + 'static, O1: Send + 'static, H1: Handler<I, O1, A1>, A1: Send + Sync + 'static,

impl<I, H1, O1, A1, H2, O2, A2> Handler<I, (O1, O2), (A1, A2)> for Sink<(H1, H2)>

where I: Clone + Send + Sync + 'static, O1: Send + 'static, H1: Handler<I, O1, A1>, A1: Send + Sync + 'static, O2: Send + 'static, H2: Handler<I, O2, A2>, A2: Send + Sync + 'static,

impl<I, H1, O1, A1, H2, O2, A2, H3, O3, A3> Handler<I, (O1, O2, O3), (A1, A2, A3)> for Sink<(H1, H2, H3)>

where I: Clone + Send + Sync + 'static, O1: Send + 'static, H1: Handler<I, O1, A1>, A1: Send + Sync + 'static, O2: Send + 'static, H2: Handler<I, O2, A2>, A2: Send + Sync + 'static, O3: Send + 'static, H3: Handler<I, O3, A3>, A3: Send + Sync + 'static,

impl<I, H1, O1, A1, H2, O2, A2, H3, O3, A3, H4, O4, A4> Handler<I, (O1, O2, O3, O4), (A1, A2, A3, A4)> for Sink<(H1, H2, H3, H4)>

where I: Clone + Send + Sync + 'static, O1: Send + 'static, H1: Handler<I, O1, A1>, A1: Send + Sync + 'static, O2: Send + 'static, H2: Handler<I, O2, A2>, A2: Send + Sync + 'static, O3: Send + 'static, H3: Handler<I, O3, A3>, A3: Send + Sync + 'static, O4: Send + 'static, H4: Handler<I, O4, A4>, A4: Send + Sync + 'static,

impl<I, H1, O1, A1, H2, O2, A2, H3, O3, A3, H4, O4, A4, H5, O5, A5> Handler<I, (O1, O2, O3, O4, O5), (A1, A2, A3, A4, A5)> for Sink<(H1, H2, H3, H4, H5)>

where I: Clone + Send + Sync + 'static, O1: Send + 'static, H1: Handler<I, O1, A1>, A1: Send + Sync + 'static, O2: Send + 'static, H2: Handler<I, O2, A2>, A2: Send + Sync + 'static, O3: Send + 'static, H3: Handler<I, O3, A3>, A3: Send + Sync + 'static, O4: Send + 'static, H4: Handler<I, O4, A4>, A4: Send + Sync + 'static, O5: Send + 'static, H5: Handler<I, O5, A5>, A5: Send + Sync + 'static,

impl<I, H1, O1, A1, H2, O2, A2, H3, O3, A3, H4, O4, A4, H5, O5, A5, H6, O6, A6> Handler<I, (O1, O2, O3, O4, O5, O6), (A1, A2, A3, A4, A5, A6)> for Sink<(H1, H2, H3, H4, H5, H6)>

where I: Clone + Send + Sync + 'static, O1: Send + 'static, H1: Handler<I, O1, A1>, A1: Send + Sync + 'static, O2: Send + 'static, H2: Handler<I, O2, A2>, A2: Send + Sync + 'static, O3: Send + 'static, H3: Handler<I, O3, A3>, A3: Send + Sync + 'static, O4: Send + 'static, H4: Handler<I, O4, A4>, A4: Send + Sync + 'static, O5: Send + 'static, H5: Handler<I, O5, A5>, A5: Send + Sync + 'static, O6: Send + 'static, H6: Handler<I, O6, A6>, A6: Send + Sync + 'static,

impl<I, H1, O1, A1, H2, O2, A2, H3, O3, A3, H4, O4, A4, H5, O5, A5, H6, O6, A6, H7, O7, A7> Handler<I, (O1, O2, O3, O4, O5, O6, O7), (A1, A2, A3, A4, A5, A6, A7)> for Sink<(H1, H2, H3, H4, H5, H6, H7)>

where I: Clone + Send + Sync + 'static, O1: Send + 'static, H1: Handler<I, O1, A1>, A1: Send + Sync + 'static, O2: Send + 'static, H2: Handler<I, O2, A2>, A2: Send + Sync + 'static, O3: Send + 'static, H3: Handler<I, O3, A3>, A3: Send + Sync + 'static, O4: Send + 'static, H4: Handler<I, O4, A4>, A4: Send + Sync + 'static, O5: Send + 'static, H5: Handler<I, O5, A5>, A5: Send + Sync + 'static, O6: Send + 'static, H6: Handler<I, O6, A6>, A6: Send + Sync + 'static, O7: Send + 'static, H7: Handler<I, O7, A7>, A7: Send + Sync + 'static,

impl<I, H1, O1, A1, H2, O2, A2, H3, O3, A3, H4, O4, A4, H5, O5, A5, H6, O6, A6, H7, O7, A7, H8, O8, A8> Handler<I, (O1, O2, O3, O4, O5, O6, O7, O8), (A1, A2, A3, A4, A5, A6, A7, A8)> for Sink<(H1, H2, H3, H4, H5, H6, H7, H8)>

where I: Clone + Send + Sync + 'static, O1: Send + 'static, H1: Handler<I, O1, A1>, A1: Send + Sync + 'static, O2: Send + 'static, H2: Handler<I, O2, A2>, A2: Send + Sync + 'static, O3: Send + 'static, H3: Handler<I, O3, A3>, A3: Send + Sync + 'static, O4: Send + 'static, H4: Handler<I, O4, A4>, A4: Send + Sync + 'static, O5: Send + 'static, H5: Handler<I, O5, A5>, A5: Send + Sync + 'static, O6: Send + 'static, H6: Handler<I, O6, A6>, A6: Send + Sync + 'static, O7: Send + 'static, H7: Handler<I, O7, A7>, A7: Send + Sync + 'static, O8: Send + 'static, H8: Handler<I, O8, A8>, A8: Send + Sync + 'static,

impl<I, H1, O1, A1, H2, O2, A2, H3, O3, A3, H4, O4, A4, H5, O5, A5, H6, O6, A6, H7, O7, A7, H8, O8, A8, H9, O9, A9> Handler<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9), (A1, A2, A3, A4, A5, A6, A7, A8, A9)> for Sink<(H1, H2, H3, H4, H5, H6, H7, H8, H9)>

where I: Clone + Send + Sync + 'static, O1: Send + 'static, H1: Handler<I, O1, A1>, A1: Send + Sync + 'static, O2: Send + 'static, H2: Handler<I, O2, A2>, A2: Send + Sync + 'static, O3: Send + 'static, H3: Handler<I, O3, A3>, A3: Send + Sync + 'static, O4: Send + 'static, H4: Handler<I, O4, A4>, A4: Send + Sync + 'static, O5: Send + 'static, H5: Handler<I, O5, A5>, A5: Send + Sync + 'static, O6: Send + 'static, H6: Handler<I, O6, A6>, A6: Send + Sync + 'static, O7: Send + 'static, H7: Handler<I, O7, A7>, A7: Send + Sync + 'static, O8: Send + 'static, H8: Handler<I, O8, A8>, A8: Send + Sync + 'static, O9: Send + 'static, H9: Handler<I, O9, A9>, A9: Send + Sync + 'static,

impl<I, H1, O1, A1, H2, O2, A2, H3, O3, A3, H4, O4, A4, H5, O5, A5, H6, O6, A6, H7, O7, A7, H8, O8, A8, H9, O9, A9, H10, O10, A10> Handler<I, (O1, O2, O3, O4, O5, O6, O7, O8, O9, O10), (A1, A2, A3, A4, A5, A6, A7, A8, A9, A10)> for Sink<(H1, H2, H3, H4, H5, H6, H7, H8, H9, H10)>

where I: Clone + Send + Sync + 'static, O1: Send + 'static, H1: Handler<I, O1, A1>, A1: Send + Sync + 'static, O2: Send + 'static, H2: Handler<I, O2, A2>, A2: Send + Sync + 'static, O3: Send + 'static, H3: Handler<I, O3, A3>, A3: Send + Sync + 'static, O4: Send + 'static, H4: Handler<I, O4, A4>, A4: Send + Sync + 'static, O5: Send + 'static, H5: Handler<I, O5, A5>, A5: Send + Sync + 'static, O6: Send + 'static, H6: Handler<I, O6, A6>, A6: Send + Sync + 'static, O7: Send + 'static, H7: Handler<I, O7, A7>, A7: Send + Sync + 'static, O8: Send + 'static, H8: Handler<I, O8, A8>, A8: Send + Sync + 'static, O9: Send + 'static, H9: Handler<I, O9, A9>, A9: Send + Sync + 'static, O10: Send + 'static, H10: Handler<I, O10, A10>, A10: Send + Sync + 'static,

impl<I, I2> Handler<I2, I, (Input<I2>,)> for LiftHandler<I, I2>

where I: From<I2> + Send + Sync + 'static, I2: Clone + Send + Sync + 'static,

impl<P, I, O> Handler<I, O, ()> for P

where P: Pipeline<I, O>, I: Clone + Send + Sync + 'static, O: Send + 'static,