moved decimal types to separate modules, fixed all remaining warnings, formatting

Author: simplist-coder

amqp-type/src/amqp_type.rs

@@ -1,10 +1,11 @@
 use std::hash::Hash;
 
-
 use crate::array::array::Array;
 use crate::compound::list::List;
 use crate::compound::map::Map;
-use crate::fixed_width::decimal::*;
+use crate::fixed_width::decimal128::Decimal128;
+use crate::fixed_width::decimal32::Decimal32;
+use crate::fixed_width::decimal64::Decimal64;
 use crate::fixed_width::double::*;
 use crate::fixed_width::float::Float;
 use crate::fixed_width::timestamp::Timestamp;
@@ -74,6 +75,15 @@ impl Encode for AmqpType {
     }
 }
 
+impl From<Option<AmqpType>> for AmqpType {
+    fn from(value: Option<AmqpType>) -> Self {
+        match value {
+            Some(val) => val,
+            None => AmqpType::Null,
+        }
+    }
+}
+
 impl From<bool> for AmqpType {
     fn from(value: bool) -> Self {
         AmqpType::Boolean(value)
@@ -200,6 +210,24 @@ impl From<Array> for AmqpType {
     }
 }
 
+impl From<Decimal32> for AmqpType {
+    fn from(value: Decimal32) -> Self {
+        AmqpType::Decimal32(value)
+    }
+}
+
+impl From<Decimal64> for AmqpType {
+    fn from(value: Decimal64) -> Self {
+        AmqpType::Decimal64(value)
+    }
+}
+
+impl From<Decimal128> for AmqpType {
+    fn from(value: Decimal128) -> Self {
+        AmqpType::Decimal128(value)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

amqp-type/src/compound/mod.rs

@@ -1,4 +1,3 @@
-
 mod encoded_vec;
 pub(crate) mod list;
 pub(crate) mod map;

amqp-type/src/fixed_width/byte.rs

@@ -1,6 +1,6 @@
 use crate::error::AppError;
-use crate::serde::encode::{Encode, Encoded};
 use crate::serde::decode::Decode;
+use crate::serde::encode::{Encode, Encoded};
 
 const DEFAULT_CONSTR: u8 = 0x51;
 
@@ -14,15 +14,16 @@ impl Decode for i8 {
     fn can_decode(iter: impl Iterator<Item = u8>) -> bool {
         match iter.peekable().peek() {
             Some(&DEFAULT_CONSTR) => true,
-            _ => false
+            _ => false,
         }
     }
 
     fn try_decode(mut iter: impl Iterator<Item = u8>) -> Result<Self, crate::error::AppError>
-        where
-            Self: Sized {
+    where
+        Self: Sized,
+    {
         match iter.next() {
-            Some(DEFAULT_CONSTR) => Ok(parse_i8(iter)?),            
+            Some(DEFAULT_CONSTR) => Ok(parse_i8(iter)?),
             Some(c) => Err(AppError::DeserializationIllegalConstructorError(c)),
             None => Err(AppError::IteratorEmptyOrTooShortError),
         }
@@ -37,7 +38,6 @@ fn parse_i8(mut iter: impl Iterator<Item = u8>) -> Result<i8, AppError> {
     }
 }
 
-
 #[cfg(test)]
 mod test {
 
@@ -49,7 +49,7 @@ mod test {
         assert_eq!(val.encode().constructor(), 0x51);
     }
 
-   #[test]
+    #[test]
     fn can_decode_returns_true_if_constructor_is_valid() {
         let val = vec![0x51];
         assert_eq!(i8::can_decode(val.into_iter()), true);

amqp-type/src/fixed_width/decimal.rs

@@ -0,0 +1,29 @@
+use bigdecimal::BigDecimal;
+
+use crate::serde::encode::{Encode, Encoded};
+
+#[derive(Hash, Eq, PartialEq)]
+pub struct Decimal128(BigDecimal);
+
+impl Encode for Decimal128 {
+    fn encode(&self) -> Encoded {
+        0x94.into()
+    }
+}
+
+impl From<f64> for Decimal128 {
+    fn from(value: f64) -> Self {
+        Decimal128(BigDecimal::try_from(value).unwrap())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn construct_decimal_128() {
+        let val: Decimal128 = 128.0.into();
+        assert_eq!(val.encode().constructor(), 0x94);
+    }
+}

amqp-type/src/fixed_width/decimal128.rs

@@ -0,0 +1,27 @@
+use bigdecimal::BigDecimal;
+
+use crate::serde::encode::{Encode, Encoded};
+
+#[derive(Hash, Eq, PartialEq)]
+pub struct Decimal32(BigDecimal);
+
+impl Encode for Decimal32 {
+    fn encode(&self) -> Encoded {
+        0x74.into()
+    }
+}
+impl From<f32> for Decimal32 {
+    fn from(value: f32) -> Self {
+        Decimal32(BigDecimal::try_from(value).unwrap())
+    }
+}
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn construct_decimal_32() {
+        let val: Decimal32 = 32.0.into();
+        assert_eq!(val.encode().constructor(), 0x74);
+    }
+}

amqp-type/src/fixed_width/decimal32.rs

@@ -0,0 +1,29 @@
+use bigdecimal::BigDecimal;
+
+use crate::serde::encode::{Encode, Encoded};
+
+#[derive(Hash, Eq, PartialEq)]
+pub struct Decimal64(BigDecimal);
+
+impl Encode for Decimal64 {
+    fn encode(&self) -> Encoded {
+        0x84.into()
+    }
+}
+
+impl From<f64> for Decimal64 {
+    fn from(value: f64) -> Self {
+        Decimal64(BigDecimal::try_from(value).unwrap())
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn construct_decimal_64() {
+        let val: Decimal64 = 64.0.into();
+        assert_eq!(val.encode().constructor(), 0x84);
+    }
+}

amqp-type/src/fixed_width/decimal64.rs

@@ -1,10 +1,9 @@
 use crate::serde::encode::{Encode, Encoded};
 use std::hash::Hash;
 
+use crate::error::AppError;
 use crate::serde::decode::Decode;
 use crate::verify::verify_bytes_read_eq;
-use crate::error::AppError;
-
 
 /// Crate assumes nothing about the values being passed to it.
 /// Any kind of f64 value is handled as is.
@@ -46,19 +45,18 @@ impl From<f64> for Double {
     }
 }
 
-
 impl Decode for f64 {
-    
     fn can_decode(iter: impl Iterator<Item = u8>) -> bool {
         match iter.peekable().peek() {
             Some(&DEFAULT_CONSTR) => true,
-            _ => false
+            _ => false,
         }
     }
 
     fn try_decode(mut iter: impl Iterator<Item = u8>) -> Result<Self, crate::error::AppError>
-        where
-            Self: Sized {
+    where
+        Self: Sized,
+    {
         match iter.next() {
             Some(DEFAULT_CONSTR) => Ok(parse_f64(iter)?),
             Some(c) => Err(AppError::DeserializationIllegalConstructorError(c)),
@@ -78,21 +76,18 @@ fn parse_f64(iter: impl Iterator<Item = u8>) -> Result<f64, AppError> {
     Ok(f64::from_be_bytes(byte_vals))
 }
 
-
 #[cfg(test)]
 mod test {
 
     use super::*;
 
-
     #[test]
     fn construct_double() {
         let val: Double = 64.0.into();
         assert_eq!(val.encode().constructor(), 0x82);
     }
 
-    
-   #[test]
+    #[test]
     fn can_deocde_returns_true_if_constructor_is_valid() {
         let val_norm = vec![0x82];
         assert_eq!(f64::can_decode(val_norm.into_iter()), true);
@@ -106,8 +101,8 @@ mod test {
 
     #[test]
     fn try_decode_returns_correct_value() {
-        let val = vec![0x82, 0x40, 0x20, 0x00, 0x00, 0x41, 0x70,0x00, 0x10];
-        assert_eq!(f64::try_decode(val.into_iter()).unwrap(), 8.0000019501895) ;
+        let val = vec![0x82, 0x40, 0x20, 0x00, 0x00, 0x41, 0x70, 0x00, 0x10];
+        assert_eq!(f64::try_decode(val.into_iter()).unwrap(), 8.0000019501895);
     }
 
     #[test]
@@ -121,6 +116,4 @@ mod test {
         let val = vec![0x82, 0x00, 0x01];
         assert!(f64::try_decode(val.into_iter()).is_err());
     }
-
-
-}
+}