pub struct TcpStream { /* private fields */ }
Expand description
A TCP stream between a local and a remote socket.
A TCP stream can either be created by connecting to an endpoint, via the
connect
method, or by accepting a connection from a listener. A
TCP stream can also be created via the TcpSocket
type.
Reading and writing to a TcpStream
is usually done using the
convenience methods found on the AsyncReadExt
and AsyncWriteExt
traits.
Examples
use tokio::net::TcpStream;
use tokio::io::AsyncWriteExt;
use std::error::Error;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
// Connect to a peer
let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
// Write some data.
stream.write_all(b"hello world!").await?;
Ok(())
}
The write_all
method is defined on the AsyncWriteExt
trait.
To shut down the stream in the write direction, you can call the
shutdown()
method. This will cause the other peer to receive a read of
length 0, indicating that no more data will be sent. This only closes
the stream in one direction.
Implementations
sourceimpl TcpStream
impl TcpStream
sourcepub async fn connect<A: ToSocketAddrs>(addr: A) -> Result<TcpStream>
pub async fn connect<A: ToSocketAddrs>(addr: A) -> Result<TcpStream>
Opens a TCP connection to a remote host.
addr
is an address of the remote host. Anything which implements the
ToSocketAddrs
trait can be supplied as the address. If addr
yields multiple addresses, connect will be attempted with each of the
addresses until a connection is successful. If none of the addresses
result in a successful connection, the error returned from the last
connection attempt (the last address) is returned.
To configure the socket before connecting, you can use the TcpSocket
type.
Examples
use tokio::net::TcpStream;
use tokio::io::AsyncWriteExt;
use std::error::Error;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
// Connect to a peer
let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
// Write some data.
stream.write_all(b"hello world!").await?;
Ok(())
}
The write_all
method is defined on the AsyncWriteExt
trait.
sourcepub fn from_std(stream: TcpStream) -> Result<TcpStream>
pub fn from_std(stream: TcpStream) -> Result<TcpStream>
Creates new TcpStream
from a std::net::TcpStream
.
This function is intended to be used to wrap a TCP stream from the standard library in the Tokio equivalent. The conversion assumes nothing about the underlying stream; it is left up to the user to set it in non-blocking mode.
Examples
use std::error::Error;
use tokio::net::TcpStream;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
let std_stream = std::net::TcpStream::connect("127.0.0.1:34254")?;
std_stream.set_nonblocking(true)?;
let stream = TcpStream::from_std(std_stream)?;
Ok(())
}
Panics
This function panics if thread-local runtime is not set.
The runtime is usually set implicitly when this function is called
from a future driven by a tokio runtime, otherwise runtime can be set
explicitly with Runtime::enter
function.
sourcepub fn into_std(self) -> Result<TcpStream>
pub fn into_std(self) -> Result<TcpStream>
Turns a tokio::net::TcpStream
into a std::net::TcpStream
.
The returned std::net::TcpStream
will have nonblocking mode set as true
.
Use set_nonblocking
to change the blocking mode if needed.
Examples
use std::error::Error;
use std::io::Read;
use tokio::net::TcpListener;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
let mut data = [0u8; 12];
let listener = TcpListener::bind("127.0.0.1:34254").await?;
let (tokio_tcp_stream, _) = listener.accept().await?;
let mut std_tcp_stream = tokio_tcp_stream.into_std()?;
std_tcp_stream.set_nonblocking(false)?;
std_tcp_stream.read_exact(&mut data)?;
Ok(())
}
sourcepub fn local_addr(&self) -> Result<SocketAddr>
pub fn local_addr(&self) -> Result<SocketAddr>
Returns the local address that this stream is bound to.
Examples
use tokio::net::TcpStream;
let stream = TcpStream::connect("127.0.0.1:8080").await?;
println!("{:?}", stream.local_addr()?);
sourcepub fn take_error(&self) -> Result<Option<Error>>
pub fn take_error(&self) -> Result<Option<Error>>
Returns the value of the SO_ERROR
option.
sourcepub fn peer_addr(&self) -> Result<SocketAddr>
pub fn peer_addr(&self) -> Result<SocketAddr>
Returns the remote address that this stream is connected to.
Examples
use tokio::net::TcpStream;
let stream = TcpStream::connect("127.0.0.1:8080").await?;
println!("{:?}", stream.peer_addr()?);
sourcepub fn poll_peek(
&self,
cx: &mut Context<'_>,
buf: &mut ReadBuf<'_>
) -> Poll<Result<usize>>
pub fn poll_peek(
&self,
cx: &mut Context<'_>,
buf: &mut ReadBuf<'_>
) -> Poll<Result<usize>>
Attempts to receive data on the socket, without removing that data from the queue, registering the current task for wakeup if data is not yet available.
Note that on multiple calls to poll_peek
, poll_read
or
poll_read_ready
, only the Waker
from the Context
passed to the
most recent call is scheduled to receive a wakeup. (However,
poll_write
retains a second, independent waker.)
Return value
The function returns:
Poll::Pending
if data is not yet available.Poll::Ready(Ok(n))
if data is available.n
is the number of bytes peeked.Poll::Ready(Err(e))
if an error is encountered.
Errors
This function may encounter any standard I/O error except WouldBlock
.
Examples
use tokio::io::{self, ReadBuf};
use tokio::net::TcpStream;
use futures::future::poll_fn;
#[tokio::main]
async fn main() -> io::Result<()> {
let stream = TcpStream::connect("127.0.0.1:8000").await?;
let mut buf = [0; 10];
let mut buf = ReadBuf::new(&mut buf);
poll_fn(|cx| {
stream.poll_peek(cx, &mut buf)
}).await?;
Ok(())
}
sourcepub async fn ready(&self, interest: Interest) -> Result<Ready>
pub async fn ready(&self, interest: Interest) -> Result<Ready>
Waits for any of the requested ready states.
This function is usually paired with try_read()
or try_write()
. It
can be used to concurrently read / write to the same socket on a single
task without splitting the socket.
Cancel safety
This method is cancel safe. Once a readiness event occurs, the method
will continue to return immediately until the readiness event is
consumed by an attempt to read or write that fails with WouldBlock
or
Poll::Pending
.
Examples
Concurrently read and write to the stream on the same task without splitting.
use tokio::io::Interest;
use tokio::net::TcpStream;
use std::error::Error;
use std::io;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
let stream = TcpStream::connect("127.0.0.1:8080").await?;
loop {
let ready = stream.ready(Interest::READABLE | Interest::WRITABLE).await?;
if ready.is_readable() {
let mut data = vec![0; 1024];
// Try to read data, this may still fail with `WouldBlock`
// if the readiness event is a false positive.
match stream.try_read(&mut data) {
Ok(n) => {
println!("read {} bytes", n);
}
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
continue;
}
Err(e) => {
return Err(e.into());
}
}
}
if ready.is_writable() {
// Try to write data, this may still fail with `WouldBlock`
// if the readiness event is a false positive.
match stream.try_write(b"hello world") {
Ok(n) => {
println!("write {} bytes", n);
}
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
continue
}
Err(e) => {
return Err(e.into());
}
}
}
}
}
sourcepub async fn readable(&self) -> Result<()>
pub async fn readable(&self) -> Result<()>
Waits for the socket to become readable.
This function is equivalent to ready(Interest::READABLE)
and is usually
paired with try_read()
.
Cancel safety
This method is cancel safe. Once a readiness event occurs, the method
will continue to return immediately until the readiness event is
consumed by an attempt to read that fails with WouldBlock
or
Poll::Pending
.
Examples
use tokio::net::TcpStream;
use std::error::Error;
use std::io;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
// Connect to a peer
let stream = TcpStream::connect("127.0.0.1:8080").await?;
let mut msg = vec![0; 1024];
loop {
// Wait for the socket to be readable
stream.readable().await?;
// Try to read data, this may still fail with `WouldBlock`
// if the readiness event is a false positive.
match stream.try_read(&mut msg) {
Ok(n) => {
msg.truncate(n);
break;
}
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
continue;
}
Err(e) => {
return Err(e.into());
}
}
}
println!("GOT = {:?}", msg);
Ok(())
}
sourcepub fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<Result<()>>
pub fn poll_read_ready(&self, cx: &mut Context<'_>) -> Poll<Result<()>>
Polls for read readiness.
If the tcp stream is not currently ready for reading, this method will
store a clone of the Waker
from the provided Context
. When the tcp
stream becomes ready for reading, Waker::wake
will be called on the
waker.
Note that on multiple calls to poll_read_ready
, poll_read
or
poll_peek
, only the Waker
from the Context
passed to the most
recent call is scheduled to receive a wakeup. (However,
poll_write_ready
retains a second, independent waker.)
This function is intended for cases where creating and pinning a future
via readable
is not feasible. Where possible, using readable
is
preferred, as this supports polling from multiple tasks at once.
Return value
The function returns:
Poll::Pending
if the tcp stream is not ready for reading.Poll::Ready(Ok(()))
if the tcp stream is ready for reading.Poll::Ready(Err(e))
if an error is encountered.
Errors
This function may encounter any standard I/O error except WouldBlock
.
sourcepub fn try_read(&self, buf: &mut [u8]) -> Result<usize>
pub fn try_read(&self, buf: &mut [u8]) -> Result<usize>
Tries to read data from the stream into the provided buffer, returning how many bytes were read.
Receives any pending data from the socket but does not wait for new data
to arrive. On success, returns the number of bytes read. Because
try_read()
is non-blocking, the buffer does not have to be stored by
the async task and can exist entirely on the stack.
Usually, readable()
or ready()
is used with this function.
Return
If data is successfully read, Ok(n)
is returned, where n
is the
number of bytes read. Ok(0)
indicates the stream’s read half is closed
and will no longer yield data. If the stream is not ready to read data
Err(io::ErrorKind::WouldBlock)
is returned.
Examples
use tokio::net::TcpStream;
use std::error::Error;
use std::io;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
// Connect to a peer
let stream = TcpStream::connect("127.0.0.1:8080").await?;
loop {
// Wait for the socket to be readable
stream.readable().await?;
// Creating the buffer **after** the `await` prevents it from
// being stored in the async task.
let mut buf = [0; 4096];
// Try to read data, this may still fail with `WouldBlock`
// if the readiness event is a false positive.
match stream.try_read(&mut buf) {
Ok(0) => break,
Ok(n) => {
println!("read {} bytes", n);
}
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
continue;
}
Err(e) => {
return Err(e.into());
}
}
}
Ok(())
}
sourcepub fn try_read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize>
pub fn try_read_vectored(&self, bufs: &mut [IoSliceMut<'_>]) -> Result<usize>
Tries to read data from the stream into the provided buffers, returning how many bytes were read.
Data is copied to fill each buffer in order, with the final buffer
written to possibly being only partially filled. This method behaves
equivalently to a single call to try_read()
with concatenated
buffers.
Receives any pending data from the socket but does not wait for new data
to arrive. On success, returns the number of bytes read. Because
try_read_vectored()
is non-blocking, the buffer does not have to be
stored by the async task and can exist entirely on the stack.
Usually, readable()
or ready()
is used with this function.
Return
If data is successfully read, Ok(n)
is returned, where n
is the
number of bytes read. Ok(0)
indicates the stream’s read half is closed
and will no longer yield data. If the stream is not ready to read data
Err(io::ErrorKind::WouldBlock)
is returned.
Examples
use tokio::net::TcpStream;
use std::error::Error;
use std::io::{self, IoSliceMut};
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
// Connect to a peer
let stream = TcpStream::connect("127.0.0.1:8080").await?;
loop {
// Wait for the socket to be readable
stream.readable().await?;
// Creating the buffer **after** the `await` prevents it from
// being stored in the async task.
let mut buf_a = [0; 512];
let mut buf_b = [0; 1024];
let mut bufs = [
IoSliceMut::new(&mut buf_a),
IoSliceMut::new(&mut buf_b),
];
// Try to read data, this may still fail with `WouldBlock`
// if the readiness event is a false positive.
match stream.try_read_vectored(&mut bufs) {
Ok(0) => break,
Ok(n) => {
println!("read {} bytes", n);
}
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
continue;
}
Err(e) => {
return Err(e.into());
}
}
}
Ok(())
}
sourcepub fn try_read_buf<B: BufMut>(&self, buf: &mut B) -> Result<usize>
pub fn try_read_buf<B: BufMut>(&self, buf: &mut B) -> Result<usize>
Tries to read data from the stream into the provided buffer, advancing the buffer’s internal cursor, returning how many bytes were read.
Receives any pending data from the socket but does not wait for new data
to arrive. On success, returns the number of bytes read. Because
try_read_buf()
is non-blocking, the buffer does not have to be stored by
the async task and can exist entirely on the stack.
Usually, readable()
or ready()
is used with this function.
Return
If data is successfully read, Ok(n)
is returned, where n
is the
number of bytes read. Ok(0)
indicates the stream’s read half is closed
and will no longer yield data. If the stream is not ready to read data
Err(io::ErrorKind::WouldBlock)
is returned.
Examples
use tokio::net::TcpStream;
use std::error::Error;
use std::io;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
// Connect to a peer
let stream = TcpStream::connect("127.0.0.1:8080").await?;
loop {
// Wait for the socket to be readable
stream.readable().await?;
let mut buf = Vec::with_capacity(4096);
// Try to read data, this may still fail with `WouldBlock`
// if the readiness event is a false positive.
match stream.try_read_buf(&mut buf) {
Ok(0) => break,
Ok(n) => {
println!("read {} bytes", n);
}
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
continue;
}
Err(e) => {
return Err(e.into());
}
}
}
Ok(())
}
sourcepub async fn writable(&self) -> Result<()>
pub async fn writable(&self) -> Result<()>
Waits for the socket to become writable.
This function is equivalent to ready(Interest::WRITABLE)
and is usually
paired with try_write()
.
Cancel safety
This method is cancel safe. Once a readiness event occurs, the method
will continue to return immediately until the readiness event is
consumed by an attempt to write that fails with WouldBlock
or
Poll::Pending
.
Examples
use tokio::net::TcpStream;
use std::error::Error;
use std::io;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
// Connect to a peer
let stream = TcpStream::connect("127.0.0.1:8080").await?;
loop {
// Wait for the socket to be writable
stream.writable().await?;
// Try to write data, this may still fail with `WouldBlock`
// if the readiness event is a false positive.
match stream.try_write(b"hello world") {
Ok(n) => {
break;
}
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
continue;
}
Err(e) => {
return Err(e.into());
}
}
}
Ok(())
}
sourcepub fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<Result<()>>
pub fn poll_write_ready(&self, cx: &mut Context<'_>) -> Poll<Result<()>>
Polls for write readiness.
If the tcp stream is not currently ready for writing, this method will
store a clone of the Waker
from the provided Context
. When the tcp
stream becomes ready for writing, Waker::wake
will be called on the
waker.
Note that on multiple calls to poll_write_ready
or poll_write
, only
the Waker
from the Context
passed to the most recent call is
scheduled to receive a wakeup. (However, poll_read_ready
retains a
second, independent waker.)
This function is intended for cases where creating and pinning a future
via writable
is not feasible. Where possible, using writable
is
preferred, as this supports polling from multiple tasks at once.
Return value
The function returns:
Poll::Pending
if the tcp stream is not ready for writing.Poll::Ready(Ok(()))
if the tcp stream is ready for writing.Poll::Ready(Err(e))
if an error is encountered.
Errors
This function may encounter any standard I/O error except WouldBlock
.
sourcepub fn try_write(&self, buf: &[u8]) -> Result<usize>
pub fn try_write(&self, buf: &[u8]) -> Result<usize>
Try to write a buffer to the stream, returning how many bytes were written.
The function will attempt to write the entire contents of buf
, but
only part of the buffer may be written.
This function is usually paired with writable()
.
Return
If data is successfully written, Ok(n)
is returned, where n
is the
number of bytes written. If the stream is not ready to write data,
Err(io::ErrorKind::WouldBlock)
is returned.
Examples
use tokio::net::TcpStream;
use std::error::Error;
use std::io;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
// Connect to a peer
let stream = TcpStream::connect("127.0.0.1:8080").await?;
loop {
// Wait for the socket to be writable
stream.writable().await?;
// Try to write data, this may still fail with `WouldBlock`
// if the readiness event is a false positive.
match stream.try_write(b"hello world") {
Ok(n) => {
break;
}
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
continue;
}
Err(e) => {
return Err(e.into());
}
}
}
Ok(())
}
sourcepub fn try_write_vectored(&self, bufs: &[IoSlice<'_>]) -> Result<usize>
pub fn try_write_vectored(&self, bufs: &[IoSlice<'_>]) -> Result<usize>
Tries to write several buffers to the stream, returning how many bytes were written.
Data is written from each buffer in order, with the final buffer read
from possible being only partially consumed. This method behaves
equivalently to a single call to try_write()
with concatenated
buffers.
This function is usually paired with writable()
.
Return
If data is successfully written, Ok(n)
is returned, where n
is the
number of bytes written. If the stream is not ready to write data,
Err(io::ErrorKind::WouldBlock)
is returned.
Examples
use tokio::net::TcpStream;
use std::error::Error;
use std::io;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
// Connect to a peer
let stream = TcpStream::connect("127.0.0.1:8080").await?;
let bufs = [io::IoSlice::new(b"hello "), io::IoSlice::new(b"world")];
loop {
// Wait for the socket to be writable
stream.writable().await?;
// Try to write data, this may still fail with `WouldBlock`
// if the readiness event is a false positive.
match stream.try_write_vectored(&bufs) {
Ok(n) => {
break;
}
Err(ref e) if e.kind() == io::ErrorKind::WouldBlock => {
continue;
}
Err(e) => {
return Err(e.into());
}
}
}
Ok(())
}
sourcepub fn try_io<R>(
&self,
interest: Interest,
f: impl FnOnce() -> Result<R>
) -> Result<R>
pub fn try_io<R>(
&self,
interest: Interest,
f: impl FnOnce() -> Result<R>
) -> Result<R>
Tries to read or write from the socket using a user-provided IO operation.
If the socket is ready, the provided closure is called. The closure
should attempt to perform IO operation from the socket by manually
calling the appropriate syscall. If the operation fails because the
socket is not actually ready, then the closure should return a
WouldBlock
error and the readiness flag is cleared. The return value
of the closure is then returned by try_io
.
If the socket is not ready, then the closure is not called
and a WouldBlock
error is returned.
The closure should only return a WouldBlock
error if it has performed
an IO operation on the socket that failed due to the socket not being
ready. Returning a WouldBlock
error in any other situation will
incorrectly clear the readiness flag, which can cause the socket to
behave incorrectly.
The closure should not perform the IO operation using any of the methods
defined on the Tokio TcpStream
type, as this will mess with the
readiness flag and can cause the socket to behave incorrectly.
Usually, readable()
, writable()
or ready()
is used with this function.
sourcepub async fn peek(&self, buf: &mut [u8]) -> Result<usize>
pub async fn peek(&self, buf: &mut [u8]) -> Result<usize>
Receives data on the socket from the remote address to which it is connected, without removing that data from the queue. On success, returns the number of bytes peeked.
Successive calls return the same data. This is accomplished by passing
MSG_PEEK
as a flag to the underlying recv system call.
Examples
use tokio::net::TcpStream;
use tokio::io::AsyncReadExt;
use std::error::Error;
#[tokio::main]
async fn main() -> Result<(), Box<dyn Error>> {
// Connect to a peer
let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
let mut b1 = [0; 10];
let mut b2 = [0; 10];
// Peek at the data
let n = stream.peek(&mut b1).await?;
// Read the data
assert_eq!(n, stream.read(&mut b2[..n]).await?);
assert_eq!(&b1[..n], &b2[..n]);
Ok(())
}
The read
method is defined on the AsyncReadExt
trait.
sourcepub fn nodelay(&self) -> Result<bool>
pub fn nodelay(&self) -> Result<bool>
Gets the value of the TCP_NODELAY
option on this socket.
For more information about this option, see set_nodelay
.
Examples
use tokio::net::TcpStream;
let stream = TcpStream::connect("127.0.0.1:8080").await?;
println!("{:?}", stream.nodelay()?);
sourcepub fn set_nodelay(&self, nodelay: bool) -> Result<()>
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.
Examples
use tokio::net::TcpStream;
let stream = TcpStream::connect("127.0.0.1:8080").await?;
stream.set_nodelay(true)?;
sourcepub fn linger(&self) -> Result<Option<Duration>>
pub fn linger(&self) -> Result<Option<Duration>>
Reads the linger duration for this socket by getting the SO_LINGER
option.
For more information about this option, see set_linger
.
Examples
use tokio::net::TcpStream;
let stream = TcpStream::connect("127.0.0.1:8080").await?;
println!("{:?}", stream.linger()?);
sourcepub fn set_linger(&self, dur: Option<Duration>) -> Result<()>
pub fn set_linger(&self, dur: Option<Duration>) -> Result<()>
Sets the linger duration of this socket by setting the SO_LINGER option.
This option controls the action taken when a stream has unsent messages and the stream is closed. If SO_LINGER is set, the system shall block the process until it can transmit the data or until the time expires.
If SO_LINGER is not specified, and the stream is closed, the system handles the call in a way that allows the process to continue as quickly as possible.
Examples
use tokio::net::TcpStream;
let stream = TcpStream::connect("127.0.0.1:8080").await?;
stream.set_linger(None)?;
sourcepub fn set_ttl(&self, ttl: u32) -> Result<()>
pub fn set_ttl(&self, ttl: u32) -> Result<()>
Sets the value for the IP_TTL
option on this socket.
This value sets the time-to-live field that is used in every packet sent from this socket.
Examples
use tokio::net::TcpStream;
let stream = TcpStream::connect("127.0.0.1:8080").await?;
stream.set_ttl(123)?;
sourcepub fn split<'a>(&'a mut self) -> (ReadHalf<'a>, WriteHalf<'a>)
pub fn split<'a>(&'a mut self) -> (ReadHalf<'a>, WriteHalf<'a>)
Splits a TcpStream
into a read half and a write half, which can be used
to read and write the stream concurrently.
This method is more efficient than into_split
, but the halves cannot be
moved into independently spawned tasks.
sourcepub fn into_split(self) -> (OwnedReadHalf, OwnedWriteHalf)
pub fn into_split(self) -> (OwnedReadHalf, OwnedWriteHalf)
Splits a TcpStream
into a read half and a write half, which can be used
to read and write the stream concurrently.
Unlike split
, the owned halves can be moved to separate tasks, however
this comes at the cost of a heap allocation.
Note: Dropping the write half will shut down the write half of the TCP
stream. This is equivalent to calling shutdown()
on the TcpStream
.
Trait Implementations
sourceimpl AsRef<TcpStream> for OwnedReadHalf
impl AsRef<TcpStream> for OwnedReadHalf
sourceimpl AsRef<TcpStream> for OwnedWriteHalf
impl AsRef<TcpStream> for OwnedWriteHalf
sourceimpl AsyncWrite for TcpStream
impl AsyncWrite for TcpStream
sourcefn poll_write(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &[u8]
) -> Poll<Result<usize>>
fn poll_write(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
buf: &[u8]
) -> Poll<Result<usize>>
Attempt to write bytes from buf
into the object. Read more
sourcefn poll_write_vectored(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
bufs: &[IoSlice<'_>]
) -> Poll<Result<usize>>
fn poll_write_vectored(
self: Pin<&mut Self>,
cx: &mut Context<'_>,
bufs: &[IoSlice<'_>]
) -> Poll<Result<usize>>
Like poll_write
, except that it writes from a slice of buffers. Read more
sourcefn is_write_vectored(&self) -> bool
fn is_write_vectored(&self) -> bool
Determines if this writer has an efficient poll_write_vectored
implementation. Read more
Auto Trait Implementations
impl RefUnwindSafe for TcpStream
impl Send for TcpStream
impl Sync for TcpStream
impl Unpin for TcpStream
impl UnwindSafe for TcpStream
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more