Struct xitca_web::handler::websocket::WebSocket

pub struct WebSocket<B = RequestBody>
where
    B: BodyStream,
{ /* private fields */ }

Implementations

impl<B> WebSocket<B>

where B: BodyStream,

pub fn set_ping_interval(&mut self, dur: Duration) -> &mut Self

Set interval duration of server side ping message to client.

pub fn set_max_unanswered_ping(&mut self, size: u8) -> &mut Self

Set max number of consecutive server side ping messages that are not answered by client.

Panic:

when 0 is passed as argument.

pub fn msg_sender(&self) -> &ResponseSender

Get a reference of Websocket message sender. Can be used to send message to client.

pub fn on_msg<F>(&mut self, func: F) -> &mut Self

where F: for<'a> FnMut(&'a mut ResponseSender, Message) -> Pin<Box<dyn Future<Output = ()> + 'a>> + 'static,

Async function that would be called when new message arrived from client.

pub fn on_err<F, Fut>(&mut self, func: F) -> &mut Self

where F: FnMut(WsError<B::Error>) -> Fut + 'static, Fut: Future<Output = ()> + 'static,

Async function that would be called when error occurred.

pub fn on_close<F, Fut>(&mut self, func: F) -> &mut Self

where F: FnOnce() -> Fut + 'static, Fut: Future<Output = ()> + 'static,

Async function that would be called when closing the websocket connection.

Trait Implementations

impl<'a, 'r, C, B> FromRequest<'a, WebContext<'r, C, B>> for WebSocket<B>

where C: 'static, B: BodyStream + Default + 'static,

type Type<'b> = WebSocket<B>

type Error = Error<C>

async fn from_request( ctx: &'a WebContext<'r, C, B> ) -> Result<Self, Self::Error>

impl<'r, C, B> Responder<WebContext<'r, C, B>> for WebSocket<B>

where B: BodyStream + 'static,

type Response = Response<ResponseBody>

type Error = Infallible

async fn respond( self, _: WebContext<'r, C, B> ) -> Result<Self::Response, Self::Error>

generate response from given request.

fn map(self, res: Self::Response) -> Result<Self::Response, Self::Error>

where Self: Sized,

map response type and mutate it’s state. default to pass through without any modification.