Struct BufSink 

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

A fixed-capacity output sink wrapping a borrowed &mut [u8].

Writes are UTF-8 bytes; on overflow the excess is dropped and BufSink::overflowed returns true (the buffer is never written past its end). BufSink::as_str returns the bytes written so far.

Implementations

impl<'a> BufSink<'a>

pub fn new(buf: &'a mut [u8]) -> BufSink<'a>

Wrap a byte buffer as an output sink.

Examples found in repository

examples/disasm.rs (line 55)

fn emit_word<W: Write>(token: &str, out: &mut W) -> io::Result<()> {
    let token = token.trim();
    if token.is_empty() {
        return Ok(());
    }
    // Accept an optional `0x` prefix and surrounding whitespace.
    let hex = token.trim_start_matches("0x").trim_start_matches("0X");
    let word = match u32::from_str_radix(hex, 16) {
        Ok(w) => w,
        Err(_) => {
            writeln!(out, "{token}\t<invalid hex>")?;
            return Ok(());
        }
    };

    // Keep the manual diagnostic resilient if an unexpected decoder panic is
    // introduced: one bad word should not abort a stream of spot checks.
    let rendered = std::panic::catch_unwind(|| {
        let bytes = word.to_le_bytes();
        let mut dec = Decoder::new(&bytes, ADDRESS, DecoderOptions::default());
        let insn = dec.decode();

        // Zero-alloc format into a fixed stack buffer.
        let mut buf = [0u8; 256];
        let mut sink = BufSink::new(&mut buf);
        FmtFormatter::new().format(&insn, &mut sink);
        sink.as_str().to_string()
    })
    .unwrap_or_else(|_| String::from("<unimplemented>"));

    writeln!(out, "{word:08X}\t{rendered}")?;
    Ok(())
}

pub fn as_str(&self) -> &str

The bytes written so far, as &str (always valid UTF-8 because only whole &str chunks are appended, truncated only at chunk granularity).

Examples found in repository

examples/disasm.rs (line 57)

fn emit_word<W: Write>(token: &str, out: &mut W) -> io::Result<()> {
    let token = token.trim();
    if token.is_empty() {
        return Ok(());
    }
    // Accept an optional `0x` prefix and surrounding whitespace.
    let hex = token.trim_start_matches("0x").trim_start_matches("0X");
    let word = match u32::from_str_radix(hex, 16) {
        Ok(w) => w,
        Err(_) => {
            writeln!(out, "{token}\t<invalid hex>")?;
            return Ok(());
        }
    };

    // Keep the manual diagnostic resilient if an unexpected decoder panic is
    // introduced: one bad word should not abort a stream of spot checks.
    let rendered = std::panic::catch_unwind(|| {
        let bytes = word.to_le_bytes();
        let mut dec = Decoder::new(&bytes, ADDRESS, DecoderOptions::default());
        let insn = dec.decode();

        // Zero-alloc format into a fixed stack buffer.
        let mut buf = [0u8; 256];
        let mut sink = BufSink::new(&mut buf);
        FmtFormatter::new().format(&insn, &mut sink);
        sink.as_str().to_string()
    })
    .unwrap_or_else(|_| String::from("<unimplemented>"));

    writeln!(out, "{word:08X}\t{rendered}")?;
    Ok(())
}

pub fn len(&self) -> usize

Number of bytes written.

pub fn is_empty(&self) -> bool

true if nothing has been written.

pub fn overflowed(&self) -> bool

true if any write was truncated due to insufficient capacity.

Trait Implementations

impl<'a> Debug for BufSink<'a>

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

Formats the value using the given formatter.

impl Write for BufSink<'_>

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.