Struct kernel::utilities::binary_write::WriteToBinaryOffsetWrapper

pub struct WriteToBinaryOffsetWrapper<'a> { /* private fields */ }

Wrapper to convert a binary buffer writer to provide a core::fmt::Write interface with offset tracking. This allows a synchronous writer to use an underlying asynchronous write implementation.

This struct allows a synchronous writer to use the core::fmt::Write interface when there is a limited size buffer underneath. This struct tracks where in the overall write has actually been written to the underlying BinaryWrite implementation.

The expected usage of this tool looks like:

let wrapper = WriteToBinaryOffsetWrapper::new(binary_writer);

// Set the byte index of the long, synchronous write where we should
// actually start passing to the binary writer.
wrapper.set_offset(offset);

// Do the long, synchronous write.
let _ = wrapper.write_fmt(format_args!(...));

if wrapper.bytes_remaining() {
    // Some of the write did not finish (likely that means the binary
    // writer's buffer filled up).
    let next_offset = wrapper.get_index();

    // Now wait for the binary write to finish, and start this process
    // over but from the new offset.
} else {
    // Nothing left to print, we're done!
}

Implementations

impl<'a> WriteToBinaryOffsetWrapper<'a>

pub fn new( binary_writer: &'a mut dyn BinaryWrite, ) -> WriteToBinaryOffsetWrapper<'_>

pub fn set_offset(&mut self, offset: usize)

Set the byte to start printing from on this iteration. Call this before calling Write.

pub fn get_index(&self) -> usize

After printing, get the index we left off on to use as the offset for the next iteration.

pub fn bytes_remaining(&self) -> bool

After printing, check if there is more to print that the binary_writer did not print.

Trait Implementations

impl<'a> Write for WriteToBinaryOffsetWrapper<'a>

fn write_str(&mut self, s: &str) -> Result

Writes a string slice into this writer, returning whether the write succeeded.

fn write_char(&mut self, c: char) -> Result<(), Error>

Writes a char into this writer, returning whether the write succeeded.

fn write_fmt(&mut self, args: Arguments<'_>) -> Result<(), Error>

Glue for usage of the write! macro with implementors of this trait.