1use core::marker::PhantomData;
30
31use super::reader::{Element, TlvReader, Value};
32use super::types::{ContainerKind, Tag};
33use super::writer::TlvWriter;
34use crate::error::{Error, ErrorCode, Result, bail};
35
36pub trait ToTlv {
38 fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()>;
40}
41
42pub trait FromTlv<'a>: Sized {
48 fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self>;
50}
51
52impl ToTlv for bool {
55 fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
56 w.bool(tag, *self)
57 }
58}
59
60impl FromTlv<'_> for bool {
61 fn from_tlv(_reader: &mut TlvReader<'_>, element: &Element<'_>) -> Result<Self> {
62 element.bool()
63 }
64}
65
66macro_rules! unsigned {
72 ($($ty:ty),+) => {$(
73 impl ToTlv for $ty {
74 fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
75 w.unsigned(tag, u64::from(*self))
76 }
77 }
78
79 impl FromTlv<'_> for $ty {
80 fn from_tlv(_reader: &mut TlvReader<'_>, element: &Element<'_>) -> Result<Self> {
81 Self::try_from(element.unsigned()?)
82 .map_err(|_| Error::new(ErrorCode::TlvOutOfRange))
83 }
84 }
85 )+};
86}
87unsigned!(u8, u16, u32);
88
89impl ToTlv for u64 {
90 fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
91 w.unsigned(tag, *self)
92 }
93}
94
95impl FromTlv<'_> for u64 {
96 fn from_tlv(_reader: &mut TlvReader<'_>, element: &Element<'_>) -> Result<Self> {
97 element.unsigned()
98 }
99}
100
101macro_rules! signed {
102 ($($ty:ty),+) => {$(
103 impl ToTlv for $ty {
104 fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
105 w.signed(tag, i64::from(*self))
106 }
107 }
108
109 impl FromTlv<'_> for $ty {
110 fn from_tlv(_reader: &mut TlvReader<'_>, element: &Element<'_>) -> Result<Self> {
111 Self::try_from(element.signed()?)
112 .map_err(|_| Error::new(ErrorCode::TlvOutOfRange))
113 }
114 }
115 )+};
116}
117signed!(i8, i16, i32);
118
119impl ToTlv for i64 {
120 fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
121 w.signed(tag, *self)
122 }
123}
124
125impl FromTlv<'_> for i64 {
126 fn from_tlv(_reader: &mut TlvReader<'_>, element: &Element<'_>) -> Result<Self> {
127 element.signed()
128 }
129}
130
131impl ToTlv for f32 {
132 fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
133 w.float(tag, *self)
134 }
135}
136
137impl FromTlv<'_> for f32 {
138 fn from_tlv(_reader: &mut TlvReader<'_>, element: &Element<'_>) -> Result<Self> {
139 match element.value {
140 Value::Float(v) => Ok(v),
141 _ => Err(Error::new(ErrorCode::TlvWrongType)),
144 }
145 }
146}
147
148impl ToTlv for f64 {
149 fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
150 w.double(tag, *self)
151 }
152}
153
154impl FromTlv<'_> for f64 {
155 fn from_tlv(_reader: &mut TlvReader<'_>, element: &Element<'_>) -> Result<Self> {
156 match element.value {
157 Value::Double(v) => Ok(v),
158 Value::Float(v) => Ok(f64::from(v)),
161 _ => Err(Error::new(ErrorCode::TlvWrongType)),
162 }
163 }
164}
165
166impl ToTlv for &str {
167 fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
168 w.utf8(tag, self)
169 }
170}
171
172impl<'a> FromTlv<'a> for &'a str {
173 fn from_tlv(_reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
174 element.utf8()
175 }
176}
177
178impl ToTlv for &[u8] {
179 fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
180 w.octets(tag, self)
181 }
182}
183
184impl<'a> FromTlv<'a> for &'a [u8] {
185 fn from_tlv(_reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
186 element.octets()
187 }
188}
189
190macro_rules! newtype {
197 ($($ty:path => $inner:ty),+ $(,)?) => {$(
198 impl ToTlv for $ty {
199 fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
200 self.0.to_tlv(w, tag)
201 }
202 }
203
204 impl<'a> FromTlv<'a> for $ty {
205 fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
206 <$inner as FromTlv<'a>>::from_tlv(reader, element).map(Self)
207 }
208 }
209 )+};
210}
211newtype!(
212 crate::msg::NodeId => u64,
213 crate::msg::GroupId => u16,
214 crate::msg::VendorId => u16,
215 crate::msg::FabricIndex => u8,
216);
217
218#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Default)]
229pub struct Nullable<T>(pub Option<T>);
230
231impl<T> Nullable<T> {
232 pub const fn some(value: T) -> Self {
234 Self(Some(value))
235 }
236
237 pub const fn null() -> Self {
239 Self(None)
240 }
241
242 pub const fn is_null(&self) -> bool {
244 self.0.is_none()
245 }
246}
247
248impl<T: ToTlv> ToTlv for Nullable<T> {
249 fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
250 match &self.0 {
251 Some(value) => value.to_tlv(w, tag),
252 None => w.null(tag),
253 }
254 }
255}
256
257impl<'a, T: FromTlv<'a>> FromTlv<'a> for Nullable<T> {
258 fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
259 if element.value.is_null() {
260 return Ok(Self(None));
261 }
262 T::from_tlv(reader, element).map(Self::some)
263 }
264}
265
266#[derive(Debug, Clone, Copy, PartialEq, Eq)]
279pub struct TlvList<'a, T> {
280 members: &'a [u8],
281 _entry: PhantomData<fn() -> T>,
282}
283
284impl<T> Default for TlvList<'_, T> {
285 fn default() -> Self {
287 Self {
288 members: &[],
289 _entry: PhantomData,
290 }
291 }
292}
293
294impl<'a, T> TlvList<'a, T> {
295 #[must_use]
297 pub const fn from_members(members: &'a [u8]) -> Self {
298 Self {
299 members,
300 _entry: PhantomData,
301 }
302 }
303
304 #[must_use]
306 pub const fn members(&self) -> &'a [u8] {
307 self.members
308 }
309
310 #[must_use]
312 pub const fn is_empty(&self) -> bool {
313 self.members.is_empty()
314 }
315}
316
317impl<'a, T: FromTlv<'a>> TlvList<'a, T> {
318 pub fn iter(&self) -> impl Iterator<Item = Result<T>> + 'a {
320 let mut reader = TlvReader::new_members(self.members, ContainerKind::Array);
321 core::iter::from_fn(move || match reader.next_element() {
322 Ok(None) => None,
323 Ok(Some(element)) if element.value == Value::EndOfContainer => None,
324 Ok(Some(element)) => Some(T::from_tlv(&mut reader, &element)),
325 Err(error) => Some(Err(error)),
326 })
327 }
328
329 pub fn count(&self) -> Result<usize> {
334 let mut n = 0usize;
335 for entry in self.iter() {
336 entry?;
337 n = n.saturating_add(1);
338 }
339 Ok(n)
340 }
341}
342
343impl<T> ToTlv for TlvList<'_, T> {
344 fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
345 w.start_array(tag)?;
346 let mut reader = TlvReader::new_members(self.members, ContainerKind::Array);
350 loop {
351 let start = reader.position();
352 let Some(element) = reader.next_element()? else {
353 break;
354 };
355 if element.value == Value::EndOfContainer {
356 break;
357 }
358 reader.skip_value(&element)?;
359 w.raw_element(reader.slice_from(start)?)?;
360 }
361 w.end_container()
362 }
363}
364
365impl<'a, T> FromTlv<'a> for TlvList<'a, T> {
366 fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
367 if element.value.container() != Some(ContainerKind::Array) {
368 bail!(TlvWrongType)
369 }
370 let start = reader.position();
375 let end = loop {
376 let before = reader.position();
377 let Some(member) = reader.next_element()? else {
378 bail!(TlvTruncated)
379 };
380 if member.value == Value::EndOfContainer {
381 break before;
382 }
383 reader.skip_value(&member)?;
384 };
385 let members = reader
386 .slice_from(start)?
387 .get(..end.saturating_sub(start))
388 .ok_or(Error::new(ErrorCode::TlvTruncated))?;
389 Ok(Self::from_members(members))
390 }
391}
392
393#[cfg(test)]
394mod tests {
395 use super::*;
396
397 fn round_trip<'a, T>(value: &T, buf: &'a mut [u8]) -> &'a [u8]
398 where
399 T: ToTlv,
400 {
401 let mut w = TlvWriter::new(buf);
402 value.to_tlv(&mut w, Tag::Anonymous).expect("encode");
403 w.finish().expect("finish")
404 }
405
406 fn decode<'a, T: FromTlv<'a>>(bytes: &'a [u8]) -> Result<T> {
407 let mut reader = TlvReader::new(bytes);
408 let element = reader.next_element()?.expect("an element");
409 T::from_tlv(&mut reader, &element)
410 }
411
412 #[test]
413 fn the_primitives_round_trip() {
414 let mut buf = [0u8; 64];
415 assert!(decode::<bool>(round_trip(&true, &mut buf)).expect("bool"));
416 assert_eq!(
417 decode::<u16>(round_trip(&1234u16, &mut buf)).expect("u16"),
418 1234
419 );
420 assert_eq!(
421 decode::<i32>(round_trip(&-7i32, &mut buf)).expect("i32"),
422 -7
423 );
424 assert_eq!(
425 decode::<u64>(round_trip(&u64::MAX, &mut buf)).expect("u64"),
426 u64::MAX
427 );
428 let bytes = round_trip(&"hello", &mut buf);
429 assert_eq!(decode::<&str>(bytes).expect("str"), "hello");
430 let mut buf2 = [0u8; 64];
431 let bytes = round_trip(&&[1u8, 2, 3][..], &mut buf2);
432 assert_eq!(decode::<&[u8]>(bytes).expect("octets"), &[1, 2, 3]);
433 }
434
435 #[test]
436 fn a_value_too_wide_for_its_field_is_refused_rather_than_truncated() {
437 let mut buf = [0u8; 32];
441 let wide = round_trip(&300u32, &mut buf);
442 assert_eq!(
443 decode::<u8>(wide).map_err(|e| e.code()),
444 Err(ErrorCode::TlvOutOfRange)
445 );
446 assert_eq!(decode::<u16>(wide).expect("fits"), 300);
447 }
448
449 #[test]
450 fn null_and_absent_are_different_things() {
451 let mut buf = [0u8; 32];
455 let bytes = round_trip(&Nullable::<u8>::null(), &mut buf);
456 let decoded: Nullable<u8> = decode(bytes).expect("null");
457 assert!(decoded.is_null());
458
459 let bytes = round_trip(&Nullable::some(9u8), &mut buf);
460 assert_eq!(
461 decode::<Nullable<u8>>(bytes).expect("value"),
462 Nullable::some(9)
463 );
464
465 let present_and_null: Option<Nullable<u8>> = Some(Nullable::null());
468 assert!(present_and_null.is_some_and(|n| n.is_null()));
469 }
470
471 #[test]
472 fn a_list_is_read_where_it_lies() {
473 let mut buf = [0u8; 128];
474 let mut w = TlvWriter::new(&mut buf);
475 w.start_array(Tag::Anonymous).expect("array");
476 for value in 1..=5u16 {
477 w.unsigned(Tag::Anonymous, u64::from(value))
478 .expect("member");
479 }
480 w.end_container().expect("end");
481 let bytes = w.finish().expect("finish");
482
483 let list: TlvList<'_, u16> = decode(bytes).expect("list");
484 assert_eq!(list.count().expect("count"), 5);
485 let values: Result<heapless::Vec<u16, 8>> = list.iter().collect();
486 assert_eq!(values.expect("members").as_slice(), &[1, 2, 3, 4, 5]);
487
488 let mut buf = [0u8; 16];
490 let mut w = TlvWriter::new(&mut buf);
491 w.start_array(Tag::Anonymous).expect("array");
492 w.end_container().expect("end");
493 let bytes = w.finish().expect("finish");
494 let empty: TlvList<'_, u16> = decode(bytes).expect("list");
495 assert!(empty.is_empty());
496 assert_eq!(empty.count().expect("count"), 0);
497 }
498
499 #[test]
500 fn a_decoded_list_re_encodes_to_the_same_bytes() {
501 let mut buf = [0u8; 128];
504 let mut w = TlvWriter::new(&mut buf);
505 w.start_array(Tag::Anonymous).expect("array");
506 for value in [7u32, 70, 700, 7000] {
507 w.unsigned(Tag::Anonymous, u64::from(value))
508 .expect("member");
509 }
510 w.end_container().expect("end");
511 let original = w.finish().expect("finish").to_vec();
512
513 let list: TlvList<'_, u32> = decode(&original).expect("list");
514 let mut out = [0u8; 128];
515 let again = round_trip(&list, &mut out);
516 assert_eq!(again, original.as_slice());
517 }
518
519 #[test]
520 fn a_list_of_the_wrong_container_kind_is_refused() {
521 let mut buf = [0u8; 64];
525 let mut w = TlvWriter::new(&mut buf);
526 w.start_structure(Tag::Anonymous).expect("structure");
527 w.unsigned(Tag::Context(0), 1).expect("member");
528 w.end_container().expect("end");
529 let bytes = w.finish().expect("finish");
530 assert_eq!(
531 decode::<TlvList<'_, u16>>(bytes).map_err(|e| e.code()),
532 Err(ErrorCode::TlvWrongType)
533 );
534 }
535
536 #[test]
537 fn a_member_that_does_not_decode_surfaces_at_that_member() {
538 let mut buf = [0u8; 64];
541 let mut w = TlvWriter::new(&mut buf);
542 w.start_array(Tag::Anonymous).expect("array");
543 w.unsigned(Tag::Anonymous, 1).expect("member");
544 w.utf8(Tag::Anonymous, "not a number").expect("member");
545 w.end_container().expect("end");
546 let bytes = w.finish().expect("finish");
547
548 let list: TlvList<'_, u16> = decode(bytes).expect("the list itself is well formed");
549 let mut entries = list.iter();
550 assert_eq!(entries.next().expect("first").expect("a number"), 1);
551 assert!(entries.next().expect("second").is_err());
552 }
553}