usbfs 0.1.1

Port of the usbfs Linux userspace library in pure Rust
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

use std::fmt;

/// Represents USBFS connection information.
#[repr(C)]
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub struct UsbfsConnectInfo {
    devnum: u32,
    slow: u8,
}

impl UsbfsConnectInfo {
    /// Creates a new [UsbfsConnectInfo].
    pub const fn new() -> Self {
        Self { devnum: 0, slow: 0 }
    }

    /// Creates a new [UsbfsConnectInfo] from the provided parameter.
    pub const fn create(devnum: u32, slow: u8) -> Self {
        Self { devnum, slow }
    }

    /// Gets the device number.
    pub const fn devnum(&self) -> u32 {
        self.devnum
    }

    /// Sets the device number.
    pub fn set_devnum(&mut self, devnum: u32) {
        self.devnum = devnum;
    }

    /// Builder function that sets the device number.
    pub fn with_devnum(mut self, devnum: u32) -> Self {
        self.set_devnum(devnum);
        self
    }

    /// Gets the slow field.
    pub const fn slow(&self) -> u8 {
        self.slow
    }

    /// Sets the slow number.
    pub fn set_slow(&mut self, slow: u8) {
        self.slow = slow;
    }

    /// Builder function that sets the slow number.
    pub fn with_slow(mut self, slow: u8) -> Self {
        self.set_slow(slow);
        self
    }
}

impl fmt::Display for UsbfsConnectInfo {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{{")?;
        write!(f, r#""devnum": {}, "#, self.devnum)?;
        write!(f, r#""slow": {}"#, self.slow)?;
        write!(f, "}}")
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_usbfs_connect_info() {
        let exp_devnum = 42;
        let exp_slow = 1;

        let exp_info = UsbfsConnectInfo::create(exp_devnum, exp_slow);
        let mut null_info = UsbfsConnectInfo::new();

        assert_eq!(exp_info.devnum(), exp_devnum);
        assert_eq!(exp_info.slow(), exp_slow);

        assert_eq!(null_info.devnum(), 0);
        assert_eq!(null_info.slow(), 0);

        null_info.set_devnum(exp_devnum);
        assert_eq!(null_info.devnum(), exp_devnum);

        null_info.set_slow(exp_slow);
        assert_eq!(null_info.slow(), exp_slow);

        assert_eq!(
            UsbfsConnectInfo::new().with_devnum(exp_devnum).devnum(),
            exp_devnum
        );
        assert_eq!(UsbfsConnectInfo::new().with_slow(exp_slow).slow(), exp_slow);
    }
}