Struct AsyncWriter 

pub struct AsyncWriter<W> { /* private fields */ }

Wraps an AsyncWrite and writes length-delimited CBOR values.

Requires cargo feature "async-io".

Implementations

impl<W> AsyncWriter<W>

pub fn new(writer: W) -> Self

Create a new writer with a max. buffer size of 512KiB.

pub fn with_buffer(writer: W, buffer: Vec<u8>) -> Self

Create a new writer with a max. buffer size of 512KiB.

pub fn set_max_len(&mut self, val: u32)

Set the max. buffer size in bytes.

If length values greater than this are encoded, an Error::InvalidLen will be returned.

pub fn buffer(&self) -> &Vec<u8>

Get a reference to the inner buffer.

pub fn buffer_mut(&mut self) -> &mut Vec<u8>

Get a mutable reference to the inner buffer.

pub fn writer(&self) -> &W

Get a reference to the inner writer.

pub fn writer_mut(&mut self) -> &mut W

Get a mutable reference to the inner writer.

pub fn into_parts(self) -> (W, Vec<u8>)

Deconstruct this writer into the inner writer and the buffer.

impl<W: AsyncWrite + Unpin> AsyncWriter<W>

pub async fn write<T: Encode<()>>(&mut self, val: T) -> Result<usize, Error>

Encode and write a CBOR value and return its size in bytes.

The value will be preceded by a u32 (4 bytes in network byte order), denoting the length of bytes constituting the serialised value.

Cancellation

If the future returned by AsyncWriter::write is dropped while still pending, subsequent calls to AsyncWriter::write will discard any buffered data and instead encode, buffer and commit the new value. Cancelling a future thus cancels the transfer. However, it is also possible to resume the transfer by calling AsyncWriter::sync after cancellation, which is normally called implicitly by this method.

pub async fn write_with<C, T: Encode<C>>( &mut self, val: T, ctx: &mut C, ) -> Result<usize, Error>

Like AsyncWriter::write but accepting a user provided encoding context.

pub async fn sync(&mut self) -> Result<(), Error>

Commit any buffered data to the inner AsyncWrite.

This method is implicitly called by AsyncWriter::write. The only reason to call it explicitly is to resume the write operation started by a previously unfinished, i.e. cancelled, AsyncWriter::write call.

pub async fn flush(&mut self) -> Result<(), Error>

Flush the inner AsyncWrite.

Trait Implementations

impl<W: Debug> Debug for AsyncWriter<W>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.