use std::cell::RefCell;
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct ByteWriter {
buf: Vec<u8>,
big_endian: bool,
}
impl ByteWriter {
#[must_use]
pub fn le() -> Self {
Self::default()
}
#[must_use]
pub fn be() -> Self {
Self {
buf: Vec::new(),
big_endian: true,
}
}
pub fn set_big_endian(&mut self, big: bool) -> &mut Self {
self.big_endian = big;
self
}
#[must_use]
pub fn len(&self) -> usize {
self.buf.len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.buf.is_empty()
}
#[must_use]
pub fn into_inner(self) -> Vec<u8> {
self.buf
}
#[must_use]
pub fn as_slice(&self) -> &[u8] {
&self.buf
}
pub fn bytes(&mut self, b: &[u8]) -> &mut Self {
self.buf.extend_from_slice(b);
self
}
pub fn cstr(&mut self, b: &[u8]) -> &mut Self {
self.buf.extend_from_slice(b);
self.buf.push(0);
self
}
pub fn align(&mut self, n: usize) -> &mut Self {
if n > 1 {
let pad = (n - self.buf.len() % n) % n;
self.buf.resize(self.buf.len() + pad, 0);
}
self
}
pub fn u8(&mut self, v: u8) -> &mut Self {
self.buf.push(v);
self
}
pub fn bool(&mut self, v: bool) -> &mut Self {
self.u8(u8::from(v))
}
pub fn i8(&mut self, v: i8) -> &mut Self {
self.bytes(&v.to_le_bytes())
}
}
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct Field {
pub width: usize,
pub big_endian: bool,
pub value: u64,
}
struct Hook {
written: Vec<Field>,
overrides: Vec<(usize, u64)>,
}
thread_local! {
static HOOK: RefCell<Option<Hook>> = const { RefCell::new(None) };
}
pub fn with_fields<T>(overrides: &[(usize, u64)], build: impl FnOnce() -> T) -> (T, Vec<Field>) {
let mut sorted = overrides.to_vec();
sorted.sort_unstable();
let outer = HOOK.with(|h| {
h.borrow_mut().replace(Hook {
written: Vec::new(),
overrides: sorted,
})
});
let out = build();
let hook = HOOK.with(|h| std::mem::replace(&mut *h.borrow_mut(), outer));
(out, hook.map(|h| h.written).unwrap_or_default())
}
fn field(width: usize, big_endian: bool, value: u64) -> u64 {
HOOK.with(|h| {
let mut h = h.borrow_mut();
let Some(hook) = h.as_mut() else {
return value;
};
let n = hook.written.len();
hook.written.push(Field {
width,
big_endian,
value,
});
hook.overrides
.binary_search_by_key(&n, |o| o.0)
.ok()
.and_then(|i| hook.overrides.get(i))
.map_or(value, |o| o.1)
})
}
macro_rules! field {
($($name:ident: $t:ty, $u:ty),*) => {
impl ByteWriter {
$(
#[doc = concat!("A `", stringify!($t), "` in the writer's byte order: a field (module docs).")]
pub fn $name(&mut self, v: $t) -> &mut Self {
let width = std::mem::size_of::<$t>();
let bits = <$u>::from_ne_bytes(v.to_ne_bytes());
let w = field(width, self.big_endian, u64::from(bits));
let low = w.to_le_bytes();
let mut b = [0u8; std::mem::size_of::<$t>()];
b.copy_from_slice(&low[..width]);
let v = <$u>::from_le_bytes(b);
if self.big_endian {
self.buf.extend_from_slice(&v.to_be_bytes());
} else {
self.buf.extend_from_slice(&v.to_le_bytes());
}
self
}
)*
}
};
}
field!(u32: u32, u32, i32: i32, u32, u64: u64, u64, i64: i64, u64);
macro_rules! put {
($($name:ident: $t:ty),*) => {
impl ByteWriter {
$(
#[doc = concat!("A `", stringify!($t), "` in the writer's byte order.")]
pub fn $name(&mut self, v: $t) -> &mut Self {
if self.big_endian {
self.buf.extend_from_slice(&v.to_be_bytes());
} else {
self.buf.extend_from_slice(&v.to_le_bytes());
}
self
}
)*
}
};
}
put!(u16: u16, i16: i16, f32: f32, f64: f64);
#[cfg(test)]
mod tests {
use super::{ByteWriter, Field, with_fields};
#[test]
fn fields_are_numbered_reported_and_overridden() {
let build = || {
let mut w = ByteWriter::le();
w.u32(5)
.u16(7)
.i64(-1)
.set_big_endian(true)
.i32(-2)
.f32(1.0);
w.into_inner()
};
let (plain, fields) = with_fields(&[], build);
assert_eq!(plain, build(), "no override, no change");
assert_eq!(
fields,
[
Field {
width: 4,
big_endian: false,
value: 5
},
Field {
width: 8,
big_endian: false,
value: u64::MAX
},
Field {
width: 4,
big_endian: true,
value: 0xFFFF_FFFE
},
]
);
let (b, _) = with_fields(&[(2, 0x0102_0304), (1, 9)], build);
let mut want = vec![5, 0, 0, 0, 7, 0, 9, 0, 0, 0, 0, 0, 0, 0, 1, 2, 3, 4];
want.extend_from_slice(&1.0f32.to_be_bytes());
assert_eq!(b, want);
let (b, _) = with_fields(&[(0, 0x1_0000_0006)], build);
assert_eq!(&b[..4], &[6, 0, 0, 0]);
assert_eq!(build(), plain);
}
#[test]
fn a_nested_build_numbers_its_own_fields() {
let (outer, fields) = with_fields(&[(1, 8)], || {
let mut w = ByteWriter::le();
w.u32(1);
let (inner, inner_fields) = with_fields(&[(0, 4)], || {
let mut v = ByteWriter::le();
v.u32(2);
v.into_inner()
});
assert_eq!(inner, [4, 0, 0, 0]);
assert_eq!(inner_fields.len(), 1);
w.u32(3);
w.into_inner()
});
assert_eq!(outer, [1, 0, 0, 0, 8, 0, 0, 0]);
assert_eq!(fields.len(), 2);
}
#[test]
fn order_and_align() {
let mut w = ByteWriter::be();
w.u8(1)
.align(4)
.u32(0x0102_0304)
.set_big_endian(false)
.u16(0x0506)
.cstr(b"ab");
assert_eq!(
w.into_inner(),
[1, 0, 0, 0, 1, 2, 3, 4, 6, 5, b'a', b'b', 0]
);
}
}