[−][src]Struct runtime::net::TcpStream
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.
Examples
#![feature(async_await, await_macro, futures_api)] use futures::prelude::*; use runtime::net::TcpStream; #[runtime::main] async fn main() -> Result<(), failure::Error> { let mut stream = await!(TcpStream::connect("127.0.0.1:8080"))?; println!("Connected to {}", &stream.peer_addr()?); let msg = "hello world"; println!("<- {}", msg); await!(stream.write_all(msg.as_bytes()))?; let mut buf = vec![0u8; 1024]; await!(stream.read(&mut buf))?; println!("-> {}\n", std::str::from_utf8(&mut buf)?); Ok(()) }
Methods
impl TcpStream
[src]
ⓘImportant traits for Connectpub fn connect<A: ToSocketAddrs>(addr: A) -> Connect
[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 runtime::net::TcpStream; let stream = await!(TcpStream::connect("127.0.0.1:0"))?;
pub fn local_addr(&self) -> Result<SocketAddr>
[src]
Returns the local address that this stream is connected to.
Examples
#![feature(async_await, await_macro, futures_api)] use runtime::net::TcpStream; use std::net::{IpAddr, Ipv4Addr}; let stream = await!(TcpStream::connect("127.0.0.1:8080"))?; 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 runtime::net::TcpStream; use std::net::{IpAddr, Ipv4Addr}; let stream = await!(TcpStream::connect("127.0.0.1:8080"))?; let expected = IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)); assert_eq!(stream.peer_addr()?.ip(), 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 std::net::Shutdown; use runtime::net::TcpStream; let stream = await!(TcpStream::connect("127.0.0.1:8080"))?; stream.shutdown(Shutdown::Both)?;
Trait Implementations
impl Debug for TcpStream
[src]
impl AsRawFd for TcpStream
[src]
impl AsyncRead for TcpStream
[src]
fn poll_read(
self: Pin<&mut Self>,
cx: &mut Context,
buf: &mut [u8]
) -> Poll<Result<usize>>
[src]
self: Pin<&mut Self>,
cx: &mut Context,
buf: &mut [u8]
) -> Poll<Result<usize>>
fn poll_vectored_read(
self: Pin<&mut Self>,
cx: &mut Context,
vec: &mut [&mut IoVec]
) -> Poll<Result<usize>>
[src]
self: Pin<&mut Self>,
cx: &mut Context,
vec: &mut [&mut IoVec]
) -> Poll<Result<usize>>
unsafe default fn initializer(&self) -> Initializer
[src]
Determines if this AsyncRead
er can work with buffers of uninitialized memory. Read more
impl AsyncWrite for TcpStream
[src]
fn poll_write(
self: Pin<&mut Self>,
cx: &mut Context,
buf: &[u8]
) -> Poll<Result<usize>>
[src]
self: Pin<&mut Self>,
cx: &mut Context,
buf: &[u8]
) -> Poll<Result<usize>>
fn poll_flush(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<()>>
[src]
fn poll_close(self: Pin<&mut Self>, cx: &mut Context) -> Poll<Result<()>>
[src]
fn poll_vectored_write(
self: Pin<&mut Self>,
cx: &mut Context,
vec: &[&IoVec]
) -> Poll<Result<usize>>
[src]
self: Pin<&mut Self>,
cx: &mut Context,
vec: &[&IoVec]
) -> Poll<Result<usize>>
Auto Trait Implementations
Blanket Implementations
impl<T> From for T
[src]
impl<T, U> Into for T where
U: From<T>,
[src]
U: From<T>,
impl<T, U> TryFrom for T where
U: Into<T>,
[src]
U: Into<T>,
type Error = Infallible
The type returned in the event of a conversion error.
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>
[src]
impl<T> Borrow for T where
T: ?Sized,
[src]
T: ?Sized,
impl<T> BorrowMut for T where
T: ?Sized,
[src]
T: ?Sized,
fn borrow_mut(&mut self) -> &mut T
[src]
impl<T, U> TryInto for T where
U: TryFrom<T>,
[src]
U: TryFrom<T>,
type Error = <U as TryFrom<T>>::Error
The type returned in the event of a conversion error.
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>
[src]
impl<T> Any for T where
T: 'static + ?Sized,
[src]
T: 'static + ?Sized,
impl<R> AsyncReadExt for R where
R: AsyncRead + ?Sized,
[src]
R: AsyncRead + ?Sized,
default fn copy_into<W>(
&'a mut self,
writer: &'a mut W
) -> CopyInto<'a, Self, W> where
Self: Unpin,
W: AsyncWrite + Unpin,
[src]
&'a mut self,
writer: &'a mut W
) -> CopyInto<'a, Self, W> where
Self: Unpin,
W: AsyncWrite + Unpin,
Creates a future which copies all the bytes from one object to another. Read more
default fn read(&'a mut self, buf: &'a mut [u8]) -> Read<'a, Self> where
Self: Unpin,
[src]
Self: Unpin,
Tries to read some bytes directly into the given buf
in asynchronous manner, returning a future type. Read more
default fn read_exact(&'a mut self, buf: &'a mut [u8]) -> ReadExact<'a, Self> where
Self: Unpin,
[src]
Self: Unpin,
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
default fn read_to_end(
&'a mut self,
buf: &'a mut Vec<u8>
) -> ReadToEnd<'a, Self> where
Self: Unpin,
[src]
&'a mut self,
buf: &'a mut Vec<u8>
) -> ReadToEnd<'a, Self> where
Self: Unpin,
Creates a future which will read all the bytes from this AsyncRead
. Read more
default fn split(self) -> (ReadHalf<Self>, WriteHalf<Self>) where
Self: AsyncWrite,
[src]
Self: AsyncWrite,
Helper method for splitting this read/write object into two halves. Read more
default fn compat(self) -> Compat<Self> where
Self: Unpin,
[src]
Self: Unpin,
Wraps an [AsyncRead
] in a compatibility wrapper that allows it to be used as a futures 0.1 / tokio-io 0.1 AsyncRead
. If the wrapped type implements [AsyncWrite
] as well, the result will also implement the futures 0.1 / tokio 0.1 AsyncWrite
trait. Read more
impl<W> AsyncWriteExt for W where
W: AsyncWrite + ?Sized,
[src]
W: AsyncWrite + ?Sized,
default fn flush(&mut self) -> Flush<Self> where
Self: Unpin,
[src]
Self: Unpin,
Creates a future which will entirely flush this AsyncWrite
. Read more
default fn close(&mut self) -> Close<Self> where
Self: Unpin,
[src]
Self: Unpin,
Creates a future which will entirely close this AsyncWrite
.
default fn write_all(&'a mut self, buf: &'a [u8]) -> WriteAll<'a, Self> where
Self: Unpin,
[src]
Self: Unpin,
Write data into this object. Read more
default fn compat_write(self) -> Compat<Self> where
Self: Unpin,
[src]
Self: Unpin,
Wraps an [AsyncWrite
] in a compatibility wrapper that allows it to be used as a futures 0.1 / tokio-io 0.1 AsyncWrite
. Requires the io-compat
feature to enable. Read more