implemented decode for long, float and double, some refactoring

Author: simplist-coder

amqp-type/src/fixed_width/double.rs

@@ -1,15 +1,22 @@
 use crate::serde::encode::{Encode, Encoded};
 use std::hash::Hash;
 
+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 f32 value is handled as is.
+/// Any kind of f64 value is handled as is.
 /// This means that the hash function considers only the bytes of a float.
-/// Two f32 or f64 values are considered Equal if and only if, the entirety of their by sequences match.
+/// Two f64 or f64 values are considered Equal if and only if, the entirety of their by sequences match.
 /// This ensures that no information is lost.
 /// regardless of whether they mean Nan or similar things.
 /// As a result, Nan == Nan if and only if the two numbers have the exact same byte sequence.
 pub struct Double(f64);
 
+const DEFAULT_CONSTR: u8 = 0x82;
+
 impl Hash for Double {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
         self.0.to_bits().hash(state)
@@ -39,13 +46,81 @@ 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
+        }
+    }
+
+    fn try_decode(mut iter: impl Iterator<Item = u8>) -> Result<Self, crate::error::AppError>
+        where
+            Self: Sized {
+        match iter.next() {
+            Some(DEFAULT_CONSTR) => Ok(parse_f64(iter)?),
+            Some(c) => Err(AppError::DeserializationIllegalConstructorError(c)),
+            None => Err(AppError::IteratorEmptyOrTooShortError),
+        }
+    }
+}
+
+fn parse_f64(iter: impl Iterator<Item = u8>) -> Result<f64, AppError> {
+    let mut byte_vals = [0; 8];
+    let mut index = 0;
+    for b in iter.take(8) {
+        byte_vals[index] = b;
+        index += 1;
+    }
+    verify_bytes_read_eq(index, 8)?;
+    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]
+    fn can_deocde_returns_true_if_constructor_is_valid() {
+        let val_norm = vec![0x82];
+        assert_eq!(f64::can_decode(val_norm.into_iter()), true);
+    }
+
+    #[test]
+    fn can_decode_return_false_if_constructor_is_invalid() {
+        let val = vec![0x75];
+        assert_eq!(f64::can_decode(val.into_iter()), false);
+    }
+
+    #[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) ;
+    }
+
+    #[test]
+    fn try_decode_returns_error_when_value_bytes_are_invalid() {
+        let val = vec![0x66, 0x44];
+        assert!(f64::try_decode(val.into_iter()).is_err());
+    }
+
+    #[test]
+    fn try_decode_returns_error_when_bytes_are_missing() {
+        let val = vec![0x82, 0x00, 0x01];
+        assert!(f64::try_decode(val.into_iter()).is_err());
+    }
+
+
+}

amqp-type/src/fixed_width/float.rs

@@ -1,8 +1,15 @@
-use crate::serde::encode::{Encode, Encoded};
 use std::hash::Hash;
+use crate::serde::encode::{Encode, Encoded};
+use crate::serde::decode::Decode;
+use crate::verify::verify_bytes_read_eq;
+use crate::error::AppError;
+
+const DEFAULT_CONSTR: u8 = 0x72;
 
 pub struct Float(f32);
 
+
+
 impl Hash for Float {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
         self.0.to_bits().hash(state)
@@ -23,7 +30,7 @@ impl Eq for Float {}
 
 impl Encode for Float {
     fn encode(&self) -> Encoded {
-        Encoded::new_fixed(0x72, self.0.to_be_bytes().to_vec())
+        Encoded::new_fixed(DEFAULT_CONSTR, self.0.to_be_bytes().to_vec())
     }
 }
 
@@ -33,6 +40,38 @@ impl From<f32> for Float {
     }
 }
 
+impl Decode for f32 {
+    
+    fn can_decode(iter: impl Iterator<Item = u8>) -> bool {
+        match iter.peekable().peek() {
+            Some(&DEFAULT_CONSTR) => true,
+            _ => false
+        }
+    }
+
+    fn try_decode(mut iter: impl Iterator<Item = u8>) -> Result<Self, crate::error::AppError>
+        where
+            Self: Sized {
+        match iter.next() {
+            Some(DEFAULT_CONSTR) => Ok(parse_f32(iter)?),
+            Some(c) => Err(AppError::DeserializationIllegalConstructorError(c)),
+            None => Err(AppError::IteratorEmptyOrTooShortError),
+        }
+    }
+}
+
+fn parse_f32(iter: impl Iterator<Item = u8>) -> Result<f32, AppError> {
+    let mut byte_vals = [0; 4];
+    let mut index = 0;
+    for b in iter.take(4) {
+        byte_vals[index] = b;
+        index += 1;
+    }
+    verify_bytes_read_eq(index, 4)?;
+    Ok(f32::from_be_bytes(byte_vals))
+}
+
+
 #[cfg(test)]
 mod test {
 
@@ -43,4 +82,37 @@ mod test {
         let val: Float = 32.0.into();
         assert_eq!(val.encode().constructor(), 0x72);
     }
-}
+
+    
+   #[test]
+    fn can_deocde_returns_true_if_constructor_is_valid() {
+        let val_norm = vec![0x72];
+        assert_eq!(f32::can_decode(val_norm.into_iter()), true);
+    }
+
+    #[test]
+    fn can_decode_return_false_if_constructor_is_invalid() {
+        let val = vec![0x75];
+        assert_eq!(f32::can_decode(val.into_iter()), false);
+    }
+
+    #[test]
+    fn try_decode_returns_correct_value() {
+        let val = vec![0x72, 0x41, 0x70,0x00, 0x10];
+        assert_eq!(f32::try_decode(val.into_iter()).unwrap(), 15.000015) ;
+    }
+
+    #[test]
+    fn try_decode_returns_error_when_value_bytes_are_invalid() {
+        let val = vec![0x66, 0x44];
+        assert!(f32::try_decode(val.into_iter()).is_err());
+    }
+
+    #[test]
+    fn try_decode_returns_error_when_bytes_are_missing() {
+        let val = vec![0x72, 0x00, 0x01];
+        assert!(f32::try_decode(val.into_iter()).is_err());
+    }
+
+
+}

