use core::fmt::{self, Formatter, Write};
const RENDER_CAPACITY: usize = 128;
pub(crate) struct StackStr<const N: usize> {
buf: [u8; N],
len: usize,
overflow: bool,
}
impl<const N: usize> StackStr<N> {
pub(crate) const fn new() -> Self {
Self { buf: [0; N], len: 0, overflow: false }
}
pub(crate) fn as_str(&self) -> &str {
core::str::from_utf8(&self.buf[..self.len]).unwrap_or("")
}
pub(crate) const fn overflowed(&self) -> bool {
self.overflow
}
}
impl<const N: usize> Write for StackStr<N> {
fn write_str(&mut self, s: &str) -> fmt::Result {
let bytes = s.as_bytes();
if self.len + bytes.len() > N {
self.overflow = true;
return Ok(());
}
self.buf[self.len..self.len + bytes.len()].copy_from_slice(bytes);
self.len += bytes.len();
Ok(())
}
}
pub(crate) fn pad_rendered(
f: &mut Formatter<'_>,
render: impl Fn(&mut dyn Write) -> fmt::Result,
) -> fmt::Result {
let mut buf = StackStr::<RENDER_CAPACITY>::new();
render(&mut buf)?;
if buf.overflowed() {
render(f)
} else {
f.pad(buf.as_str())
}
}
pub(crate) const POW10: [u128; 39] = {
let mut table = [1u128; 39];
let mut i = 1;
while i < 39 {
table[i] = table[i - 1] * 10;
i += 1;
}
table
};
pub(crate) const fn digits_of(mut n: u128) -> u32 {
let mut d = 1;
while n >= 10 {
n /= 10;
d += 1;
}
d
}
pub(crate) fn write_zero_padded(out: &mut dyn Write, value: u128, width: usize) -> fmt::Result {
write!(out, "{value:0width$}")
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn buffer_reports_overflow_instead_of_failing() {
let mut buf = StackStr::<4>::new();
assert!(write!(buf, "ab").is_ok());
assert!(write!(buf, "cde").is_ok());
assert!(buf.overflowed());
assert_eq!(buf.as_str(), "ab");
}
#[test]
fn pow10_and_digits_agree() {
assert_eq!(POW10[0], 1);
assert_eq!(POW10[18], 1_000_000_000_000_000_000);
assert_eq!(digits_of(0), 1);
assert_eq!(digits_of(9), 1);
assert_eq!(digits_of(10), 2);
assert_eq!(digits_of(u128::MAX), 39);
}
}