[][src]Struct smol::Async

pub struct Async<T> { /* fields omitted */ }

Async adapter for I/O types.

This type puts an I/O handle into non-blocking mode, registers it in epoll/kqueue/event ports/wepoll, and then provides an async interface for it.

NOTE: Do not use this type with File, Stdin, Stdout, or Stderr because all of the supported operating systems have issues with them when put in non-blocking mode.

Examples

Connect to a server and echo incoming messages back to the server:

use async_io::Async;
use futures_lite::io;
use std::net::TcpStream;

// Connect to a local server.
let stream = Async::<TcpStream>::connect(([127, 0, 0, 1], 8000)).await?;

// Echo all messages from the read side of the stream into the write side.
io::copy(&stream, &stream).await?;

You can use either predefined async methods or wrap blocking I/O operations in Async::read_with(), Async::read_with_mut(), Async::write_with(), and Async::write_with_mut():

use async_io::Async;
use std::net::TcpListener;

let listener = Async::<TcpListener>::bind(([127, 0, 0, 1], 0))?;

// These two lines are equivalent:
let (stream, addr) = listener.accept().await?;
let (stream, addr) = listener.read_with(|inner| inner.accept()).await?;

Implementations

impl<T> Async<T> where
    T: AsRawFd
[src]

pub fn new(io: T) -> Result<Async<T>, Error>[src]

Creates an async I/O handle.

This function will put the handle in non-blocking mode and register it in epoll/kqueue/event ports/wepoll.

On Unix systems, the handle must implement AsRawFd, while on Windows it must implement AsRawSocket.

Examples

use async_io::Async;
use std::net::{SocketAddr, TcpListener};

let listener = TcpListener::bind(SocketAddr::from(([127, 0, 0, 1], 0)))?;
let listener = Async::new(listener)?;

impl<T> Async<T>[src]

pub fn get_ref(&self) -> &T

Notable traits for &'_ mut F

impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized
type Output = <F as Future>::Output;
[src]

Gets a reference to the inner I/O handle.

Examples

use async_io::Async;
use std::net::TcpListener;

let listener = Async::<TcpListener>::bind(([127, 0, 0, 1], 0))?;
let inner = listener.get_ref();

pub fn get_mut(&mut self) -> &mut T

Notable traits for &'_ mut F

impl<'_, F> Future for &'_ mut F where
    F: Unpin + Future + ?Sized
type Output = <F as Future>::Output;
[src]

Gets a mutable reference to the inner I/O handle.

Examples

use async_io::Async;
use std::net::TcpListener;

let mut listener = Async::<TcpListener>::bind(([127, 0, 0, 1], 0))?;
let inner = listener.get_mut();

pub fn into_inner(self) -> Result<T, Error>[src]

Unwraps the inner I/O handle.

This method will not put the I/O handle back into blocking mode.

Examples

use async_io::Async;
use std::net::TcpListener;

let listener = Async::<TcpListener>::bind(([127, 0, 0, 1], 0))?;
let inner = listener.into_inner()?;

// Put the listener back into blocking mode.
inner.set_nonblocking(false)?;

