Struct FmtWriter 

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

🖹 A specialized formatter with a fixed byte buffer and truncation detection.

---

^{📍 text/fmt}

---

It should be faster at runtime than the default formatter.

Implementations

impl<'a> FmtWriter<'a>

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

Creates a new writer for the given buffer.

pub const fn is_truncated(&self) -> bool

Returns true if truncation occurred.

pub const fn written_len(&self) -> usize

Returns the number of bytes written.

pub fn format( buf: &'a mut [u8], args: FmtArguments<'_>, ) -> Result<&'a str, &'a str>

Writes formatted output into the given byte buffer, returning a string slice.

Returns:

• Ok(&str) if all the formatted data fits into buf.
• Err(&str) containing the valid partial result if truncation occurred.

Examples

let mut buf = [0u8; 32]; // Big enough to fit everything
let s = FmtWriter::format(&mut buf, format_args!["Test: {} {}", "foo", 42]);
assert_eq!(Ok("Test: foo 42"), s);

let mut buf = [0u8; 9]; // Can't fit everything
let s = FmtWriter::format(&mut buf, format_args!["Test: {} {}", "foo", 42]);
assert_eq!(Err("Test: foo"), s);

pub fn format_len( buf: &'a mut [u8], args: FmtArguments<'_>, ) -> Result<usize, usize>

Writes formatted output into the given byte buffer, returning the number of written bytes.

Returns:

• Ok(usize) if all the formatted data fits into buf.
• Err(usize) containing the number of valid UTF-8 written bytes if truncation ocurred,

Examples

let mut buf = [0u8; 32];
assert_eq![Ok(12), FmtWriter::format_len(&mut buf, format_args!["Test: {} {}", "foo", 42])];

let mut buf = [0u8; 9];
assert_eq![Err(9), FmtWriter::format_len(&mut buf, format_args!["Test: {} {}", "foo", 42])];

pub fn format_len_unchecked(buf: &'a mut [u8], args: FmtArguments<'_>) -> usize

Writes formatted output into the given byte buffer, returning the number of written bytes.

pub const fn write_str_truncate(&mut self, s: &str) -> usize

Writes a string slice to the buffer, returning the number of bytes written.

It copies as much of the string as will fit into the remaining buffer space.

Examples

const fn create_message(buf: &mut [u8]) -> &str {
    let mut writer = FmtWriter::new(buf);
    writer.write_str_truncate("Hello");
    writer.write_str_truncate(" world");
    writer.into_str_const()
}

pub const fn write_str_truncate_checked( &mut self, s: &str, ) -> Result<&str, &str>

Writes a string slice, returning the actually written part.

Returns Err if truncation occurred, with the truncated result.

pub const fn write_str_truncate_checked_len( &mut self, s: &str, ) -> Result<usize, usize>

Writes a string slice, returning the number of the bytes actually written.

pub fn as_str(&self) -> &str

Returns the written content as a valid UTF‑8 string.

If the final write ended in the middle of a multi‑byte codepoint only the valid prefix is returned.

Features

Makes use of the dep_simd_utf8 feature to accelerate validation, and of the unsafe_str feature to avoid double validation.

pub fn into_str(self) -> &'a str

Returns the written content as a valid UTF‑8 string.

If the final write ended in the middle of a multi‑byte codepoint only the valid prefix is returned.

Features

Makes use of the dep_simd_utf8 feature to accelerate validation, and of the unsafe_str feature to avoid double validation.

pub const fn as_str_const(&'a self) -> &'a str

Returns the written content as a valid UTF‑8 string.

If the final write ended in the middle of a multi‑byte codepoint only the valid prefix is returned. Compile-time friendly version using basic validation.

Features

Makes use of the unsafe_str feature to avoid double validation.

pub const fn into_str_const(self) -> &'a str

Returns the written content as a valid UTF‑8 string.

If the final write ended in the middle of a multi‑byte codepoint only the valid prefix is returned. Compile-time friendly version using basic validation.

Features

Makes use of the unsafe_str feature to avoid double validation.

Trait Implementations

impl<'a> Debug for FmtWriter<'a>

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

Formats the value using the given formatter.

impl Write for FmtWriter<'_>

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

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.