implemented decode for byte, short and int

Author: simplist-coder

amqp-type/src/fixed_width/byte.rs

@@ -1,11 +1,43 @@
+use crate::error::AppError;
 use crate::serde::encode::{Encode, Encoded};
+use crate::serde::decode::Decode;
+
+const DEFAULT_CONSTR: u8 = 0x51;
 
 impl Encode for i8 {
     fn encode(&self) -> Encoded {
-        Encoded::new_fixed(0x51, self.to_be_bytes().to_vec())
+        Encoded::new_fixed(DEFAULT_CONSTR, self.to_be_bytes().to_vec())
+    }
+}
+
+impl Decode for i8 {
+    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_i8(iter)?),            
+            Some(c) => Err(AppError::DeserializationIllegalConstructorError(c)),
+            None => Err(AppError::IteratorEmptyOrTooShortError),
+        }
     }
 }
 
+fn parse_i8(mut iter: impl Iterator<Item = u8>) -> Result<i8, AppError> {
+    if let Some(val) = iter.next() {
+        Ok(val as i8)
+    } else {
+        Err(AppError::IteratorEmptyOrTooShortError)
+    }
+}
+
+
 #[cfg(test)]
 mod test {
 
@@ -16,4 +48,34 @@ mod test {
         let val: i8 = 8;
         assert_eq!(val.encode().constructor(), 0x51);
     }
+
+   #[test]
+    fn can_decode_returns_true_if_constructor_is_valid() {
+        let val = vec![0x51];
+        assert_eq!(i8::can_decode(val.into_iter()), true);
+    }
+
+    #[test]
+    fn can_decode_return_false_if_constructor_is_invalid() {
+        let val = vec![0x71];
+        assert_eq!(i8::can_decode(val.into_iter()), false);
+    }
+
+    #[test]
+    fn try_decode_returns_correct_value() {
+        let val = vec![0x51, 0x10];
+        assert_eq!(i8::try_decode(val.into_iter()).unwrap(), 16);
+    }
+
+    #[test]
+    fn decode_returns_error_when_value_bytes_are_invalid() {
+        let val = vec![0x66, 0x44];
+        assert!(i8::try_decode(val.into_iter()).is_err());
+    }
+
+    #[test]
+    fn decode_returns_error_when_bytes_are_missing() {
+        let val = vec![0x51];
+        assert!(i8::try_decode(val.into_iter()).is_err());
+    }
 }

amqp-type/src/fixed_width/int.rs

