Struct actix_web::HttpContext
[−]
[src]
pub struct HttpContext<A, S = ()> where
A: Actor<Context = HttpContext<A, S>>, { /* fields omitted */ }
Http actor execution context
Methods
impl<A, S: 'static> HttpContext<A, S> where
A: Actor<Context = Self>,
[src]
A: Actor<Context = Self>,
pub fn new(req: HttpRequest<S>, actor: A) -> HttpContext<A, S>
[src]
pub fn from_request(req: HttpRequest<S>) -> HttpContext<A, S>
[src]
pub fn actor(self, actor: A) -> HttpContext<A, S>
[src]
impl<A, S> HttpContext<A, S> where
A: Actor<Context = Self>,
[src]
A: Actor<Context = Self>,
ⓘImportant traits for &'a mut Wpub fn state(&self) -> &S
[src]
Shared application state
ⓘImportant traits for HttpRequest<S>pub fn request(&mut self) -> &mut HttpRequest<S>
[src]
Incoming request
pub fn write<B: Into<Binary>>(&mut self, data: B)
[src]
Write payload
pub fn write_eof(&mut self)
[src]
Indicate end of streaming payload. Also this method calls Self::close
.
pub fn drain(&mut self) -> Drain<A>
[src]
Returns drain future
pub fn connected(&self) -> bool
[src]
Check if connection still open
pub fn handle(&self) -> SpawnHandle
[src]
Handle of the running future
SpawnHandle is the handle returned by AsyncContext::spawn()
method.
Trait Implementations
impl<A, S> ActorContext for HttpContext<A, S> where
A: Actor<Context = Self>,
[src]
A: Actor<Context = Self>,
fn stop(&mut self)
[src]
Immediately stop processing incoming messages and switch to a stopping
state
fn terminate(&mut self)
[src]
Terminate actor execution
fn state(&self) -> ActorState
[src]
Actor execution state
impl<A, S> AsyncContext<A> for HttpContext<A, S> where
A: Actor<Context = Self>,
[src]
A: Actor<Context = Self>,
fn spawn<F>(&mut self, fut: F) -> SpawnHandle where
F: ActorFuture<Item = (), Error = (), Actor = A> + 'static,
[src]
F: ActorFuture<Item = (), Error = (), Actor = A> + 'static,
Spawn async future into context. Returns handle of the item, could be used for cancelling execution. Read more
fn wait<F>(&mut self, fut: F) where
F: ActorFuture<Item = (), Error = (), Actor = A> + 'static,
[src]
F: ActorFuture<Item = (), Error = (), Actor = A> + 'static,
Spawn future into the context. Stop processing any of incoming events until this future resolves. Read more
fn cancel_future(&mut self, handle: SpawnHandle) -> bool
[src]
Cancel future. idx is a value returned by spawn
method.
fn address<Address>(&mut self) -> Address where
A: ActorAddress<A, Address>,
[src]
A: ActorAddress<A, Address>,
Get actor address
fn waiting(&self) -> bool
[src]
Check if context is paused (waiting for future completion or stopping)
fn add_stream<S>(&mut self, fut: S) -> SpawnHandle where
A: StreamHandler<<S as Stream>::Item, <S as Stream>::Error>,
S: Stream + 'static,
[src]
A: StreamHandler<<S as Stream>::Item, <S as Stream>::Error>,
S: Stream + 'static,
This method register stream to an actor context and allows to handle Stream
in similar way as normal actor messages. Read more
fn add_message_stream<S>(&mut self, fut: S) where
A: Handler<<S as Stream>::Item>,
S: Stream<Error = ()> + 'static,
<S as Stream>::Item: Message,
[src]
A: Handler<<S as Stream>::Item>,
S: Stream<Error = ()> + 'static,
<S as Stream>::Item: Message,
This method is similar to add_stream
but it skips stream errors. Read more
fn notify<M>(&mut self, msg: M) where
A: Handler<M>,
M: Message + 'static,
[src]
A: Handler<M>,
M: Message + 'static,
Send message msg
to self.
fn notify_later<M>(&mut self, msg: M, after: Duration) -> SpawnHandle where
A: Handler<M>,
M: Message + 'static,
[src]
A: Handler<M>,
M: Message + 'static,
Send message msg
to self after specified period of time. Returns spawn handle which could be used for cancellation. Notification get cancelled if context's stop method get called. Read more
fn run_later<F>(&mut self, dur: Duration, f: F) -> SpawnHandle where
F: FnOnce(&mut A, &mut <A as Actor>::Context) + 'static,
[src]
F: FnOnce(&mut A, &mut <A as Actor>::Context) + 'static,
Execute closure after specified period of time within same Actor and Context. Execution get cancelled if context's stop method get called. Read more
impl<A, M, S> ToEnvelope<Syn, A, M> for HttpContext<A, S> where
A: Actor<Context = HttpContext<A, S>> + Handler<M>,
M: Message + Send + 'static,
M::Result: Send,
[src]
A: Actor<Context = HttpContext<A, S>> + Handler<M>,
M: Message + Send + 'static,
M::Result: Send,
fn pack(msg: M, tx: Option<Sender<M::Result>>) -> SyncEnvelope<A>
[src]
Pack message into suitable envelope
impl<A, S> From<HttpContext<A, S>> for Body where
A: Actor<Context = HttpContext<A, S>>,
S: 'static,
[src]
A: Actor<Context = HttpContext<A, S>>,
S: 'static,
fn from(ctx: HttpContext<A, S>) -> Body
[src]
Performs the conversion.