Struct ws_stream_tungstenite::WsStream

pub struct WsStream<S: AsyncRead01 + AsyncWrite01> { /* fields omitted */ }

Takes a WebSocketStream from tokio-tungstenite and implements futures 0.3 AsyncRead/AsyncWrite. Please look at the documentation of the impls for those traits below for details (rustdoc will collapse them).

Methods

impl<S: AsyncRead01 + AsyncWrite01> WsStream<S>

pub fn new(inner: TTungSocket<S>) -> Self

Create a new WsStream.

Trait Implementations

impl<S: AsyncRead01 + AsyncWrite01> Debug for WsStream<S>

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

Formats the value using the given formatter.

impl<S: AsyncRead01 + AsyncWrite01> AsyncRead for WsStream<S>

When None is returned, it means it is safe to drop the underlying connection.

Errors

fn poll_read(
    self: Pin<&mut Self>,
    cx: &mut Context,
    buf: &mut [u8]
) -> Poll<Result<usize>>

Attempt to read from the AsyncRead into buf.

fn poll_read_vectored(
    self: Pin<&mut Self>,
    cx: &mut Context,
    bufs: &mut [IoSliceMut]
) -> Poll<Result<usize, Error>>

Attempt to read from the AsyncRead into bufs using vectored IO operations.

impl<S: AsyncRead01 + AsyncWrite01> AsyncWrite for WsStream<S>

Errors

The following errors can be returned when writing to the stream:

• io::ErrorKind::NotConnected: This means that the connection is already closed. You should drop it. It is safe to drop the underlying connection.

• io::ErrorKind::InvalidData: This means that a tungstenite::error::Capacity occurred. This means that you send in a buffer bigger than the maximum message size configured on the underlying websocket connection. If you did not set it manually, the default for tungstenite is 64MB.

• other std::io::Error's generally mean something went wrong on the underlying transport. Consider these fatal and just drop the connection.

fn poll_write(
    self: Pin<&mut Self>,
    cx: &mut Context,
    buf: &[u8]
) -> Poll<Result<usize>>

Will always flush the underlying socket. Will always create an entire Websocket message from every write, so call with a sufficiently large buffer if you have performance problems.

fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<()>>

Attempt to flush the object, ensuring that any buffered data reach their destination.

fn poll_close(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<()>>

Attempt to close the object.

fn poll_write_vectored(
    self: Pin<&mut Self>,
    cx: &mut Context,
    bufs: &[IoSlice]
) -> Poll<Result<usize, Error>>

Attempt to write bytes from bufs into the object using vectored IO operations.

impl<S> Observable<WsEvent> for WsStream<S> where
    S: AsyncRead01 + AsyncWrite01, 

type Error = Error

The error type that is returned if observing is not possible.

fn observe(
    &mut self,
    options: ObserveConfig<WsEvent>
) -> Result<Events<WsEvent>, Self::Error>

Add an observer to the observable. Options allow chosing the channel type and to filter events with a predicate.