blue 0.0.1

An extensive unified bluetooth library
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

mod os;
mod addr;

pub use addr::Addr;

#[derive(Clone, Hash, Eq, PartialEq)]
pub struct RadioInfo {
    inner: os::RadioInfo,
}

impl RadioInfo {
    pub fn addr(&self) -> Addr {
        self.inner.addr()
    }

    pub fn name(&self) -> &str {
        self.inner.name()
    }

    pub fn class(&self) -> u32 {
        self.inner.class()
    }

    pub fn subversion(&self) -> u16 {
        self.inner.subversion()
    }

    pub fn manufacturer(&self) -> u16 {
        self.inner.manufacturer()
    }
}

impl std::fmt::Debug for RadioInfo {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        f.debug_struct("RadioInfo")
            .field("addr", &self.addr())
            .field("name", &self.name())
            .field("class", &format_args!("0x{:X}", self.class()))
            .field("subversion", &format_args!("0x{:X}", self.subversion()))
            .field("manufacturer", &format_args!("0x{:X}", self.manufacturer()))
            .finish()
    }
}

#[derive(Debug)]
pub struct Radio {
    inner: os::Radio,
}

impl Radio {
    pub fn info(&self) -> RadioInfo {
        RadioInfo { inner: self.inner.info() }
    }
}

#[derive(Debug)]
pub struct Radios {
    inner: os::Radios
}

impl Iterator for Radios {
    type Item = Radio;

    fn next(&mut self) -> Option<Self::Item> {
        self.inner.next().map(|inner| Radio { inner })
    }
}

pub fn radios() -> Radios {
    Radios {
        inner: os::radios()
    }
}