Struct async_listen::ByteStream

pub struct ByteStream { /* fields omitted */ }

A wrapper around TcpStream and UnixStream

This structure is yielded by the stream created by ListenExt::backpressure_wrapper

This wrapper serves two purposes:

1. Holds backpressure token
2. Abstract away differences between TcpStream and UnixStream

The structure implements AsyncRead and AsyncWrite so can be used for protocol implementation directly.

Methods

impl ByteStream

pub fn new_tcp(token: Token, stream: TcpStream) -> ByteStream

Create a bytestream for a tcp socket

pub fn new_unix(token: Token, stream: UnixStream) -> ByteStream

Create a bytestream for a unix socket

pub fn peer_addr(&self) -> Result<PeerAddr>

Returns the remote address that this stream is connected to.

Note: even on non-unix platforms (Windows) PeerAddr still contains Unix option so you don't have to use conditional compilation when matching.

Examples

let peer = stream.peer_addr()?;
match peer.peer_addr()? {
    PeerAddr::Tcp(addr) => println!("TCP addr {}", addr),
    PeerAddr::Unix(None) => println!("Unnamed unix socket"),
    PeerAddr::Unix(Some(path)) => println!("Unix {}", path.display()),
}

pub fn nodelay(&self) -> Result<bool>

Gets the value of the TCP_NODELAY option on this socket.

For Unix sockets this function always returns true (Unix sockets always behave like the option is off).

For more information about this option, see set_nodelay.

pub fn set_nodelay(&self, nodelay: bool) -> Result<()>

Sets the value of the TCP_NODELAY option on this socket.

If set, this option disables the Nagle algorithm. This means that segments are always sent as soon as possible, even if there is only a small amount of data. When not set, data is buffered until there is a sufficient amount to send out, thereby avoiding the frequent sending of small packets.

For Unix sockets this function does nothing (Unix sockets always behave like the option is enabled, and there is no way to change that).

pub fn shutdown(&self, how: Shutdown) -> Result<(), Error>

Shuts down the read, write, or both halves of this connection.

This function will cause all pending and future I/O calls on the specified portions to immediately return with an appropriate value (see the documentation of Shutdown).

Trait Implementations

impl AsyncRead for ByteStream

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

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 AsyncWrite for ByteStream

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

Attempt to write bytes from buf into the object.

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

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<(), Error>>

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 Debug for ByteStream

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

Formats the value using the given formatter.

impl From<(Token, TcpStream)> for ByteStream

fn from((token, stream): (Token, TcpStream)) -> ByteStream

Performs the conversion.

impl From<(Token, UnixStream)> for ByteStream

fn from((token, stream): (Token, UnixStream)) -> ByteStream

Performs the conversion.