udevrs 0.5.0

Pure Rust implementation of the user-land udev 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

use std::cmp;

use crate::{hwdb, Error, Result};

/// Trie child entry in the hardware database.
///
/// Array of child entries that directly follows the node record.
#[repr(C, packed(8))]
#[derive(Clone, Copy, Debug, Default, Eq, PartialEq)]
pub struct TrieChildEntry {
    c: u8,
    _padding: [u8; 7],
    child_off: u64,
}

impl TrieChildEntry {
    /// Creates a new [TrieChildEntry].
    pub const fn new() -> Self {
        Self {
            c: 0,
            _padding: [0u8; 7],
            child_off: 0,
        }
    }

    /// Gets the length of the encoded [TrieChildEntry].
    pub fn len(&self) -> usize {
        hwdb::child_entry_size()
    }

    /// Gets whether the [TrieChildEntry] is empty.
    pub const fn is_empty(&self) -> bool {
        false
    }

    /// Gets the index of the child node.
    pub const fn c(&self) -> u8 {
        self.c
    }

    /// Sets the index of the child node.
    pub fn set_c(&mut self, val: u8) {
        self.c = val;
    }

    /// Builder function that sets the index of the child node.
    pub fn with_c(mut self, val: u8) -> Self {
        self.set_c(val);
        self
    }

    /// Gets the offset of the child node.
    pub const fn child_off(&self) -> u64 {
        self.child_off
    }

    /// Sets the offset of the child node.
    pub fn set_child_off(&mut self, val: u64) {
        self.child_off = val;
    }

    /// Builder function that sets the offset of the child node.
    pub fn with_child_off(mut self, val: u64) -> Self {
        self.set_child_off(val);
        self
    }
}

impl TryFrom<&[u8]> for TrieChildEntry {
    type Error = Error;

    fn try_from(val: &[u8]) -> Result<Self> {
        if val.len() < hwdb::child_entry_size() {
            Err(Error::InvalidLen(val.len()))
        } else {
            // TODO: parse use get ranges and offsets
            let mut idx = 0usize;

            let c = val[idx];
            let _padding = [0u8; 7];

            // skip `c` index + padding
            idx += 8;

            let child_off =
                u64::from_le_bytes(val[idx..idx + std::mem::size_of::<u64>()].try_into()?);

            Ok(Self {
                c,
                _padding,
                child_off,
            })
        }
    }
}

impl Ord for TrieChildEntry {
    fn cmp(&self, other: &Self) -> cmp::Ordering {
        self.c.cmp(&other.c)
    }
}

impl PartialOrd for TrieChildEntry {
    fn partial_cmp(&self, other: &Self) -> Option<cmp::Ordering> {
        Some(self.c.cmp(&other.c))
    }
}