use core::cell::RefCell;
use crate::im::{ClusterId, EndpointId};
pub trait DataVersionSource: core::fmt::Debug {
fn version(&self, endpoint: EndpointId, cluster: ClusterId) -> u32;
fn touch(&self, endpoint: EndpointId, cluster: ClusterId);
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
struct Entry {
endpoint: EndpointId,
cluster: ClusterId,
version: u32,
}
#[derive(Debug)]
pub struct DataVersions<const N: usize> {
entries: RefCell<heapless::Vec<Entry, N>>,
seed: RefCell<u32>,
changed: RefCell<heapless::Vec<(EndpointId, ClusterId), N>>,
}
impl<const N: usize> DataVersions<N> {
#[must_use]
pub fn new(seed: u32) -> Self {
Self {
entries: RefCell::new(heapless::Vec::new()),
seed: RefCell::new(seed),
changed: RefCell::new(heapless::Vec::new()),
}
}
#[must_use]
pub fn drain_changes(&self) -> heapless::Vec<(EndpointId, ClusterId), N> {
core::mem::take(&mut self.changed.borrow_mut())
}
#[must_use]
pub fn len(&self) -> usize {
self.entries.borrow().len()
}
#[must_use]
pub fn is_empty(&self) -> bool {
self.entries.borrow().is_empty()
}
fn next_seed(&self) -> u32 {
let mut seed = self.seed.borrow_mut();
*seed = seed.wrapping_add(0x9E37_79B9);
*seed
}
}
impl<const N: usize> DataVersionSource for DataVersions<N> {
fn version(&self, endpoint: EndpointId, cluster: ClusterId) -> u32 {
if let Some(entry) = self
.entries
.borrow()
.iter()
.find(|e| e.endpoint == endpoint && e.cluster == cluster)
{
return entry.version;
}
let version = self.next_seed();
let _ = self.entries.borrow_mut().push(Entry {
endpoint,
cluster,
version,
});
version
}
fn touch(&self, endpoint: EndpointId, cluster: ClusterId) {
{
let mut changed = self.changed.borrow_mut();
if !changed.contains(&(endpoint, cluster)) {
let _ = changed.push((endpoint, cluster));
}
}
let mut entries = self.entries.borrow_mut();
if let Some(entry) = entries
.iter_mut()
.find(|e| e.endpoint == endpoint && e.cluster == cluster)
{
entry.version = entry.version.wrapping_add(1);
}
}
}
#[cfg(test)]
#[allow(clippy::arithmetic_side_effects, clippy::indexing_slicing)]
mod tests {
use super::*;
#[test]
fn a_version_is_stable_until_something_changes() {
let versions = DataVersions::<8>::new(1);
let first = versions.version(0, 0x0006);
assert_eq!(versions.version(0, 0x0006), first);
versions.touch(0, 0x0006);
assert_eq!(versions.version(0, 0x0006), first.wrapping_add(1));
}
#[test]
fn each_cluster_instance_has_its_own() {
let versions = DataVersions::<8>::new(1);
let a = versions.version(0, 0x0006);
let b = versions.version(1, 0x0006);
let c = versions.version(0, 0x0008);
assert_ne!(a, b);
assert_ne!(a, c);
versions.touch(0, 0x0006);
assert_eq!(versions.version(1, 0x0006), b, "the neighbour did not move");
assert_eq!(versions.version(0, 0x0008), c);
}
#[test]
fn versions_do_not_start_at_zero_or_together() {
let versions = DataVersions::<8>::new(0xDEAD_BEEF);
let a = versions.version(0, 0x0006);
let b = versions.version(0, 0x0008);
assert_ne!(a, 0);
assert_ne!(b, 0);
assert_ne!(a, b);
}
#[test]
fn the_version_wraps_rather_than_overflowing() {
let versions = DataVersions::<8>::new(0);
let _ = versions.version(0, 0x0006);
{
let mut entries = versions.entries.borrow_mut();
entries[0].version = u32::MAX;
}
versions.touch(0, 0x0006);
assert_eq!(versions.version(0, 0x0006), 0);
}
#[test]
fn a_full_table_still_answers() {
let versions = DataVersions::<2>::new(7);
let _ = versions.version(0, 1);
let _ = versions.version(0, 2);
assert_eq!(versions.len(), 2);
let overflow = versions.version(0, 3);
assert_ne!(overflow, 0);
assert_eq!(versions.len(), 2, "and does not evict a tracked instance");
}
}