feanor_math/
serialization.rs

1use serde::de::*;
2use serde::{Deserializer, Serialize, Serializer};
3
4use crate::ring::*;
5
6///
7/// Trait for rings whose elements can be serialized.
8/// 
9/// Serialization and deserialization mostly follow the principles of the `serde` crate, with
10/// the main difference that ring elements cannot be serialized/deserialized on their own, but
11/// only w.r.t. a specific ring.
12/// 
13#[stability::unstable(feature = "enable")]
14pub trait SerializableElementRing: RingBase {
15
16    ///
17    /// Deserializes an element of this ring from the given deserializer.
18    /// 
19    fn deserialize<'de, D>(&self, deserializer: D) -> Result<Self::Element, D::Error>
20        where D: Deserializer<'de>;
21
22    ///
23    /// Serializes an element of this ring to the given serializer.
24    /// 
25    fn serialize<S>(&self, el: &Self::Element, serializer: S) -> Result<S::Ok, S::Error>
26        where S: Serializer;
27}
28
29///
30/// Wrapper of a ring that implements [`serde::DeserializationSeed`] by trying to deserialize an element
31/// w.r.t. the wrapped ring.
32/// 
33#[stability::unstable(feature = "enable")]
34#[derive(Clone)]
35pub struct DeserializeWithRing<R: RingStore>
36    where R::Type: SerializableElementRing
37{
38    ring: R
39}
40
41impl<R> DeserializeWithRing<R>
42    where R::Type: SerializableElementRing,
43        R: RingStore
44{
45    #[stability::unstable(feature = "enable")]
46    pub fn new(ring: R) -> Self {
47        Self { ring }
48    }
49}
50
51impl<'de, R> DeserializeSeed<'de> for DeserializeWithRing<R>
52    where R::Type: SerializableElementRing,
53        R: RingStore
54{
55    type Value = El<R>;
56
57    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
58        where D: Deserializer<'de>
59    {
60        self.ring.get_ring().deserialize(deserializer)
61    }
62}
63
64///
65/// Wraps a ring and a reference to one of its elements. Implements [`serde::Serialize`] and
66/// will serialize the element w.r.t. the ring.
67/// 
68#[stability::unstable(feature = "enable")]
69pub struct SerializeWithRing<'a, R: RingStore>
70    where R::Type: SerializableElementRing
71{
72    ring: R,
73    el: &'a El<R>
74}
75
76impl<'a, R: RingStore> SerializeWithRing<'a, R>
77    where R::Type: SerializableElementRing
78{
79    #[stability::unstable(feature = "enable")]
80    pub fn new(el: &'a El<R>, ring: R) -> Self {
81        Self { el, ring }
82    }
83}
84
85impl<'a, R: RingStore> Serialize for SerializeWithRing<'a, R>
86    where R::Type: SerializableElementRing
87{
88    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
89        where S: Serializer
90    {
91        self.ring.get_ring().serialize(self.el, serializer)
92    }
93}
94
95///
96/// Wraps a ring and a one of its elements. Implements [`serde::Serialize`] and
97/// will serialize the element w.r.t. the ring.
98/// 
99#[stability::unstable(feature = "enable")]
100pub struct SerializeOwnedWithRing<R: RingStore>
101    where R::Type: SerializableElementRing
102{
103    ring: R,
104    el: El<R>
105}
106
107impl<R: RingStore> SerializeOwnedWithRing<R>
108    where R::Type: SerializableElementRing
109{
110    #[stability::unstable(feature = "enable")]
111    pub fn new(el: El<R>, ring: R) -> Self {
112        Self { el, ring }
113    }
114}
115
116impl<R: RingStore> Serialize for SerializeOwnedWithRing<R>
117    where R::Type: SerializableElementRing
118{
119    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
120        where S: Serializer
121    {
122        self.ring.get_ring().serialize(&self.el, serializer)
123    }
124}
125
126#[stability::unstable(feature = "enable")]
127#[cfg(any(test, feature = "generic_tests"))]
128pub mod generic_tests {
129
130    use super::*;
131
132    #[stability::unstable(feature = "enable")]
133    pub fn test_serialization<R: RingStore, I: Iterator<Item = El<R>>>(ring: R, edge_case_elements: I)
134        where R::Type: SerializableElementRing
135    {
136        let edge_case_elements = edge_case_elements.collect::<Vec<_>>();
137
138        let serializer = serde_assert::Serializer::builder().is_human_readable(true).build();
139        for x in &edge_case_elements {
140            let tokens = ring.get_ring().serialize(&x, &serializer).unwrap();
141            let mut deserializer = serde_assert::Deserializer::builder(tokens).is_human_readable(true).build();
142            let result = ring.get_ring().deserialize(&mut deserializer).unwrap();
143            assert_el_eq!(ring, &result, &x);
144        }
145
146        let serializer = serde_assert::Serializer::builder().is_human_readable(false).build();
147        for x in &edge_case_elements {
148            let tokens = ring.get_ring().serialize(&x, &serializer).unwrap();
149            let mut deserializer = serde_assert::Deserializer::builder(tokens).is_human_readable(false).build();
150            let result = ring.get_ring().deserialize(&mut deserializer).unwrap();
151            assert_el_eq!(ring, &result, &x);
152        }
153    }
154
155    #[stability::unstable(feature = "enable")]
156    pub fn test_serialize_deserialize<T: Serialize + for<'de> Deserialize<'de> + PartialEq>(x: T) {
157        let serializer = serde_assert::Serializer::builder().is_human_readable(true).build();
158        let tokens = x.serialize(&serializer).unwrap();
159        let mut deserializer = serde_assert::Deserializer::builder(tokens).is_human_readable(true).build();
160        let result = T::deserialize(&mut deserializer).unwrap();
161        assert!(result == x);
162
163        let serializer = serde_assert::Serializer::builder().is_human_readable(false).build();
164        let tokens = x.serialize(&serializer).unwrap();
165        let mut deserializer = serde_assert::Deserializer::builder(tokens).is_human_readable(false).build();
166        let result = T::deserialize(&mut deserializer).unwrap();
167        assert!(result == x);
168    }
169}
170
171#[cfg(test)]
172use crate::integer::{BigIntRing, IntegerRingStore};
173
174#[test]
175fn test_serialize() {
176    let value = BigIntRing::RING.add(BigIntRing::RING.power_of_two(128), BigIntRing::RING.one());
177    let json = serde_json::to_string(&SerializeWithRing::new(&value, BigIntRing::RING)).unwrap();
178    assert_eq!("\"340282366920938463463374607431768211457\"", json);
179}
feanor_math/serialization.rs

feanor_math/
serialization.rs
