serde_seeded/
lib.rs

1//! This library provides types, traits and derive macros to deal with seeded
2//! serialization/deserialization with serde.
3//! - A `SerializeSeeded` trait and derive macro to serialize types with a seed.
4//! - A `Seeded<Q, T>` type that implements `Serialize` calling
5//!   `T::serialize_seeded` with a seed `Q`.
6//! - A `DeserializeSeeded` trait and derive macro to deserialize types with a
7//!   seed.
8//! - A `Seed<Q, T>` type implementing `DeserializeSeed` calling
9//!   `T::deserialize_seeded` with a seed `Q`.
10//!
11//! See the `tests` folder to find some examples.
12#[cfg(feature = "derive")]
13pub use serde_seeded_derive::{DeserializeSeeded, SerializeSeeded};
14
15pub mod ser;
16pub use ser::SerializeSeeded;
17
18pub mod de;
19pub use de::DeserializeSeeded;
20
21pub mod unseeded {
22	use serde::{Deserialize, Deserializer, Serialize, Serializer};
23
24	pub fn serialize_seeded<T, Q, S>(value: &T, _seed: &Q, serializer: S) -> Result<S::Ok, S::Error>
25	where
26		T: Serialize,
27		S: Serializer,
28	{
29		value.serialize(serializer)
30	}
31
32	pub fn deserialize_seeded<'de, T, Q, D>(_seed: &Q, deserializer: D) -> Result<T, D::Error>
33	where
34		T: Deserialize<'de>,
35		D: Deserializer<'de>,
36	{
37		T::deserialize(deserializer)
38	}
39}
40
41pub mod unseeded_btreemap_key {
42	use crate::{de::Seed, ser::Seeded, DeserializeSeeded, SerializeSeeded};
43	use serde::{ser::SerializeMap, Deserialize, Deserializer, Serialize, Serializer};
44	use std::{collections::BTreeMap, marker::PhantomData};
45
46	pub fn serialize_seeded<K, V, Q, S>(
47		value: &BTreeMap<K, V>,
48		seed: &Q,
49		serializer: S,
50	) -> Result<S::Ok, S::Error>
51	where
52		K: Serialize,
53		V: SerializeSeeded<Q>,
54		S: Serializer,
55	{
56		let mut s = serializer.serialize_map(Some(value.len()))?;
57
58		for (key, value) in value {
59			s.serialize_entry(key, &Seeded::new(seed, value))?;
60		}
61
62		s.end()
63	}
64
65	pub fn deserialize_seeded<'de, K, V, Q, D>(
66		seed: &Q,
67		deserializer: D,
68	) -> Result<BTreeMap<K, V>, D::Error>
69	where
70		K: Ord + Deserialize<'de>,
71		V: DeserializeSeeded<'de, Q>,
72		D: Deserializer<'de>,
73	{
74		struct Visitor<'seed, Q, K, V>(&'seed Q, PhantomData<BTreeMap<K, V>>);
75
76		impl<'de, Q, K, V> ::serde::de::Visitor<'de> for Visitor<'_, Q, K, V>
77		where
78			K: Ord + Deserialize<'de>,
79			V: DeserializeSeeded<'de, Q>,
80		{
81			type Value = BTreeMap<K, V>;
82
83			fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
84				write!(formatter, "a map")
85			}
86
87			fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
88			where
89				A: serde::de::MapAccess<'de>,
90			{
91				let mut result = BTreeMap::new();
92
93				while let Some(key) = map.next_key()? {
94					let value = map.next_value_seed(Seed::new(self.0))?;
95					result.insert(key, value);
96				}
97
98				Ok(result)
99			}
100		}
101
102		deserializer.deserialize_map(Visitor(seed, PhantomData))
103	}
104}
105
106pub mod unseeded_hashmap_key {
107	use crate::{de::Seed, ser::Seeded, DeserializeSeeded, SerializeSeeded};
108	use serde::{ser::SerializeMap, Deserialize, Deserializer, Serialize, Serializer};
109	use std::{collections::HashMap, hash::Hash, marker::PhantomData};
110
111	pub fn serialize_seeded<K, V, Q, S>(
112		value: &HashMap<K, V>,
113		seed: &Q,
114		serializer: S,
115	) -> Result<S::Ok, S::Error>
116	where
117		K: Serialize,
118		V: SerializeSeeded<Q>,
119		S: Serializer,
120	{
121		let mut s = serializer.serialize_map(Some(value.len()))?;
122
123		for (key, value) in value {
124			s.serialize_entry(key, &Seeded::new(seed, value))?;
125		}
126
127		s.end()
128	}
129
130	pub fn deserialize_seeded<'de, K, V, Q, D>(
131		seed: &Q,
132		deserializer: D,
133	) -> Result<HashMap<K, V>, D::Error>
134	where
135		K: Eq + Hash + Deserialize<'de>,
136		V: DeserializeSeeded<'de, Q>,
137		D: Deserializer<'de>,
138	{
139		struct Visitor<'seed, Q, K, V>(&'seed Q, PhantomData<HashMap<K, V>>);
140
141		impl<'de, Q, K, V> ::serde::de::Visitor<'de> for Visitor<'_, Q, K, V>
142		where
143			K: Eq + Hash + Deserialize<'de>,
144			V: DeserializeSeeded<'de, Q>,
145		{
146			type Value = HashMap<K, V>;
147
148			fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
149				write!(formatter, "a map")
150			}
151
152			fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
153			where
154				A: serde::de::MapAccess<'de>,
155			{
156				let mut result = HashMap::new();
157
158				while let Some(key) = map.next_key()? {
159					let value = map.next_value_seed(Seed::new(self.0))?;
160					result.insert(key, value);
161				}
162
163				Ok(result)
164			}
165		}
166
167		deserializer.deserialize_map(Visitor(seed, PhantomData))
168	}
169}
serde_seeded/lib.rs

serde_seeded/
lib.rs
