nanondef 0.0.1

A no-std, no-alloc, minimal NDEF encoding and decoding library.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106

use crate::{
    tag::message::{record::Record, IterRaw, IterRecord},
    Error,
};
use core::any::type_name;

/// A unified iterator over [`Record`] values.
///
/// This wrapper abstracts over two concrete iterator types:
/// - [`RawIter`] decodes records on demand from a byte slice
/// - [`DataIter`] yields already-decoded records from a slice or vec
///
/// # Lifetimes
/// - `'r`: lifetime of the underlying record data.
/// - `'i`: lifetime of the slice being iterated.
pub enum Iter<'r, 'i> {
    /// Decode records directly from a raw byte slice.
    Raw(IterRaw<'r>),

    /// Iterate over an in-memory list of decoded records.
    Decoded(IterRecord<'r, 'i>),
}

impl<'r, 'i> Iterator for Iter<'r, 'i> {
    type Item = crate::Result<Record<'r>>;

    fn next(&mut self) -> Option<Self::Item> {
        match self {
            Self::Decoded(iter) => iter.next(),
            Self::Raw(iter) => iter.next(),
        }
    }
}

impl<'r, 'i> From<&'r [u8]> for Iter<'r, 'i> {
    #[inline]
    fn from(bytes: &'r [u8]) -> Self {
        Self::Raw(bytes.into())
    }
}

impl<'r, 'i> From<&'i [Record<'r>]> for Iter<'r, 'i> {
    #[inline]
    fn from(s: &'i [Record<'r>]) -> Self {
        Self::Decoded(s.into())
    }
}

#[cfg(any(feature = "std", feature = "alloc"))]
impl<'r, 'i> From<&'i Vec<Record<'r>>> for Iter<'r, 'i> {
    #[inline]
    fn from(vec: &'i Vec<Record<'r>>) -> Self {
        Self::Decoded(vec.into())
    }
}

impl<'r, 'i, const L: usize> From<&'i heapless::Vec<Record<'r>, L>> for Iter<'r, 'i> {
    #[inline]
    fn from(vec: &'i heapless::Vec<Record<'r>, L>) -> Self {
        Self::Decoded(vec.into())
    }
}

impl<'r, 'i> From<IterRaw<'r>> for Iter<'r, 'i> {
    #[inline(always)]
    fn from(i: IterRaw<'r>) -> Self {
        Self::Raw(i)
    }
}

impl<'r, 'i> TryFrom<Iter<'r, 'i>> for IterRaw<'r> {
    type Error = Error;

    #[inline]
    fn try_from(i: Iter<'r, 'i>) -> Result<Self, Self::Error> {
        match i {
            Iter::Raw(i) => Ok(i),
            Iter::Decoded(_) => Err(Error::WrongRecordIter {
                got: type_name::<IterRecord>(),
                want: type_name::<IterRaw>(),
            }),
        }
    }
}

impl<'r, 'i> From<IterRecord<'r, 'i>> for Iter<'r, 'i> {
    #[inline(always)]
    fn from(i: IterRecord<'r, 'i>) -> Self {
        Self::Decoded(i)
    }
}

impl<'r, 'i> TryFrom<Iter<'r, 'i>> for IterRecord<'r, 'i> {
    type Error = Error;

    #[inline]
    fn try_from(i: Iter<'r, 'i>) -> Result<Self, Self::Error> {
        match i {
            Iter::Raw(_) => Err(Error::WrongRecordIter {
                got: type_name::<IterRaw>(),
                want: type_name::<IterRecord>(),
            }),
            Iter::Decoded(i) => Ok(i),
        }
    }
}