Skip to main content

osom_lib_primitives/
serde_impl.rs

1use serde::{Deserialize, Serialize, de};
2
3use osom_lib_reprc::traits::ReprC;
4
5use super::coption::COption;
6use super::kvp::KVP;
7use super::length::Length;
8use super::power_of_two::{PowerOfTwo32, PowerOfTwo64};
9
10impl<TValue: ReprC + Serialize> Serialize for COption<TValue> {
11    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
12    where
13        S: serde::Serializer,
14    {
15        self.as_ref().into_option().serialize(serializer)
16    }
17}
18
19impl<'de, TValue: ReprC + Deserialize<'de>> Deserialize<'de> for COption<TValue> {
20    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
21    where
22        D: serde::Deserializer<'de>,
23    {
24        let option = Option::<TValue>::deserialize(deserializer)?;
25        Ok(COption::from_option(option))
26    }
27}
28
29impl Serialize for Length {
30    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
31    where
32        S: serde::Serializer,
33    {
34        self.as_u32().serialize(serializer)
35    }
36}
37
38impl<'de> Deserialize<'de> for Length {
39    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
40    where
41        D: serde::Deserializer<'de>,
42    {
43        let value = u32::deserialize(deserializer)?;
44        Length::try_from_u32(value).map_err(de::Error::custom)
45    }
46}
47
48impl Serialize for PowerOfTwo32 {
49    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
50    where
51        S: serde::Serializer,
52    {
53        self.value().serialize(serializer)
54    }
55}
56
57impl<'de> Deserialize<'de> for PowerOfTwo32 {
58    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
59    where
60        D: serde::Deserializer<'de>,
61    {
62        let value = u32::deserialize(deserializer)?;
63        PowerOfTwo32::new(value).map_err(de::Error::custom)
64    }
65}
66
67impl Serialize for PowerOfTwo64 {
68    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
69    where
70        S: serde::Serializer,
71    {
72        self.value().serialize(serializer)
73    }
74}
75
76impl<'de> Deserialize<'de> for PowerOfTwo64 {
77    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
78    where
79        D: serde::Deserializer<'de>,
80    {
81        let value = u64::deserialize(deserializer)?;
82        PowerOfTwo64::new(value).map_err(de::Error::custom)
83    }
84}
85
86impl<TKey: Serialize, TValue: Serialize> Serialize for KVP<TKey, TValue> {
87    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
88    where
89        S: serde::Serializer,
90    {
91        self.as_tuple().serialize(serializer)
92    }
93}
94
95impl<'de, TKey: Deserialize<'de>, TValue: Deserialize<'de>> Deserialize<'de> for KVP<TKey, TValue> {
96    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
97    where
98        D: serde::Deserializer<'de>,
99    {
100        let tuple = <(TKey, TValue)>::deserialize(deserializer)?;
101        Ok(tuple.into())
102    }
103}