messages: run cargo fmt

Author: andresv

testing/can-messages/src/messages.rs

@@ -23,7 +23,7 @@ impl Messages {
     #[inline(never)]
     pub fn from_can_message(id: u32, payload: &[u8]) -> Result<Self, CanError> {
         use core::convert::TryFrom;
-        
+
         let res = match id {
             256 => Messages::Foo(Foo::try_from(payload)?),
             512 => Messages::Bar(Bar::try_from(payload)?),
@@ -46,20 +46,20 @@ pub struct Foo {
 
 impl Foo {
     pub const MESSAGE_ID: u32 = 256;
-    
+
     /// Construct new Foo from values
     pub fn new(voltage: f32, current: f32) -> Result<Self, CanError> {
         let mut res = Self { raw: [0u8; 4] };
         res.set_voltage(voltage)?;
         res.set_current(current)?;
         Ok(res)
     }
-    
+
     /// Access message payload raw value
     pub fn raw(&self) -> &[u8] {
         &self.raw
     }
-    
+
     /// Voltage
     ///
     /// - Min: 0
@@ -70,7 +70,7 @@ impl Foo {
     pub fn voltage(&self) -> f32 {
         self.voltage_raw()
     }
-    
+
     /// Get raw value of Voltage
     ///
     /// - Start bit: 16
@@ -82,27 +82,29 @@ impl Foo {
     #[inline(always)]
     pub fn voltage_raw(&self) -> f32 {
         let signal = u16::unpack_le_bits(&self.raw, 16, 16);
-        
+
         let factor = 0.000976562_f32;
         let offset = 0_f32;
         (signal as f32) * factor + offset
     }
-    
+
     /// Set value of Voltage
     #[inline(always)]
     pub fn set_voltage(&mut self, value: f32) -> Result<(), CanError> {
         #[cfg(feature = "range_checked")]
-        if value < 0_f32 || 63.9990234375_f32 < value { return Err(CanError::ParameterOutOfRange{ message_id: 256 }); }
+        if value < 0_f32 || 63.9990234375_f32 < value {
+            return Err(CanError::ParameterOutOfRange { message_id: 256 });
+        }
         let factor = 0.000976562_f32;
         let offset = 0_f32;
         let value = ((value - offset) / factor) as u16;
-        
+
         let start_bit = 16;
         let bits = 16;
         value.pack_le_bits(&mut self.raw, start_bit, bits);
         Ok(())
     }
-    
+
     /// Current
     ///
     /// - Min: -2048
@@ -113,7 +115,7 @@ impl Foo {
     pub fn current(&self) -> f32 {
         self.current_raw()
     }
-    
+
     /// Get raw value of Current
     ///
     /// - Start bit: 0
@@ -125,42 +127,44 @@ impl Foo {
     #[inline(always)]
     pub fn current_raw(&self) -> f32 {
         let signal = i16::unpack_le_bits(&self.raw, 0, 16);
-        
+
         let factor = 0.0625_f32;
         let offset = 0_f32;
         (signal as f32) * factor + offset
     }
-    
+
     /// Set value of Current
     #[inline(always)]
     pub fn set_current(&mut self, value: f32) -> Result<(), CanError> {
         #[cfg(feature = "range_checked")]
-        if value < -2048_f32 || 2047.9375_f32 < value { return Err(CanError::ParameterOutOfRange{ message_id: 256 }); }
+        if value < -2048_f32 || 2047.9375_f32 < value {
+            return Err(CanError::ParameterOutOfRange { message_id: 256 });
+        }
         let factor = 0.0625_f32;
         let offset = 0_f32;
         let value = ((value - offset) / factor) as i16;
-        
+
         let start_bit = 0;
         let bits = 16;
         value.pack_le_bits(&mut self.raw, start_bit, bits);
         Ok(())
     }
-    
 }
 
 impl core::convert::TryFrom<&[u8]> for Foo {
     type Error = CanError;
-    
+
     #[inline(always)]
     fn try_from(payload: &[u8]) -> Result<Self, Self::Error> {
-        if payload.len() != 4 { return Err(CanError::InvalidPayloadSize); }
+        if payload.len() != 4 {
+            return Err(CanError::InvalidPayloadSize);
+        }
         let mut raw = [0u8; 4];
         raw.copy_from_slice(&payload[..4]);
         Ok(Self { raw })
     }
 }
 
-
 /// Bar
 ///
 /// - ID: 512 (0x200)
@@ -174,7 +178,7 @@ pub struct Bar {
 
 impl Bar {
     pub const MESSAGE_ID: u32 = 512;
-    
+
     /// Construct new Bar from values
     pub fn new(one: u8, two: f32, three: u8, four: u8, five: bool) -> Result<Self, CanError> {
         let mut res = Self { raw: [0u8; 8] };
@@ -185,12 +189,12 @@ impl Bar {
         res.set_five(five)?;
         Ok(res)
     }
-    
+
     /// Access message payload raw value
     pub fn raw(&self) -> &[u8] {
         &self.raw
     }
-    
+
     /// One
     ///
     /// - Min: 0
@@ -201,7 +205,7 @@ impl Bar {
     pub fn one(&self) -> u8 {
         self.one_raw()
     }
-    
+
     /// Get raw value of One
     ///
     /// - Start bit: 15
@@ -213,21 +217,23 @@ impl Bar {
     #[inline(always)]
     pub fn one_raw(&self) -> u8 {
         let signal = u8::unpack_be_bits(&self.raw, (15 - (2 - 1)), 2);
-        
+
         signal
     }
-    
+
     /// Set value of One
     #[inline(always)]
     pub fn set_one(&mut self, value: u8) -> Result<(), CanError> {
         #[cfg(feature = "range_checked")]
-        if value < 0_u8 || 3_u8 < value { return Err(CanError::ParameterOutOfRange{ message_id: 512 }); }
+        if value < 0_u8 || 3_u8 < value {
+            return Err(CanError::ParameterOutOfRange { message_id: 512 });
+        }
         let start_bit = 15;
         let bits = 2;
         value.pack_be_bits(&mut self.raw, start_bit, bits);
         Ok(())
     }
-    
+
     /// Two
     ///
     /// - Min: 0
@@ -238,7 +244,7 @@ impl Bar {
     pub fn two(&self) -> f32 {
         self.two_raw()
     }
-    
+
     /// Get raw value of Two
     ///
     /// - Start bit: 7
@@ -250,27 +256,29 @@ impl Bar {
     #[inline(always)]
     pub fn two_raw(&self) -> f32 {
         let signal = u8::unpack_be_bits(&self.raw, (7 - (8 - 1)), 8);
-        
+
         let factor = 0.39_f32;
         let offset = 0_f32;
         (signal as f32) * factor + offset
     }
-    
+
     /// Set value of Two
     #[inline(always)]
     pub fn set_two(&mut self, value: f32) -> Result<(), CanError> {
         #[cfg(feature = "range_checked")]
-        if value < 0_f32 || 100_f32 < value { return Err(CanError::ParameterOutOfRange{ message_id: 512 }); }
+        if value < 0_f32 || 100_f32 < value {
+            return Err(CanError::ParameterOutOfRange { message_id: 512 });
+        }
         let factor = 0.39_f32;
         let offset = 0_f32;
         let value = ((value - offset) / factor) as u8;
-        
+
         let start_bit = 7;
         let bits = 8;
         value.pack_be_bits(&mut self.raw, start_bit, bits);
         Ok(())
     }
-    
+
     /// Three
     ///
     /// - Min: 0
@@ -287,7 +295,7 @@ impl Bar {
             x => BarThree::Other(x),
         }
     }
-    
+
     /// Get raw value of Three
     ///
     /// - Start bit: 13
@@ -299,21 +307,23 @@ impl Bar {
     #[inline(always)]
     pub fn three_raw(&self) -> u8 {
         let signal = u8::unpack_be_bits(&self.raw, (13 - (3 - 1)), 3);
-        
+
         signal
     }
-    
+
     /// Set value of Three
     #[inline(always)]
     pub fn set_three(&mut self, value: u8) -> Result<(), CanError> {
         #[cfg(feature = "range_checked")]
-        if value < 0_u8 || 7_u8 < value { return Err(CanError::ParameterOutOfRange{ message_id: 512 }); }
+        if value < 0_u8 || 7_u8 < value {
+            return Err(CanError::ParameterOutOfRange { message_id: 512 });
+        }
         let start_bit = 13;
         let bits = 3;
         value.pack_be_bits(&mut self.raw, start_bit, bits);
         Ok(())
     }
-    
+
     /// Four
     ///
     /// - Min: 0
@@ -330,7 +340,7 @@ impl Bar {
             x => BarFour::Other(x),
         }
     }
-    
+
     /// Get raw value of Four
     ///
     /// - Start bit: 10
@@ -342,21 +352,23 @@ impl Bar {
     #[inline(always)]
     pub fn four_raw(&self) -> u8 {
         let signal = u8::unpack_be_bits(&self.raw, (10 - (2 - 1)), 2);
-        
+
         signal
     }
-    
+
     /// Set value of Four
     #[inline(always)]
     pub fn set_four(&mut self, value: u8) -> Result<(), CanError> {
         #[cfg(feature = "range_checked")]
-        if value < 0_u8 || 3_u8 < value { return Err(CanError::ParameterOutOfRange{ message_id: 512 }); }
+        if value < 0_u8 || 3_u8 < value {
+            return Err(CanError::ParameterOutOfRange { message_id: 512 });
+        }
         let start_bit = 10;
         let bits = 2;
         value.pack_be_bits(&mut self.raw, start_bit, bits);
         Ok(())
     }
-    
+
     /// Five
     ///
     /// - Min: 0
@@ -373,7 +385,7 @@ impl Bar {
             x => BarFive::Other(x),
         }
     }
-    
+
     /// Get raw value of Five
     ///
     /// - Start bit: 30
@@ -385,10 +397,10 @@ impl Bar {
     #[inline(always)]
     pub fn five_raw(&self) -> bool {
         let signal = u8::unpack_be_bits(&self.raw, (30 - (1 - 1)), 1);
-        
+
         signal == 1
     }
-    
+
     /// Set value of Five
     #[inline(always)]
     pub fn set_five(&mut self, value: bool) -> Result<(), CanError> {
@@ -398,15 +410,16 @@ impl Bar {
         value.pack_be_bits(&mut self.raw, start_bit, bits);
         Ok(())
     }
-    
 }
 
 impl core::convert::TryFrom<&[u8]> for Bar {
     type Error = CanError;
-    
+
     #[inline(always)]
     fn try_from(payload: &[u8]) -> Result<Self, Self::Error> {
-        if payload.len() != 8 { return Err(CanError::InvalidPayloadSize); }
+        if payload.len() != 8 {
+            return Err(CanError::InvalidPayloadSize);
+        }
         let mut raw = [0u8; 8];
         raw.copy_from_slice(&payload[..8]);
         Ok(Self { raw })
@@ -444,7 +457,6 @@ pub enum BarFive {
     Other(bool),
 }
 
-
 /// This is just to make testing easier
 fn main() {}
 
@@ -460,4 +472,3 @@ pub enum CanError {
     },
     InvalidPayloadSize,
 }
-