wit_parser/
serde_.rs

1use crate::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 = serializer.serialize_seq(Some(arena.len()))?;
21    for (_, item) 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) => 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 = serializer.serialize_map(Some(map.len()))?;
50    for (key, 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) => serializer.serialize_u64(type_id.index() as u64),
76        }
77    }
78}
79
80pub fn serialize_params<S>(params: &[(String, Type)], serializer: S) -> Result<S::Ok, S::Error>
81where
82    S: Serializer,
83{
84    let mut seq = serializer.serialize_seq(Some(params.len()))?;
85    for (name, typ) in params.iter() {
86        let param = Param {
87            name: name.to_string(),
88            typ: *typ,
89        };
90        seq.serialize_element(&param)?;
91    }
92    seq.end()
93}
94
95#[derive(Debug, Clone, PartialEq, serde_derive::Serialize)]
96struct Param {
97    #[serde(skip_serializing_if = "String::is_empty")]
98    pub name: String,
99    #[serde(rename = "type")]
100    pub typ: Type,
101}
102
103pub fn serialize_version<S>(version: &Version, serializer: S) -> Result<S::Ok, S::Error>
104where
105    S: Serializer,
106{
107    version.to_string().serialize(serializer)
108}
109
110pub fn deserialize_version<'de, D>(deserializer: D) -> Result<Version, D::Error>
111where
112    D: serde::de::Deserializer<'de>,
113{
114    let version: String = String::deserialize(deserializer)?;
115    version.parse().map_err(|e| D::Error::custom(e))
116}
117
118pub fn serialize_optional_version<S>(
119    version: &Option<Version>,
120    serializer: S,
121) -> Result<S::Ok, S::Error>
122where
123    S: Serializer,
124{
125    version
126        .as_ref()
127        .map(|s| s.to_string())
128        .serialize(serializer)
129}
130
131pub fn deserialize_optional_version<'de, D>(deserializer: D) -> Result<Option<Version>, D::Error>
132where
133    D: serde::de::Deserializer<'de>,
134{
135    match <Option<String>>::deserialize(deserializer)? {
136        Some(version) => Ok(Some(version.parse().map_err(|e| D::Error::custom(e))?)),
137        None => Ok(None),
138    }
139}
wit_parser/serde_.rs

wit_parser/
serde_.rs
