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

wit_parser/
serde_.rs
