Trait actix::dev::MessageResponse

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

A trait which defines message responses.

We offer implementation for some common language types, if you need to respond with a new type you can use MessageResult.

If Actor::Context implements AsyncContext it's possible to handle the message asynchronously. For asynchronous message handling we offer the following possible response types:

• ResponseFuture should be used for when the future returned doesn't need to access Actor's internal state or context to progress, either because it's completely agnostic to it or because the required data has already been moved to it and it won't need Actor state to continue.
• ResponseActFuture should be used when the future returned will, at some point, need to access Actor's internal state or context in order to finish.
• AtomicResponse should be used when the future returned needs exclusive access to Actor's internal state or context.

Required methods

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

Loading content...

Implementations on Foreign Types

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Loading content...

Implementors

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

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

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

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

impl<A, M, I: 'static> MessageResponse<A, M> for ResponseFuture<I> where
    A: Actor,
    M::Result: Send,
    M: Message<Result = I>,
    A::Context: AsyncContext<A>, 

MessageResponse trait impl to enbale the use of any I: 'static with asynchronous message handling

Examples

Usage with Result<I,E>:

pub struct MyQuestion{}
impl Message for MyQuestion {
    type Result = Result<u8,u8>;
}
impl Handler<MyQuestion> for MyActorAsync {
    type Result = ResponseFuture<Result<u8,u8>>;
    fn handle(&mut self, question: MyQuestion, _ctx: &mut Context<Self>) -> Self::Result {
        Box::pin(async {Ok(5)})
    }
}

Usage with Option<I>:

pub struct MyQuestion{}
impl Message for MyQuestion {
    type Result = Option<u8>;
}
impl Handler<MyQuestion> for MyActorAsync {
    type Result = ResponseFuture<Option<u8>>;
    fn handle(&mut self, question: MyQuestion, _ctx: &mut Context<Self>) -> Self::Result {
        Box::pin(async {Some(5)})
    }
}

Usage with any I: 'static:

pub struct MyQuestion{}
impl Message for MyQuestion {
    type Result = u8;
}
impl Handler<MyQuestion> for MyActorAsync {
    type Result = ResponseFuture<u8>;
    fn handle(&mut self, question: MyQuestion, _ctx: &mut Context<Self>) -> Self::Result {
        Box::pin(async {5})
    }
}

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

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

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

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

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

impl<A, M, T: 'static> MessageResponse<A, M> for AtomicResponse<A, T> where
    A: Actor,
    M: Message<Result = T>,
    A::Context: AsyncContext<A>, 

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

impl<A, M, T: 'static> MessageResponse<A, M> for ResponseActFuture<A, T> where
    A: Actor,
    M: Message<Result = T>,
    A::Context: AsyncContext<A>, 

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

Loading content...