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

use crate::tag::{message::DecodeMessage, CapabilityContainer, IterBlock};
use crate::Encode;

#[cfg(any(feature = "std", feature = "alloc"))]
use alloc::vec::Vec;

/// A raw TLV tag consisting of a Capability Container and a borrowed byte
/// slice.
///
/// Parsing into [`HeaplessTag`] or the allocated [`Tag`] type is performed
/// via [`blocks`], which produces a [`IterBlock`].
///
/// This type does **not** validate the TLV payload by itself.
///
/// [`blocks`]: RawTag::blocks
/// [`Tag`]: crate::Tag
/// [`HeaplessTag`]: crate::HeaplessTag
#[derive(Debug, Clone, derive_new::new)]
pub struct RawTag<'t> {
    pub cc: CapabilityContainer,
    pub bytes: &'t [u8],
}

impl<'t> RawTag<'t> {
    #[inline(always)]
    pub fn decode(bytes: &'t [u8]) -> crate::Result<Self> {
        Self::try_from(bytes)
    }

    pub fn blocks<B: DecodeMessage<'t>>(&self) -> IterBlock<'t, B> {
        IterBlock::new(self.bytes)
    }
}

impl<'t> TryFrom<&'t [u8]> for RawTag<'t> {
    type Error = crate::Error;

    fn try_from(bytes: &'t [u8]) -> Result<Self, Self::Error> {
        let cc = CapabilityContainer::try_from(bytes)?;
        Ok(Self { cc, bytes: &bytes[cc.encoded_len()..] })
    }
}

#[cfg(any(feature = "std", feature = "alloc"))]
impl<'t> TryFrom<&'t Vec<u8>> for RawTag<'t> {
    type Error = crate::Error;

    fn try_from(bytes: &'t Vec<u8>) -> Result<Self, Self::Error> {
        Self::try_from(bytes.as_slice())
    }
}

#[cfg(not(any(feature = "std", feature = "alloc")))]
impl<'t, const L: usize> TryFrom<&'t heapless::Vec<u8, L>> for RawTag<'t> {
    type Error = crate::Error;

    fn try_from(bytes: &'t heapless::Vec<u8, L>) -> Result<Self, Self::Error> {
        Self::try_from(bytes.as_slice())
    }
}