burble 0.2.2

A cross-platform user-mode Bluetooth LE 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
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135

use std::fmt::{Debug, Formatter, Write};
use std::num::NonZeroU16;

use crate::{hci, name_of};

/// LE-U logical link ([Vol 1] Part A, Section 3.5.5.2.2).
#[derive(Clone, Copy, Eq, Hash, PartialEq)]
#[repr(transparent)]
pub struct LeU(hci::ConnHandle);

impl LeU {
    /// Creates an LE-U logical link from an HCI connection handle.
    #[inline]
    #[must_use]
    pub(super) const fn new(cn: hci::ConnHandle) -> Self {
        Self(cn)
    }

    /// Associates a channel identifier with an LE-U logical link.
    #[inline]
    #[must_use]
    pub(super) fn chan(self, chan: Cid) -> LeCid {
        assert!(chan.is_le());
        LeCid { link: self, chan }
    }
}

impl From<LeU> for u16 {
    #[inline]
    fn from(link: LeU) -> Self {
        Self::from(link.0)
    }
}

impl From<LeU> for hci::ConnHandle {
    #[inline]
    fn from(link: LeU) -> Self {
        link.0
    }
}

impl Debug for LeU {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}({:#05X})", name_of!(LeU), u16::from(*self))
    }
}

/// Channel identifier ([Vol 3] Part A, Section 2.1).
#[derive(Clone, Copy, Eq, Hash, Ord, PartialEq, PartialOrd)]
#[repr(transparent)]
pub struct Cid(NonZeroU16);

impl Cid {
    /// Attribute protocol channel.
    pub(crate) const ATT: Self = Self::fixed(0x0004);
    /// LE signaling channel.
    pub(crate) const SIG: Self = Self::fixed(0x0005);
    /// Security Manager protocol channel.
    pub(crate) const SMP: Self = Self::fixed(0x0006);

    /// Wraps a fixed CID.
    #[inline]
    #[must_use]
    const fn fixed(v: u16) -> Self {
        // SAFETY: Only called for valid fixed channels
        Self(unsafe { NonZeroU16::new_unchecked(v) })
    }

    /// Wraps a raw CID. Returns `None` if the CID is invalid.
    #[inline]
    #[must_use]
    pub(super) const fn new(v: u16) -> Option<Self> {
        // TODO: Use map() when it is const stable
        match NonZeroU16::new(v) {
            Some(nz) => Some(Self(nz)),
            None => None,
        }
    }

    /// Returns whether the CID is valid for an LE-U logical link
    /// ([Vol 3] Part A, Section 2.1, Table 2.3 and
    /// [Assigned Numbers] Section 2.9).
    #[inline]
    #[must_use]
    pub(super) const fn is_le(self) -> bool {
        matches!(
            self.0.get(),
            0x0004 | 0x0005 | 0x0006 /* | 0x0020..=0x003E */ | 0x0040..=0x007F
        )
    }

    /// Writes CID name to `f`.
    #[inline(always)]
    fn write_fmt(self, f: &mut Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::ATT => f.write_str("ATT"),
            Self::SIG => f.write_str("SIG"),
            Self::SMP => f.write_str("SMP"),
            _ => write!(f, "{:#06X}", self.0.get()),
        }
    }
}

impl From<Cid> for u16 {
    #[inline]
    fn from(cid: Cid) -> Self {
        cid.0.get()
    }
}

impl Debug for Cid {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        f.write_str(name_of!(Cid))?;
        f.write_char('(')?;
        self.write_fmt(f)?;
        f.write_char(')')
    }
}

/// Channel identifier for an established LE-U logical link.
#[derive(Clone, Copy, Eq, Hash, PartialEq)]
pub struct LeCid {
    pub(crate) link: LeU,
    pub(crate) chan: Cid,
}

impl Debug for LeCid {
    fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
        write!(f, "{}({:#05X}, ", name_of!(LeCid), u16::from(self.link),)?;
        self.chan.write_fmt(f)?;
        f.write_char(')')
    }
}

crate::impl_display_via_debug! { LeU, Cid, LeCid }