Merge pull request #370 from fililip/main

Implement #367

Author: Dirbaio

src/de.rs

@@ -1,5 +1,5 @@
 use crate::{
-    binary_heap::Kind as BinaryHeapKind, BinaryHeap, IndexMap, IndexSet, LinearMap, String, Vec,
+    binary_heap::Kind as BinaryHeapKind, BinaryHeap, Deque, IndexMap, IndexSet, LinearMap, String, Vec,
 };
 use core::{
     fmt,
@@ -133,6 +133,45 @@ where
     }
 }
 
+impl<'de, T, const N: usize> Deserialize<'de> for Deque<T, N>
+where
+    T: Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct ValueVisitor<'de, T, const N: usize>(PhantomData<(&'de (), T)>);
+
+        impl<'de, T, const N: usize> serde::de::Visitor<'de> for ValueVisitor<'de, T, N>
+        where
+            T: Deserialize<'de>,
+        {
+            type Value = Deque<T, N>;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                formatter.write_str("a sequence")
+            }
+
+            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+            where
+                A: SeqAccess<'de>,
+            {
+                let mut values = Deque::new();
+
+                while let Some(value) = seq.next_element()? {
+                    if values.push_back(value).is_err() {
+                        return Err(A::Error::invalid_length(values.capacity() + 1, &self))?;
+                    }
+                }
+
+                Ok(values)
+            }
+        }
+        deserializer.deserialize_seq(ValueVisitor(PhantomData))
+    }
+}
+
 // Dictionaries
 
 impl<'de, K, V, S, const N: usize> Deserialize<'de> for IndexMap<K, V, BuildHasherDefault<S>, N>

src/ser.rs

@@ -1,7 +1,7 @@
 use core::hash::{BuildHasher, Hash};
 
 use crate::{
-    binary_heap::Kind as BinaryHeapKind, BinaryHeap, IndexMap, IndexSet, LinearMap, String, Vec,
+    binary_heap::Kind as BinaryHeapKind, BinaryHeap, Deque, IndexMap, IndexSet, LinearMap, String, Vec,
 };
 use serde::ser::{Serialize, SerializeMap, SerializeSeq, Serializer};
 
@@ -57,6 +57,22 @@ where
     }
 }
 
+impl<T, const N: usize> Serialize for Deque<T, N>
+where
+    T: Serialize,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let mut seq = serializer.serialize_seq(Some(self.len()))?;
+        for element in self {
+            seq.serialize_element(element)?;
+        }
+        seq.end()
+    }
+}
+
 // Dictionaries
 
 impl<K, V, S, const N: usize> Serialize for IndexMap<K, V, S, N>