Struct rbatis_core::runtime::net::TcpStream

pub struct TcpStream { /* fields omitted */ }

A TCP stream between a local and a remote socket.

A TcpStream can either be created by connecting to an endpoint, via the connect method, or by accepting a connection from a listener. It can be read or written to using the AsyncRead, AsyncWrite, and related extension traits in futures::io.

The connection will be closed when the value is dropped. The reading and writing portions of the connection can also be shut down individually with the shutdown method.

This type is an async version of std::net::TcpStream.

Examples

use async_std::net::TcpStream;
use async_std::prelude::*;

let mut stream = TcpStream::connect("127.0.0.1:8080").await?;
stream.write_all(b"hello world").await?;

let mut buf = vec![0u8; 1024];
let n = stream.read(&mut buf).await?;

Implementations

impl TcpStream

pub async fn connect<A>(addrs: A) -> Result<TcpStream, Error> where
    A: ToSocketAddrs, 

Creates a new TCP stream connected to the specified address.

This method will create a new TCP socket and attempt to connect it to the addr provided. The returned future will be resolved once the stream has successfully connected, or it will return an error if one occurs.

Examples

use async_std::net::TcpStream;

let stream = TcpStream::connect("127.0.0.1:0").await?;

pub fn local_addr(&self) -> Result<SocketAddr, Error>

Returns the local address that this stream is connected to.

Examples

use async_std::net::TcpStream;

let stream = TcpStream::connect("127.0.0.1:8080").await?;
let addr = stream.local_addr()?;

pub fn peer_addr(&self) -> Result<SocketAddr, Error>

Returns the remote address that this stream is connected to.

Examples

use async_std::net::TcpStream;

let stream = TcpStream::connect("127.0.0.1:8080").await?;
let peer = stream.peer_addr()?;

pub fn ttl(&self) -> Result<u32, Error>

Gets the value of the IP_TTL option for this socket.

For more information about this option, see set_ttl.

Examples

use async_std::net::TcpStream;

let stream = TcpStream::connect("127.0.0.1:8080").await?;

stream.set_ttl(100)?;
assert_eq!(stream.ttl()?, 100);

pub fn set_ttl(&self, ttl: u32) -> Result<(), Error>

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 async_std::net::TcpStream;

let stream = TcpStream::connect("127.0.0.1:8080").await?;

stream.set_ttl(100)?;
assert_eq!(stream.ttl()?, 100);

pub async fn peek(&'_ self, buf: &'_ mut [u8]) -> Result<usize, Error>

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 async_std::net::TcpStream;

let stream = TcpStream::connect("127.0.0.1:8000").await?;

let mut buf = vec![0; 1024];
let n = stream.peek(&mut buf).await?;

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

Gets the value of the TCP_NODELAY option on this socket.

For more information about this option, see set_nodelay.

Examples

use async_std::net::TcpStream;

let stream = TcpStream::connect("127.0.0.1:8080").await?;

stream.set_nodelay(true)?;
assert_eq!(stream.nodelay()?, true);

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

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 async_std::net::TcpStream;

let stream = TcpStream::connect("127.0.0.1:8080").await?;

stream.set_nodelay(true)?;
assert_eq!(stream.nodelay()?, true);

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

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

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

Examples

use std::net::Shutdown;

use async_std::net::TcpStream;

let stream = TcpStream::connect("127.0.0.1:8080").await?;
stream.shutdown(Shutdown::Both)?;

Trait Implementations

impl AsRawFd for TcpStream

pub fn as_raw_fd(&self) -> i32

Extracts the raw file descriptor.

impl<'_> AsyncRead for &'_ TcpStream

pub fn poll_read(
    self: Pin<&mut &'_ TcpStream>,
    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 AsyncRead for TcpStream

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

Attempt to read from the AsyncRead into buf.

pub fn poll_read_vectored(
    self: Pin<&mut TcpStream>,
    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 &'_ TcpStream

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

Attempt to write bytes from buf into the object.

pub fn poll_flush(
    self: Pin<&mut &'_ TcpStream>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Error>>

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

pub fn poll_close(
    self: Pin<&mut &'_ TcpStream>,
    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 AsyncWrite for TcpStream

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

Attempt to write bytes from buf into the object.

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

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

pub fn poll_flush(
    self: Pin<&mut TcpStream>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Error>>

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

pub fn poll_close(
    self: Pin<&mut TcpStream>,
    cx: &mut Context<'_>
) -> Poll<Result<(), Error>>

Attempt to close the object.

impl Clone for TcpStream

pub fn clone(&self) -> TcpStream

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for TcpStream

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

Formats the value using the given formatter.

impl From<TcpStream> for TcpStream

pub fn from(stream: TcpStream) -> TcpStream

Converts a std::net::TcpStream into its asynchronous equivalent.

impl FromRawFd for TcpStream

pub unsafe fn from_raw_fd(fd: i32) -> TcpStream

Constructs a new instance of Self from the given raw file descriptor.

impl IntoRawFd for TcpStream

pub fn into_raw_fd(self) -> i32

Consumes this object, returning the raw underlying file descriptor.