@@ -1,4 +1,9 @@
-use crate::serde::encode::{Encode, Encoded};
+use crate::{serde::encode::{Encode, Encoded}, error::AppError};
+use crate::serde::decode::Decode;
+use crate::verify::verify_bytes_read_eq;
+
+const DEFAULT_CONSTR: u8 = 0x71;
+const SMALL_INT_CONSTR: u8 = 0x54;
 
 impl Encode for i32 {
     fn encode(&self) -> Encoded {
@@ -9,11 +14,98 @@ impl Encode for i32 {
     }
 }
 
+impl Decode for i32 {
+    fn can_decode(iter: impl Iterator<Item = u8>) -> bool {
+        match iter.peekable().peek() {
+            Some(&DEFAULT_CONSTR) => true,
+            Some(&SMALL_INT_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_i32(iter)?),
+            Some(SMALL_INT_CONSTR) => Ok(parse_small_i32(iter)?),
+            Some(c) => Err(AppError::DeserializationIllegalConstructorError(c)),
+            None => Err(AppError::IteratorEmptyOrTooShortError),
+        }
+    }
+}
+
+fn parse_i32(iter: impl Iterator<Item = u8>) -> Result<i32, AppError> {
+    let mut val_bytes = [0; 4];
+    let mut index = 0;
+    for b in iter.take(4) {
+        val_bytes[index] = b;
+        index += 1;
+    }
+    verify_bytes_read_eq(index, 4)?;
+    Ok(i32::from_be_bytes(val_bytes))
+}
+
+fn parse_small_i32(mut iter: impl Iterator<Item = u8>) -> Result<i32, AppError> {
+    if let Some(val) = iter.next() {
+        Ok(val as i32)
+    } else {
+        Err(AppError::IteratorEmptyOrTooShortError)
+    }
+}
+
 #[cfg(test)]
 mod test {
 
     use super::*;
 
+
+    #[test]
+    fn can_deocde_returns_true_if_constructor_is_valid() {
+        let val = vec![0x71, 0x41];
+        let small_val = vec![0x54, 0x41];
+        assert_eq!(i32::can_decode(val.into_iter()), true);
+        assert_eq!(i32::can_decode(small_val.into_iter()), true);
+    }
+
+    #[test]
+    fn can_decode_return_false_if_constructor_is_invalid() {
+        let val = vec![0x70];
+        assert_eq!(i32::can_decode(val.into_iter()), false);
+    }
+
+    #[test]
+    fn try_decode_returns_correct_value() {
+        let val = vec![0x71, 0x00, 0x00, 0x00, 0x10];
+        assert_eq!(i32::try_decode(val.into_iter()).unwrap(), 16)
+    }
+
+    #[test]
+    fn decode_returns_error_when_value_bytes_are_invalid() {
+        let val = vec![0x56, 0x44];
+        assert!(i32::try_decode(val.into_iter()).is_err());
+    }
+
+    #[test]
+    fn decode_returns_error_when_bytes_are_missing() {
+        let val = vec![0x71, 0x01];
+        assert!(i32::try_decode(val.into_iter()).is_err());
+    }
+
+    
+    #[test]
+    fn try_decode_can_decode_smallulong_values() {
+        let val = vec![0x54, 0xff];
+        assert_eq!(i32::try_decode(val.into_iter()).unwrap(), 255);
+    }
+
+    #[test]
+    fn try_decode_returns_error_when_parsing_small_ulong_and_bytes_are_missing() {
+        let val = vec![0x54];
+        assert!(i32::try_decode(val.into_iter()).is_err());
+    }
+
     #[test]
     fn construct_int() {
         let val = 500;

amqp-type/src/fixed_width/short.rs

@@ -1,19 +1,84 @@
+use crate::error::AppError;
 use crate::serde::encode::{Encode, Encoded};
+use crate::serde::decode::Decode;
+use crate::verify::verify_bytes_read_eq;
+
+const DEFAULT_CONSTR: u8 = 0x61;
 
 impl Encode for i16 {
     fn encode(&self) -> Encoded {
         Encoded::new_fixed(0x61, self.to_be_bytes().to_vec())
     }
 }
+impl Decode for i16 {
+    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_i16(iter)?),
+            Some(c) => Err(AppError::DeserializationIllegalConstructorError(c)),
+            None => Err(AppError::IteratorEmptyOrTooShortError),
+        }
+    }
+}
+
+fn parse_i16(iter: impl Iterator<Item = u8>) -> Result<i16, AppError> {
+    let mut val_bytes = [0; 2];
+    let mut index = 0;
+    for b in iter.take(2) {
+        val_bytes[index] = b;
+        index += 1;
+    }
+    verify_bytes_read_eq(index, 2)?;
+    Ok(i16::from_be_bytes(val_bytes))
+}
 
 #[cfg(test)]
 mod test {
 
     use super::*;
 
     #[test]
-    fn construct_short() {
-        let val: i16 = 8;
+    fn construct_ushort() {
+        let val: i16 = 16;
         assert_eq!(val.encode().constructor(), 0x61);
     }
-}
+
+    #[test]
+    fn can_deocde_returns_true_if_constructor_is_valid() {
+        let val = vec![0x61, 0x41];
+        assert_eq!(i16::can_decode(val.into_iter()), true);
+    }
+
+    #[test]
+    fn can_decode_return_false_if_constructor_is_invalid() {
+        let val = vec![0x60];
+        assert_eq!(i16::can_decode(val.into_iter()), false);
+    }
+
+    #[test]
+    fn try_decode_returns_correct_value() {
+        let val = vec![0x61, 0x00, 0x10];
+        assert_eq!(i16::try_decode(val.into_iter()).unwrap(), 16)
+    }
+
+    #[test]
+    fn decode_returns_error_when_value_bytes_are_invalid() {
+        let val = vec![0x56, 0x44];
+        assert!(i16::try_decode(val.into_iter()).is_err());
+    }
+
+    #[test]
+    fn decode_returns_error_when_bytes_are_missing() {
+        let val = vec![0x61, 0x01];
+        assert!(i16::try_decode(val.into_iter()).is_err());
+    }
+}