Trait actix_web::actix::dev::MessageResponse

pub trait MessageResponse<A, M> where
    A: Actor,
    M: Message, {
    fn handle<R>(self, ctx: &mut <A as Actor>::Context, tx: Option<R>)
    where
        R: ResponseChannel<M>;
}

Trait which defines message response

Required methods

fn handle<R>(self, ctx: &mut <A as Actor>::Context, tx: Option<R>) where
    R: ResponseChannel<M>, 

Loading content...

Implementations on Foreign Types

impl<A, M> MessageResponse<A, M> for f32 where
    A: Actor,
    M: Message<Result = f32>, 

fn handle<R>(self, &mut <A as Actor>::Context, tx: Option<R>) where
    R: ResponseChannel<M>, 

impl<A, M> MessageResponse<A, M> for u16 where
    A: Actor,
    M: Message<Result = u16>, 

fn handle<R>(self, &mut <A as Actor>::Context, tx: Option<R>) where
    R: ResponseChannel<M>, 

impl<A, M> MessageResponse<A, M> for u32 where
    A: Actor,
    M: Message<Result = u32>, 

fn handle<R>(self, &mut <A as Actor>::Context, tx: Option<R>) where
    R: ResponseChannel<M>, 

impl<A, M> MessageResponse<A, M> for String where
    A: Actor,
    M: Message<Result = String>, 

fn handle<R>(self, &mut <A as Actor>::Context, tx: Option<R>) where
    R: ResponseChannel<M>, 

impl<A, M> MessageResponse<A, M> for i8 where
    A: Actor,
    M: Message<Result = i8>, 

fn handle<R>(self, &mut <A as Actor>::Context, tx: Option<R>) where
    R: ResponseChannel<M>, 

impl<A, M> MessageResponse<A, M> for u64 where
    A: Actor,
    M: Message<Result = u64>, 

fn handle<R>(self, &mut <A as Actor>::Context, tx: Option<R>) where
    R: ResponseChannel<M>, 

impl<A, M, I, E> MessageResponse<A, M> for Box<dyn Future<Item = I, Error = E> + 'static> where
    A: Actor,
    E: 'static,
    I: 'static,
    M: Message<Result = Result<I, E>>,
    <M as Message>::Result: Send,
    <A as Actor>::Context: AsyncContext<A>, 

fn handle<R>(self, &mut <A as Actor>::Context, tx: Option<R>) where
    R: ResponseChannel<M>, 

impl<A, M> MessageResponse<A, M> for bool where
    A: Actor,
    M: Message<Result = bool>, 

fn handle<R>(self, &mut <A as Actor>::Context, tx: Option<R>) where
    R: ResponseChannel<M>, 

impl<A, M> MessageResponse<A, M> for i64 where
    A: Actor,
    M: Message<Result = i64>, 

fn handle<R>(self, &mut <A as Actor>::Context, tx: Option<R>) where
    R: ResponseChannel<M>, 

impl<A, M> MessageResponse<A, M> for i32 where
    A: Actor,
    M: Message<Result = i32>, 

fn handle<R>(self, &mut <A as Actor>::Context, tx: Option<R>) where
    R: ResponseChannel<M>, 

impl<A, M> MessageResponse<A, M> for u8 where
    A: Actor,
    M: Message<Result = u8>, 

fn handle<R>(self, &mut <A as Actor>::Context, tx: Option<R>) where
    R: ResponseChannel<M>, 

impl<A, M, I> MessageResponse<A, M> for Option<I> where
    A: Actor,
    I: 'static,
    M: Message<Result = Option<I>>, 

fn handle<R>(self, &mut <A as Actor>::Context, tx: Option<R>) where
    R: ResponseChannel<M>, 

impl<A, M> MessageResponse<A, M> for () where
    A: Actor,
    M: Message<Result = ()>, 

fn handle<R>(self, &mut <A as Actor>::Context, tx: Option<R>) where
    R: ResponseChannel<M>, 

impl<A, M> MessageResponse<A, M> for f64 where
    A: Actor,
    M: Message<Result = f64>, 

fn handle<R>(self, &mut <A as Actor>::Context, tx: Option<R>) where
    R: ResponseChannel<M>, 

impl<A, M, I, E> MessageResponse<A, M> for Box<dyn ActorFuture<Error = E, Item = I, Actor = A> + 'static> where
    A: Actor,
    E: 'static,
    I: 'static,
    M: Message<Result = Result<I, E>>,
    <A as Actor>::Context: AsyncContext<A>, 

fn handle<R>(self, ctx: &mut <A as Actor>::Context, tx: Option<R>) where
    R: ResponseChannel<M>, 

impl<A, M> MessageResponse<A, M> for i16 where
    A: Actor,
    M: Message<Result = i16>, 

fn handle<R>(self, &mut <A as Actor>::Context, tx: Option<R>) where
    R: ResponseChannel<M>, 

impl<A, M> MessageResponse<A, M> for usize where
    A: Actor,
    M: Message<Result = usize>, 

fn handle<R>(self, &mut <A as Actor>::Context, tx: Option<R>) where
    R: ResponseChannel<M>, 

impl<A, M, I, E> MessageResponse<A, M> for Result<I, E> where
    A: Actor,
    E: 'static,
    I: 'static,
    M: Message<Result = Result<I, E>>, 

fn handle<R>(self, &mut <A as Actor>::Context, tx: Option<R>) where
    R: ResponseChannel<M>, 

impl<A, M> MessageResponse<A, M> for isize where
    A: Actor,
    M: Message<Result = isize>, 

fn handle<R>(self, &mut <A as Actor>::Context, tx: Option<R>) where
    R: ResponseChannel<M>, 

Loading content...

Implementors

impl<A, M> MessageResponse<A, M> for MessageResult<M> where
    A: Actor,
    M: Message, 

fn handle<R>(self, &mut <A as Actor>::Context, tx: Option<R>) where
    R: ResponseChannel<M>, 

impl<A, M, B> MessageResponse<A, M> for Addr<B> where
    A: Actor,
    B: Actor<Context = Context<B>>,
    M: Message<Result = Addr<B>>, 

fn handle<R>(self, &mut <A as Actor>::Context, tx: Option<R>) where
    R: ResponseChannel<M>, 

impl<A, M, I, E> MessageResponse<A, M> for ActorResponse<A, I, E> where
    A: Actor,
    E: 'static,
    I: 'static,
    M: Message<Result = Result<I, E>>,
    <A as Actor>::Context: AsyncContext<A>, 

fn handle<R>(self, ctx: &mut <A as Actor>::Context, tx: Option<R>) where
    R: ResponseChannel<M>, 

impl<A, M, I, E> MessageResponse<A, M> for Response<I, E> where
    A: Actor,
    E: 'static,
    I: 'static,
    M: Message<Result = Result<I, E>>,
    <A as Actor>::Context: AsyncContext<A>, 

fn handle<R>(self, &mut <A as Actor>::Context, tx: Option<R>) where
    R: ResponseChannel<M>, 

Loading content...