rivet_util_serde/
lib.rs

1use std::{
2	collections::HashMap,
3	fmt,
4	hash::{Hash, Hasher},
5	marker::PhantomData,
6	ops::{Deref, DerefMut},
7};
8
9use ::serde::{
10	Deserialize, Deserializer, Serialize, Serializer,
11	de::{self, DeserializeOwned},
12};
13use indexmap::IndexMap;
14use serde_json::{Number, value::RawValue};
15use thiserror::Error;
16
17/// Like serde_json::Value but with no nesting types (arrays, objects).
18#[derive(Debug, Clone, PartialEq, Eq)]
19pub enum SimpleValue {
20	Null,
21	Bool(bool),
22	Number(Number),
23	String(String),
24}
25
26#[derive(Debug, Error)]
27pub enum DeserializeError {
28	#[error("arrays and objects are not supported")]
29	OnlySimple,
30}
31
32impl<'de> Deserialize<'de> for SimpleValue {
33	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
34	where
35		D: Deserializer<'de>,
36	{
37		struct SimpleValueVisitor;
38
39		impl<'de> de::Visitor<'de> for SimpleValueVisitor {
40			type Value = SimpleValue;
41
42			fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
43				formatter.write_str("a simple value (null, bool, number, or string)")
44			}
45
46			fn visit_bool<E>(self, value: bool) -> Result<Self::Value, E> {
47				Ok(SimpleValue::Bool(value))
48			}
49
50			fn visit_i64<E>(self, value: i64) -> Result<Self::Value, E> {
51				Ok(SimpleValue::Number(value.into()))
52			}
53
54			fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E> {
55				Ok(SimpleValue::Number(value.into()))
56			}
57
58			fn visit_f64<E>(self, value: f64) -> Result<Self::Value, E> {
59				Ok(Number::from_f64(value).map_or(SimpleValue::Null, SimpleValue::Number))
60			}
61
62			fn visit_str<E>(self, value: &str) -> Result<Self::Value, E> {
63				Ok(SimpleValue::String(value.to_owned()))
64			}
65
66			fn visit_string<E>(self, value: String) -> Result<Self::Value, E> {
67				Ok(SimpleValue::String(value))
68			}
69
70			fn visit_none<E>(self) -> Result<Self::Value, E> {
71				Ok(SimpleValue::Null)
72			}
73
74			fn visit_unit<E>(self) -> Result<Self::Value, E> {
75				Ok(SimpleValue::Null)
76			}
77
78			fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
79			where
80				D: Deserializer<'de>,
81			{
82				Deserialize::deserialize(deserializer)
83			}
84
85			fn visit_map<V>(self, _visitor: V) -> Result<Self::Value, V::Error>
86			where
87				V: de::MapAccess<'de>,
88			{
89				Err(de::Error::custom(DeserializeError::OnlySimple))
90			}
91
92			fn visit_seq<V>(self, _visitor: V) -> Result<Self::Value, V::Error>
93			where
94				V: de::SeqAccess<'de>,
95			{
96				Err(de::Error::custom(DeserializeError::OnlySimple))
97			}
98		}
99
100		deserializer.deserialize_any(SimpleValueVisitor)
101	}
102}
103
104impl Serialize for SimpleValue {
105	#[inline]
106	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
107	where
108		S: ::serde::Serializer,
109	{
110		match self {
111			SimpleValue::Null => serializer.serialize_unit(),
112			SimpleValue::Bool(b) => serializer.serialize_bool(*b),
113			SimpleValue::Number(n) => n.serialize(serializer),
114			SimpleValue::String(s) => serializer.serialize_str(s),
115		}
116	}
117}
118
119/// Used in workflow activity inputs/outputs. Using this over BTreeMap is preferred because this does not
120/// reorder keys, providing faster insert and lookup.
121#[derive(::serde::Serialize, ::serde::Deserialize)]
122pub struct HashableMap<K: Eq + Hash, V: Hash>(IndexMap<K, V>);
123
124impl<K: Eq + Hash, V: Hash> HashableMap<K, V> {
125	pub fn new() -> Self {
126		HashableMap(IndexMap::new())
127	}
128
129	pub fn with_capacity(capacity: usize) -> Self {
130		HashableMap(IndexMap::with_capacity(capacity))
131	}
132}
133
134impl<K: Eq + Hash, V: Hash> Default for HashableMap<K, V> {
135	fn default() -> Self {
136		HashableMap::new()
137	}
138}
139
140impl<K: Eq + Hash, V: PartialEq + Hash> PartialEq for HashableMap<K, V> {
141	fn eq(&self, other: &HashableMap<K, V>) -> bool {
142		if self.len() != other.len() {
143			return false;
144		}
145
146		self.0
147			.iter()
148			.all(|(key, value)| other.get(key).map_or(false, |v| *value == *v))
149	}
150}
151
152impl<K: Eq + Hash, V: Eq + Hash> Eq for HashableMap<K, V> {}
153
154impl<K: Eq + Hash, V: Hash> Deref for HashableMap<K, V> {
155	type Target = IndexMap<K, V>;
156
157	fn deref(&self) -> &Self::Target {
158		&self.0
159	}
160}
161
162impl<K: Eq + Hash, V: Hash> DerefMut for HashableMap<K, V> {
163	fn deref_mut(&mut self) -> &mut Self::Target {
164		&mut self.0
165	}
166}
167
168impl<K: Eq + Ord + Hash, V: Hash> Hash for HashableMap<K, V> {
169	fn hash<H: Hasher>(&self, state: &mut H) {
170		let mut kv = Vec::from_iter(&self.0);
171		kv.sort_unstable_by(|a, b| a.0.cmp(b.0));
172		kv.hash(state);
173	}
174}
175
176impl<K: Eq + Hash + fmt::Debug, V: Hash + fmt::Debug> fmt::Debug for HashableMap<K, V> {
177	fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
178		f.debug_map().entries(self.iter()).finish()
179	}
180}
181
182impl<K: Eq + Hash + Clone, V: Hash + Clone> Clone for HashableMap<K, V> {
183	fn clone(&self) -> Self {
184		HashableMap(self.0.clone())
185	}
186
187	fn clone_from(&mut self, other: &Self) {
188		self.0.clone_from(&other.0);
189	}
190}
191
192pub trait AsHashableExt<K: Eq + Hash, V: Hash> {
193	/// Converts the iterable to a `HashableMap` via cloning.
194	fn as_hashable(&self) -> HashableMap<K, V>;
195}
196
197impl<K: Eq + Clone + Hash, V: Clone + Hash> AsHashableExt<K, V> for HashMap<K, V> {
198	fn as_hashable(&self) -> HashableMap<K, V> {
199		HashableMap(self.iter().map(|(k, v)| (k.clone(), v.clone())).collect())
200	}
201}
202
203impl<K: Eq + Clone + Hash, V: Clone + Hash> From<HashMap<K, V>> for HashableMap<K, V> {
204	fn from(val: HashMap<K, V>) -> Self {
205		HashableMap(val.into_iter().collect())
206	}
207}
208
209impl<K: Eq + Clone + Hash, V: Clone + Hash> From<HashableMap<K, V>> for HashMap<K, V> {
210	fn from(val: HashableMap<K, V>) -> Self {
211		val.into_iter().collect()
212	}
213}
214
215impl<K: Eq + Hash, V: Hash> FromIterator<(K, V)> for HashableMap<K, V> {
216	fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self {
217		HashableMap(iter.into_iter().collect())
218	}
219}
220
221impl<K: Eq + Hash, V: Hash> IntoIterator for HashableMap<K, V> {
222	type Item = (K, V);
223	type IntoIter = indexmap::map::IntoIter<K, V>;
224
225	fn into_iter(self) -> Self::IntoIter {
226		self.0.into_iter()
227	}
228}
229
230impl<'a, K: Eq + Hash, V: Hash> IntoIterator for &'a HashableMap<K, V> {
231	type Item = (&'a K, &'a V);
232	type IntoIter = indexmap::map::Iter<'a, K, V>;
233
234	fn into_iter(self) -> Self::IntoIter {
235		self.0.iter()
236	}
237}
238
239impl<'a, K: Eq + Hash, V: Hash> IntoIterator for &'a mut HashableMap<K, V> {
240	type Item = (&'a K, &'a mut V);
241	type IntoIter = indexmap::map::IterMut<'a, K, V>;
242
243	fn into_iter(self) -> Self::IntoIter {
244		self.0.iter_mut()
245	}
246}
247
248impl<K: Eq + Hash, V: Hash> Extend<(K, V)> for HashableMap<K, V> {
249	fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T) {
250		self.0.extend(iter);
251	}
252}
253
254// TODO: This doesn't work
255// impl<K: ToSchema + Eq + Hash, T: ToSchema + Hash> ToSchema for HashableMap<K, T> {
256// 	fn schemas(
257// 		schemas: &mut Vec<(
258// 			String,
259// 			utoipa::openapi::RefOr<utoipa::openapi::schema::Schema>,
260// 		)>,
261// 	) {
262// 		K::schemas(schemas);
263// 		T::schemas(schemas);
264// 	}
265// }
266//
267// impl<K: ToSchema + Eq + Hash, T: ToSchema + Hash> PartialSchema for HashableMap<K, T> {
268// 	fn schema() -> utoipa::openapi::RefOr<utoipa::openapi::schema::Schema> {
269// 		utoipa::openapi::ObjectBuilder::new()
270// 			.additional_properties(Some(T::schema()))
271// 			.into()
272// 	}
273// }
274
275/// Allows partial json ser/de.
276/// Effectively a `serde_json::value::RawValue` with type information.
277pub struct Raw<T> {
278	_marker: PhantomData<T>,
279	inner: Box<RawValue>,
280}
281
282impl<T> Raw<T> {
283	pub fn from_string(s: String) -> Result<Self, serde_json::Error> {
284		Ok(Raw {
285			_marker: PhantomData,
286			inner: serde_json::value::RawValue::from_string(s)?,
287		})
288	}
289}
290
291impl<T: ::serde::Serialize> Raw<T> {
292	pub fn new(t: &T) -> Result<Self, serde_json::Error> {
293		Ok(Raw {
294			_marker: PhantomData,
295			inner: serde_json::value::to_raw_value(t)?,
296		})
297	}
298}
299
300impl<T: DeserializeOwned> Raw<T> {
301	pub fn deserialize(&self) -> Result<T, serde_json::Error> {
302		serde_json::from_str(self.inner.get())
303	}
304}
305
306impl<T> Serialize for Raw<T> {
307	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
308	where
309		S: Serializer,
310	{
311		self.inner.serialize(serializer)
312	}
313}
314
315impl<'de, T> Deserialize<'de> for Raw<T>
316where
317	T: DeserializeOwned,
318{
319	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
320	where
321		D: Deserializer<'de>,
322	{
323		let inner = Box::<RawValue>::deserialize(deserializer)?;
324		Ok(Raw {
325			_marker: PhantomData,
326			inner,
327		})
328	}
329}
330
331impl<T> Clone for Raw<T> {
332	fn clone(&self) -> Self {
333		Raw {
334			_marker: PhantomData,
335			inner: self.inner.clone(),
336		}
337	}
338}
339
340impl<T: Hash> Hash for Raw<T> {
341	fn hash<H: Hasher>(&self, state: &mut H) {
342		self.inner.get().hash(state);
343	}
344}
345
346impl<T> std::ops::Deref for Raw<T> {
347	type Target = RawValue;
348
349	fn deref(&self) -> &Self::Target {
350		self.inner.as_ref()
351	}
352}
353
354impl<T: std::fmt::Debug> std::fmt::Debug for Raw<T> {
355	fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
356		f.debug_tuple("Raw")
357			.field(&format_args!("{}", self.inner.get()))
358			.finish()
359	}
360}
361
362/// A map-like structure that serializes/deserializes as a JSON object but is backed by a Vec.
363/// Preserves insertion order and allows duplicate keys.
364#[derive(Debug, Clone, PartialEq, Eq)]
365pub struct FakeMap<K, V>(Vec<(K, V)>);
366
367impl<K, V> FakeMap<K, V> {
368	pub fn new() -> Self {
369		FakeMap(Vec::new())
370	}
371
372	pub fn with_capacity(capacity: usize) -> Self {
373		FakeMap(Vec::with_capacity(capacity))
374	}
375}
376
377impl<K: Ord, V> FakeMap<K, V> {
378	/// Sort by keys.
379	pub fn sort(&mut self)
380	where
381		K: Ord,
382	{
383		self.0.sort_by(|a, b| a.0.cmp(&b.0));
384	}
385}
386
387impl<K, V> Default for FakeMap<K, V> {
388	fn default() -> Self {
389		FakeMap::new()
390	}
391}
392
393impl<K, V> Deref for FakeMap<K, V> {
394	type Target = Vec<(K, V)>;
395
396	fn deref(&self) -> &Self::Target {
397		&self.0
398	}
399}
400
401impl<K, V> DerefMut for FakeMap<K, V> {
402	fn deref_mut(&mut self) -> &mut Self::Target {
403		&mut self.0
404	}
405}
406
407impl<K: Eq + Hash, V> From<Vec<(K, V)>> for FakeMap<K, V> {
408	fn from(val: Vec<(K, V)>) -> Self {
409		FakeMap(val)
410	}
411}
412
413impl<K: Eq + Hash, V> From<FakeMap<K, V>> for Vec<(K, V)> {
414	fn from(val: FakeMap<K, V>) -> Self {
415		val.0
416	}
417}
418
419impl<K: Eq + Hash, V> From<HashMap<K, V>> for FakeMap<K, V> {
420	fn from(val: HashMap<K, V>) -> Self {
421		FakeMap(val.into_iter().collect())
422	}
423}
424
425impl<K: Eq + Hash, V> From<FakeMap<K, V>> for HashMap<K, V> {
426	fn from(val: FakeMap<K, V>) -> Self {
427		val.into_iter().collect()
428	}
429}
430
431impl<K: Serialize, V: Serialize> Serialize for FakeMap<K, V> {
432	fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
433	where
434		S: Serializer,
435	{
436		use ::serde::ser::SerializeMap;
437
438		let mut map = serializer.serialize_map(Some(self.0.len()))?;
439		for (k, v) in &self.0 {
440			map.serialize_entry(k, v)?;
441		}
442		map.end()
443	}
444}
445
446impl<'de, K: Deserialize<'de>, V: Deserialize<'de>> Deserialize<'de> for FakeMap<K, V> {
447	fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
448	where
449		D: Deserializer<'de>,
450	{
451		struct FakeMapVisitor<K, V> {
452			marker: PhantomData<(K, V)>,
453		}
454
455		impl<'de, K: Deserialize<'de>, V: Deserialize<'de>> de::Visitor<'de> for FakeMapVisitor<K, V> {
456			type Value = FakeMap<K, V>;
457
458			fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
459				formatter.write_str("a map")
460			}
461
462			fn visit_map<M>(self, mut access: M) -> Result<Self::Value, M::Error>
463			where
464				M: de::MapAccess<'de>,
465			{
466				let mut vec = Vec::with_capacity(access.size_hint().unwrap_or(0));
467				while let Some((key, value)) = access.next_entry()? {
468					vec.push((key, value));
469				}
470				Ok(FakeMap(vec))
471			}
472		}
473
474		deserializer.deserialize_map(FakeMapVisitor {
475			marker: PhantomData,
476		})
477	}
478}
479
480impl<K, V> FromIterator<(K, V)> for FakeMap<K, V> {
481	fn from_iter<I: IntoIterator<Item = (K, V)>>(iter: I) -> Self {
482		FakeMap(iter.into_iter().collect())
483	}
484}
485
486impl<K, V> IntoIterator for FakeMap<K, V> {
487	type Item = (K, V);
488	type IntoIter = std::vec::IntoIter<(K, V)>;
489
490	fn into_iter(self) -> Self::IntoIter {
491		self.0.into_iter()
492	}
493}
494
495impl<'a, K, V> IntoIterator for &'a FakeMap<K, V> {
496	type Item = &'a (K, V);
497	type IntoIter = std::slice::Iter<'a, (K, V)>;
498
499	fn into_iter(self) -> Self::IntoIter {
500		self.0.iter()
501	}
502}
503
504impl<'a, K, V> IntoIterator for &'a mut FakeMap<K, V> {
505	type Item = &'a mut (K, V);
506	type IntoIter = std::slice::IterMut<'a, (K, V)>;
507
508	fn into_iter(self) -> Self::IntoIter {
509		self.0.iter_mut()
510	}
511}
512
513impl<K, V> Extend<(K, V)> for FakeMap<K, V> {
514	fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T) {
515		self.0.extend(iter);
516	}
517}
rivet_util_serde/lib.rs

rivet_util_serde/
lib.rs
