Struct WithTimeout 

pub struct WithTimeout<T>(/* private fields */);

Re-export the edge-nal crate A type that wraps an IO stream type and adds a timeout to all operations.

The operations decorated with a timeout are the ones offered via the following traits:

• embedded_io_async::Read
• embedded_io_async::Write
• Readable
• TcpConnect
• TcpShutdown

Additionally, wrapping with WithTimeout an IO type that implements TcpAccept will result in a TcpAccept implementation that - while waiting potentially indefinitely for an incoming connection - will return a connected socket readily wrapped with a timeout.

Implementations

impl<T> WithTimeout<T>

pub const fn new(timeout_ms: u32, io: T) -> WithTimeout<T>

Create a new WithTimeout instance.

Parameters:

• timeout_ms: The timeout duration in milliseconds
• io: The IO type to add a timeout to

pub fn io(&self) -> &T

Get a reference to the inner IO type.

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

Get a mutable reference to the inner IO type.

pub fn timeout_ms(&self) -> u32

Get the timeout duration in milliseconds.

pub fn into_io(self) -> T

Get the IO type by destructuring the WithTimeout instance.

Trait Implementations

impl<T> ErrorType for WithTimeout<T>

where T: ErrorType,

type Error = WithTimeoutError<<T as ErrorType>::Error>

Error type of all the IO operations on this type.

impl<T> Read for WithTimeout<T>

where T: Read,

async fn read( &mut self, buf: &mut [u8], ) -> Result<usize, <WithTimeout<T> as ErrorType>::Error>

Read some bytes from this source into the specified buffer, returning how many bytes were read.

async fn read_exact( &mut self, buf: &mut [u8], ) -> Result<(), ReadExactError<Self::Error>>

Read the exact number of bytes required to fill buf.

impl<T> Readable for WithTimeout<T>

where T: Readable,

async fn readable(&mut self) -> Result<(), <WithTimeout<T> as ErrorType>::Error>

impl<T> TcpAccept for WithTimeout<T>

where T: TcpAccept,

type Error = WithTimeoutError<<T as TcpAccept>::Error>

Error type returned on socket creation failure

type Socket<'a> = WithTimeout<<T as TcpAccept>::Socket<'a>> where WithTimeout<T>: 'a

The socket type returned by the factory

async fn accept( &self, ) -> Result<(SocketAddr, <WithTimeout<T> as TcpAccept>::Socket<'_>), <WithTimeout<T> as TcpAccept>::Error>

Accepts an incoming connection Returns the socket address of the remote peer, as well as the accepted socket.

impl<T> TcpConnect for WithTimeout<T>

where T: TcpConnect,

type Error = WithTimeoutError<<T as TcpConnect>::Error>

Error type returned on socket creation failure

type Socket<'a> = WithTimeout<<T as TcpConnect>::Socket<'a>> where WithTimeout<T>: 'a

The socket type returned by the factory

async fn connect( &self, remote: SocketAddr, ) -> Result<<WithTimeout<T> as TcpConnect>::Socket<'_>, <WithTimeout<T> as TcpConnect>::Error>

Connect to a remote socket

impl<T> TcpShutdown for WithTimeout<T>

where T: TcpShutdown,

async fn close( &mut self, what: Close, ) -> Result<(), <WithTimeout<T> as ErrorType>::Error>

Gracefully shutdown either or both the read and write halves of the socket.

async fn abort(&mut self) -> Result<(), <WithTimeout<T> as ErrorType>::Error>

Abort the connection, sending an RST packet to the peer

impl<T> TcpSplit for WithTimeout<T>

where T: TcpSplit,

type Read<'a> = WithTimeout<<T as TcpSplit>::Read<'a>> where WithTimeout<T>: 'a

type Write<'a> = WithTimeout<<T as TcpSplit>::Write<'a>> where WithTimeout<T>: 'a

fn split( &mut self, ) -> (<WithTimeout<T> as TcpSplit>::Read<'_>, <WithTimeout<T> as TcpSplit>::Write<'_>)

impl<T> Write for WithTimeout<T>

where T: Write,

async fn write( &mut self, buf: &[u8], ) -> Result<usize, <WithTimeout<T> as ErrorType>::Error>

Write a buffer into this writer, returning how many bytes were written.

async fn flush(&mut self) -> Result<(), <WithTimeout<T> as ErrorType>::Error>

Flush this output stream, ensuring that all intermediately buffered contents reach their destination.

async fn write_all(&mut self, buf: &[u8]) -> Result<(), Self::Error>

Write an entire buffer into this writer.