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
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

use std::fmt;

pub const SPEED_UNKNOWN: u32 = 0;
pub const SPEED_LOW: u32 = 1;
pub const SPEED_FULL: u32 = 2;
pub const SPEED_HIGH: u32 = 3;
pub const SPEED_WIRELESS: u32 = 4;
pub const SPEED_SUPER: u32 = 5;
pub const SPEED_SUPER_PLUS: u32 = 6;

/// Represents USBFS transfer speeds.
#[repr(u32)]
#[derive(Clone, Copy, Debug, Default, PartialEq)]
pub enum UsbfsSpeed {
    #[default]
    Unknown = SPEED_UNKNOWN,
    Low = SPEED_LOW,
    Full = SPEED_FULL,
    High = SPEED_HIGH,
    Wireless = SPEED_WIRELESS,
    Super = SPEED_SUPER,
    SuperPlus = SPEED_SUPER_PLUS,
}

impl UsbfsSpeed {
    /// Creates a new [UsbfsSpeed].
    pub const fn new() -> Self {
        Self::Unknown
    }

    /// Creates a new [UsbfsSpeed] from the provided parameter.
    pub const fn create(val: u32) -> Self {
        match val {
            SPEED_UNKNOWN => Self::Unknown,
            SPEED_LOW => Self::Low,
            SPEED_FULL => Self::Full,
            SPEED_HIGH => Self::High,
            SPEED_WIRELESS => Self::Wireless,
            SPEED_SUPER => Self::Super,
            SPEED_SUPER_PLUS => Self::SuperPlus,
            _ => Self::Unknown,
        }
    }

    /// Gets the inner representation of the [UsbfsSpeed].
    pub const fn inner(&self) -> u32 {
        *self as u32
    }

    /// Converts into the inner representation of the [UsbfsSpeed].
    pub fn into_inner(self) -> u32 {
        self as u32
    }
}

impl From<&UsbfsSpeed> for &'static str {
    fn from(val: &UsbfsSpeed) -> Self {
        match val {
            UsbfsSpeed::Unknown => "unknown",
            UsbfsSpeed::Low => "low",
            UsbfsSpeed::Full => "full",
            UsbfsSpeed::High => "high",
            UsbfsSpeed::Wireless => "wireless",
            UsbfsSpeed::Super => "super",
            UsbfsSpeed::SuperPlus => "super plus",
        }
    }
}

impl From<UsbfsSpeed> for &'static str {
    fn from(val: UsbfsSpeed) -> Self {
        (&val).into()
    }
}

impl From<u32> for UsbfsSpeed {
    fn from(val: u32) -> Self {
        Self::create(val)
    }
}

impl From<&UsbfsSpeed> for u32 {
    fn from(val: &UsbfsSpeed) -> Self {
        val.inner()
    }
}

impl From<UsbfsSpeed> for u32 {
    fn from(val: UsbfsSpeed) -> Self {
        val.into_inner()
    }
}

impl fmt::Display for UsbfsSpeed {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, r#""{}""#, <&str>::from(self))
    }
}

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

    #[test]
    fn test_usbfs_speed() {
        assert_eq!(SPEED_UNKNOWN, UsbfsSpeed::Unknown.inner());
        assert_eq!(SPEED_LOW, UsbfsSpeed::Low.inner());
        assert_eq!(SPEED_FULL, UsbfsSpeed::Full.inner());
        assert_eq!(SPEED_HIGH, UsbfsSpeed::High.inner());
        assert_eq!(SPEED_WIRELESS, UsbfsSpeed::Wireless.inner());
        assert_eq!(SPEED_SUPER, UsbfsSpeed::Super.inner());
        assert_eq!(SPEED_SUPER_PLUS, UsbfsSpeed::SuperPlus.inner());

        assert_eq!(UsbfsSpeed::from(SPEED_UNKNOWN), UsbfsSpeed::Unknown);
        assert_eq!(UsbfsSpeed::from(SPEED_LOW), UsbfsSpeed::Low);
        assert_eq!(UsbfsSpeed::from(SPEED_FULL), UsbfsSpeed::Full);
        assert_eq!(UsbfsSpeed::from(SPEED_HIGH), UsbfsSpeed::High);
        assert_eq!(UsbfsSpeed::from(SPEED_WIRELESS), UsbfsSpeed::Wireless);
        assert_eq!(UsbfsSpeed::from(SPEED_SUPER), UsbfsSpeed::Super);
        assert_eq!(UsbfsSpeed::from(SPEED_SUPER_PLUS), UsbfsSpeed::SuperPlus);
    }
}