Struct actix_web::HttpContext

pub struct HttpContext<A> where
    A: Actor<Context = HttpContext<A>> + Route,  { /* fields omitted */ }

Actor execution context

Methods

impl<A> HttpContext<A> where
    A: Actor<Context = Self> + Route, 

fn new(state: Rc<<A as Route>::State>) -> HttpContext<A>

impl<A> HttpContext<A> where
    A: Actor<Context = Self> + Route, 

fn state(&self) -> &<A as Route>::State

Shared application state

fn start<R: Into<HttpResponse>>(&mut self, response: R)

Start response processing

fn write<B: Into<Bytes>>(&mut self, data: B)

Write payload

fn write_eof(&mut self)

Indicate end of streamimng payload

Trait Implementations

impl<A> ActorContext<A> for HttpContext<A> where
    A: Actor<Context = Self> + Route, 

fn stop(&mut self)

Stop actor execution

fn terminate(&mut self)

Terminate actor execution

fn state(&self) -> ActorState

Actor execution state

fn alive(&self) -> bool

Check if execution context is alive

fn address<Address>(&mut self) -> Address where
    A: ActorAddress<A, Address>, 

Get actor address

impl<A> AsyncContext<A> for HttpContext<A> where
    A: Actor<Context = Self> + Route, 

fn spawn<F>(&mut self, fut: F) -> SpawnHandle where
    F: ActorFuture<Item = (), Error = (), Actor = A> + 'static, 

Spawn async future into context. Returns handle of the item, could be used for cancelling execution.

fn wait<F>(&mut self, fut: F) where
    F: ActorFuture<Item = (), Error = (), Actor = A> + 'static, 

Spawn future into the context. Stop processing any of incoming events until this future resolves.

fn cancel_future(&mut self, handle: SpawnHandle) -> bool

Cancel future. idx is a value returned by spawn method.

fn add_future<F>(&mut self, fut: F) where
    A: Handler<<F as Future>::Item, <F as Future>::Error>,
    F: Future + 'static,
    <F as Future>::Item: ResponseType, 

This method allow to handle Future in similar way as normal actor messages.

fn add_stream<S>(&mut self, fut: S) where
    A: Handler<<S as Stream>::Item, <S as Stream>::Error> + StreamHandler<<S as Stream>::Item, <S as Stream>::Error>,
    S: Stream + 'static,
    <S as Stream>::Item: ResponseType, 

This method is similar to add_future but works with streams.

fn notify<M, E>(&mut self, msg: M, after: Duration) -> SpawnHandle where
    A: Handler<M, E>,
    E: 'static,
    M: ResponseType + 'static, 

Send message msg to self after specified period of time. Returns spawn handle which could be used for cancelation.

fn run_later<F>(&mut self, dur: Duration, f: F) -> SpawnHandle where
    F: FnOnce(&mut A, &mut <A as Actor>::Context) -> () + 'static, 

Execute closure after specified period of time within same Actor and Context

impl<A, M> ToEnvelope<A, M> for HttpContext<A> where
    A: Actor<Context = HttpContext<A>> + Route + Handler<M>,
    M: ResponseType + Send + 'static,
    M::Item: Send,
    M::Error: Send, 

fn pack(msg: M, tx: Option<Sender<Result<M::Item, M::Error>>>) -> Envelope<A>

Pack message into envelope