use crate::id::CanId;
use alloc::boxed::Box;
fn transmitted_bits(id: CanId) -> impl Iterator<Item = bool> {
match id {
CanId::Standard(v) => Box::new(
(0..11)
.rev()
.map(move |bit| (u32::from(v) >> bit) & 1 == 1)
.chain(core::iter::once(false)), ) as Box<dyn Iterator<Item = bool>>,
CanId::Extended(v) => Box::new(
(18..29)
.rev()
.map(move |bit| (v >> bit) & 1 == 1)
.chain(core::iter::once(true)) .chain(core::iter::once(true)) .chain((0..18).rev().map(move |bit| (v >> bit) & 1 == 1)),
) as Box<dyn Iterator<Item = bool>>,
}
}
#[must_use]
pub fn dominates(a: CanId, b: CanId) -> bool {
let mut a_bits = transmitted_bits(a);
let mut b_bits = transmitted_bits(b);
core::iter::from_fn(|| Some((a_bits.next()?, b_bits.next()?)))
.find(|(x, y)| x != y)
.is_some_and(|(x, y)| !x && y)
}
#[cfg(test)]
mod tests {
#![allow(clippy::unwrap_used, clippy::expect_used, clippy::indexing_slicing)]
use super::*;
use alloc::vec::Vec;
#[test]
fn lower_id_wins_among_equal_widths() {
for (a, b) in [
(0x000, 0x001),
(0x100, 0x200),
(0x7FE, 0x7FF),
(0x123, 0x456),
] {
let a = CanId::standard(a).unwrap();
let b = CanId::standard(b).unwrap();
assert!(dominates(a, b), "{a:?} should dominate {b:?}");
assert!(!dominates(b, a));
}
let lo = CanId::extended(0x0000_0100).unwrap();
let hi = CanId::extended(0x0000_0200).unwrap();
assert!(dominates(lo, hi));
assert!(!dominates(hi, lo));
}
#[test]
fn identical_ids_dominate_nothing() {
let a = CanId::standard(0x123).unwrap();
assert!(!dominates(a, a));
let e = CanId::extended(0x0123_4567).unwrap();
assert!(!dominates(e, e));
}
#[test]
fn standard_beats_extended_on_shared_prefix() {
let std = CanId::standard(0x7F0).unwrap();
let ext = CanId::extended(0x1FC0_0001).unwrap();
assert_eq!(ext.raw() >> 18, 0x7F0); assert!(dominates(std, ext));
assert!(!dominates(ext, std));
}
#[test]
fn extended_wins_on_genuinely_lower_prefix() {
let std = CanId::standard(0x200).unwrap();
let ext = CanId::extended(0x0100_0000).unwrap();
assert!(dominates(ext, std));
assert!(!dominates(std, ext));
}
#[test]
fn wire_sequence_shape() {
assert!(transmitted_bits(CanId::Standard(0)).all(|bit| !bit));
let bits: Vec<_> = transmitted_bits(CanId::Standard(0x7FF)).collect();
assert_eq!(bits.len(), 12);
assert!(bits[..11].iter().all(|bit| *bit));
assert!(!bits[11]);
let bits: Vec<_> = transmitted_bits(CanId::Extended(0x1FFF_FFFF)).collect();
assert_eq!(bits.len(), 31);
assert!(bits.iter().all(|bit| *bit));
assert!(!transmitted_bits(CanId::Extended(0)).next().unwrap());
}
}