base/
custom_serde.rs

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
7use std::result::Result;
8use std::sync::Arc;
9
10use serde::de::Error;
11use serde::Deserialize;
12use serde::Deserializer;
13use serde::Serialize;
14use serde::Serializer;
15use 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.
22pub 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.
34pub fn serialize_arr<S, T: Sized + Serialize, const SIZE: usize>(
35    data: &[T; SIZE],
36    serializer: S,
37) -> Result<S::Ok, S::Error>
38where
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.
46pub 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>
54where
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
64pub 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>
74where
75    S: Serializer,
76{
77    let kv_vec: Vec<(&MapKeyType, &MapValType)> = map.into_iter().collect();
78    serde::Serialize::serialize(&kv_vec, serializer)
79}
80
81pub 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>
90where
91    D: Deserializer<'de>,
92{
93    let kv_vec: Vec<(MapKeyType, MapValType)> = serde::Deserialize::deserialize(deserializer)?;
94    Ok(MapType::from_iter(kv_vec))
95}