* Properly implemented List encode

* Rustfmt

Author: simplist-coder

amqp-lib/src/types/amqp_type.rs

@@ -1,50 +1,46 @@
 use std::hash::Hash;
 
-use crate::error::AppError;
+use bigdecimal::num_traits::ToBytes;
+use indexmap::IndexMap;
+
 use crate::types::binary::Binary;
 use crate::types::collection::*;
 use crate::types::decimal::*;
 use crate::types::floating_point::*;
-use bigdecimal::BigDecimal;
-use bigdecimal::num_traits::ToBytes;
-use indexmap::IndexMap;
 
-pub trait Hashable: std::hash::Hash {}
+pub trait Hashable: Hash {}
 pub trait Encode {
     fn encode(&self) -> Encoded;
 }
 
 pub trait Decode<'a>: From<&'a [u8]> + Encode {}
 
-
-
 pub enum Encoded {
-    Empty(u8), // Constructor
-    Fixed(u8, Vec<u8>), // Constructor, Data
-    Variable(u8, Vec<u8>), // Constructor, Data, size is computed from data
-    Compound(u8, u32, Vec<u8>), // Constructor, count, data
-    Array(u8, u32, u8, Vec<u8>) // Constructor, count, element constructor, data
+    Empty(u8),                   // Constructor
+    Fixed(u8, Vec<u8>),          // Constructor, Data
+    Variable(u8, Vec<u8>),       // Constructor, Data, size is computed from data
+    Compound(u8, u32, Vec<u8>),  // Constructor, count, data
+    Array(u8, u32, u8, Vec<u8>), // Constructor, count, element constructor, data
 }
 
-
 impl Encoded {
     pub fn new_empty(constructor: u8) -> Self {
         Encoded::Empty(constructor)
     }
 
-    pub fn new_fixed(constructor: u8, data: Vec<u8>) -> Self  {
+    pub fn new_fixed(constructor: u8, data: Vec<u8>) -> Self {
         Encoded::Fixed(constructor, data)
-     }
+    }
 
-    pub fn new_variable(constructor: u8, data: Vec<u8>) -> Self  {
+    pub fn new_variable(constructor: u8, data: Vec<u8>) -> Self {
         Encoded::Variable(constructor, data)
     }
 
-    pub fn new_compound(constructor: u8, count: u32, data: Vec<u8>) -> Self  {
+    pub fn new_compound(constructor: u8, count: u32, data: Vec<u8>) -> Self {
         Encoded::Compound(constructor, count, data)
     }
 
-    pub fn new_array(constructor: u8, count: u32, element_constructor: u8, data: Vec<u8>) -> Self  {
+    pub fn new_array(constructor: u8, count: u32, element_constructor: u8, data: Vec<u8>) -> Self {
         Encoded::Array(constructor, count, element_constructor, data)
     }
 
@@ -54,7 +50,7 @@ impl Encoded {
             Self::Fixed(c, _) => c.to_owned(),
             Self::Variable(c, _) => c.to_owned(),
             Self::Compound(c, _, _) => c.to_owned(),
-            Self::Array(c, _, _, _) => c.to_owned()
+            Self::Array(c, _, _, _) => c.to_owned(),
         }
     }
 
@@ -65,7 +61,6 @@ impl Encoded {
             Self::Variable(_, data) => data.len(),
             Self::Compound(_, _, data) => data.len(),
             Self::Array(_, _, _, data) => data.len(),
-            
         }
     }
 }
@@ -75,29 +70,19 @@ impl From<Encoded> for Vec<u8> {
         let mut res = Vec::new();
         match value {
             Encoded::Empty(c) => res.push(c),
-            Encoded::Fixed(c, data) => {
+            Encoded::Fixed(c, mut data) => {
                 res.push(c);
-                res.append(data);
+                res.append(&mut data);
             }
-            Encoded::Variable(c, data) => {
+            Encoded::Variable(c, mut data) => {
                 res.push(c);
-                res.append(data);
+                res.append(&mut data);
             }
-            Encoded::Compound(c, count, data) => {
-                
-            }
-        }
-        res
-    }
-}
+            Encoded::Compound(c, count, data) => {}
 
-
-impl From<Encoded> for &mut Vec<u8> {
-    fn from(value: Encoded) -> Self {
-        match value {
-            
+            Encoded::Array(_, _, _, _) => {}
         }
-        todo!()
+        res
     }
 }
 
@@ -207,7 +192,7 @@ impl Encode for bool {
     fn encode(&self) -> Encoded {
         match self {
             true => Encoded::new_fixed(0x56, vec![0x01]),
-            false => Encoded::new_fixed(0x56, vec![0x00])
+            false => Encoded::new_fixed(0x56, vec![0x00]),
         }
     }
 }
@@ -262,7 +247,7 @@ impl Encode for u64 {
         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())
+            _ => Encoded::new_fixed(0x80, self.to_be_bytes().to_vec()),
         }
     }
 }
@@ -271,7 +256,7 @@ impl Encode for i32 {
     fn encode(&self) -> Encoded {
         match self {
             x if x >= &-128 && x <= &127 => Encoded::new_fixed(0x54, x.to_be_bytes().to_vec()),
-            _ => Encoded::new_fixed(0x71, self.to_be_bytes().to_vec())
+            _ => Encoded::new_fixed(0x71, self.to_be_bytes().to_vec()),
         }
     }
 }
