use zerocopy::{FromBytes, FromZeros, Immutable, IntoBytes, KnownLayout, Unalign, Unaligned};
use crate::entry::EntryHeader;
use crate::error::Error;
use crate::typed::SensorData;
pub const SCHEMA_TAG_SIZE: usize = 1;
#[derive(FromBytes, IntoBytes, KnownLayout, Immutable, Unaligned)]
#[repr(C)]
pub(crate) struct Tagged<T> {
schema: u8,
value: Unalign<T>,
}
impl<T: SensorData> Tagged<T> {
pub(crate) fn empty() -> Self {
Self::new_zeroed()
}
pub(crate) fn bytes(&self) -> &[u8] {
self.as_bytes()
}
pub(crate) fn bytes_mut(&mut self) -> &mut [u8] {
self.as_mut_bytes()
}
}
pub(crate) fn read_tagged<T: SensorData>(
read: impl FnOnce(&mut [u8]) -> Result<Option<(EntryHeader, usize)>, Error>,
) -> Result<Option<(EntryHeader, T)>, Error> {
let mut framed = Tagged::<T>::empty();
let found = read(framed.bytes_mut())?;
untag(found, framed)
}
pub(crate) const fn tagged_size<T: SensorData>() -> usize {
SCHEMA_TAG_SIZE + core::mem::size_of::<T>()
}
pub(crate) fn tag<T: SensorData>(data: &T) -> Tagged<T> {
let mut framed = Tagged::<T>::new_zeroed();
let bytes = framed.as_mut_bytes();
bytes[0] = T::SCHEMA_VERSION;
bytes[SCHEMA_TAG_SIZE..].copy_from_slice(data.as_bytes());
framed
}
pub(crate) fn untag<T: SensorData>(
found: Option<(EntryHeader, usize)>,
framed: Tagged<T>,
) -> Result<Option<(EntryHeader, T)>, Error> {
let Some((header, len)) = found else {
return Ok(None);
};
if len >= SCHEMA_TAG_SIZE {
let found = framed.schema;
if found != T::SCHEMA_VERSION {
return Err(Error::SchemaMismatch {
expected: T::SCHEMA_VERSION,
found,
});
}
}
let expected = tagged_size::<T>();
if len != expected {
return Err(Error::SizeMismatch {
expected,
actual: len,
});
}
Ok(Some((header, framed.value.into_inner())))
}
pub(crate) fn untag_payload<T: SensorData>(payload: &[u8]) -> Option<T> {
let (&schema, body) = payload.split_first()?;
if schema != T::SCHEMA_VERSION || body.len() != core::mem::size_of::<T>() {
return None;
}
T::read_from_bytes(body).ok()
}
#[cfg(test)]
mod tests {
use super::*;
#[derive(FromBytes, IntoBytes, KnownLayout, Immutable, Debug, PartialEq)]
#[repr(C)]
struct Reading {
celsius: f32,
raw: u32,
}
impl SensorData for Reading {
const SENSOR_ID: u16 = 0x42;
}
#[derive(FromBytes, IntoBytes, KnownLayout, Immutable, Debug, PartialEq)]
#[repr(C)]
struct ReadingV2 {
celsius: f32,
raw: u32,
}
impl SensorData for ReadingV2 {
const SENSOR_ID: u16 = 0x42;
const SCHEMA_VERSION: u8 = 1;
}
#[test]
fn the_tag_precedes_the_value_with_no_padding() {
assert_eq!(tagged_size::<Reading>(), 1 + 8);
let framed = tag(&Reading {
celsius: 25.5,
raw: 0x0102_0304,
});
let bytes = framed.as_bytes();
assert_eq!(bytes.len(), 9);
assert_eq!(bytes[0], 0);
assert_eq!(&bytes[1..5], 25.5f32.to_ne_bytes());
assert_eq!(&bytes[5..9], 0x0102_0304u32.to_ne_bytes());
}
#[test]
fn a_value_survives_the_round_trip() {
let original = Reading {
celsius: -3.25,
raw: 7,
};
let bytes = tag(&original);
assert_eq!(untag_payload::<Reading>(bytes.as_bytes()), Some(original));
}
#[test]
fn two_versions_of_the_same_size_are_distinguishable() {
assert_eq!(
core::mem::size_of::<Reading>(),
core::mem::size_of::<ReadingV2>()
);
let v1 = tag(&Reading {
celsius: 1.0,
raw: 1,
});
assert!(untag_payload::<ReadingV2>(v1.as_bytes()).is_none());
assert!(untag_payload::<Reading>(v1.as_bytes()).is_some());
}
#[test]
fn a_wrong_version_is_named_in_the_error() {
let stored = tag(&Reading {
celsius: 1.0,
raw: 1,
});
let mut framed = Tagged::<ReadingV2>::new_zeroed();
framed.as_mut_bytes().copy_from_slice(stored.as_bytes());
let header = EntryHeader {
sensor_id: 0x42,
timestamp: 0,
payload_len: 9,
kind: crate::entry::EntryKind::Single,
};
assert_eq!(
untag::<ReadingV2>(Some((header, 9)), framed),
Err(Error::SchemaMismatch {
expected: 1,
found: 0
})
);
}
#[test]
fn a_wrong_length_is_a_size_mismatch_including_the_tag() {
let framed = Tagged::<Reading>::new_zeroed();
let header = EntryHeader {
sensor_id: 0x42,
timestamp: 0,
payload_len: 4,
kind: crate::entry::EntryKind::Single,
};
assert_eq!(
untag::<Reading>(Some((header, 4)), framed),
Err(Error::SizeMismatch {
expected: 9,
actual: 4
})
);
}
#[test]
fn an_empty_payload_is_not_a_value() {
assert!(untag_payload::<Reading>(&[]).is_none());
}
}