Struct sockjs::SockJSContext
[−]
[src]
pub struct SockJSContext<A> where
A: Session,
A::Context: AsyncContext<A>, { /* fields omitted */ }
Sockjs session context
Methods
impl<A> SockJSContext<A> where
A: Session<Context = Self>,
[src]
A: Session<Context = Self>,
fn sid(&self) -> &Arc<String>
[src]
Session id
fn send<M>(&mut self, message: M) where
M: Into<Message>,
[src]
M: Into<Message>,
Send message to peer
fn broadcast<M>(&mut self, message: M) where
M: Into<Message>,
[src]
M: Into<Message>,
Send message to all sessions
fn close(&mut self)
[src]
Close session
fn connected(&mut self) -> bool
[src]
Check if transport is connected
Trait Implementations
impl<A> ActorContext for SockJSContext<A> where
A: Session<Context = Self>,
[src]
A: Session<Context = Self>,
fn stop(&mut self)
[src]
Stop actor execution
fn terminate(&mut self)
[src]
Terminate actor execution
fn state(&self) -> ActorState
[src]
Actor execution state
fn alive(&self) -> bool
[src]
Check if execution context is alive
impl<A> AsyncContext<A> for SockJSContext<A> where
A: Session<Context = Self>,
[src]
A: Session<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 cancel_future_on_stop(&mut self, handle: SpawnHandle)
[src]
fn address<Address>(&mut self) -> Address where
A: ActorAddress<A, Address>,
[src]
A: ActorAddress<A, Address>,
Get actor address
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,
[src]
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. Read more
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,
[src]
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. Read more
fn notify<M, E>(&mut self, msg: M, after: Duration) -> SpawnHandle where
A: Handler<M, E>,
E: 'static,
M: ResponseType + 'static,
[src]
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. 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> AsyncContextApi<A> for SockJSContext<A> where
A: Session<Context = Self>,
[src]
A: Session<Context = Self>,