pub async fn readable(&'_ self) -> Result<(), Error>[src]

Waits until the I/O handle is readable.

This function completes when a read operation on this I/O handle wouldn't block.

Examples

use async_io::Async;
use std::net::TcpListener;

let mut listener = Async::<TcpListener>::bind(([127, 0, 0, 1], 0))?;

// Wait until a client can be accepted.
listener.readable().await?;

pub async fn writable(&'_ self) -> Result<(), Error>[src]

Waits until the I/O handle is writable.

This function completes when a write operation on this I/O handle wouldn't block.

Examples

use async_io::Async;
use std::net::{TcpStream, ToSocketAddrs};

let addr = "example.com:80".to_socket_addrs()?.next().unwrap();
let stream = Async::<TcpStream>::connect(addr).await?;

// Wait until the stream is writable.
stream.writable().await?;

pub async fn read_with<R>(
    &'_ self,
    op: impl FnMut(&T) -> Result<R, Error>
) -> Result<R, Error>
[src]

Performs a read operation asynchronously.

The I/O handle is registered in the reactor and put in non-blocking mode. This function invokes the op closure in a loop until it succeeds or returns an error other than io::ErrorKind::WouldBlock. In between iterations of the loop, it waits until the OS sends a notification that the I/O handle is readable.

The closure receives a shared reference to the I/O handle.

Examples

use async_io::Async;
use std::net::TcpListener;

let listener = Async::<TcpListener>::bind(([127, 0, 0, 1], 0))?;

// Accept a new client asynchronously.
let (stream, addr) = listener.read_with(|l| l.accept()).await?;

pub async fn read_with_mut<R>(
    &'_ mut self,
    op: impl FnMut(&mut T) -> Result<R, Error>
) -> Result<R, Error>
[src]

Performs a read operation asynchronously.

The I/O handle is registered in the reactor and put in non-blocking mode. This function invokes the op closure in a loop until it succeeds or returns an error other than io::ErrorKind::WouldBlock. In between iterations of the loop, it waits until the OS sends a notification that the I/O handle is readable.

The closure receives a mutable reference to the I/O handle.

Examples

use async_io::Async;
use std::net::TcpListener;

let mut listener = Async::<TcpListener>::bind(([127, 0, 0, 1], 0))?;

// Accept a new client asynchronously.
let (stream, addr) = listener.read_with_mut(|l| l.accept()).await?;

pub async fn write_with<R>(
    &'_ self,
    op: impl FnMut(&T) -> Result<R, Error>
) -> Result<R, Error>
[src]

Performs a write operation asynchronously.

The I/O handle is registered in the reactor and put in non-blocking mode. This function invokes the op closure in a loop until it succeeds or returns an error other than io::ErrorKind::WouldBlock. In between iterations of the loop, it waits until the OS sends a notification that the I/O handle is writable.

The closure receives a shared reference to the I/O handle.

Examples

use async_io::Async;
use std::net::UdpSocket;

let socket = Async::<UdpSocket>::bind(([127, 0, 0, 1], 8000))?;
socket.get_ref().connect("127.0.0.1:9000")?;

let msg = b"hello";
let len = socket.write_with(|s| s.send(msg)).await?;

pub async fn write_with_mut<R>(
    &'_ mut self,
    op: impl FnMut(&mut T) -> Result<R, Error>
) -> Result<R, Error>
[src]

Performs a write operation asynchronously.

The I/O handle is registered in the reactor and put in non-blocking mode. This function invokes the op closure in a loop until it succeeds or returns an error other than io::ErrorKind::WouldBlock. In between iterations of the loop, it waits until the OS sends a notification that the I/O handle is writable.

The closure receives a mutable reference to the I/O handle.

Examples

use async_io::Async;
use std::net::UdpSocket;

let mut socket = Async::<UdpSocket>::bind(([127, 0, 0, 1], 8000))?;
socket.get_ref().connect("127.0.0.1:9000")?;

let msg = b"hello";
let len = socket.write_with_mut(|s| s.send(msg)).await?;

impl Async<TcpListener>[src]

pub fn bind<A>(addr: A) -> Result<Async<TcpListener>, Error> where
    A: Into<SocketAddr>, 
[src]

Creates a TCP listener bound to the specified address.

Binding with port number 0 will request an available port from the OS.

Examples

use async_io::Async;
use std::net::TcpListener;

let listener = Async::<TcpListener>::bind(([127, 0, 0, 1], 0))?;
println!("Listening on {}", listener.get_ref().local_addr()?);

pub async fn accept(&'_ self) -> Result<(Async<TcpStream>, SocketAddr), Error>[src]

Accepts a new incoming TCP connection.

When a connection is established, it will be returned as a TCP stream together with its remote address.

Examples

use async_io::Async;
use std::net::TcpListener;

let listener = Async::<TcpListener>::bind(([127, 0, 0, 1], 8000))?;
let (stream, addr) = listener.accept().await?;
println!("Accepted client: {}", addr);

pub fn incoming(
    &self
) -> impl Send + Stream<Item = Result<Async<TcpStream>, Error>>
[src]

Returns a stream of incoming TCP connections.

The stream is infinite, i.e. it never stops with a None.

Examples

use async_io::Async;
use futures_lite::{pin, stream::StreamExt};
use std::net::TcpListener;

let listener = Async::<TcpListener>::bind(([127, 0, 0, 1], 8000))?;
let incoming = listener.incoming();
pin!(incoming);

while let Some(stream) = incoming.next().await {
    let stream = stream?;
    println!("Accepted client: {}", stream.get_ref().peer_addr()?);
}

impl Async<TcpStream>[src]

pub async fn connect<A>(addr: A) -> Result<Async<TcpStream>, Error> where
    A: Into<SocketAddr>, 
[src]

Creates a TCP connection to the specified address.

Examples

use async_io::Async;
use std::net::{TcpStream, ToSocketAddrs};

let addr = "example.com:80".to_socket_addrs()?.next().unwrap();
let stream = Async::<TcpStream>::connect(addr).await?;

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

Reads data from the stream without removing it from the buffer.

Returns the number of bytes read. Successive calls of this method read the same data.

Examples

use async_io::Async;
use futures_lite::{io::AsyncWriteExt, stream::StreamExt};
use std::net::{TcpStream, ToSocketAddrs};

let addr = "example.com:80".to_socket_addrs()?.next().unwrap();
let mut stream = Async::<TcpStream>::connect(addr).await?;

stream
    .write_all(b"GET / HTTP/1.1\r\nHost: example.com\r\n\r\n")
    .await?;

let mut buf = [0u8; 1024];
let len = stream.peek(&mut buf).await?;

impl Async<UdpSocket>[src]

pub fn bind<A>(addr: A) -> Result<Async<UdpSocket>, Error> where
    A: Into<SocketAddr>, 
[src]

Creates a UDP socket bound to the specified address.

Binding with port number 0 will request an available port from the OS.

Examples

use async_io::Async;
use std::net::UdpSocket;

let socket = Async::<UdpSocket>::bind(([127, 0, 0, 1], 0))?;
println!("Bound to {}", socket.get_ref().local_addr()?);

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

Receives a single datagram message.

Returns the number of bytes read and the address the message came from.

This method must be called with a valid byte slice of sufficient size to hold the message. If the message is too long to fit, excess bytes may get discarded.

Examples

use async_io::Async;
use std::net::UdpSocket;

let socket = Async::<UdpSocket>::bind(([127, 0, 0, 1], 8000))?;

let mut buf = [0u8; 1024];
let (len, addr) = socket.recv_from(&mut buf).await?;

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

Receives a single datagram message without removing it from the queue.

Returns the number of bytes read and the address the message came from.

This method must be called with a valid byte slice of sufficient size to hold the message. If the message is too long to fit, excess bytes may get discarded.

Examples

use async_io::Async;
use std::net::UdpSocket;

let socket = Async::<UdpSocket>::bind(([127, 0, 0, 1], 8000))?;

let mut buf = [0u8; 1024];
let (len, addr) = socket.peek_from(&mut buf).await?;

pub async fn send_to<A>(
    &'_ self,
    buf: &'_ [u8],
    addr: A
) -> Result<usize, Error> where
    A: Into<SocketAddr>, 
[src]

Sends data to the specified address.

Returns the number of bytes writen.

Examples

use async_io::Async;
use std::net::UdpSocket;

let socket = Async::<UdpSocket>::bind(([127, 0, 0, 1], 0))?;
let addr = socket.get_ref().local_addr()?;

let msg = b"hello";
let len = socket.send_to(msg, addr).await?;

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

Receives a single datagram message from the connected peer.

Returns the number of bytes read.

This method must be called with a valid byte slice of sufficient size to hold the message. If the message is too long to fit, excess bytes may get discarded.

The connect method connects this socket to a remote address. This method will fail if the socket is not connected.

Examples

use async_io::Async;
use std::net::UdpSocket;

let socket = Async::<UdpSocket>::bind(([127, 0, 0, 1], 8000))?;
socket.get_ref().connect("127.0.0.1:9000")?;

let mut buf = [0u8; 1024];
let len = socket.recv(&mut buf).await?;

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

Receives a single datagram message from the connected peer without removing it from the queue.

Returns the number of bytes read and the address the message came from.

This method must be called with a valid byte slice of sufficient size to hold the message. If the message is too long to fit, excess bytes may get discarded.

The connect method connects this socket to a remote address. This method will fail if the socket is not connected.

Examples

use async_io::Async;
use std::net::UdpSocket;

let socket = Async::<UdpSocket>::bind(([127, 0, 0, 1], 8000))?;
socket.get_ref().connect("127.0.0.1:9000")?;

let mut buf = [0u8; 1024];
let len = socket.peek(&mut buf).await?;

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

Sends data to the connected peer.

Returns the number of bytes written.

The connect method connects this socket to a remote address. This method will fail if the socket is not connected.

Examples

use async_io::Async;
use std::net::UdpSocket;

let socket = Async::<UdpSocket>::bind(([127, 0, 0, 1], 8000))?;
socket.get_ref().connect("127.0.0.1:9000")?;

let msg = b"hello";
let len = socket.send(msg).await?;

impl Async<UnixListener>[src]

pub fn bind<P>(path: P) -> Result<Async<UnixListener>, Error> where
    P: AsRef<Path>, 
[src]

Creates a UDS listener bound to the specified path.

Examples

use async_io::Async;
use std::os::unix::net::UnixListener;

let listener = Async::<UnixListener>::bind("/tmp/socket")?;
println!("Listening on {:?}", listener.get_ref().local_addr()?);

pub async fn accept(&'_ self) -> Result<(Async<UnixStream>, SocketAddr), Error>[src]

Accepts a new incoming UDS stream connection.

When a connection is established, it will be returned as a stream together with its remote address.

Examples

use async_io::Async;
use std::os::unix::net::UnixListener;

let listener = Async::<UnixListener>::bind("/tmp/socket")?;
let (stream, addr) = listener.accept().await?;
println!("Accepted client: {:?}", addr);

pub fn incoming(
    &self
) -> impl Send + Stream<Item = Result<Async<UnixStream>, Error>>
[src]

Returns a stream of incoming UDS connections.

The stream is infinite, i.e. it never stops with a None item.

Examples

use async_io::Async;
use futures_lite::{pin, stream::StreamExt};
use std::os::unix::net::UnixListener;

let listener = Async::<UnixListener>::bind("/tmp/socket")?;
let incoming = listener.incoming();
pin!(incoming);

while let Some(stream) = incoming.next().await {
    let stream = stream?;
    println!("Accepted client: {:?}", stream.get_ref().peer_addr()?);
}

impl Async<UnixStream>[src]

pub async fn connect<P>(path: P) -> Result<Async<UnixStream>, Error> where
    P: AsRef<Path>, 
[src]

Creates a UDS stream connected to the specified path.

Examples

use async_io::Async;
use std::os::unix::net::UnixStream;

let stream = Async::<UnixStream>::connect("/tmp/socket").await?;

pub fn pair() -> Result<(Async<UnixStream>, Async<UnixStream>), Error>[src]

Creates an unnamed pair of connected UDS stream sockets.

Examples

use async_io::Async;
use std::os::unix::net::UnixStream;

let (stream1, stream2) = Async::<UnixStream>::pair()?;

impl Async<UnixDatagram>[src]

pub fn bind<P>(path: P) -> Result<Async<UnixDatagram>, Error> where
    P: AsRef<Path>, 
[src]

Creates a UDS datagram socket bound to the specified path.

Examples

use async_io::Async;
use std::os::unix::net::UnixDatagram;

let socket = Async::<UnixDatagram>::bind("/tmp/socket")?;

pub fn unbound() -> Result<Async<UnixDatagram>, Error>[src]

Creates a UDS datagram socket not bound to any address.

Examples

use async_io::Async;
use std::os::unix::net::UnixDatagram;

let socket = Async::<UnixDatagram>::unbound()?;

pub fn pair() -> Result<(Async<UnixDatagram>, Async<UnixDatagram>), Error>[src]

Creates an unnamed pair of connected Unix datagram sockets.

Examples

use async_io::Async;
use std::os::unix::net::UnixDatagram;

let (socket1, socket2) = Async::<UnixDatagram>::pair()?;

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

Receives data from the socket.

Returns the number of bytes read and the address the message came from.

Examples

use async_io::Async;
use std::os::unix::net::UnixDatagram;

let socket = Async::<UnixDatagram>::bind("/tmp/socket")?;

let mut buf = [0u8; 1024];
let (len, addr) = socket.recv_from(&mut buf).await?;

pub async fn send_to<P>(
    &'_ self,
    buf: &'_ [u8],
    path: P
) -> Result<usize, Error> where
    P: AsRef<Path>, 
[src]

Sends data to the specified address.

Returns the number of bytes written.

Examples

use async_io::Async;
use std::os::unix::net::UnixDatagram;

let socket = Async::<UnixDatagram>::unbound()?;

let msg = b"hello";
let addr = "/tmp/socket";
let len = socket.send_to(msg, addr).await?;

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

Receives data from the connected peer.

Returns the number of bytes read and the address the message came from.

The connect method connects this socket to a remote address. This method will fail if the socket is not connected.

Examples

use async_io::Async;
use std::os::unix::net::UnixDatagram;

let socket = Async::<UnixDatagram>::bind("/tmp/socket1")?;
socket.get_ref().connect("/tmp/socket2")?;

let mut buf = [0u8; 1024];
let len = socket.recv(&mut buf).await?;

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

Sends data to the connected peer.

Returns the number of bytes written.

The connect method connects this socket to a remote address. This method will fail if the socket is not connected.

Examples

use async_io::Async;
use std::os::unix::net::UnixDatagram;

let socket = Async::<UnixDatagram>::bind("/tmp/socket1")?;
socket.get_ref().connect("/tmp/socket2")?;

let msg = b"hello";
let len = socket.send(msg).await?;

Trait Implementations

impl<T> AsRawFd for Async<T> where
    T: AsRawFd
[src]

impl<'_, T> AsyncRead for &'_ Async<T> where
    &'a T: for<'a> Read
[src]

impl<T> AsyncRead for Async<T> where
    T: Read
[src]

impl<T> AsyncWrite for Async<T> where
    T: Write
[src]

impl<'_, T> AsyncWrite for &'_ Async<T> where
    &'a T: for<'a> Write
[src]

impl<T> Debug for Async<T> where
    T: Debug
[src]

impl<T> Drop for Async<T>[src]

impl From<Async<TcpListener>> for TcpListener[src]

impl From<Async<TcpStream>> for TcpStream[src]

impl From<Async<UdpSocket>> for UdpSocket[src]

impl From<Async<UnixDatagram>> for UnixDatagram[src]

impl From<Async<UnixListener>> for UnixListener[src]

impl From<Async<UnixStream>> for UnixStream[src]

impl TryFrom<TcpListener> for Async<TcpListener>[src]

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<TcpStream> for Async<TcpStream>[src]

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<UdpSocket> for Async<UdpSocket>[src]

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<UnixDatagram> for Async<UnixDatagram>[src]

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<UnixListener> for Async<UnixListener>[src]

type Error = Error

The type returned in the event of a conversion error.

impl TryFrom<UnixStream> for Async<UnixStream>[src]

type Error = Error

The type returned in the event of a conversion error.

impl<T> Unpin for Async<T>[src]

Auto Trait Implementations

impl<T> RefUnwindSafe for Async<T> where
    T: RefUnwindSafe

impl<T> Send for Async<T> where
    T: Send

impl<T> Sync for Async<T> where
    T: Sync

impl<T> UnwindSafe for Async<T> where
    T: UnwindSafe

Blanket Implementations

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

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

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

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

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

impl<T> From<T> for T[src]

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

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

type Error = Infallible

The type returned in the event of a conversion error.

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

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

The type returned in the event of a conversion error.