1 // Copyright 2023 The ChromiumOS Authors
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4
5 //! Library for custom implementations of serialize/deserialize.
6
7 use std::result::Result;
8 use std::sync::Arc;
9
10 use serde::de::Error;
11 use serde::Deserialize;
12 use serde::Deserializer;
13 use serde::Serialize;
14 use serde::Serializer;
15 use sync::Mutex;
16
17 /// Serialize data `T` inside an `Arc<Mutex<T>>`. `T` must be serializable.
18 ///
19 /// NOTE: This does not validate already serialized Mutexes and data. If multiple structs contain a
20 /// clone of the Arc, and they are all being serialized, this will result in the same data being
21 /// serialized, once per clone.
serialize_arc_mutex<S: Serializer, T: Serialize + ?Sized>( item: &Arc<Mutex<T>>, serializer: S, ) -> Result<S::Ok, S::Error>22 pub fn serialize_arc_mutex<S: Serializer, T: Serialize + ?Sized>(
23 item: &Arc<Mutex<T>>,
24 serializer: S,
25 ) -> Result<S::Ok, S::Error> {
26 let lock = item.lock();
27 serde::Serialize::serialize(&*lock, serializer)
28 }
29
30 /// Serialize data T inside arrays as a seq instead of a tuple. T must be serializable.
31 /// When deserializing, an array size validation is required to transform the slice to an array.
32 ///
33 /// This approach is used to go around serde's limitation of serializable array sizes.
serialize_arr<S, T: Sized + Serialize, const SIZE: usize>( data: &[T; SIZE], serializer: S, ) -> Result<S::Ok, S::Error> where S: Serializer,34 pub fn serialize_arr<S, T: Sized + Serialize, const SIZE: usize>(
35 data: &[T; SIZE],
36 serializer: S,
37 ) -> Result<S::Ok, S::Error>
38 where
39 S: Serializer,
40 {
41 serde::Serialize::serialize(&data[..], serializer)
42 }
43
44 /// Deserialize sequence of T into an Array of SIZE == Size of sequence.
45 /// This function is a workaround to the serde limitation on array size (32) deserialization.
deserialize_seq_to_arr< 'de, D, T: Sized + Deserialize<'de> + std::fmt::Debug, const SIZE: usize, >( deserializer: D, ) -> Result<[T; SIZE], D::Error> where D: Deserializer<'de>,46 pub fn deserialize_seq_to_arr<
47 'de,
48 D,
49 T: Sized + Deserialize<'de> + std::fmt::Debug,
50 const SIZE: usize,
51 >(
52 deserializer: D,
53 ) -> Result<[T; SIZE], D::Error>
54 where
55 D: Deserializer<'de>,
56 {
57 let vals_vec: Vec<T> = serde::Deserialize::deserialize(deserializer)?;
58 let vals_arr: [T; SIZE] = vals_vec.try_into().map_err(|_| {
59 <D as Deserializer>::Error::custom("failed to convert vector to array while deserializing")
60 })?;
61 Ok(vals_arr)
62 }
63
serialize_map_as_kv_vec< 'se, MapKeyType: 'se + Serialize, MapValType: 'se + Serialize, MapType: std::iter::IntoIterator<Item = (&'se MapKeyType, &'se MapValType)>, S, >( map: MapType, serializer: S, ) -> Result<S::Ok, S::Error> where S: Serializer,64 pub fn serialize_map_as_kv_vec<
65 'se,
66 MapKeyType: 'se + Serialize,
67 MapValType: 'se + Serialize,
68 MapType: std::iter::IntoIterator<Item = (&'se MapKeyType, &'se MapValType)>,
69 S,
70 >(
71 map: MapType,
72 serializer: S,
73 ) -> Result<S::Ok, S::Error>
74 where
75 S: Serializer,
76 {
77 let kv_vec: Vec<(&MapKeyType, &MapValType)> = map.into_iter().collect();
78 serde::Serialize::serialize(&kv_vec, serializer)
79 }
80
deserialize_map_from_kv_vec< 'de, MapKeyType: Deserialize<'de>, MapValType: Deserialize<'de>, MapType: std::iter::FromIterator<(MapKeyType, MapValType)>, D, >( deserializer: D, ) -> Result<MapType, D::Error> where D: Deserializer<'de>,81 pub fn deserialize_map_from_kv_vec<
82 'de,
83 MapKeyType: Deserialize<'de>,
84 MapValType: Deserialize<'de>,
85 MapType: std::iter::FromIterator<(MapKeyType, MapValType)>,
86 D,
87 >(
88 deserializer: D,
89 ) -> Result<MapType, D::Error>
90 where
91 D: Deserializer<'de>,
92 {
93 let kv_vec: Vec<(MapKeyType, MapValType)> = serde::Deserialize::deserialize(deserializer)?;
94 Ok(MapType::from_iter(kv_vec))
95 }
96