naive implementation of list constructor

Author: simplist-coder

amqp-lib/src/types/amqp_type.rs

@@ -4,6 +4,7 @@ use crate::error::AppError;
 use crate::types::binary::Binary;
 use crate::types::collection::*;
 use crate::types::decimal::*;
+use crate::types::floating_point::*;
 use bigdecimal::BigDecimal;
 use indexmap::IndexMap;
 
@@ -20,6 +21,10 @@ pub struct Encoded {
 }
 
 impl Encoded {
+    pub fn new(constructor: u8, data: Option<Vec<u8>>) -> Self {
+        Encoded { constructor, data }
+    }
+
     pub fn constructor(&self) -> u8 {
         self.constructor
     }
@@ -51,8 +56,6 @@ pub struct Described();
 pub struct Constructor(u8);
 #[derive(Hash, Eq, PartialEq)]
 pub struct Timestamp(u64);
-pub struct Float(f32);
-pub struct Double(f64);
 
 #[derive(Hash, Eq, PartialEq)]
 pub enum AmqpType {
@@ -113,40 +116,6 @@ impl Encode for AmqpType {
     }
 }
 
-impl Hash for Float {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.0.to_bits().hash(state)
-    }
-}
-
-impl Hash for Double {
-    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
-        self.0.to_bits().hash(state)
-    }
-}
-
-impl PartialEq for Float {
-    fn eq(&self, other: &Self) -> bool {
-        self.0.to_bits() == other.0.to_bits()
-    }
-
-    fn ne(&self, other: &Self) -> bool {
-        !self.eq(other)
-    }
-}
-
-impl Eq for Float {}
-
-impl PartialEq for Double {
-    fn eq(&self, other: &Self) -> bool {
-        self.0.to_bits() == self.0.to_bits()
-    }
-
-    fn ne(&self, other: &Self) -> bool {
-        !self.eq(other)
-    }
-}
-
 impl Eq for Double {}
 impl From<u8> for Constructor {
     fn from(value: u8) -> Self {
@@ -267,7 +236,9 @@ impl Encode for i64 {
 impl Encode for String {
     fn encode(&self) -> Encoded {
         match self.len() {
-            x if x >= 0 as usize && x <= 255 as usize => 0xa1.into(),
+            x if x >= 0 as usize && x <= 255 as usize => {
+                Encoded::new(0xa1, Some(self.as_bytes().to_vec()))
+            }
             _ => 0xb1.into(),
         }
     }
@@ -348,23 +319,13 @@ impl From<Float> for AmqpType {
     }
 }
 
-impl From<f32> for Float {
-    fn from(value: f32) -> Self {
-        Float(value)
-    }
-}
 
 impl From<Double> for AmqpType {
     fn from(value: Double) -> Self {
         AmqpType::Double(value.into())
     }
 }
 
-impl From<f64> for Double {
-    fn from(value: f64) -> Self {
-        Double(value)
-    }
-}
 
 impl From<char> for AmqpType {
     fn from(value: char) -> Self {
@@ -673,4 +634,15 @@ mod tests {
         let val = AmqpType::Array(arr.into());
         assert_eq!(val.encode().constructor(), 0xf0);
     }
+
+    #[test]
+    fn amqp_type_can_construct_array_with_less_than_255_elements_and_larger_than_255_bytes() {
+        let mut arr = vec![];
+        for i in 0..100 {
+            arr.push("aaaaaaaaaaaaaaaaaaaa".into());
+        }
+        let val = AmqpType::Array(arr.into());
+        assert_eq!(val.encode().constructor(), 0xe0);
+        
+    }
 }

amqp-lib/src/types/collection.rs

@@ -13,9 +13,9 @@ pub struct Map(IndexMap<AmqpType, AmqpType>);
 
 impl Encode for List {
     fn encode(&self) -> Encoded {
-        let encoded_list: Vec<Encoded> = self.0.iter().map(|x| x.encode()).collect();
-        let byte_size = encoded_list.iter().fold(0, |acc, x| acc + x.data_len());
-        match (encoded_list.len(), byte_size) {
+        let encoded: Vec<Encoded> = self.0.iter().map(|x| x.encode()).collect();
+        let byte_size = encoded.iter().fold(0, |acc, x| acc + x.data_len());
+        match (encoded.len(), byte_size) {
             (0, _) => 0x45.into(),
             (len, size) if len <= 255 && size < 256 => 0xc0.into(),
             (_, _) => 0xd0.into(),
@@ -31,7 +31,13 @@ impl Encode for Map {
 
 impl Encode for Array {
     fn encode(&self) -> Encoded {
-        todo!()
+        let encoded: Vec<Encoded> = self.0.iter().map(|x| x.encode()).collect();
+        let byte_size = encoded.iter().fold(0, |acc, x| acc + x.data_len());
+        match (encoded.len(), byte_size) {
+            (len, size) if len <= 255 && size < 256 => 0xe0.into(),
+            (_, _) => 0xf0.into(),
+        }
+        
     }
 }
 

amqp-lib/src/types/floating_point.rs

@@ -0,0 +1,56 @@
+use std::hash::Hash;
+
+pub struct Float(f32);
+pub struct Double(f64);
+
+/// Crate assumes nothing about the values being passed to it. 
+/// Any kind of f32 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.
+/// 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.
+impl Hash for Float {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.0.to_bits().hash(state)
+    }
+}
+
+impl Hash for Double {
+    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+        self.0.to_bits().hash(state)
+    }
+}
+
+impl PartialEq for Float {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.to_bits() == other.0.to_bits()
+    }
+
+    fn ne(&self, other: &Self) -> bool {
+        !self.eq(other)
+    }
+}
+
+impl Eq for Float {}
+
+impl PartialEq for Double {
+    fn eq(&self, other: &Self) -> bool {
+        self.0.to_bits() == self.0.to_bits()
+    }
+
+    fn ne(&self, other: &Self) -> bool {
+        !self.eq(other)
+    }
+}
+
+impl From<f32> for Float {
+    fn from(value: f32) -> Self {
+        Float(value)
+    }
+}
+impl From<f64> for Double {
+    fn from(value: f64) -> Self {
+        Double(value)
+    }
+}

amqp-lib/src/types/mod.rs

@@ -2,3 +2,4 @@ pub mod amqp_type;
 pub mod binary;
 pub mod collection;
 pub mod decimal;
+pub mod floating_point;