Skip to main content

wowlab_engine_domain/rotation/buffer/
standalone.rs

1use super::{ByteOffset, DescriptorId};
2
3/// Inventory-collected standalone default for a descriptor-based field.
4#[derive(Debug)]
5pub struct StandaloneDefault {
6    pub matches: fn(DescriptorId) -> bool,
7    pub value: DefaultValue,
8}
9
10/// Typed value for a standalone buffer default.
11#[derive(Debug)]
12#[non_exhaustive]
13pub enum DefaultValue {
14    F64(f64),
15    I32(i32),
16    Bool(bool),
17}
18
19impl DefaultValue {
20    #[inline]
21    // #t(fn: rust_unchecked_indexing) offsets are schema-validated at build time
22    pub fn write_to(&self, data: &mut [u8], offset: ByteOffset) {
23        let offset = offset.as_usize();
24
25        match self {
26            Self::F64(v) => {
27                data[offset..offset + size_of::<f64>()].copy_from_slice(&v.to_ne_bytes());
28            }
29            Self::I32(v) => {
30                data[offset..offset + size_of::<i32>()].copy_from_slice(&v.to_ne_bytes());
31            }
32            Self::Bool(v) => data[offset] = u8::from(*v),
33        }
34    }
35}
36
37inventory::collect!(StandaloneDefault);
38
39#[cfg(test)]
40mod tests {
41    use googletest::prelude::*;
42
43    use super::*;
44
45    #[gtest]
46    fn write_f64_lands_at_offset_and_leaves_prefix_untouched() -> Result<()> {
47        let mut data = [0u8; 32];
48
49        DefaultValue::F64(1.5).write_to(&mut data, ByteOffset::new(8));
50        let read = f64::from_ne_bytes(data[8..16].try_into().unwrap());
51
52        verify_that!(read, near(1.5, 1e-9))?;
53        let prefix = f64::from_ne_bytes(data[0..8].try_into().unwrap());
54
55        verify_that!(prefix, near(0.0, 1e-9))?;
56
57        Ok(())
58    }
59
60    #[gtest]
61    fn write_i32_round_trips() -> Result<()> {
62        let mut data = [0u8; 32];
63
64        DefaultValue::I32(-7).write_to(&mut data, ByteOffset::new(0));
65        let read = i32::from_ne_bytes(data[0..4].try_into().unwrap());
66
67        verify_that!(read, eq(-7))
68    }
69
70    #[gtest]
71    fn write_bool_writes_single_byte() -> Result<()> {
72        let mut data = [0u8; 32];
73
74        DefaultValue::Bool(true).write_to(&mut data, ByteOffset::new(4));
75        verify_that!(data[4], eq(1))?;
76        DefaultValue::Bool(false).write_to(&mut data, ByteOffset::new(4));
77        verify_that!(data[4], eq(0))?;
78
79        Ok(())
80    }
81}