circular_queue/
serde_support.rs

1extern crate serde;
2
3use super::*;
4
5use self::serde::ser::{Serialize, SerializeSeq, SerializeStruct, Serializer};
6use self::serde::{Deserialize, Deserializer};
7
8/// Struct used to hold the iterator over the data for serialization
9struct CircularQueueSerialize<'a, T> {
10    length: usize,
11    values: AscIter<'a, T>,
12}
13
14impl<'a, T> Serialize for CircularQueueSerialize<'a, T>
15where
16    T: Serialize,
17{
18    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
19    where
20        S: Serializer,
21    {
22        let mut seq = serializer.serialize_seq(Some(self.length))?;
23        for e in self.values.clone() {
24            seq.serialize_element(e)?;
25        }
26        seq.end()
27    }
28}
29
30impl<T> Serialize for CircularQueue<T>
31where
32    T: Serialize,
33{
34    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
35    where
36        S: Serializer,
37    {
38        let to_ser = CircularQueueSerialize {
39            length: self.len(),
40            values: self.asc_iter(),
41        };
42
43        let mut seq = serializer.serialize_struct("CircularQueueData", 2)?;
44        seq.serialize_field("capacity", &self.capacity)?;
45        seq.serialize_field("values", &to_ser)?;
46        seq.end()
47    }
48}
49
50#[derive(Deserialize)]
51struct CircularQueueData<T> {
52    capacity: usize,
53    values: Vec<T>,
54}
55
56impl<'de, T> Deserialize<'de> for CircularQueue<T>
57where
58    T: Deserialize<'de>,
59{
60    fn deserialize<D>(deserializer: D) -> Result<CircularQueue<T>, D::Error>
61    where
62        D: Deserializer<'de>,
63    {
64        let data = CircularQueueData::deserialize(deserializer)?;
65        let mut queue = CircularQueue::with_capacity(data.capacity);
66        for elem in data.values {
67            queue.push(elem);
68        }
69        Ok(queue)
70    }
71}
72
73#[cfg(feature = "serde_support_test")]
74#[cfg(test)]
75mod tests {
76    use super::*;
77    extern crate bincode;
78    extern crate serde_json;
79    extern crate serde_test;
80
81    use self::serde_test::{assert_tokens, Token};
82
83    #[test]
84    fn serialization_works() {
85        let mut q = CircularQueue::with_capacity(8);
86        q.push(1);
87        q.push(2);
88
89        assert_tokens(
90            &q,
91            &[
92                Token::Struct {
93                    name: "CircularQueueData",
94                    len: 2,
95                },
96                Token::Str("capacity"),
97                Token::U64(8),
98                Token::Str("values"),
99                Token::Seq { len: Some(2) },
100                Token::I32(1),
101                Token::I32(2),
102                Token::SeqEnd,
103                Token::StructEnd,
104            ],
105        );
106    }
107
108    #[test]
109    fn serialization_with_empty_queue() {
110        let q = CircularQueue::<()>::with_capacity(0);
111
112        assert_tokens(
113            &q,
114            &[
115                Token::Struct {
116                    name: "CircularQueueData",
117                    len: 2,
118                },
119                Token::Str("capacity"),
120                Token::U64(0),
121                Token::Str("values"),
122                Token::Seq { len: Some(0) },
123                Token::SeqEnd,
124                Token::StructEnd,
125            ],
126        );
127    }
128
129    #[test]
130    fn serialization_preserves_order() {
131        let mut q = CircularQueue::with_capacity(4);
132        // Fill the q
133        for i in 0..4 {
134            q.push(i);
135        }
136        // Add a couple of new values
137        q.push(4);
138        q.push(5);
139        // At this point, the queue should be [2, 3, 4, 5]
140
141        assert_tokens(
142            &q,
143            &[
144                Token::Struct {
145                    name: "CircularQueueData",
146                    len: 2,
147                },
148                Token::Str("capacity"),
149                Token::U64(4),
150                Token::Str("values"),
151                Token::Seq { len: Some(4) },
152                Token::I32(2),
153                Token::I32(3),
154                Token::I32(4),
155                Token::I32(5),
156                Token::SeqEnd,
157                Token::StructEnd,
158            ],
159        );
160    }
161
162    #[test]
163    fn serialization_to_json() {
164        let mut q = CircularQueue::with_capacity(4);
165        q.push(3);
166        q.push(7);
167        assert_eq!(
168            serde_json::to_string(&q).unwrap(),
169            r#"{"capacity":4,"values":[3,7]}"#
170        );
171    }
172
173    #[test]
174    fn serialization_from_json() {
175        let mut q = CircularQueue::with_capacity(4);
176        q.push(3);
177        q.push(7);
178        let p =
179            serde_json::from_str::<CircularQueue<i32>>(r#"{"capacity":4,"values":[3,7]}"#).unwrap();
180        assert_eq!(p, q);
181    }
182
183    #[test]
184    fn serialization_from_json_empty() {
185        let q = CircularQueue::with_capacity(4);
186        let p =
187            serde_json::from_str::<CircularQueue<i32>>(r#"{"capacity":4,"values":[]}"#).unwrap();
188        assert_eq!(p, q);
189    }
190
191    #[test]
192    fn serialization_to_bincode() {
193        let mut q = CircularQueue::with_capacity(4);
194        q.push(3);
195        q.push(9);
196        let v = bincode::serialize(&q).unwrap();
197        let p = bincode::deserialize::<CircularQueue<i32>>(&v).unwrap();
198        assert_eq!(p, q);
199    }
200
201    #[test]
202    fn serialization_with_oversized_vector_preserves_last_values() {
203        let mut q = CircularQueue::with_capacity(2);
204        q.push(7);
205        q.push(8);
206        let oversize =
207            serde_json::from_str::<CircularQueue<i32>>(r#"{"capacity":2,"values":[3,7,8]}"#)
208                .unwrap();
209        assert_eq!(oversize, q);
210    }
211}
circular_queue/serde_support.rs

circular_queue/
serde_support.rs
