moved constructors to constants, implemented decode for ulong

Author: simplist-coder

amqp-type/src/fixed_width/uint.rs

@@ -3,22 +3,27 @@ use crate::serde::decode::Decode;
 use crate::serde::encode::{Encode, Encoded};
 use crate::verify::verify_bytes_read_eq;
 
+
+const DEFAULT_CONSTR: u8 = 0x70;
+const SMALL_UINT_CONSTR: u8 = 0x52;
+const UINT_0_CONSTR: u8 = 0x43;
+
 impl Encode for u32 {
     fn encode(&self) -> Encoded {
         match self {
-            0 => Encoded::new_empty(0x43),
-            x if x > &0 && x <= &255 => Encoded::new_fixed(0x52, x.to_be_bytes().to_vec()),
-            _ => Encoded::new_fixed(0x70, self.to_be_bytes().to_vec()),
+            0 => Encoded::new_empty(UINT_0_CONSTR),
+            x if x > &0 && x <= &255 => Encoded::new_fixed(SMALL_UINT_CONSTR, x.to_be_bytes().to_vec()),
+            _ => Encoded::new_fixed(DEFAULT_CONSTR, self.to_be_bytes().to_vec()),
         }
     }
 }
 
 impl Decode for u32 {
     fn can_decode(iter: impl Iterator<Item = u8>) -> bool {
         match iter.peekable().peek() {
-            Some(0x70) => true,
-            Some(0x52) => true,
-            Some(0x43) => true,
+            Some(&DEFAULT_CONSTR) => true,
+            Some(&SMALL_UINT_CONSTR) => true,
+            Some(&UINT_0_CONSTR) => true,
             _ => false,
         }
     }
@@ -28,9 +33,9 @@ impl Decode for u32 {
         Self: Sized,
     {
         match iter.next() {
-            Some(0x70) => Ok(parse_uint(iter)?),
-            Some(0x52) => Ok(parse_small_uint(iter)?),
-            Some(0x43) => Ok(0u32),
+            Some(DEFAULT_CONSTR) => Ok(parse_uint(iter)?),
+            Some(SMALL_UINT_CONSTR) => Ok(parse_small_uint(iter)?),
+            Some(UINT_0_CONSTR) => Ok(0u32),
             Some(c) => Err(AppError::DeserializationIllegalConstructorError(c)),
             None => Err(AppError::IteratorEmptyOrTooShortError),
         }

amqp-type/src/fixed_width/ulong.rs

@@ -1,15 +1,66 @@
+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 = 0x80;
+const SMALL_ULONG_CONSTR: u8 = 0x53;
+const ULONG_0_CONSTR: u8 = 0x44;
 
 impl Encode for u64 {
     fn encode(&self) -> Encoded {
         match self {
-            0 => Encoded::new_empty(0x44),
-            x if x > &&0 && x <= &255 => Encoded::new_fixed(0x53, x.to_be_bytes().to_vec()),
-            _ => Encoded::new_fixed(0x80, self.to_be_bytes().to_vec()),
+            0 => Encoded::new_empty(ULONG_0_CONSTR),
+            x if x > &&0 && x <= &255 => Encoded::new_fixed(SMALL_ULONG_CONSTR, x.to_be_bytes().to_vec()),
+            _ => Encoded::new_fixed(DEFAULT_CONSTR, self.to_be_bytes().to_vec()),
+        }
+    }
+}
+
+impl Decode for u64 {
+    
+    fn can_decode(iter: impl Iterator<Item = u8>) -> bool {
+        match iter.peekable().peek() {
+            Some(&DEFAULT_CONSTR) => true,
+            Some(&SMALL_ULONG_CONSTR) => true,
+            Some(&ULONG_0_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_ulong(iter)?),
+            Some(SMALL_ULONG_CONSTR) => Ok(parse_small_ulong(iter)?),
+            Some(ULONG_0_CONSTR) => Ok(0),
+            Some(c) => Err(AppError::DeserializationIllegalConstructorError(c)),
+            None => Err(AppError::IteratorEmptyOrTooShortError),
         }
     }
 }
 
+fn parse_ulong(mut iter: impl Iterator<Item = u8>) -> Result<u64, 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(u64::from_be_bytes(byte_vals))
+}
+
+fn parse_small_ulong(mut iter: impl Iterator<Item = u8>) -> Result<u64, AppError> {
+    if let Some(val) = iter.next() {
+        Ok(val as u64)
+    } else {
+        Err(AppError::IteratorEmptyOrTooShortError)
+    }
+}
+
 #[cfg(test)]
 mod test {
 
@@ -32,4 +83,56 @@ mod test {
         let val: u64 = 0;
         assert_eq!(val.encode().constructor(), 0x44);
     }
+    
+   #[test]
+    fn can_deocde_returns_true_if_constructor_is_valid() {
+        let val_norm = vec![0x80];
+        let val_small = vec![0x53];
+        let val_zero = vec![0x44];
+        assert_eq!(u64::can_decode(val_norm.into_iter()), true);
+        assert_eq!(u64::can_decode(val_small.into_iter()), true);
+        assert_eq!(u64::can_decode(val_zero.into_iter()), true);
+    }
+
+    #[test]
+    fn can_decode_return_false_if_constructor_is_invalid() {
+        let val = vec![0x71];
+        assert_eq!(u64::can_decode(val.into_iter()), false);
+    }
+
+    #[test]
+    fn try_decode_returns_correct_value() {
+        let val = vec![0x80, 0x01, 0x01,0x11, 0x10, 0x10, 0x00,  0x00, 0x10];
+        assert_eq!(u64::try_decode(val.into_iter()).unwrap(), 72357829700222992);
+    }
+
+    #[test]
+    fn decode_returns_error_when_value_bytes_are_invalid() {
+        let val = vec![0x66, 0x44];
+        assert!(u64::try_decode(val.into_iter()).is_err());
+    }
+
+    #[test]
+    fn decode_returns_error_when_bytes_are_missing() {
+        let val = vec![0x70, 0x00, 0x00, 0x01];
+        assert!(u64::try_decode(val.into_iter()).is_err());
+    }
+
+    #[test]
+    fn try_decode_can_decode_zero_length_value_zero() {
+        let val = vec![0x44];
+        assert_eq!(u64::try_decode(val.into_iter()).unwrap(), 0);
+    }
+
+    #[test]
+    fn try_decode_can_decode_smallulong_values() {
+        let val = vec![0x53, 0xff];
+        assert_eq!(u64::try_decode(val.into_iter()).unwrap(), 255);
+    }
+
+    #[test]
+    fn try_decode_returns_error_when_parsing_small_ulong_and_bytes_are_missing() {
+        let val = vec![0x53];
+        assert!(u64::try_decode(val.into_iter()).is_err());
+    }
 }

amqp-type/src/serde/decode.rs

@@ -4,7 +4,14 @@ use crate::error::AppError;
 pub struct Constructor(u8);
 
 pub trait Decode {
+    /// This function determines if an implementor can decode itself from the current position in the iterator
+    /// by checking whether the next byte in the iterator is a valid constructor for this type.
+    /// TODO: make this function async
     fn can_decode(iter: impl Iterator<Item = u8>) -> bool;
+
+    /// Tries to decode the implementing type from the byte iterator. this advances the iterator until the 
+    /// type and its value are completely decoded.
+    /// TODO: Make this function async
     fn try_decode(iter: impl Iterator<Item = u8>) -> Result<Self, AppError>
     where
         Self: Sized;