# Struct actix_web::ws::WebsocketContext[−][src]

    pub struct WebsocketContext<A, S = ()> where
        A: Actor<Context = WebsocketContext<A, S>>,  { /* fields omitted */ }

Execution context for `WebSockets` actors

## Methods

###

`impl<A, S: 'static> WebsocketContext<A, S> where A: Actor<Context = Self>,`

[src]

####

`pub fn create<P>(req: HttpRequest<S>, actor: A, stream: WsStream<P>) -> Body where A: StreamHandler<Message, ProtocolError>, P: Stream<Item = Bytes, Error = PayloadError> + 'static,`

[src]

Create a new Websocket context from a request and an actor

####

`pub fn with_factory<F>(req: HttpRequest<S>, f: F) -> Body where F: FnOnce(&mut Self) -> A + 'static,`

[src]

Create a new Websocket context

###

`impl<A, S> WebsocketContext<A, S> where A: Actor<Context = Self>,`

[src]

####

`pub fn write_raw(&mut self, data: FramedMessage)`

[src]

Write payload

This is a low-level function that accepts framed messages that should be created using `Frame::message()`. If you want to send text or binary data you should prefer the `text()` or `binary()` convenience functions that handle the framing for you.

####
ⓘImportant traits for &'a mut R

### Important traits for &'a mut R

`impl<'a, R> Read for &'a mut R where
R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
W: Write + ?Sized, impl<'a, I> Iterator for &'a mut I where
I: Iterator + ?Sized, type Item = <I as Iterator>::Item;`

`pub fn state(&self) -> &S`

[src]

Shared application state

####

`pub fn request(&mut self) -> &mut HttpRequest<S>`

[src]

Incoming request

####

`pub fn drain(&mut self) -> Drain<A>`

[src]

Returns drain future

####

`pub fn text<T: Into<Binary>>(&mut self, text: T)`

[src]

Send text frame

####

`pub fn binary<B: Into<Binary>>(&mut self, data: B)`

[src]

Send binary frame

####

`pub fn ping(&mut self, message: &str)`

[src]

Send ping frame

####

`pub fn pong(&mut self, message: &str)`

[src]

Send pong frame

####

`pub fn close(&mut self, reason: Option<CloseReason>)`

[src]

Send close frame

####

`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 WebsocketContext<A, S> where A: Actor<Context = Self>,`

[src]

####

`fn stop(&mut self)`

[src]

Immediately stop processing incoming messages and switch to a `stopping` state Read more

####

`fn terminate(&mut self)`

[src]

Terminate actor execution

####

`fn state(&self) -> ActorState`

[src]

Actor execution state

###

`impl<A, S> AsyncContext<A> for WebsocketContext<A, S> where A: Actor<Context = Self>,`

[src]

####

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

[src]

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]

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. handle is a value returned by `spawn` method.

####

`fn address(&self) -> Addr<A>`

[src]

Return `Address` of the context

####

`fn waiting(&self) -> bool` |

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,` |

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,` |

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,` |

Send message `msg` to self.

####

`fn notify_later<M>(&mut self, msg: M, after: Duration) -> SpawnHandle where 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,` |

Execute closure after specified period of time within same Actor and Context. Execution get cancelled if context's stop method get called. Read more

####

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

Spawns job to execute closure with specified interval

###

`impl<A, S> WsWriter for WebsocketContext<A, S> where A: Actor<Context = Self>, S: 'static,`

[src]

####

`fn send_text<T: Into<Binary>>(&mut self, text: T)`

[src]

Send text frame

####

`fn send_binary<B: Into<Binary>>(&mut self, data: B)`

[src]

Send binary frame

####

`fn send_ping(&mut self, message: &str)`

[src]

Send ping frame

####

`fn send_pong(&mut self, message: &str)`

[src]

Send pong frame

####

`fn send_close(&mut self, reason: Option<CloseReason>)`

[src]

Send close frame

###

`impl<A, S> AsyncContextParts<A> for WebsocketContext<A, S> where A: Actor<Context = Self>,`

[src]

####

`fn parts(&mut self) -> &mut ContextParts<A>`

[src]

###

`impl<A, M, S> ToEnvelope<A, M> for WebsocketContext<A, S> where A: Actor<Context = WebsocketContext<A, S>> + Handler<M>, M: ActixMessage + Send + 'static, M::Result: Send,`

[src]

####

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

[src]

Pack message into suitable envelope

## Auto Trait Implementations

###

`impl<A, S = ()> !Send for WebsocketContext<A, S>`

###

`impl<A, S = ()> !Sync for WebsocketContext<A, S>`

# Help

## Keyboard Shortcuts

`?`
  Show this help dialog
`S`
  Focus the search field
`↑`
  Move up in search results
`↓`
  Move down in search results
`↹`
  Switch tab
`⏎`
  Go to active search result
`+`
  Expand all sections
`-`
  Collapse all sections

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize` or `* -> vec`)

Search multiple things at once by splitting your query with comma (e.g. `str,u8` or `String,struct:Vec,test`)