dbc_rs/bit_timing/builder/
impls.rs

1use super::BitTimingBuilder;
2
3impl BitTimingBuilder {
4    /// Creates a new `BitTimingBuilder` with no values set.
5    ///
6    /// # Examples
7    ///
8    /// ```rust,no_run
9    /// use dbc_rs::BitTimingBuilder;
10    ///
11    /// let builder = BitTimingBuilder::new();
12    /// let bt = builder.build()?;
13    /// assert!(bt.is_empty());
14    /// # Ok::<(), dbc_rs::Error>(())
15    /// ```
16    pub fn new() -> Self {
17        Self {
18            baudrate: None,
19            btr1: None,
20            btr2: None,
21        }
22    }
23
24    /// Sets the baudrate in bits per second.
25    ///
26    /// # Arguments
27    ///
28    /// * `baudrate` - The CAN bus baudrate (e.g., 500000 for 500 kbps)
29    ///
30    /// # Examples
31    ///
32    /// ```rust,no_run
33    /// use dbc_rs::BitTimingBuilder;
34    ///
35    /// let bt = BitTimingBuilder::new()
36    ///     .baudrate(500000)
37    ///     .build()?;
38    /// assert_eq!(bt.baudrate(), Some(500000));
39    /// # Ok::<(), dbc_rs::Error>(())
40    /// ```
41    #[must_use = "builder method returns modified builder"]
42    pub fn baudrate(mut self, baudrate: u32) -> Self {
43        self.baudrate = Some(baudrate);
44        self
45    }
46
47    /// Sets the Bus Timing Register 1 (BTR1) value.
48    ///
49    /// BTR1 is typically only meaningful when baudrate is also set.
50    ///
51    /// # Arguments
52    ///
53    /// * `btr1` - The BTR1 register value
54    ///
55    /// # Examples
56    ///
57    /// ```rust,no_run
58    /// use dbc_rs::BitTimingBuilder;
59    ///
60    /// let bt = BitTimingBuilder::new()
61    ///     .baudrate(500000)
62    ///     .btr1(1)
63    ///     .build()?;
64    /// assert_eq!(bt.btr1(), Some(1));
65    /// # Ok::<(), dbc_rs::Error>(())
66    /// ```
67    #[must_use = "builder method returns modified builder"]
68    pub fn btr1(mut self, btr1: u32) -> Self {
69        self.btr1 = Some(btr1);
70        self
71    }
72
73    /// Sets the Bus Timing Register 2 (BTR2) value.
74    ///
75    /// BTR2 is typically only meaningful when baudrate and BTR1 are also set.
76    ///
77    /// # Arguments
78    ///
79    /// * `btr2` - The BTR2 register value
80    ///
81    /// # Examples
82    ///
83    /// ```rust,no_run
84    /// use dbc_rs::BitTimingBuilder;
85    ///
86    /// let bt = BitTimingBuilder::new()
87    ///     .baudrate(500000)
88    ///     .btr1(1)
89    ///     .btr2(2)
90    ///     .build()?;
91    /// assert_eq!(bt.btr2(), Some(2));
92    /// # Ok::<(), dbc_rs::Error>(())
93    /// ```
94    #[must_use = "builder method returns modified builder"]
95    pub fn btr2(mut self, btr2: u32) -> Self {
96        self.btr2 = Some(btr2);
97        self
98    }
99}
100
101#[cfg(test)]
102mod tests {
103    use super::BitTimingBuilder;
104
105    #[test]
106    fn test_bit_timing_builder_empty() {
107        let bt = BitTimingBuilder::new().build().unwrap();
108        assert!(bt.is_empty());
109        assert_eq!(bt.baudrate(), None);
110        assert_eq!(bt.btr1(), None);
111        assert_eq!(bt.btr2(), None);
112    }
113
114    #[test]
115    fn test_bit_timing_builder_baudrate_only() {
116        let bt = BitTimingBuilder::new().baudrate(500000).build().unwrap();
117        assert!(!bt.is_empty());
118        assert_eq!(bt.baudrate(), Some(500000));
119        assert_eq!(bt.btr1(), None);
120        assert_eq!(bt.btr2(), None);
121    }
122
123    #[test]
124    fn test_bit_timing_builder_full() {
125        let bt = BitTimingBuilder::new().baudrate(500000).btr1(1).btr2(2).build().unwrap();
126        assert!(!bt.is_empty());
127        assert_eq!(bt.baudrate(), Some(500000));
128        assert_eq!(bt.btr1(), Some(1));
129        assert_eq!(bt.btr2(), Some(2));
130    }
131
132    #[test]
133    fn test_bit_timing_builder_default() {
134        let bt = BitTimingBuilder::default().build().unwrap();
135        assert!(bt.is_empty());
136    }
137}
138
139impl Default for BitTimingBuilder {
140    fn default() -> Self {
141        Self::new()
142    }
143}