restructured types into individual modules

Author: simplist-coder

amqp-type/src/amqp_type.rs

@@ -0,0 +1,53 @@
+use crate::amqp_type::AmqpType;
+use crate::serde::encode::{Encode, Encoded};
+
+#[derive(Hash, Eq, PartialEq)]
+pub struct Array(Vec<AmqpType>);
+
+impl Encode for Array {
+    fn encode(&self) -> Encoded {
+        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(),
+        }
+    }
+}
+impl From<Vec<AmqpType>> for Array {
+    fn from(value: Vec<AmqpType>) -> Self {
+        Array(value)
+    }
+}
+
+
+#[cfg(test)]
+mod test {
+    use super::*;
+
+    #[test]
+    fn construct_array_with_less_than_255_elements() {
+        let val = Array(Vec::new());
+        assert_eq!(val.encode().constructor(), 0xe0);
+    }
+
+    #[test]
+    fn construct_array_with_more_than_255_elements() {
+        let mut arr = vec![];
+        for i in 0..500 {
+            arr.push(i.into())
+        }
+        let val = Array(arr);
+        assert_eq!(val.encode().constructor(), 0xf0);
+    }
+
+    #[test]
+    fn construct_array_with_less_than_255_elements_and_larger_than_255_bytes() {
+        let mut arr = vec![];
+        for _ in 0..100 {
+            arr.push("aaaaaaaaaaaaaaaaaaaa".into());
+        }
+        let val = Array(arr);
+        assert_eq!(val.encode().constructor(), 0xf0);
+    }
+}

amqp-type/src/array/array.rs

@@ -0,0 +1 @@
+pub(crate) mod array;

amqp-type/src/array/mod.rs

@@ -0,0 +1,20 @@
+use crate::serde::encode::Encoded;
+
+pub struct EncodedVec(Vec<Encoded>);
+
+impl EncodedVec {
+    pub fn new(data: Vec<Encoded>) -> Self {
+        EncodedVec(data)
+    }
+}
+
+impl From<EncodedVec> for Vec<u8> {
+    fn from(value: EncodedVec) -> Self {
+        let mut res = Vec::new();
+        for val in value.0 {
+            let mut enc: Vec<u8> = val.into();
+            res.append(&mut enc);
+        }
+        res
+    }
+}

amqp-type/src/collection.rs

@@ -0,0 +1,64 @@
+use crate::amqp_type::AmqpType;
+use crate::compound::encoded_vec::EncodedVec;
+use crate::serde::encode::{Encode, Encoded};
+
+#[derive(Hash, Eq, PartialEq)]
+pub struct List(Vec<AmqpType>);
+
+impl Encode for List {
+    fn encode(&self) -> Encoded {
+        let encoded: Vec<Encoded> = self.0.iter().map(|x| x.encode()).collect();
+        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, EncodedVec::new(encoded).into())
+            }
+            (_, _) => Encoded::new_compound(0xd0, count, EncodedVec::new(encoded).into()),
+        }
+    }
+}
+
+impl From<Vec<AmqpType>> for List {
+    fn from(value: Vec<AmqpType>) -> Self {
+        List(value)
+    }
+}
+
+#[cfg(test)]
+mod test {
+
+    use super::*;
+    #[test]
+    fn construct_empty_list() {
+        let val = AmqpType::List(vec![].into());
+        assert_eq!(val.encode().constructor(), 0x45);
+    }
+
+    #[test]
+    fn construct_list_with_less_than_255_elements() {
+        let val = AmqpType::List(vec![1.into()].into());
+        assert_eq!(val.encode().constructor(), 0xc0);
+    }
+
+    #[test]
+    fn construct_list_with_more_than_255_elements() {
+        let mut arr = vec![];
+        for i in 0..500 {
+            arr.push(i.into())
+        }
+        let val = AmqpType::List(arr.into());
+        assert_eq!(val.encode().constructor(), 0xd0);
+    }
+
+    #[test]
+    fn construct_list_with_less_than_255_elements_and_larger_than_255_bytes() {
+        let mut arr = vec![];
+        for _ in 0..100 {
+            arr.push("aaaaaaaaaaaaaaaaaaaa".into());
+        }
+        let val = AmqpType::List(arr.into());
+        assert_eq!(val.encode().constructor(), 0xd0);
+    }
+}

amqp-type/src/compound/encoded_vec.rs

