toml/ser/value/
array.rs

1use core::fmt::Write as _;
2
3use toml_writer::TomlWrite as _;
4
5use super::Error;
6use super::Style;
7use crate::alloc_prelude::*;
8
9#[doc(hidden)]
10pub struct SerializeValueArray<'d> {
11    dst: &'d mut String,
12    seen_value: bool,
13    style: Style,
14    len: Option<usize>,
15}
16
17impl<'d> SerializeValueArray<'d> {
18    pub(crate) fn seq(
19        dst: &'d mut String,
20        style: Style,
21        len: Option<usize>,
22    ) -> Result<Self, Error> {
23        dst.open_array()?;
24        Ok(Self {
25            dst,
26            seen_value: false,
27            style,
28            len,
29        })
30    }
31
32    fn end(self) -> Result<&'d mut String, Error> {
33        if self.multiline_array() && self.seen_value {
34            self.dst.newline()?;
35        }
36        self.dst.close_array()?;
37        Ok(self.dst)
38    }
39
40    fn multiline_array(&self) -> bool {
41        self.style.multiline_array && 2 <= self.len.unwrap_or(usize::MAX)
42    }
43}
44
45impl<'d> serde::ser::SerializeSeq for SerializeValueArray<'d> {
46    type Ok = &'d mut String;
47    type Error = Error;
48
49    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
50    where
51        T: serde::ser::Serialize + ?Sized,
52    {
53        if self.multiline_array() {
54            self.dst.newline()?;
55            write!(self.dst, "    ")?;
56        } else {
57            if self.seen_value {
58                self.dst.val_sep()?;
59                self.dst.space()?;
60            }
61        }
62        self.seen_value = true;
63        value.serialize(super::ValueSerializer::with_style(self.dst, self.style))?;
64        if self.multiline_array() {
65            self.dst.val_sep()?;
66        }
67        Ok(())
68    }
69
70    fn end(self) -> Result<Self::Ok, Self::Error> {
71        self.end()
72    }
73}
74
75impl<'d> serde::ser::SerializeTuple for SerializeValueArray<'d> {
76    type Ok = &'d mut String;
77    type Error = Error;
78
79    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
80    where
81        T: serde::ser::Serialize + ?Sized,
82    {
83        serde::ser::SerializeSeq::serialize_element(self, value)
84    }
85
86    fn end(self) -> Result<Self::Ok, Self::Error> {
87        serde::ser::SerializeSeq::end(self)
88    }
89}
90
91impl<'d> serde::ser::SerializeTupleStruct for SerializeValueArray<'d> {
92    type Ok = &'d mut String;
93    type Error = Error;
94
95    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
96    where
97        T: serde::ser::Serialize + ?Sized,
98    {
99        serde::ser::SerializeSeq::serialize_element(self, value)
100    }
101
102    fn end(self) -> Result<Self::Ok, Self::Error> {
103        serde::ser::SerializeSeq::end(self)
104    }
105}
106
107pub struct SerializeTupleVariant<'d> {
108    inner: SerializeValueArray<'d>,
109}
110
111impl<'d> SerializeTupleVariant<'d> {
112    pub(crate) fn tuple(
113        dst: &'d mut String,
114        variant: &'static str,
115        len: usize,
116        style: Style,
117    ) -> Result<Self, Error> {
118        dst.open_inline_table()?;
119        dst.space()?;
120        dst.key(variant)?;
121        dst.space()?;
122        dst.keyval_sep()?;
123        dst.space()?;
124        Ok(Self {
125            inner: SerializeValueArray::seq(dst, style, Some(len))?,
126        })
127    }
128}
129
130impl<'d> serde::ser::SerializeTupleVariant for SerializeTupleVariant<'d> {
131    type Ok = &'d mut String;
132    type Error = Error;
133
134    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
135    where
136        T: serde::ser::Serialize + ?Sized,
137    {
138        serde::ser::SerializeSeq::serialize_element(&mut self.inner, value)
139    }
140
141    fn end(self) -> Result<Self::Ok, Self::Error> {
142        let dst = self.inner.end()?;
143        dst.space()?;
144        dst.close_inline_table()?;
145        Ok(dst)
146    }
147}
toml/ser/value/array.rs

toml/ser/value/
array.rs
