use core::marker::PhantomData;
use super::reader::{Element, TlvReader, Value};
use super::types::{ContainerKind, Tag};
use super::writer::TlvWriter;
use crate::error::{Error, ErrorCode, Result, bail};
pub trait ToTlv {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()>;
}
pub trait FromTlv<'a>: Sized {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self>;
}
impl ToTlv for bool {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.bool(tag, *self)
}
}
impl FromTlv<'_> for bool {
fn from_tlv(_reader: &mut TlvReader<'_>, element: &Element<'_>) -> Result<Self> {
element.bool()
}
}
macro_rules! unsigned {
($($ty:ty),+) => {$(
impl ToTlv for $ty {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.unsigned(tag, u64::from(*self))
}
}
impl FromTlv<'_> for $ty {
fn from_tlv(_reader: &mut TlvReader<'_>, element: &Element<'_>) -> Result<Self> {
Self::try_from(element.unsigned()?)
.map_err(|_| Error::new(ErrorCode::TlvOutOfRange))
}
}
)+};
}
unsigned!(u8, u16, u32);
impl ToTlv for u64 {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.unsigned(tag, *self)
}
}
impl FromTlv<'_> for u64 {
fn from_tlv(_reader: &mut TlvReader<'_>, element: &Element<'_>) -> Result<Self> {
element.unsigned()
}
}
macro_rules! signed {
($($ty:ty),+) => {$(
impl ToTlv for $ty {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.signed(tag, i64::from(*self))
}
}
impl FromTlv<'_> for $ty {
fn from_tlv(_reader: &mut TlvReader<'_>, element: &Element<'_>) -> Result<Self> {
Self::try_from(element.signed()?)
.map_err(|_| Error::new(ErrorCode::TlvOutOfRange))
}
}
)+};
}
signed!(i8, i16, i32);
impl ToTlv for i64 {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.signed(tag, *self)
}
}
impl FromTlv<'_> for i64 {
fn from_tlv(_reader: &mut TlvReader<'_>, element: &Element<'_>) -> Result<Self> {
element.signed()
}
}
impl ToTlv for f32 {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.float(tag, *self)
}
}
impl FromTlv<'_> for f32 {
fn from_tlv(_reader: &mut TlvReader<'_>, element: &Element<'_>) -> Result<Self> {
match element.value {
Value::Float(v) => Ok(v),
_ => Err(Error::new(ErrorCode::TlvWrongType)),
}
}
}
impl ToTlv for f64 {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.double(tag, *self)
}
}
impl FromTlv<'_> for f64 {
fn from_tlv(_reader: &mut TlvReader<'_>, element: &Element<'_>) -> Result<Self> {
match element.value {
Value::Double(v) => Ok(v),
Value::Float(v) => Ok(f64::from(v)),
_ => Err(Error::new(ErrorCode::TlvWrongType)),
}
}
}
impl ToTlv for &str {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.utf8(tag, self)
}
}
impl<'a> FromTlv<'a> for &'a str {
fn from_tlv(_reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
element.utf8()
}
}
impl ToTlv for &[u8] {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.octets(tag, self)
}
}
impl<'a> FromTlv<'a> for &'a [u8] {
fn from_tlv(_reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
element.octets()
}
}
macro_rules! newtype {
($($ty:path => $inner:ty),+ $(,)?) => {$(
impl ToTlv for $ty {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.0.to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for $ty {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
<$inner as FromTlv<'a>>::from_tlv(reader, element).map(Self)
}
}
)+};
}
newtype!(
crate::msg::NodeId => u64,
crate::msg::GroupId => u16,
crate::msg::VendorId => u16,
crate::msg::FabricIndex => u8,
);
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
pub struct Nullable<T>(pub Option<T>);
impl<T> Nullable<T> {
pub const fn some(value: T) -> Self {
Self(Some(value))
}
pub const fn null() -> Self {
Self(None)
}
pub const fn is_null(&self) -> bool {
self.0.is_none()
}
}
impl<T: ToTlv> ToTlv for Nullable<T> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
match &self.0 {
Some(value) => value.to_tlv(w, tag),
None => w.null(tag),
}
}
}
impl<'a, T: FromTlv<'a>> FromTlv<'a> for Nullable<T> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.is_null() {
return Ok(Self(None));
}
T::from_tlv(reader, element).map(Self::some)
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TlvList<'a, T> {
members: &'a [u8],
_entry: PhantomData<fn() -> T>,
}
impl<T> Default for TlvList<'_, T> {
fn default() -> Self {
Self {
members: &[],
_entry: PhantomData,
}
}
}
impl<'a, T> TlvList<'a, T> {
#[must_use]
pub const fn from_members(members: &'a [u8]) -> Self {
Self {
members,
_entry: PhantomData,
}
}
#[must_use]
pub const fn members(&self) -> &'a [u8] {
self.members
}
#[must_use]
pub const fn is_empty(&self) -> bool {
self.members.is_empty()
}
}
impl<'a, T: FromTlv<'a>> TlvList<'a, T> {
pub fn iter(&self) -> impl Iterator<Item = Result<T>> + 'a {
let mut reader = TlvReader::new_members(self.members, ContainerKind::Array);
core::iter::from_fn(move || match reader.next_element() {
Ok(None) => None,
Ok(Some(element)) if element.value == Value::EndOfContainer => None,
Ok(Some(element)) => Some(T::from_tlv(&mut reader, &element)),
Err(error) => Some(Err(error)),
})
}
pub fn count(&self) -> Result<usize> {
let mut n = 0usize;
for entry in self.iter() {
entry?;
n = n.saturating_add(1);
}
Ok(n)
}
}
impl<T> ToTlv for TlvList<'_, T> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_array(tag)?;
let mut reader = TlvReader::new_members(self.members, ContainerKind::Array);
loop {
let start = reader.position();
let Some(element) = reader.next_element()? else {
break;
};
if element.value == Value::EndOfContainer {
break;
}
reader.skip_value(&element)?;
w.raw_element(reader.slice_from(start)?)?;
}
w.end_container()
}
}
impl<'a, T> FromTlv<'a> for TlvList<'a, T> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Array) {
bail!(TlvWrongType)
}
let start = reader.position();
let end = loop {
let before = reader.position();
let Some(member) = reader.next_element()? else {
bail!(TlvTruncated)
};
if member.value == Value::EndOfContainer {
break before;
}
reader.skip_value(&member)?;
};
let members = reader
.slice_from(start)?
.get(..end.saturating_sub(start))
.ok_or(Error::new(ErrorCode::TlvTruncated))?;
Ok(Self::from_members(members))
}
}
#[cfg(test)]
mod tests {
use super::*;
fn round_trip<'a, T>(value: &T, buf: &'a mut [u8]) -> &'a [u8]
where
T: ToTlv,
{
let mut w = TlvWriter::new(buf);
value.to_tlv(&mut w, Tag::Anonymous).expect("encode");
w.finish().expect("finish")
}
fn decode<'a, T: FromTlv<'a>>(bytes: &'a [u8]) -> Result<T> {
let mut reader = TlvReader::new(bytes);
let element = reader.next_element()?.expect("an element");
T::from_tlv(&mut reader, &element)
}
#[test]
fn the_primitives_round_trip() {
let mut buf = [0u8; 64];
assert!(decode::<bool>(round_trip(&true, &mut buf)).expect("bool"));
assert_eq!(
decode::<u16>(round_trip(&1234u16, &mut buf)).expect("u16"),
1234
);
assert_eq!(
decode::<i32>(round_trip(&-7i32, &mut buf)).expect("i32"),
-7
);
assert_eq!(
decode::<u64>(round_trip(&u64::MAX, &mut buf)).expect("u64"),
u64::MAX
);
let bytes = round_trip(&"hello", &mut buf);
assert_eq!(decode::<&str>(bytes).expect("str"), "hello");
let mut buf2 = [0u8; 64];
let bytes = round_trip(&&[1u8, 2, 3][..], &mut buf2);
assert_eq!(decode::<&[u8]>(bytes).expect("octets"), &[1, 2, 3]);
}
#[test]
fn a_value_too_wide_for_its_field_is_refused_rather_than_truncated() {
let mut buf = [0u8; 32];
let wide = round_trip(&300u32, &mut buf);
assert_eq!(
decode::<u8>(wide).map_err(|e| e.code()),
Err(ErrorCode::TlvOutOfRange)
);
assert_eq!(decode::<u16>(wide).expect("fits"), 300);
}
#[test]
fn null_and_absent_are_different_things() {
let mut buf = [0u8; 32];
let bytes = round_trip(&Nullable::<u8>::null(), &mut buf);
let decoded: Nullable<u8> = decode(bytes).expect("null");
assert!(decoded.is_null());
let bytes = round_trip(&Nullable::some(9u8), &mut buf);
assert_eq!(
decode::<Nullable<u8>>(bytes).expect("value"),
Nullable::some(9)
);
let present_and_null: Option<Nullable<u8>> = Some(Nullable::null());
assert!(present_and_null.is_some_and(|n| n.is_null()));
}
#[test]
fn a_list_is_read_where_it_lies() {
let mut buf = [0u8; 128];
let mut w = TlvWriter::new(&mut buf);
w.start_array(Tag::Anonymous).expect("array");
for value in 1..=5u16 {
w.unsigned(Tag::Anonymous, u64::from(value))
.expect("member");
}
w.end_container().expect("end");
let bytes = w.finish().expect("finish");
let list: TlvList<'_, u16> = decode(bytes).expect("list");
assert_eq!(list.count().expect("count"), 5);
let values: Result<heapless::Vec<u16, 8>> = list.iter().collect();
assert_eq!(values.expect("members").as_slice(), &[1, 2, 3, 4, 5]);
let mut buf = [0u8; 16];
let mut w = TlvWriter::new(&mut buf);
w.start_array(Tag::Anonymous).expect("array");
w.end_container().expect("end");
let bytes = w.finish().expect("finish");
let empty: TlvList<'_, u16> = decode(bytes).expect("list");
assert!(empty.is_empty());
assert_eq!(empty.count().expect("count"), 0);
}
#[test]
fn a_decoded_list_re_encodes_to_the_same_bytes() {
let mut buf = [0u8; 128];
let mut w = TlvWriter::new(&mut buf);
w.start_array(Tag::Anonymous).expect("array");
for value in [7u32, 70, 700, 7000] {
w.unsigned(Tag::Anonymous, u64::from(value))
.expect("member");
}
w.end_container().expect("end");
let original = w.finish().expect("finish").to_vec();
let list: TlvList<'_, u32> = decode(&original).expect("list");
let mut out = [0u8; 128];
let again = round_trip(&list, &mut out);
assert_eq!(again, original.as_slice());
}
#[test]
fn a_list_of_the_wrong_container_kind_is_refused() {
let mut buf = [0u8; 64];
let mut w = TlvWriter::new(&mut buf);
w.start_structure(Tag::Anonymous).expect("structure");
w.unsigned(Tag::Context(0), 1).expect("member");
w.end_container().expect("end");
let bytes = w.finish().expect("finish");
assert_eq!(
decode::<TlvList<'_, u16>>(bytes).map_err(|e| e.code()),
Err(ErrorCode::TlvWrongType)
);
}
#[test]
fn a_member_that_does_not_decode_surfaces_at_that_member() {
let mut buf = [0u8; 64];
let mut w = TlvWriter::new(&mut buf);
w.start_array(Tag::Anonymous).expect("array");
w.unsigned(Tag::Anonymous, 1).expect("member");
w.utf8(Tag::Anonymous, "not a number").expect("member");
w.end_container().expect("end");
let bytes = w.finish().expect("finish");
let list: TlvList<'_, u16> = decode(bytes).expect("the list itself is well formed");
let mut entries = list.iter();
assert_eq!(entries.next().expect("first").expect("a number"), 1);
assert!(entries.next().expect("second").is_err());
}
}