cantools 0.2.1

CAN-bus data analysis 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

//! Module providing utility traits for accessing and mutating CAN-bus data.
//!
//! The [CANRead] trait provides methods and retrieve the [DLC](CANRead::dlc), the number of
//! available bytes, and a [data](CANRead::data) slice that is read-only. In theory, only the
//! [data](CANRead::data) slice is needed since one can retrieve the DLC from the slice as well.
//!
//! The [CANWrite] trait provides one additional methods. The [mut_data](CANWrite::mut_data) method
//! allows for mutating the slice.

/// A trait providing methods for accessing the underlying bytes of some CAN-bus data.
pub trait CANRead {
    /// Returns a slice representing the accessible bytes.
    fn data(&self) -> &[u8];

    /// Returns the number of accessible bytes.
    fn dlc(&self) -> usize;
}

/// A trait providing methods for accessing the underlying data in a mutable fashion.
pub trait CANWrite: CANRead {
    /// Returns a mutable slice representing the mutable data.
    fn mut_data(&mut self) -> &mut [u8];
}

impl CANRead for Vec<u8> {
    /// # Example
    /// ```
    /// use cantools::data::CANRead;
    /// let v = Vec::<u8>::new();
    /// assert_eq!(CANRead::data(&v), &[]);
    /// ```
    fn data(&self) -> &[u8] {
        self.as_slice()
    }

    /// # Example
    /// ```
    /// use cantools::data::CANRead;
    /// let v = Vec::<u8>::new();
    /// assert_eq!(CANRead::dlc(&v), 0);
    /// ```
    fn dlc(&self) -> usize {
        self.len()
    }
}

impl CANWrite for Vec<u8> {
    fn mut_data(&mut self) -> &mut [u8] {
        self.as_mut_slice()
    }
}

impl CANRead for &[u8] {
    /// ```
    /// use cantools::data::CANRead;
    /// let v : [u8; 0] = [];
    /// assert_eq!(CANRead::data(&v), &[]);
    /// ```
    fn data(&self) -> &[u8] {
        self
    }

    /// # Example
    /// ```
    /// use cantools::data::CANRead;
    /// let v : [u8; 0] = [];
    /// assert_eq!(CANRead::dlc(&v), 0);
    /// ```
    fn dlc(&self) -> usize {
        self.len()
    }
}

impl CANRead for &mut [u8] {
    fn data(&self) -> &[u8] {
        self
    }

    fn dlc(&self) -> usize {
        self.len()
    }
}

impl CANWrite for &mut [u8] {
    fn mut_data(&mut self) -> &mut [u8] {
        self
    }
}

impl<const N: usize> CANRead for [u8; N] {
    fn data(&self) -> &[u8] {
        self.as_ref()
    }

    fn dlc(&self) -> usize {
        self.len()
    }
}

impl<const N: usize> CANWrite for [u8; N] {
    fn mut_data(&mut self) -> &mut [u8] {
        self.as_mut()
    }
}

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

    #[test]
    fn test_001() {
        for i in 0..8 {
            let mut v = Vec::new();
            for j in 0..i {
                v.push(j);
            }
            assert_eq!(CANRead::dlc(&v), i as usize);
        }
    }

    #[test]
    fn test_002() {
        for i in 0..8 {
            let mut v = Vec::new();
            for j in 0..i {
                v.push(j);
            }
            assert_eq!(CANRead::data(&v), v.as_slice());
        }
    }
}