1use crate::{Params, Type};
2use id_arena::{Arena, Id};
3use indexmap::IndexMap;
4use semver::Version;
5use serde::ser::{SerializeMap, SerializeSeq, Serializer};
6use serde::{de::Error, Deserialize, Serialize};
7
8pub fn serialize_none<S>(serializer: S) -> Result<S::Ok, S::Error>
9where
10 S: Serializer,
11{
12 serializer.serialize_none()
13}
14
15pub fn serialize_arena<T, S>(arena: &Arena<T>, serializer: S) -> Result<S::Ok, S::Error>
16where
17 T: Serialize,
18 S: Serializer,
19{
20 let mut seq: ::SerializeSeq = serializer.serialize_seq(len:Some(arena.len()))?;
21 for (_, item: &T) in arena.iter() {
22 seq.serialize_element(&item)?;
23 }
24 seq.end()
25}
26
27pub fn serialize_id<T, S>(id: &Id<T>, serializer: S) -> Result<S::Ok, S::Error>
28where
29 S: Serializer,
30{
31 serializer.serialize_u64(id.index() as u64)
32}
33
34pub fn serialize_optional_id<T, S>(id: &Option<Id<T>>, serializer: S) -> Result<S::Ok, S::Error>
35where
36 S: Serializer,
37{
38 match id {
39 Some(id: &Id) => serialize_id(&id, serializer),
40 None => serializer.serialize_none(),
41 }
42}
43
44pub fn serialize_id_map<K, T, S>(map: &IndexMap<K, Id<T>>, serializer: S) -> Result<S::Ok, S::Error>
45where
46 K: Serialize,
47 S: Serializer,
48{
49 let mut s: ::SerializeMap = serializer.serialize_map(len:Some(map.len()))?;
50 for (key: &K, id: &Id) in map.iter() {
51 s.serialize_entry(key, &(id.index() as u64))?;
52 }
53 s.end()
54}
55
56impl Serialize for Type {
57 fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
58 where
59 S: Serializer,
60 {
61 match self {
62 Type::Bool => serializer.serialize_str("bool"),
63 Type::U8 => serializer.serialize_str("u8"),
64 Type::U16 => serializer.serialize_str("u16"),
65 Type::U32 => serializer.serialize_str("u32"),
66 Type::U64 => serializer.serialize_str("u64"),
67 Type::S8 => serializer.serialize_str("s8"),
68 Type::S16 => serializer.serialize_str("s16"),
69 Type::S32 => serializer.serialize_str("s32"),
70 Type::S64 => serializer.serialize_str("s64"),
71 Type::F32 => serializer.serialize_str("f32"),
72 Type::F64 => serializer.serialize_str("f64"),
73 Type::Char => serializer.serialize_str("char"),
74 Type::String => serializer.serialize_str("string"),
75 Type::Id(type_id: &Id) => serializer.serialize_u64(type_id.index() as u64),
76 }
77 }
78}
79
80pub fn serialize_anon_result<S>(typ: &Type, serializer: S) -> Result<S::Ok, S::Error>
81where
82 S: Serializer,
83{
84 let params: Params = vec![(String::default(), *typ)];
85 serialize_params(&params, serializer)
86}
87
88pub fn serialize_params<S>(params: &Params, serializer: S) -> Result<S::Ok, S::Error>
89where
90 S: Serializer,
91{
92 let mut seq: ::SerializeSeq = serializer.serialize_seq(len:Some(params.len()))?;
93 for (name: &String, typ: &Type) in params.iter() {
94 let param: Param = Param {
95 name: name.to_string(),
96 typ: *typ,
97 };
98 seq.serialize_element(&param)?;
99 }
100 seq.end()
101}
102
103#[derive(Debug, Clone, PartialEq, serde_derive::Serialize)]
104struct Param {
105 #[serde(skip_serializing_if = "String::is_empty")]
106 pub name: String,
107 #[serde(rename = "type")]
108 pub typ: Type,
109}
110
111pub fn serialize_version<S>(version: &Version, serializer: S) -> Result<S::Ok, S::Error>
112where
113 S: Serializer,
114{
115 version.to_string().serialize(serializer)
116}
117
118pub fn deserialize_version<'de, D>(deserializer: D) -> Result<Version, D::Error>
119where
120 D: serde::de::Deserializer<'de>,
121{
122 let version: String = String::deserialize(deserializer)?;
123 version.parse().map_err(|e: Error| D::Error::custom(msg:e))
124}
125
126pub fn serialize_optional_version<S>(
127 version: &Option<Version>,
128 serializer: S,
129) -> Result<S::Ok, S::Error>
130where
131 S: Serializer,
132{
133 versionOption
134 .as_ref()
135 .map(|s: &Version| s.to_string())
136 .serialize(serializer)
137}
138
139pub fn deserialize_optional_version<'de, D>(deserializer: D) -> Result<Option<Version>, D::Error>
140where
141 D: serde::de::Deserializer<'de>,
142{
143 match <Option<String>>::deserialize(deserializer)? {
144 Some(version: String) => Ok(Some(version.parse().map_err(|e: Error| D::Error::custom(msg:e))?)),
145 None => Ok(None),
146 }
147}
148