use zerocopy::IntoBytes;
use crate::entry::{EntryHeader, EntryKind};
use crate::error::Error;
use crate::schema::SCHEMA_TAG_SIZE;
use crate::typed::SensorData;
pub const RUN_FRAME_SIZE: usize = SCHEMA_TAG_SIZE + 8 + 2;
const INTERVAL_AT: usize = SCHEMA_TAG_SIZE;
const COUNT_AT: usize = INTERVAL_AT + 8;
#[derive(Debug, Clone, Copy)]
pub struct Run<'a> {
sensor_id: u16,
base_timestamp: u64,
interval: u64,
schema_version: u8,
count: u16,
samples: &'a [u8],
}
impl<'a> Run<'a> {
pub fn of<T: SensorData>(
base_timestamp: u64,
interval: u64,
samples: &'a [T],
) -> Result<Self, Error> {
let stride = core::mem::size_of::<T>();
if stride == 0 {
return Err(Error::InvalidRun);
}
let count = u16::try_from(samples.len())
.ok()
.filter(|&n| n > 0)
.ok_or(Error::InvalidRun)?;
interval
.checked_mul(u64::from(count - 1))
.and_then(|span| base_timestamp.checked_add(span))
.ok_or(Error::InvalidRun)?;
let bytes = samples.as_bytes();
if RUN_FRAME_SIZE + bytes.len() > u16::MAX as usize {
return Err(Error::InvalidRun);
}
Ok(Self {
sensor_id: T::SENSOR_ID,
base_timestamp,
interval,
schema_version: T::SCHEMA_VERSION,
count,
samples: bytes,
})
}
pub fn sensor_id(&self) -> u16 {
self.sensor_id
}
pub fn base_timestamp(&self) -> u64 {
self.base_timestamp
}
pub fn interval(&self) -> u64 {
self.interval
}
pub fn count(&self) -> u32 {
u32::from(self.count)
}
pub fn span_end(&self) -> u64 {
self.base_timestamp + self.interval * u64::from(self.count - 1)
}
pub fn payload_len(&self) -> usize {
RUN_FRAME_SIZE + self.samples.len()
}
pub(crate) fn samples(&self) -> &'a [u8] {
self.samples
}
pub(crate) fn write_frame(&self, buf: &mut [u8]) {
buf[0] = self.schema_version;
buf[INTERVAL_AT..INTERVAL_AT + 8].copy_from_slice(&self.interval.to_le_bytes());
buf[COUNT_AT..COUNT_AT + 2].copy_from_slice(&self.count.to_le_bytes());
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub(crate) struct RunFrame {
schema_version: u8,
interval: u64,
count: u32,
stride: usize,
}
impl RunFrame {
pub(crate) fn parse(payload: &[u8]) -> Option<Self> {
if payload.len() <= RUN_FRAME_SIZE {
return None;
}
let mut interval = [0u8; 8];
interval.copy_from_slice(&payload[INTERVAL_AT..INTERVAL_AT + 8]);
let count = u32::from(u16::from_le_bytes([
payload[COUNT_AT],
payload[COUNT_AT + 1],
]));
if count == 0 {
return None;
}
let body = payload.len() - RUN_FRAME_SIZE;
if !body.is_multiple_of(count as usize) {
return None;
}
Some(Self {
schema_version: payload[0],
interval: u64::from_le_bytes(interval),
count,
stride: body / count as usize,
})
}
pub(crate) fn count(&self) -> u32 {
self.count
}
pub(crate) fn timestamp_at(&self, base: u64, index: u32) -> u64 {
base.saturating_add(self.interval.saturating_mul(u64::from(index)))
}
pub(crate) fn span_end(&self, base: u64) -> u64 {
self.timestamp_at(base, self.count - 1)
}
pub(crate) fn header_at(&self, sensor_id: u16, base: u64, index: u32) -> EntryHeader {
EntryHeader {
sensor_id,
timestamp: self.timestamp_at(base, index),
payload_len: (SCHEMA_TAG_SIZE + self.stride) as u16,
kind: EntryKind::Single,
}
}
pub(crate) fn tagged_sample<'a>(&self, payload: &'a mut [u8], index: u32) -> &'a [u8] {
debug_assert!(index < self.count);
let start = RUN_FRAME_SIZE + index as usize * self.stride;
payload[start - SCHEMA_TAG_SIZE] = self.schema_version;
&payload[start - SCHEMA_TAG_SIZE..start + self.stride]
}
pub(crate) fn write_tagged_sample(
&self,
payload: &[u8],
index: u32,
out: &mut [u8],
) -> Option<usize> {
debug_assert!(index < self.count);
let len = SCHEMA_TAG_SIZE + self.stride;
if out.len() < len {
return None;
}
let start = RUN_FRAME_SIZE + index as usize * self.stride;
out[0] = self.schema_version;
out[SCHEMA_TAG_SIZE..len].copy_from_slice(&payload[start..start + self.stride]);
Some(len)
}
}
#[allow(clippy::too_many_arguments)]
pub(crate) fn deliver_samples(
is_run: bool,
sensor_id: u16,
base: u64,
payload: &mut [u8],
t_start: u64,
t_end: u64,
count: &mut u32,
callback: &mut dyn FnMut(&EntryHeader, &[u8]) -> bool,
) -> bool {
let frame = match is_run {
true => match RunFrame::parse(payload) {
Some(frame) => frame,
None => return false,
},
false => {
if base < t_start || base > t_end {
return false;
}
*count += 1;
let header = EntryHeader {
sensor_id,
timestamp: base,
payload_len: payload.len() as u16,
kind: EntryKind::Single,
};
return !callback(&header, payload);
}
};
for index in 0..frame.count() {
let timestamp = frame.timestamp_at(base, index);
if timestamp > t_end {
break;
}
if timestamp < t_start {
continue;
}
*count += 1;
let header = frame.header_at(sensor_id, base, index);
if !callback(&header, frame.tagged_sample(payload, index)) {
return true;
}
}
false
}
pub(crate) fn samples_in(is_run: bool, payload: &[u8]) -> u32 {
if !is_run {
return 1;
}
RunFrame::parse(payload).map_or(0, |frame| frame.count())
}
#[cfg(test)]
mod tests {
use super::*;
use zerocopy::{FromBytes, Immutable, IntoBytes, KnownLayout};
#[derive(FromBytes, IntoBytes, KnownLayout, Immutable, Debug, Clone, Copy, PartialEq)]
#[repr(C)]
struct Reading {
raw: u32,
}
impl SensorData for Reading {
const SENSOR_ID: u16 = 0x42;
const SCHEMA_VERSION: u8 = 3;
}
fn encode(run: &Run<'_>) -> heapless::Vec<u8, 512> {
let mut buf = heapless::Vec::new();
buf.resize(run.payload_len(), 0).unwrap();
run.write_frame(&mut buf[..RUN_FRAME_SIZE]);
buf[RUN_FRAME_SIZE..].copy_from_slice(run.samples());
buf
}
#[test]
fn a_run_round_trips_through_its_own_frame() {
let samples = [Reading { raw: 1 }, Reading { raw: 2 }, Reading { raw: 3 }];
let run = Run::of(1_000, 25, &samples).unwrap();
assert_eq!(run.sensor_id(), 0x42);
assert_eq!(run.count(), 3);
assert_eq!(run.span_end(), 1_050);
assert_eq!(run.payload_len(), RUN_FRAME_SIZE + 12);
let mut payload = encode(&run);
let frame = RunFrame::parse(&payload).unwrap();
assert_eq!(frame.count(), 3);
assert_eq!(frame.span_end(1_000), 1_050);
for (i, sample) in samples.iter().enumerate() {
let i = i as u32;
assert_eq!(frame.timestamp_at(1_000, i), 1_000 + 25 * u64::from(i));
let tagged = frame.tagged_sample(&mut payload, i);
assert_eq!(tagged[0], Reading::SCHEMA_VERSION);
assert_eq!(&tagged[1..], sample.as_bytes());
}
}
#[test]
fn an_expanded_sample_is_byte_for_byte_a_single_append() {
let samples = [Reading { raw: 0xDEAD_BEEF }, Reading { raw: 7 }];
let run = Run::of(0, 1, &samples).unwrap();
let mut payload = encode(&run);
let frame = frame_of(&payload);
for (i, sample) in samples.iter().enumerate() {
let single = crate::schema::tag(sample);
assert_eq!(frame.tagged_sample(&mut payload, i as u32), single.bytes());
}
}
fn frame_of(payload: &[u8]) -> RunFrame {
RunFrame::parse(payload).unwrap()
}
#[test]
fn the_headers_a_run_expands_to_are_the_ones_single_appends_would_carry() {
let samples = [Reading { raw: 1 }; 4];
let run = Run::of(500, 10, &samples).unwrap();
let frame = frame_of(&encode(&run));
for i in 0..4u32 {
assert_eq!(
frame.header_at(Reading::SENSOR_ID, 500, i),
EntryHeader {
sensor_id: Reading::SENSOR_ID,
timestamp: 500 + 10 * u64::from(i),
payload_len: (SCHEMA_TAG_SIZE + 4) as u16,
kind: EntryKind::Single,
}
);
}
}
#[test]
fn a_single_sample_run_is_legal_and_spans_nothing() {
let run = Run::of(9, 1_000, &[Reading { raw: 1 }]).unwrap();
assert_eq!(run.count(), 1);
assert_eq!(run.span_end(), 9);
let frame = frame_of(&encode(&run));
assert_eq!(frame.span_end(9), 9);
}
#[test]
fn a_zero_interval_run_stacks_every_sample_on_one_timestamp() {
let run = Run::of(4, 0, &[Reading { raw: 1 }; 3]).unwrap();
assert_eq!(run.span_end(), 4);
let frame = frame_of(&encode(&run));
assert_eq!(frame.timestamp_at(4, 2), 4);
}
#[test]
fn an_empty_run_is_rejected_rather_than_stored_as_nothing() {
assert_eq!(
Run::of::<Reading>(0, 1, &[]).unwrap_err(),
Error::InvalidRun
);
}
#[test]
fn a_run_whose_last_timestamp_would_overflow_is_refused() {
assert!(Run::of(u64::MAX, 0, &[Reading { raw: 1 }; 4]).is_ok());
assert_eq!(
Run::of(u64::MAX - 1, 1, &[Reading { raw: 1 }; 4]).unwrap_err(),
Error::InvalidRun
);
assert_eq!(
Run::of(0, u64::MAX, &[Reading { raw: 1 }; 3]).unwrap_err(),
Error::InvalidRun
);
}
#[test]
fn a_payload_that_is_not_a_well_formed_run_parses_to_nothing() {
assert!(RunFrame::parse(&[0u8; RUN_FRAME_SIZE]).is_none());
assert!(RunFrame::parse(&[]).is_none());
let mut payload = [0u8; RUN_FRAME_SIZE + 4];
assert!(RunFrame::parse(&payload).is_none());
payload[COUNT_AT] = 3;
assert!(RunFrame::parse(&payload).is_none());
payload[COUNT_AT] = 4;
assert_eq!(RunFrame::parse(&payload).unwrap().stride, 1);
}
#[test]
fn samples_in_answers_for_both_entry_kinds() {
let run = Run::of(0, 1, &[Reading { raw: 1 }; 5]).unwrap();
assert_eq!(samples_in(true, &encode(&run)), 5);
assert_eq!(samples_in(false, &encode(&run)), 1);
assert_eq!(samples_in(true, &[0u8; 4]), 0);
}
}