[][src]Struct romio::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.

Methods

impl TcpStream[src]

pub fn connect(addr: &SocketAddr) -> ConnectFuture[src]

Create a new TCP stream connected to the specified address.

This function 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

#![feature(async_await, await_macro, futures_api)]
use romio::tcp::TcpStream;

let addr = "127.0.0.1".parse().unwrap();
await!(TcpStream::connect(&addr))

pub fn poll_read_ready(&self, waker: &Waker) -> Poll<Result<Ready>>[src]

Poll the TCP stream's readiness for reading.

If the stream is not ready for a read then the method will return Poll::Pending and schedule the current task for wakeup upon read-readiness.

Once the stream is ready for reading, it will remain so until all available bytes have been extracted (via futures::io::AsyncRead and related traits).

pub fn poll_write_ready(&self, waker: &Waker) -> Poll<Result<Ready>>[src]

Check the TCP stream's write readiness state.

This always checks for writable readiness and also checks for HUP readiness on platforms that support it.

If the resource is not ready for a write then Poll::Pending is returned and the current task is notified once a new event is received.

The I/O resource will remain in a write-ready state until calls to poll_write return NotReady.

Panics

This function panics if called from outside of a task context.

pub fn local_addr(&self) -> Result<SocketAddr>[src]

Returns the local address that this stream is bound to.

Examples

#![feature(async_await, await_macro, futures_api)]
use romio::tcp::TcpStream;
use std::net::{IpAddr, Ipv4Addr};

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

let expected = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1));
assert_eq!(stream.local_addr()?.ip(), expected);

pub fn peer_addr(&self) -> Result<SocketAddr>[src]

Returns the remote address that this stream is connected to.

Examples

#![feature(async_await, await_macro, futures_api)]
use romio::tcp::TcpStream;
use std::net::{Ipv4Addr, SocketAddr, SocketAddrV4};

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

let expected = SocketAddrV4::new(Ipv4Addr::new(127, 0, 0, 1), 8080);
assert_eq!(stream.peer_addr()?, SocketAddr::V4(expected));

pub fn shutdown(&self, how: Shutdown) -> Result<()>[src]

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

This function 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

#![feature(async_await, await_macro, futures_api)]
use romio::tcp::TcpStream;
use std::net::Shutdown;

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

stream.shutdown(Shutdown::Both)?;

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

Gets the value of the TCP_NODELAY option on this socket.

For more information about this option, see set_nodelay.

Examples

#![feature(async_await, await_macro, futures_api)]
use romio::tcp::TcpStream;

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

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

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

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

#![feature(async_await, await_macro, futures_api)]
use romio::tcp::TcpStream;

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

stream.set_nodelay(true)?;

pub fn recv_buffer_size(&self) -> Result<usize>[src]

Gets the value of the SO_RCVBUF option on this socket.

For more information about this option, see set_recv_buffer_size.

Examples

#![feature(async_await, await_macro, futures_api)]
use romio::tcp::TcpStream;

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

stream.set_recv_buffer_size(100);
assert_eq!(stream.recv_buffer_size()?, 100);

pub fn set_recv_buffer_size(&self, size: usize) -> Result<()>[src]

Sets the value of the SO_RCVBUF option on this socket.

Changes the size of the operating system's receive buffer associated with the socket.

Examples

#![feature(async_await, await_macro, futures_api)]
use romio::tcp::TcpStream;

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

stream.set_recv_buffer_size(100);

pub fn send_buffer_size(&self) -> Result<usize>[src]

Gets the value of the SO_SNDBUF option on this socket.

For more information about this option, see set_send_buffer.

Examples

#![feature(async_await, await_macro, futures_api)]
use romio::tcp::TcpStream;

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

stream.set_send_buffer_size(100);
assert_eq!(stream.send_buffer_size()?, 100);

pub fn set_send_buffer_size(&self, size: usize) -> Result<()>[src]

Sets the value of the SO_SNDBUF option on this socket.

Changes the size of the operating system's send buffer associated with the socket.

Examples

#![feature(async_await, await_macro, futures_api)]
use romio::tcp::TcpStream;

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

stream.set_send_buffer_size(100);

pub fn keepalive(&self) -> Result<Option<Duration>>[src]

Returns whether keepalive messages are enabled on this socket, and if so the duration of time between them.

For more information about this option, see set_keepalive.

Examples

#![feature(async_await, await_macro, futures_api)]
use romio::tcp::TcpStream;
use std::time::Duration;

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

stream.set_keepalive(Some(Duration::from_secs(60)))?;
assert_eq!(stream.keepalive()?, Some(Duration::from_secs(60)));

