some changes

Author: simplist-coder

amqp-lib/src/types/amqp_type.rs

@@ -72,12 +72,31 @@ impl Encoded {
 
 impl From<Encoded> for Vec<u8> {
     fn from(value: Encoded) -> Self {
-        todo!()
+        let mut res = Vec::new();
+        match value {
+            Encoded::Empty(c) => res.push(c),
+            Encoded::Fixed(c, data) => {
+                res.push(c);
+                res.append(data);
+            }
+            Encoded::Variable(c, data) => {
+                res.push(c);
+                res.append(data);
+            }
+            Encoded::Compound(c, count, data) => {
+                
+            }
+        }
+        res
     }
 }
 
-impl From<Vec<Encoded>> for Vec<u8> {
-    fn from(value: Vec<Encoded>) -> Self {
+
+impl From<Encoded> for &mut Vec<u8> {
+    fn from(value: Encoded) -> Self {
+        match value {
+            
+        }
         todo!()
     }
 }

amqp-lib/src/types/collection.rs

@@ -12,15 +12,16 @@ pub struct Array(Vec<AmqpType>);
 #[derive(Eq, PartialEq)]
 pub struct Map(IndexMap<AmqpType, AmqpType>);
 
+struct EncodedCompound(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 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, encoded.into()),
-            (_, _) => 0xd0.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()),
         }
     }
 }
@@ -43,6 +44,16 @@ impl Encode for Array {
     }
 }
 
+impl From<EncodedCompound> for Vec<u8> {
+    fn from(value: EncodedCompound) -> Self {
+        let mut res = Vec::new();
+        for val in value.0 {
+            res.append(val.into());
+        }
+        res
+    }
+}
+
 impl From<Vec<AmqpType>> for List {
     fn from(value: Vec<AmqpType>) -> Self {
         List(value)