@@ -280,7 +265,7 @@ impl Encode for i64 {
     fn encode(&self) -> Encoded {
         match self {
             x if x >= &-128 && x <= &127 => Encoded::new_fixed(0x55, x.to_be_bytes().to_vec()),
-            _ => Encoded::new_fixed(0x81, self.to_be_bytes().to_vec())
+            _ => Encoded::new_fixed(0x81, self.to_be_bytes().to_vec()),
         }
     }
 }
@@ -291,7 +276,7 @@ impl Encode for String {
             x if x >= 0 as usize && x <= 255 as usize => {
                 Encoded::new_variable(0xa1, self.as_bytes().to_vec())
             }
-            _ => Encoded::new_variable(0xb1, self.as_bytes().to_vec())
+            _ => Encoded::new_variable(0xb1, self.as_bytes().to_vec()),
         }
     }
 }
@@ -371,14 +356,12 @@ impl From<Float> for AmqpType {
     }
 }
 
-
 impl From<Double> for AmqpType {
     fn from(value: Double) -> Self {
         AmqpType::Double(value.into())
     }
 }
 
-
 impl From<char> for AmqpType {
     fn from(value: char) -> Self {
         AmqpType::Char(value)
@@ -435,7 +418,6 @@ impl From<Array> for AmqpType {
 
 #[cfg(test)]
 mod tests {
-
     use super::*;
 
     #[test]
@@ -695,6 +677,5 @@ mod tests {
         }
         let val = AmqpType::Array(arr.into());
         assert_eq!(val.encode().constructor(), 0xf0);
-        
     }
 }

amqp-lib/src/types/binary.rs

@@ -9,7 +9,7 @@ impl Encode for Binary {
     fn encode(&self) -> Encoded {
         match self.0.len() {
             x if x <= 255 => Encoded::new_variable(0xa0, self.0.to_owned()),
-            _ => Encoded::new_variable(0xb0, self.0.to_owned())
+            _ => Encoded::new_variable(0xb0, self.0.to_owned()),
         }
     }
 }

amqp-lib/src/types/collection.rs

@@ -1,27 +1,33 @@
-use crate::types::amqp_type::{AmqpType, Constructor, Encode};
-use indexmap::IndexMap;
-use tracing::info;
 use std::hash::Hash;
 
+use indexmap::IndexMap;
+
+use crate::types::amqp_type::{AmqpType, Encode};
+
 use super::amqp_type::Encoded;
 
 #[derive(Hash, Eq, PartialEq)]
 pub struct List(Vec<AmqpType>);
+
 #[derive(Hash, Eq, PartialEq)]
 pub struct Array(Vec<AmqpType>);
+
 #[derive(Eq, PartialEq)]
 pub struct Map(IndexMap<AmqpType, AmqpType>);
 
-struct EncodedCompound(Vec<Encoded>);
+struct EncodedVec(Vec<Encoded>);
+
 impl Encode for List {
     fn encode(&self) -> Encoded {
         let encoded: Vec<Encoded> = self.0.iter().map(|x| x.encode()).collect();
-        let count = encoded.len();
+        let count = encoded.len() as u32;
         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 => Encoded::new_compound(0xc0, count as u32 as u32, EncodedCompound(encoded).into()),
-            (_, _) =>Encoded::new_compound(0xd0, count as u32 as u32, EncodedCompound(encoded).into()),
+            (len, size) if len <= 255 && size < 256 => {
+                Encoded::new_compound(0xc0, count, EncodedVec(encoded).into())
+            }
+            (_, _) => Encoded::new_compound(0xd0, count, EncodedVec(encoded).into()),
         }
     }
 }
@@ -40,15 +46,15 @@ impl Encode for Array {
             (len, size) if len <= 255 && size < 256 => 0xe0.into(),
             (_, _) => 0xf0.into(),
         }
-        
     }
 }
 
-impl From<EncodedCompound> for Vec<u8> {
-    fn from(value: EncodedCompound) -> Self {
+impl From<EncodedVec> for Vec<u8> {
+    fn from(value: EncodedVec) -> Self {
         let mut res = Vec::new();
-        for val in value.0 {
-            res.append(val.into());
+        for mut val in value.0 {
+            let mut enc: Vec<u8> = val.into();
+            res.append(&mut enc);
         }
         res
     }

amqp-lib/src/types/floating_point.rs

@@ -1,11 +1,11 @@
-use std::hash::Hash;
 use crate::types::amqp_type::{Encode, Encoded};
+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. 
+/// 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.
@@ -45,8 +45,6 @@ impl PartialEq for Double {
     }
 }
 
-
-
 impl Encode for Float {
     fn encode(&self) -> Encoded {
         Encoded::new_fixed(0x72, self.0.to_be_bytes().to_vec())
@@ -59,8 +57,6 @@ impl Encode for Double {
     }
 }
 
-
-
 impl From<f32> for Float {
     fn from(value: f32) -> Self {
         Float(value)