feanor_math/
serialization.rs

1use std::marker::PhantomData;
2
3use serde::de::{DeserializeSeed, IgnoredAny, SeqAccess, Visitor};
4use serde::{Deserializer, Serialize, Serializer};
5
6use crate::seq::VectorFn;
7
8use crate::ring::*;
9
10///
11/// Trait for rings whose elements can be serialized.
12/// 
13/// Serialization and deserialization mostly follow the principles of the `serde` crate, with
14/// the main difference that ring elements cannot be serialized/deserialized on their own, but
15/// only w.r.t. a specific ring.
16/// 
17#[stability::unstable(feature = "enable")]
18pub trait SerializableElementRing: RingBase {
19
20    ///
21    /// Deserializes an element of this ring from the given deserializer.
22    /// 
23    fn deserialize<'de, D>(&self, deserializer: D) -> Result<Self::Element, D::Error>
24        where D: Deserializer<'de>;
25
26    ///
27    /// Serializes an element of this ring to the given serializer.
28    /// 
29    fn serialize<S>(&self, el: &Self::Element, serializer: S) -> Result<S::Ok, S::Error>
30        where S: Serializer;
31}
32
33
34///
35/// Wraps a [`VectorFn`] whose elements are [`Serialize`]able, and
36/// allows to serialize all elements as a sequence.
37/// 
38/// To deserialize, consider using [`DeserializeSeedSeq`].
39/// 
40#[stability::unstable(feature = "enable")]
41pub struct SerializableSeq<V, T>
42    where V: VectorFn<T>
43{
44    element: PhantomData<T>,
45    data: V
46}
47
48impl<V, T> SerializableSeq<V, T>
49    where V: VectorFn<T>
50{
51    #[stability::unstable(feature = "enable")]
52    pub fn new(data: V) -> Self {
53        Self { element: PhantomData, data: data }
54    }
55}
56
57impl<V, T> Serialize for SerializableSeq<V, T>
58    where V: VectorFn<T>, T: Serialize
59{
60    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
61        where S: serde::Serializer
62    {
63        serializer.collect_seq(self.data.iter())
64    }
65}
66
67///
68/// A [`DeserializeSeed`] that deserializes a sequence by deserializing
69/// every element according to some derived [`DeserializeSeed`]. The resulting
70/// elements are collected using a custom reducer function, akin to 
71/// [`Iterator::fold()`].
72/// 
73#[stability::unstable(feature = "enable")]
74pub struct DeserializeSeedSeq<'de, V, S, T, C>
75    where V: Iterator<Item = S>,
76        S: DeserializeSeed<'de>,
77        C: FnMut(T, S::Value) -> T
78{
79    deserializer: PhantomData<&'de ()>,
80    element_seed: PhantomData<S>,
81    seeds: V,
82    initial: T,
83    collector: C
84}
85
86impl<'de, V, S, T, C> DeserializeSeedSeq<'de, V, S, T, C>
87    where V: Iterator<Item = S>,
88        S: DeserializeSeed<'de>,
89        C: FnMut(T, S::Value) -> T
90{
91    #[stability::unstable(feature = "enable")]
92    pub fn new(seeds: V, initial: T, collector: C) -> Self {
93        Self {
94            deserializer: PhantomData,
95            element_seed: PhantomData,
96            seeds: seeds,
97            initial: initial,
98            collector: collector
99        }
100    }
101}
102
103impl<'de, V, S, T, C> DeserializeSeed<'de> for DeserializeSeedSeq<'de, V, S, T, C>
104    where V: Iterator<Item = S>, 
105        S: DeserializeSeed<'de>,
106        C: FnMut(T, S::Value) -> T
107{
108    type Value = T;
109
110    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
111        where D: serde::Deserializer<'de>
112    {
113        struct ResultVisitor<'de, V, S, T, C>
114            where V: Iterator<Item = S>,
115                S: DeserializeSeed<'de>,
116                C: FnMut(T, S::Value) -> T
117        {
118            deserializer: PhantomData<&'de ()>,
119            element_seed: PhantomData<S>,
120            seeds: V,
121            initial: T,
122            collector: C
123        }
124
125        impl<'de, V, S, T, C> Visitor<'de> for ResultVisitor<'de, V, S, T, C>
126            where V: Iterator<Item = S>,
127                S: DeserializeSeed<'de>,
128                C: FnMut(T, S::Value) -> T
129        {
130            type Value = T;
131
132            fn expecting(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
133                write!(f, "a sequence of elements")
134            }
135
136            fn visit_seq<B>(mut self, mut seq: B) -> Result<Self::Value, B::Error>
137                where B: SeqAccess<'de>
138            {
139                let mut result = self.initial;
140                for current in 0..usize::MAX {
141                    if let Some(seed) = self.seeds.next() {
142                        let el = seq.next_element_seed(seed)?;
143                        if let Some(el) = el {
144                            result = (self.collector)(result, el);
145                        } else {
146                            return Ok(result);
147                        }
148                    } else {
149                        if let Some(_) = seq.next_element::<IgnoredAny>()? {
150                            return Err(<B::Error as serde::de::Error>::invalid_length(current + 1, &format!("a sequence of at most {} elements", current).as_str()));
151                        } else {
152                            return Ok(result);
153                        }
154                    }
155                }
156                unreachable!()
157            }
158        }
159
160        return deserializer.deserialize_seq(ResultVisitor {
161            deserializer: PhantomData,
162            element_seed: PhantomData,
163            collector: self.collector,
164            initial: self.initial,
165            seeds: self.seeds
166        });
167    }
168}
169
170#[stability::unstable(feature = "enable")]
171pub struct SerializableNewtype<T>
172    where T: Serialize
173{
174    name: &'static str,
175    data: T 
176}
177
178impl<T> SerializableNewtype<T>
179    where T: Serialize
180{
181    #[stability::unstable(feature = "enable")]
182    pub fn new(name: &'static str, data: T) -> Self {
183        Self { name, data }
184    }
185}
186
187impl<T> Serialize for SerializableNewtype<T>
188    where T: Serialize
189{
190    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
191        where S: Serializer
192    {
193        serializer.serialize_newtype_struct(self.name, &self.data)
194    }
195}
196
197#[stability::unstable(feature = "enable")]
198pub struct DeserializeSeedNewtype<'de, S>
199    where S: DeserializeSeed<'de>
200{
201    deserializer: PhantomData<&'de ()>,
202    name: &'static str,
203    seed: S
204}
205
206impl<'de, S> DeserializeSeedNewtype<'de, S>
207    where S: DeserializeSeed<'de>
208{
209    #[stability::unstable(feature = "enable")]
210    pub fn new(name: &'static str, seed: S) -> Self {
211        Self { deserializer: PhantomData, name, seed }
212    }
213}
214
215impl<'de, S> DeserializeSeed<'de> for DeserializeSeedNewtype<'de, S>
216    where S: DeserializeSeed<'de>
217{
218    type Value = S::Value;
219
220    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
221        where D: Deserializer<'de>
222    {
223        struct NewtypeStructVisitor<'de, S: DeserializeSeed<'de>> {
224            seed: S,
225            name: &'static str,
226            deserializer: PhantomData<&'de ()>
227        }
228    
229        impl<'de, S: DeserializeSeed<'de>> Visitor<'de> for NewtypeStructVisitor<'de, S> {
230            type Value = S::Value;
231    
232            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
233                write!(formatter, "a newtype struct named {}", self.name)
234            }
235    
236            fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
237                where D: Deserializer<'de>
238            {
239                self.seed.deserialize(deserializer)
240            }
241        }
242    
243        return deserializer.deserialize_newtype_struct(self.name, NewtypeStructVisitor { seed: self.seed, name: self.name, deserializer: PhantomData });
244    }
245}
246
247///
248/// Wrapper of a ring that implements [`serde::DeserializationSeed`] by trying to deserialize an element
249/// w.r.t. the wrapped ring.
250/// 
251#[stability::unstable(feature = "enable")]
252#[derive(Clone)]
253pub struct DeserializeWithRing<R: RingStore>
254    where R::Type: SerializableElementRing
255{
256    ring: R
257}
258
259impl<R> DeserializeWithRing<R>
260    where R::Type: SerializableElementRing,
261        R: RingStore
262{
263    #[stability::unstable(feature = "enable")]
264    pub fn new(ring: R) -> Self {
265        Self { ring }
266    }
267}
268
269impl<'de, R> DeserializeSeed<'de> for DeserializeWithRing<R>
270    where R::Type: SerializableElementRing,
271        R: RingStore
272{
273    type Value = El<R>;
274
275    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
276        where D: Deserializer<'de>
277    {
278        self.ring.get_ring().deserialize(deserializer)
279    }
280}
281
282///
283/// Wraps a ring and a reference to one of its elements. Implements [`serde::Serialize`] and
284/// will serialize the element w.r.t. the ring.
285/// 
286#[stability::unstable(feature = "enable")]
287pub struct SerializeWithRing<'a, R: RingStore>
288    where R::Type: SerializableElementRing
289{
290    ring: R,
291    el: &'a El<R>
292}
293
294impl<'a, R: RingStore> SerializeWithRing<'a, R>
295    where R::Type: SerializableElementRing
296{
297    #[stability::unstable(feature = "enable")]
298    pub fn new(el: &'a El<R>, ring: R) -> Self {
299        Self { el, ring }
300    }
301}
302
303impl<'a, R: RingStore> Serialize for SerializeWithRing<'a, R>
304    where R::Type: SerializableElementRing
305{
306    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
307        where S: Serializer
308    {
309        self.ring.get_ring().serialize(self.el, serializer)
310    }
311}
312
313///
314/// Wraps a ring and a one of its elements. Implements [`serde::Serialize`] and
315/// will serialize the element w.r.t. the ring.
316/// 
317#[stability::unstable(feature = "enable")]
318pub struct SerializeOwnedWithRing<R: RingStore>
319    where R::Type: SerializableElementRing
320{
321    ring: R,
322    el: El<R>
323}
324
325impl<R: RingStore> SerializeOwnedWithRing<R>
326    where R::Type: SerializableElementRing
327{
328    #[stability::unstable(feature = "enable")]
329    pub fn new(el: El<R>, ring: R) -> Self {
330        Self { el, ring }
331    }
332}
333
334impl<R: RingStore> Serialize for SerializeOwnedWithRing<R>
335    where R::Type: SerializableElementRing
336{
337    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
338        where S: Serializer
339    {
340        self.ring.get_ring().serialize(&self.el, serializer)
341    }
342}
343
344#[stability::unstable(feature = "enable")]
345#[cfg(any(test, feature = "generic_tests"))]
346pub mod generic_tests {
347
348    use super::*;
349
350    #[stability::unstable(feature = "enable")]
351    pub fn test_serialization<R: RingStore, I: Iterator<Item = El<R>>>(ring: R, edge_case_elements: I)
352        where R::Type: SerializableElementRing
353    {
354        let edge_case_elements = edge_case_elements.collect::<Vec<_>>();
355
356        let serializer = serde_assert::Serializer::builder().is_human_readable(true).build();
357        for x in &edge_case_elements {
358            let tokens = ring.get_ring().serialize(&x, &serializer).unwrap();
359            let mut deserializer = serde_assert::Deserializer::builder(tokens).is_human_readable(true).build();
360            let result = ring.get_ring().deserialize(&mut deserializer).unwrap();
361            assert_el_eq!(ring, &result, &x);
362        }
363
364        let serializer = serde_assert::Serializer::builder().is_human_readable(false).build();
365        for x in &edge_case_elements {
366            let tokens = ring.get_ring().serialize(&x, &serializer).unwrap();
367            let mut deserializer = serde_assert::Deserializer::builder(tokens).is_human_readable(false).build();
368            let result = ring.get_ring().deserialize(&mut deserializer).unwrap();
369            assert_el_eq!(ring, &result, &x);
370        }
371    }
372}
373
374#[cfg(test)]
375use crate::integer::{BigIntRing, IntegerRingStore};
376
377#[test]
378fn test_serialize() {
379    let value = BigIntRing::RING.add(BigIntRing::RING.power_of_two(128), BigIntRing::RING.one());
380    let json = serde_json::to_string(&SerializeWithRing::new(&value, BigIntRing::RING)).unwrap();
381    assert_eq!("\"340282366920938463463374607431768211457\"", json);
382}
feanor_math/serialization.rs

feanor_math/
serialization.rs
