Skip to main content

toml_spanner/
impl_serde.rs

1//! Serde serialization support for [`Spanned<T>`](crate::Spanned) and
2//! [`Item`].
3//!
4//! Enabled by the `serde` feature flag. This provides [`serde::Serialize`]
5//! implementations only — deserialization uses the [`FromToml`](crate::FromToml)
6//! trait instead.
7
8use crate::Spanned;
9use crate::item::Value;
10use crate::item::table::InnerTable;
11use crate::parser::Document;
12use crate::{Item, Table};
13
14impl<T> serde::Serialize for Spanned<T>
15where
16    T: serde::Serialize,
17{
18    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
19    where
20        S: serde::Serializer,
21    {
22        self.value.serialize(serializer)
23    }
24}
25
26impl serde::Serialize for Item<'_> {
27    fn serialize<S>(&self, ser: S) -> Result<S::Ok, S::Error>
28    where
29        S: serde::Serializer,
30    {
31        match self.value() {
32            Value::String(s) => ser.serialize_str(s),
33            Value::Integer(i) => ser.serialize_i128(i.as_i128()),
34            Value::Float(f) => ser.serialize_f64(*f),
35            Value::Boolean(b) => ser.serialize_bool(*b),
36            Value::Array(arr) => {
37                use serde::ser::SerializeSeq;
38                let mut seq = ser.serialize_seq(Some(arr.len()))?;
39                for ele in arr {
40                    seq.serialize_element(ele)?;
41                }
42                seq.end()
43            }
44            Value::Table(tab) => {
45                use serde::ser::SerializeMap;
46                let mut map = ser.serialize_map(Some(tab.len()))?;
47                for (k, v) in tab {
48                    map.serialize_entry(k.name, v)?;
49                }
50                map.end()
51            }
52            Value::DateTime(m) => {
53                let mut buf = std::mem::MaybeUninit::uninit();
54                ser.serialize_str(m.format(&mut buf))
55            }
56        }
57    }
58}
59
60impl serde::Serialize for InnerTable<'_> {
61    fn serialize<S>(&self, ser: S) -> Result<S::Ok, S::Error>
62    where
63        S: serde::Serializer,
64    {
65        use serde::ser::SerializeMap;
66        let mut map = ser.serialize_map(Some(self.len()))?;
67        for (k, v) in self.entries() {
68            map.serialize_entry(k.name, v)?;
69        }
70        map.end()
71    }
72}
73
74impl serde::Serialize for Table<'_> {
75    fn serialize<S>(&self, ser: S) -> Result<S::Ok, S::Error>
76    where
77        S: serde::Serializer,
78    {
79        self.value.serialize(ser)
80    }
81}
82
83impl serde::Serialize for Document<'_> {
84    fn serialize<S>(&self, ser: S) -> Result<S::Ok, S::Error>
85    where
86        S: serde::Serializer,
87    {
88        self.table.serialize(ser)
89    }
90}