@@ -0,0 +1,62 @@
+use std::hash::Hash;
+use indexmap::IndexMap;
+use crate::amqp_type::AmqpType;
+use crate::compound::encoded_vec::EncodedVec;
+use crate::serde::encode::{Encode, Encoded};
+
+#[derive(Eq, PartialEq)]
+pub struct Map(IndexMap<AmqpType, AmqpType>);
+
+
+impl Encode for Map {
+    fn encode(&self) -> Encoded {
+        let mut res: Vec<Encoded> = Vec::new();
+        let mut data_len = 0;
+        let mut count = 0;
+        for (key, value) in &self.0 {
+            let k = key.encode();
+            let v = value.encode();
+            data_len += k.data_len() + v.data_len();
+            res.push(k);
+            res.push(v);
+            count += 2;
+        }
+        match data_len {
+            x if x <= 255 => Encoded::new_compound(0xc1, count, EncodedVec::new(res).into()),
+            _ => Encoded::new_compound(0xd1, count, EncodedVec::new(res).into())
+        }
+    }
+}
+
+impl Hash for Map {
+    fn hash<H: std::hash::Hasher>(&self, _state: &mut H) {
+        todo!()
+    }
+}
+
+impl From<IndexMap<AmqpType, AmqpType>> for Map {
+    fn from(value: IndexMap<AmqpType, AmqpType>) -> Self {
+        Map(value)
+    }
+}
+
+#[cfg(test)]
+mod test {
+
+    use super::*;
+    #[test]
+    fn construct_map_with_less_than_255_elements() {
+        let val = AmqpType::Map(IndexMap::new().into());
+        assert_eq!(val.encode().constructor(), 0xc1);
+    }
+
+    #[test]
+    fn construct_map_with_less_more_255_elements() {
+        let mut map = IndexMap::new();
+        for i in 1..500 {
+            map.insert(i.into(), i.into());
+        }
+        let val = AmqpType::Map(map.into());
+        assert_eq!(val.encode().constructor(), 0xd1);
+    }
+}

amqp-type/src/compound/list.rs

@@ -0,0 +1,5 @@
+use crate::serde::encode::Encoded;
+
+pub(crate) mod list;
+pub(crate) mod map;
+mod encoded_vec;

amqp-type/src/compound/map.rs

@@ -0,0 +1,52 @@
+use crate::amqp_type::AmqpType;
+use crate::serde::encode::{Encode, Encoded};
+
+impl From<bool> for AmqpType {
+    fn from(value: bool) -> Self {
+        AmqpType::Boolean(value)
+    }
+}
+
+impl Encode for bool {
+    #[cfg(feature = "zero-length-bools")]
+    fn encode(&self) -> Encoded {
+        match self {
+            true => 0x41.into(),
+            false => 0x42.into(),
+        }
+    }
+
+    #[cfg(not(feature = "zero-length-bools"))]
+    fn encode(&self) -> Encoded {
+        match self {
+            true => Encoded::new_fixed(0x56, vec![0x01]),
+            false => Encoded::new_fixed(0x56, vec![0x00]),
+        }
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::serde::encode::Encode;
+    use super::*;
+    #[test]
+    #[cfg(not(feature = "zero-length-bools"))]
+    fn construct_bool() {
+        let val = AmqpType::Boolean(true);
+        assert_eq!(val.encode().constructor(), 0x56);
+    }
+
+    #[test]
+    #[cfg(feature = "zero-length-bools")]
+    fn amqp_type_constructs_bool_false_as_zero_length() {
+        let val = AmqpType::Boolean(false);
+        assert_eq!(val.encode().constructor(), 0x42);
+    }
+
+    #[test]
+    #[cfg(feature = "zero-length-bools")]
+    fn amqp_type_constructs_bool_true_as_zero_length() {
+        let val = AmqpType::Boolean(true);
+        assert_eq!(val.encode().constructor(), 0x41)
+    }
+}

amqp-type/src/compound/mod.rs

@@ -0,0 +1,21 @@
+use crate::serde::encode::{Encode, Encoded};
+
+impl Encode for i8 {
+    fn encode(&self) -> Encoded {
+        Encoded::new_fixed(0x51, self.to_be_bytes().to_vec())
+    }
+}
+
+
+#[cfg(test)]
+mod test {
+
+    use super::*;
+
+
+    #[test]
+    fn construct_byte() {
+        let val: i8 = 8;
+        assert_eq!(val.encode().constructor(), 0x51);
+    }
+}