Struct ConnectionEmbedded 

pub struct ConnectionEmbedded<T>
where
    T: Read + Write + ReadReady,
{ /* private fields */ }

Contains an instance of T with Read, Write and ReadReady. We implement Connection for this rather than T directly to avoid issues with conflicting implementations of external types T that could in future add Read, Write and ReadReady

Implementations

impl<T> ConnectionEmbedded<T>

where T: Read + Write + ReadReady,

pub fn new(inner: T) -> Self

Create a new adapter

pub fn into_inner(self) -> T

Consume the adapter, returning the inner object.

pub fn inner(&self) -> &T

Borrow the inner object.

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

Mutably borrow the inner object.

Trait Implementations

impl<T> Connection for ConnectionEmbedded<T>

where T: Read + Write + ReadReady,

async fn send(&mut self, buf: &[u8]) -> Result<(), PacketWriteError>

async fn receive(&mut self, buf: &mut [u8]) -> Result<(), PacketReadError>

async fn receive_if_ready( &mut self, buf: &mut [u8], ) -> Result<bool, PacketReadError>

If no data at all is ready, then return immediately with Ok(false), leaving the underlying stream and buf unaltered. If any data is ready then receive into buffer, waiting to fill it, then return Ok(true). Note that this method can still await data, because it is only required to return Ok(false) in the case where no data at all is ready. If less data is available than buf.len(), the method may still proceed, reading the available data and then waiting for more to fill buf. This is fairly well suited to MQTT packets - first call receive_if_ready with a buf of length 1 - if this returns Ok(false) then sleep for a reasonable interval and try again. If it returns Ok(true), continue reading a whole packet using receive, using larger buffers if possible. While this may lead to an indefinite await for the rest of the packet, this should only occur in the case of a malicious server or poor connection, not in the most common case where there is a long gap between incoming packets, but once the first byte of a packet is received the rest is received quickly afterwards. This approach is used to make it easier to use a variety of underlying streams, since we only need something like embedded-async’s ReadReady trait, or tokio’s TCPStream.try_read More sophisticated approaches are definitely possible.