Struct BdxWriter 

pub struct BdxWriter<'a, 'b> { /* private fields */ }

A writer over a BDX transfer - the Sender side.

Obtained from Exchange::upload on the initiating side, or from BdxDownloadResponder::reply on the responding side. write stages and sends the data, driving the protocol as needed; finish flushes the final block and completes the transfer. It also implements embedded_io_async::Write (delegating to the inherent write).

The caller supplies the staging buffer buf, which doubles as the upper bound on the block size (so there is no hidden, MCU-unfriendly internal allocation). It must be non-empty.

Implementations

impl<'a, 'b> BdxWriter<'a, 'b>

pub async fn write(&mut self, data: &[u8]) -> Result<usize, Error>

Stage and send data, returning the number of bytes accepted (< data.len() only when the current block fills; call again with the remainder).

This is also the embedded_io_async::Write implementation; the inherent method is kept so callers need not import the trait.

pub fn max_block_size(&self) -> usize

The largest block this writer will send (and the length of the buffer returned by block_buf).

pub fn block_buf(&mut self) -> &mut [u8]

The writer’s own staging buffer (exactly max_block_size bytes), to be filled in place and then sent with commit.

This is the zero-extra-buffer alternative to write: a caller streaming from another source (a flash region, a socket) can read straight into this slice instead of into its own buffer and copying. Do not interleave it with write, which stages into the same space.

pub async fn commit(&mut self, len: usize) -> Result<(), Error>

Send len bytes - previously written into block_buf - as one block. len must not exceed max_block_size.

pub async fn finish(self) -> Result<(), Error>

Flush the final (possibly empty) block and complete the transfer.

Trait Implementations

impl ErrorType for BdxWriter<'_, '_>

type Error = Error

Error type of all the IO operations on this type.

impl Write for BdxWriter<'_, '_>

async fn flush(&mut self) -> Result<(), <BdxWriter<'_, '_> as ErrorType>::Error>

Send any staged-but-unsent bytes as a (non-final) block.

async fn write( &mut self, data: &[u8], ) -> Result<usize, <BdxWriter<'_, '_> as ErrorType>::Error>

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

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

Write an entire buffer into this writer.