pub fn set_keepalive(&self, keepalive: Option<Duration>) -> Result<()>[src]

Sets whether keepalive messages are enabled to be sent on this socket.

On Unix, this option will set the SO_KEEPALIVE as well as the TCP_KEEPALIVE or TCP_KEEPIDLE option (depending on your platform). On Windows, this will set the SIO_KEEPALIVE_VALS option.

If None is specified then keepalive messages are disabled, otherwise the duration specified will be the time to remain idle before sending a TCP keepalive probe.

Some platforms specify this value in seconds, so sub-second specifications may be omitted.

Examples

#![feature(async_await, await_macro, futures_api)]
use romio::tcp::TcpStream;
use std::time::Duration;

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

stream.set_keepalive(Some(Duration::from_secs(60)))?;

pub fn ttl(&self) -> Result<u32>[src]

Gets the value of the IP_TTL option for this socket.

For more information about this option, see set_ttl.

Examples

#![feature(async_await, await_macro, futures_api)]
use romio::tcp::TcpStream;

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

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

pub fn set_ttl(&self, ttl: u32) -> Result<()>[src]

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

#![feature(async_await, await_macro, futures_api)]
use romio::tcp::TcpStream;

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

stream.set_ttl(100)?;

pub fn linger(&self) -> Result<Option<Duration>>[src]

Reads the linger duration for this socket by getting the SO_LINGER option.

For more information about this option, see set_linger.

Examples

#![feature(async_await, await_macro, futures_api)]
use romio::tcp::TcpStream;
use std::time::Duration;

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

stream.set_linger(Some(Duration::from_millis(100)))?;
assert_eq!(stream.linger()?, Some(Duration::from_millis(100)));

pub fn set_linger(&self, dur: Option<Duration>) -> Result<()>[src]

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

#![feature(async_await, await_macro, futures_api)]
use romio::tcp::TcpStream;
use std::time::Duration;

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

stream.set_linger(Some(Duration::from_millis(100)))?;

Trait Implementations

impl Debug for TcpStream[src]

impl AsyncWrite for TcpStream[src]

impl<'a> AsyncWrite for &'a TcpStream[src]

impl AsyncRead for TcpStream[src]

unsafe fn initializer(&self) -> Initializer[src]

Determines if this AsyncReader can work with buffers of uninitialized memory. Read more

impl<'a> AsyncRead for &'a TcpStream[src]

unsafe fn initializer(&self) -> Initializer[src]

Determines if this AsyncReader can work with buffers of uninitialized memory. Read more

Auto Trait Implementations

impl Send for TcpStream

impl Sync for TcpStream

Blanket Implementations

impl<T> From for T[src]

impl<T, U> Into for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom for T where
    U: Into<T>, 
[src]

type Error = !

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

impl<T> Borrow for T where
    T: ?Sized
[src]

impl<T> BorrowMut for T where
    T: ?Sized
[src]

impl<T, U> TryInto for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

🔬 This is a nightly-only experimental API. (try_from)

The type returned in the event of a conversion error.

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<W> AsyncWriteExt for W where
    W: AsyncWrite + ?Sized
[src]

fn flush(&mut self) -> Flush<Self>[src]

Creates a future which will entirely flush this AsyncWrite. Read more

fn close(&mut self) -> Close<Self>[src]

Creates a future which will entirely close this AsyncWrite.

fn write_all(&'a mut self, buf: &'a [u8]) -> WriteAll<'a, Self>[src]

Write data into this object. Read more

impl<R> AsyncReadExt for R where
    R: AsyncRead + ?Sized
[src]

fn copy_into<W>(&'a mut self, writer: &'a mut W) -> CopyInto<'a, Self, W> where
    W: AsyncWrite
[src]

Creates a future which copies all the bytes from one object to another. Read more

fn read(&'a mut self, buf: &'a mut [u8]) -> Read<'a, Self>[src]

Tries to read some bytes directly into the given buf in asynchronous manner, returning a future type. Read more

fn read_exact(&'a mut self, buf: &'a mut [u8]) -> ReadExact<'a, Self>[src]

Creates a future which will read exactly enough bytes to fill buf, returning an error if end of file (EOF) is hit sooner. Read more

fn read_to_end(&'a mut self, buf: &'a mut Vec<u8>) -> ReadToEnd<'a, Self>[src]

Creates a future which will read all the bytes from this AsyncRead. Read more

fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>) where
    Self: AsyncWrite
[src]

Helper method for splitting this read/write object into two halves. Read more

impl<T> Erased for T