Struct ClientWebSocket 

pub struct ClientWebSocket<S = AsyncWebSocket> {
    pub socket: S,
    pub response: Parts,
    pub accepted_protocol: Option<AcceptedWebSocketProtocol>,
}

ClientWebSocket, used as input-output stream.

Utility type created via WebSocketRequestBuilder::handshake.

Fields

socket: S

Established WebSocket message transport.

response: Parts

Original HTTP handshake response metadata.

accepted_protocol: Option<AcceptedWebSocketProtocol>

Subprotocol accepted during the HTTP handshake, when any.

Implementations

impl<S> ClientWebSocket<S>

pub fn map_socket<T>(self, map: impl FnOnce(S) -> T) -> ClientWebSocket<T>

Transform the message transport while preserving handshake metadata.

pub fn send_message( &mut self, message: Message, ) -> impl Future<Output = Result<(), ProtocolError>> + Send + '_

where S: Sink<Message, Error = ProtocolError> + Send + Unpin,

Write and flush one message.

pub async fn recv_message(&mut self) -> Result<Message, ProtocolError>

where S: Stream<Item = Result<Message, ProtocolError>> + Unpin,

Receive one complete message.

pub async fn close( &mut self, message: Option<CloseFrame>, ) -> Result<(), ProtocolError>

where S: Sink<Message, Error = ProtocolError> + Send + Unpin,

Close the WebSocket.

pub fn response(&self) -> &Parts

View the original response data, from which this client web socket was created.

pub fn accepted_protocol(&self) -> Option<&str>

Return the accepted protocol (during the http handshake) of the ClientWebSocket, if any.

pub fn into_inner(self) -> S

Consume self and return its message transport.

Trait Implementations

impl<S: Debug> Debug for ClientWebSocket<S>

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

Formats the value using the given formatter.

impl<S> Deref for ClientWebSocket<S>

type Target = S

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<S> DerefMut for ClientWebSocket<S>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<S> ExtensionsRef for ClientWebSocket<S>

where S: ExtensionsRef,

fn extensions(&self) -> &Extensions

Get reference to the underlying Extensions store

impl<Inner, Socket> Service<ClientWebSocket<Socket>> for HARWebSocketService<Inner>

where Inner: Service<ClientWebSocket<HARWebSocket<Socket>>>, Socket: WebSocketIo,

type Output = <Inner as Service<ClientWebSocket<HARWebSocket<Socket>>>>::Output

The type of the output returned by the service.

type Error = <Inner as Service<ClientWebSocket<HARWebSocket<Socket>>>>::Error

The type of error returned by the service.

async fn serve( &self, websocket: ClientWebSocket<Socket>, ) -> Result<Self::Output, Self::Error>

Serve an output or an error for the given input

fn boxed(self) -> BoxService<Input, Self::Output, Self::Error>

Box this service to allow for dynamic dispatch.

impl<S> Sink<Message> for ClientWebSocket<S>

where S: Sink<Message, Error = ProtocolError> + Unpin,

type Error = ProtocolError

The type of value produced by the sink when an error occurs.

fn poll_ready( self: Pin<&mut Self>, ctx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, message: Message) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_flush( self: Pin<&mut Self>, ctx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

fn poll_close( self: Pin<&mut Self>, ctx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.

impl<S> Stream for ClientWebSocket<S>

where S: Stream<Item = Result<Message, ProtocolError>> + Unpin,

type Item = Result<Message, ProtocolError>

Values yielded by the stream.

fn poll_next( self: Pin<&mut Self>, ctx: &mut Context<'_>, ) -> Poll<Option<Self::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

fn size_hint(&self) -> (usize, Option<usize>)

Returns the bounds on the remaining length of the stream.