amqp-type/src/fixed_width/long.rs

@@ -1,4 +1,12 @@
 use crate::serde::encode::{Encode, Encoded};
+use crate::serde::decode::Decode;
+use crate::verify::verify_bytes_read_eq;
+use crate::error::AppError;
+
+
+const DEFAULT_CONSTR: u8 = 0x81;
+const SMALL_LONG_CONSTR: u8 = 0x55;
+
 
 impl Encode for i64 {
     fn encode(&self) -> Encoded {
@@ -9,6 +17,52 @@ impl Encode for i64 {
     }
 }
 
+
+impl Decode for i64 {
+    
+    fn can_decode(iter: impl Iterator<Item = u8>) -> bool {
+        match iter.peekable().peek() {
+            Some(&DEFAULT_CONSTR) => true,
+            Some(&SMALL_LONG_CONSTR) => true,
+            _ => false
+        }
+    }
+
+    fn try_decode(mut iter: impl Iterator<Item = u8>) -> Result<Self, crate::error::AppError>
+        where
+            Self: Sized {
+        match iter.next() {
+            Some(DEFAULT_CONSTR) => Ok(parse_i64(iter)?),
+            Some(SMALL_LONG_CONSTR) => Ok(parse_small_i64(iter)?),
+            Some(c) => Err(AppError::DeserializationIllegalConstructorError(c)),
+            None => Err(AppError::IteratorEmptyOrTooShortError),
+        }
+    }
+}
+
+fn parse_i64(iter: impl Iterator<Item = u8>) -> Result<i64, AppError> {
+    let mut byte_vals = [0; 8];
+    let mut index = 0;
+    for b in iter.take(8) {
+        byte_vals[index] = b;
+        index += 1;
+    }
+    verify_bytes_read_eq(index, 8)?;
+    Ok(i64::from_be_bytes(byte_vals))
+}
+
+fn parse_small_i64(mut iter: impl Iterator<Item = u8>) -> Result<i64, AppError> {
+    if let Some(val) = iter.next() {
+        Ok(val as i64)
+    } else {
+        Err(AppError::IteratorEmptyOrTooShortError)
+    }
+}
+
+
+
+
+
 #[cfg(test)]
 mod test {
 
@@ -27,4 +81,48 @@ mod test {
         assert_eq!(lower.encode().constructor(), 0x55);
         assert_eq!(higher.encode().constructor(), 0x55);
     }
-}
+    
+   #[test]
+    fn can_deocde_returns_true_if_constructor_is_valid() {
+        let val_norm = vec![0x81];
+        let val_small = vec![0x55];
+        assert_eq!(i64::can_decode(val_norm.into_iter()), true);
+        assert_eq!(i64::can_decode(val_small.into_iter()), true);
+    }
+
+    #[test]
+    fn can_decode_return_false_if_constructor_is_invalid() {
+        let val = vec![0x71];
+        assert_eq!(i64::can_decode(val.into_iter()), false);
+    }
+
+    #[test]
+    fn try_decode_returns_correct_value() {
+        let val = vec![0x81, 0x00, 0x00,0x00, 0x00, 0x00, 0x10,  0x00, 0x10];
+        assert_eq!(i64::try_decode(val.into_iter()).unwrap(), 1048592) ;
+    }
+
+    #[test]
+    fn try_decode_returns_error_when_value_bytes_are_invalid() {
+        let val = vec![0x66, 0x44];
+        assert!(i64::try_decode(val.into_iter()).is_err());
+    }
+
+    #[test]
+    fn try_decode_returns_error_when_bytes_are_missing() {
+        let val = vec![0x81, 0x00, 0x00, 0x01];
+        assert!(i64::try_decode(val.into_iter()).is_err());
+    }
+
+    #[test]
+    fn try_decode_can_decode_smalli64_values() {
+        let val = vec![0x55, 0xff];
+        assert_eq!(i64::try_decode(val.into_iter()).unwrap(), 255);
+    }
+
+    #[test]
+    fn try_decode_returns_error_when_parsing_small_i64_and_bytes_are_missing() {
+        let val = vec![0x55];
+        assert!(i64::try_decode(val.into_iter()).is_err());
+    }
+}

amqp-type/src/fixed_width/ulong.rs

@@ -42,7 +42,7 @@ impl Decode for u64 {
     }
 }
 
-fn parse_ulong(mut iter: impl Iterator<Item = u8>) -> Result<u64, AppError> {
+fn parse_ulong(iter: impl Iterator<Item = u8>) -> Result<u64, AppError> {
     let mut byte_vals = [0; 8];
     let mut index = 0;
     for b in iter.take(8) {