Struct WebSocketContext 

pub struct WebSocketContext<'ctx> { /* private fields */ }

example.rs

use mews::{WebSocketContext, Connection, Message};
 
async fn handle_websocket(
    headers: Headers/* of upgrade request */,
    tcp: TcpStream
) -> Response {
    let ctx = WebSocketContext::new(
        &headers["Sec-WebSocket-Key"]
    );
 
    let (sign, ws) = ctx.on_upgrade(
        |mut conn: Connection<TcpStream>| async move {
            while let Ok(Some(Message::Text(text))) = conn.recv().await {
                conn.send(text).await
                    .expect("failed to send message");
                sleep(Duration::from_secs(1)).await;
            }
        }
    );
 
    spawn(ws.manage(tcp));
 
    /* return `Switching Protocol` response with `sign`... */
}

Implementations

impl<'ctx> WebSocketContext<'ctx>

pub fn new(sec_websocket_key: &'ctx str) -> Self

create WebSocketContext with Sec-WebSocket-Key request header value.

pub fn with(self, config: Config) -> Self

pub fn on_upgrade<C: UnderlyingConnection, H, F>( self, handler: H, ) -> (String, WebSocket<C>)

where H: FnOnce(Connection<C>) -> F + Send + Sync + 'static, F: Future<Output = ()> + Send + 'static,

create Sec-WebSocket-Accept value and a WebSocket with the handler.

handler

any ’static FnOnce(Connection<C>) -> {impl Future<Output = ()> + Send} + Send + Sync

Trait Implementations

impl Debug for WebSocketContext<'_>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for WebSocketContext<'_>

fn eq(&self, other: &Self) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.