Trait Service 

pub trait Service<In>: Send + Sync {
    type Out;

    // Required method
    fn handle(
        &self,
        input: In,
        cx: &Context,
    ) -> impl Stream<Item = Self::Out> + Send;

    // Provided methods
    fn handle_stream(
        &self,
        input: impl Stream<Item = In> + Send,
        cx: &Context,
    ) -> impl Stream<Item = Self::Out> + Send
       where In: Send,
             Self: Send,
             Self::Out: Send { ... }
    fn finalize(&mut self, _cx: &Context) -> impl Future<Output = ()>
       where Self: Sized { ... }
}

Required Associated Types

type Out

Required Methods

fn handle( &self, input: In, cx: &Context, ) -> impl Stream<Item = Self::Out> + Send

Provided Methods

fn handle_stream( &self, input: impl Stream<Item = In> + Send, cx: &Context, ) -> impl Stream<Item = Self::Out> + Send

where In: Send, Self: Send, Self::Out: Send,

fn finalize(&mut self, _cx: &Context) -> impl Future<Output = ()>

where Self: Sized,

Dyn Compatibility

This trait is not dyn compatible.

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

Implementations on Foreign Types

impl<I, O1, E, O2, EI, S1, S2> Service<I> for (S1, S2)

where I: Send, O1: Send, O2: Send, E: Send + From<EI>, EI: Send, S1: Service<I, Out = Result<O1, E>> + Send, S2: Service<O1, Out = Result<O2, EI>> + Send,

type Out = Result<O2, E>

fn handle(&self, msg: I, cx: &Context) -> impl Stream<Item = Self::Out> + Send

impl<I: Send, E, S: Service<I, Out = Result<I, E>>> Service<I> for Option<S>

type Out = Result<I, E>

fn handle(&self, input: I, cx: &Context) -> impl Stream<Item = Self::Out> + Send

Implementors

impl<I, M, E1, O, E, S, F> Service<I> for Scope<I, M, E1, S, F>

where S: Service<M, Out = Result<O, E>> + Send, F: Send + Fn(&I) -> Result<M, E1> + Sync, M: Send + Sync, O: Send, I: Send + Sync, E: Send + Sync + From<E1>, E1: Send + Sync,

type Out = Result<(I, Vec<O>), E>

impl<I, M, O, E, E1, S, F> Service<I> for ScopeEach<I, M, S, F, E1>

where S: Service<M, Out = Result<O, E>> + Send, F: Send + Sync + Fn(&I) -> Result<M, E1>, M: Send + Sync, O: Send, I: Send + Clone + Sync + 'static, E: Send + Sync + From<E1>, E1: Send + Sync,

type Out = Result<(I, O), E>

impl<I, O1, E, O2, S1, S2> Service<I> for Left<S1, S2>

where I: Send, O1: Send, O2: Send, E: Send, S1: Service<I, Out = Result<O1, E>> + Send, S2: Service<O1, Out = O2> + Send,

type Out = Result<O2, E>

impl<I, R, E, E2, F, S> Service<I> for Except<S, F>

where S: Service<I, Out = Result<R, E>>, F: Send + Sync + Fn(E) -> Option<E2>,

type Out = Result<R, E2>

impl<I, R, E, S> Service<I> for ConcurrentEach<I, S>

where I: Send + Sync, R: Send + 'static, E: Send + 'static, S: Service<I, Out = Result<R, E>> + Clone + Send + 'static,

type Out = Result<ConcurrentRx<<S as Service<I>>::Out>, E>

impl<M, R, E, S> Service<M> for SpawnEach<M, S>

where M: Send + Sync + 'static, R: Send + 'static, E: Send + 'static, S: Service<M, Out = Result<R, E>> + 'static,

type Out = Result<ReceiverStream<Result<R, E>>, E>