formatting

Author: simplist-coder

amqp-type/src/error.rs

@@ -5,6 +5,5 @@ pub enum AppError {
     #[error("Encountered an IO Error.")]
     IoError(#[from] std::io::Error),
     #[error("Error while trying to deserialize value of type `{0}`. Reason: {1}")]
-    DeserializationError(String, String)
-    
+    DeserializationError(String, String),
 }

amqp-type/src/fixed_width/boolean.rs

@@ -1,6 +1,6 @@
+use crate::error::AppError;
 use crate::serde::decode::Decode;
 use crate::serde::encode::{Encode, Encoded};
-use crate::error::AppError;
 
 #[cfg(not(feature = "zero-length-bools"))]
 impl Encode for bool {
@@ -12,10 +12,8 @@ impl Encode for bool {
     }
 }
 
-
 #[cfg(feature = "zero-length-bools")]
 impl Encode for bool {
-    
     fn encode(&self) -> Encoded {
         match self {
             true => 0x41.into(),
@@ -24,60 +22,73 @@ impl Encode for bool {
     }
 }
 
-
-
 #[cfg(not(feature = "zero-length-bools"))]
 impl Decode for bool {
-
     fn can_decode(data: impl Iterator<Item = u8>) -> bool {
         let mut iter = data.into_iter().peekable();
         match iter.peek() {
             Some(0x56) => true,
-            _ => false
+            _ => false,
         }
     }
 
-    fn try_decode(mut iter: impl Iterator<Item = u8>) -> Result<Self, AppError> where Self: Sized {
+    fn try_decode(mut iter: impl Iterator<Item = u8>) -> Result<Self, AppError>
+    where
+        Self: Sized,
+    {
         let con = iter.next();
         let val = iter.next();
         match (con, val) {
             (Some(c), Some(v)) if c == 0x56 && v == 0x00 => Ok(false),
             (Some(c), Some(v)) if c == 0x56 && v == 0x01 => Ok(true),
-            (Some(c), _) => Err(AppError::DeserializationError("bool".to_string(),format!("bool cannot be constructed from value {:#04x}", c))),
-            (Some(c), None) => Err(AppError::DeserializationError("bool".to_string(), "Iterator was empty".to_string())),
-            (None, _) => Err(AppError::DeserializationError("bool".to_string(), "Iterator was empty".to_string())),
+            (Some(c), _) => Err(AppError::DeserializationError(
+                "bool".to_string(),
+                format!("bool cannot be constructed from value {:#04x}", c),
+            )),
+            (Some(c), None) => Err(AppError::DeserializationError(
+                "bool".to_string(),
+                "Iterator was empty".to_string(),
+            )),
+            (None, _) => Err(AppError::DeserializationError(
+                "bool".to_string(),
+                "Iterator was empty".to_string(),
+            )),
         }
-
     }
 }
 
-
-
 #[cfg(feature = "zero-length-bools")]
 impl Decode for bool {
-
     fn can_decode(data: Iterator<Item = u8>) -> bool {
         let mut iter = data.into_iter().peekable();
         match iter.peek() {
             Some(0x41) => true,
             Some(0x42) => true,
-            _ => false
+            _ => false,
         }
     }
 
-    fn try_decode(data: Iterator<Item = u8>) -> Result<Self, AppError> where Self: Sized {                
+    fn try_decode(data: Iterator<Item = u8>) -> Result<Self, AppError>
+    where
+        Self: Sized,
+    {
         if let Some(val) = iter.next() {
             return match val {
                 0x41 => Ok(true),
                 0x42 => Ok(false),
-                _ => Err(AppError::DeserializationError("bool".to_string(), format!("bool cannot be constructed from value {:#04x}", val)))
-            }
+                _ => Err(AppError::DeserializationError(
+                    "bool".to_string(),
+                    format!("bool cannot be constructed from value {:#04x}", val),
+                )),
+            };
         }
-        Err(AppError::DeserializationError("bool".to_string(), "Iterator was empty".to_string()))        
+        Err(AppError::DeserializationError(
+            "bool".to_string(),
+            "Iterator was empty".to_string(),
+        ))
     }
 }
 
-
 #[cfg(test)]
 mod test {
     use super::*;
@@ -113,7 +124,6 @@ mod test {
         assert_eq!(bool::can_decode(val_false.into_iter()), false);
     }
 
-    
     #[test]
     #[cfg(not(feature = "zero-length-bools"))]
     fn decode_returns_error_when_value_bytes_are_invalid() {
@@ -123,7 +133,6 @@ mod test {
         assert!(bool::try_decode(val_false.into_iter()).is_err());
     }
 
-
     #[test]
     #[cfg(not(feature = "zero-length-bools"))]
     fn try_decode_returns_correct_value_if_bytes_are_valid() {
@@ -132,7 +141,6 @@ mod test {
         assert_eq!(bool::try_decode(val_true.into_iter()).unwrap(), true);
         assert_eq!(bool::try_decode(val_false.into_iter()).unwrap(), false);
     }
-    
 
     #[test]
     #[cfg(feature = "zero-length-bools")]

amqp-type/src/serde/decode.rs

@@ -7,7 +7,9 @@ use crate::{
 pub struct Constructor(u8);
 
 pub trait Decode {
-    fn try_decode(data: impl Iterator<Item = u8>) -> Result<Self, AppError> where Self: Sized;
+    fn try_decode(data: impl Iterator<Item = u8>) -> Result<Self, AppError>
+    where
+        Self: Sized;
     fn can_decode(data: impl Iterator<Item = u8>) -> bool;
 }
 

amqp-type/src/serde/encode.rs

@@ -73,7 +73,7 @@ impl From<Encoded> for Vec<u8> {
                 res.push(c);
                 let mut size: Vec<u8> = match c {
                     0xA => vec![data.len() as u8],
-                    _ => (data.len() as u32).to_be_bytes().to_vec()
+                    _ => (data.len() as u32).to_be_bytes().to_vec(),
                 };
                 res.append(&mut size);
                 res.append(&mut data);
@@ -91,10 +91,8 @@ impl From<Encoded> for Vec<u8> {
     }
 }
 
-
-
 impl From<u8> for Encoded {
     fn from(value: u8) -> Self {
         Encoded::Empty(value)
     }
-}
+}