Skip to content

Commit 268a1f8

Browse files
epageepage
authored
Merge pull request #874 from epage/w
feart(write): Prep for `toml`s use
2 parents b2e9f5e + e406f94 commit 268a1f8

File tree

9 files changed

+572
-513
lines changed

9 files changed

+572
-513
lines changed

‎crates/toml/src/ser/array.rs

Lines changed: 169 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,169 @@
1+
use super::write_document;
2+
use super::write_value;
3+
use super::{Error, Serializer, ValueSerializer};
4+
use crate::fmt::DocumentFormatter;
5+
6+
type InnerSerializeDocumentSeq =
7+
<toml_edit::ser::ValueSerializer as serde::Serializer>::SerializeSeq;
8+
9+
#[doc(hidden)]
10+
pub struct SerializeDocumentArray<'d> {
11+
inner: InnerSerializeDocumentSeq,
12+
dst: &'d mut String,
13+
settings: DocumentFormatter,
14+
}
15+
16+
impl<'d> SerializeDocumentArray<'d> {
17+
pub(crate) fn new(ser: Serializer<'d>, inner: InnerSerializeDocumentSeq) -> Self {
18+
Self {
19+
inner,
20+
dst: ser.dst,
21+
settings: ser.settings,
22+
}
23+
}
24+
}
25+
26+
impl serde::ser::SerializeSeq for SerializeDocumentArray<'_> {
27+
type Ok = ();
28+
type Error = Error;
29+
30+
fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
31+
where
32+
T: serde::ser::Serialize + ?Sized,
33+
{
34+
self.inner.serialize_element(value).map_err(Error::wrap)
35+
}
36+
37+
fn end(self) -> Result<Self::Ok, Self::Error> {
38+
write_document(self.dst, self.settings, self.inner.end())
39+
}
40+
}
41+
42+
impl serde::ser::SerializeTuple for SerializeDocumentArray<'_> {
43+
type Ok = ();
44+
type Error = Error;
45+
46+
fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
47+
where
48+
T: serde::ser::Serialize + ?Sized,
49+
{
50+
self.inner.serialize_element(value).map_err(Error::wrap)
51+
}
52+
53+
fn end(self) -> Result<Self::Ok, Self::Error> {
54+
write_document(self.dst, self.settings, self.inner.end())
55+
}
56+
}
57+
58+
impl serde::ser::SerializeTupleVariant for SerializeDocumentArray<'_> {
59+
type Ok = ();
60+
type Error = Error;
61+
62+
fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
63+
where
64+
T: serde::ser::Serialize + ?Sized,
65+
{
66+
self.inner.serialize_field(value).map_err(Error::wrap)
67+
}
68+
69+
fn end(self) -> Result<Self::Ok, Self::Error> {
70+
write_document(self.dst, self.settings, self.inner.end())
71+
}
72+
}
73+
74+
impl serde::ser::SerializeTupleStruct for SerializeDocumentArray<'_> {
75+
type Ok = ();
76+
type Error = Error;
77+
78+
fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
79+
where
80+
T: serde::ser::Serialize + ?Sized,
81+
{
82+
self.inner.serialize_field(value).map_err(Error::wrap)
83+
}
84+
85+
fn end(self) -> Result<Self::Ok, Self::Error> {
86+
write_document(self.dst, self.settings, self.inner.end())
87+
}
88+
}
89+
90+
type InnerSerializeValueSeq = <toml_edit::ser::ValueSerializer as serde::Serializer>::SerializeSeq;
91+
92+
#[doc(hidden)]
93+
pub struct SerializeValueArray<'d> {
94+
inner: InnerSerializeValueSeq,
95+
dst: &'d mut String,
96+
}
97+
98+
impl<'d> SerializeValueArray<'d> {
99+
pub(crate) fn new(ser: ValueSerializer<'d>, inner: InnerSerializeValueSeq) -> Self {
100+
Self {
101+
inner,
102+
dst: ser.dst,
103+
}
104+
}
105+
}
106+
107+
impl serde::ser::SerializeSeq for SerializeValueArray<'_> {
108+
type Ok = ();
109+
type Error = Error;
110+
111+
fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
112+
where
113+
T: serde::ser::Serialize + ?Sized,
114+
{
115+
self.inner.serialize_element(value).map_err(Error::wrap)
116+
}
117+
118+
fn end(self) -> Result<Self::Ok, Self::Error> {
119+
write_value(self.dst, self.inner.end())
120+
}
121+
}
122+
123+
impl serde::ser::SerializeTuple for SerializeValueArray<'_> {
124+
type Ok = ();
125+
type Error = Error;
126+
127+
fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
128+
where
129+
T: serde::ser::Serialize + ?Sized,
130+
{
131+
self.inner.serialize_element(value).map_err(Error::wrap)
132+
}
133+
134+
fn end(self) -> Result<Self::Ok, Self::Error> {
135+
write_value(self.dst, self.inner.end())
136+
}
137+
}
138+
139+
impl serde::ser::SerializeTupleVariant for SerializeValueArray<'_> {
140+
type Ok = ();
141+
type Error = Error;
142+
143+
fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
144+
where
145+
T: serde::ser::Serialize + ?Sized,
146+
{
147+
self.inner.serialize_field(value).map_err(Error::wrap)
148+
}
149+
150+
fn end(self) -> Result<Self::Ok, Self::Error> {
151+
write_value(self.dst, self.inner.end())
152+
}
153+
}
154+
155+
impl serde::ser::SerializeTupleStruct for SerializeValueArray<'_> {
156+
type Ok = ();
157+
type Error = Error;
158+
159+
fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
160+
where
161+
T: serde::ser::Serialize + ?Sized,
162+
{
163+
self.inner.serialize_field(value).map_err(Error::wrap)
164+
}
165+
166+
fn end(self) -> Result<Self::Ok, Self::Error> {
167+
write_value(self.dst, self.inner.end())
168+
}
169+
}

‎crates/toml/src/ser/map.rs

Lines changed: 120 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,120 @@
1+
use super::write_document;
2+
use super::write_value;
3+
use super::{Error, Serializer, ValueSerializer};
4+
use crate::fmt::DocumentFormatter;
5+
6+
type InnerSerializeDocumentTable =
7+
<toml_edit::ser::ValueSerializer as serde::Serializer>::SerializeMap;
8+
9+
#[doc(hidden)]
10+
pub struct SerializeDocumentTable<'d> {
11+
inner: InnerSerializeDocumentTable,
12+
dst: &'d mut String,
13+
settings: DocumentFormatter,
14+
}
15+
16+
impl<'d> SerializeDocumentTable<'d> {
17+
pub(crate) fn new(ser: Serializer<'d>, inner: InnerSerializeDocumentTable) -> Self {
18+
Self {
19+
inner,
20+
dst: ser.dst,
21+
settings: ser.settings,
22+
}
23+
}
24+
}
25+
26+
impl serde::ser::SerializeMap for SerializeDocumentTable<'_> {
27+
type Ok = ();
28+
type Error = Error;
29+
30+
fn serialize_key<T>(&mut self, input: &T) -> Result<(), Self::Error>
31+
where
32+
T: serde::ser::Serialize + ?Sized,
33+
{
34+
self.inner.serialize_key(input).map_err(Error::wrap)
35+
}
36+
37+
fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
38+
where
39+
T: serde::ser::Serialize + ?Sized,
40+
{
41+
self.inner.serialize_value(value).map_err(Error::wrap)
42+
}
43+
44+
fn end(self) -> Result<Self::Ok, Self::Error> {
45+
write_document(self.dst, self.settings, self.inner.end())
46+
}
47+
}
48+
49+
impl serde::ser::SerializeStruct for SerializeDocumentTable<'_> {
50+
type Ok = ();
51+
type Error = Error;
52+
53+
fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
54+
where
55+
T: serde::ser::Serialize + ?Sized,
56+
{
57+
self.inner.serialize_field(key, value).map_err(Error::wrap)
58+
}
59+
60+
fn end(self) -> Result<Self::Ok, Self::Error> {
61+
write_document(self.dst, self.settings, self.inner.end())
62+
}
63+
}
64+
65+
type InnerSerializeValueTable =
66+
<toml_edit::ser::ValueSerializer as serde::Serializer>::SerializeMap;
67+
68+
#[doc(hidden)]
69+
pub struct SerializeValueTable<'d> {
70+
inner: InnerSerializeValueTable,
71+
dst: &'d mut String,
72+
}
73+
74+
impl<'d> SerializeValueTable<'d> {
75+
pub(crate) fn new(ser: ValueSerializer<'d>, inner: InnerSerializeValueTable) -> Self {
76+
Self {
77+
inner,
78+
dst: ser.dst,
79+
}
80+
}
81+
}
82+
83+
impl serde::ser::SerializeMap for SerializeValueTable<'_> {
84+
type Ok = ();
85+
type Error = Error;
86+
87+
fn serialize_key<T>(&mut self, input: &T) -> Result<(), Self::Error>
88+
where
89+
T: serde::ser::Serialize + ?Sized,
90+
{
91+
self.inner.serialize_key(input).map_err(Error::wrap)
92+
}
93+
94+
fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
95+
where
96+
T: serde::ser::Serialize + ?Sized,
97+
{
98+
self.inner.serialize_value(value).map_err(Error::wrap)
99+
}
100+
101+
fn end(self) -> Result<Self::Ok, Self::Error> {
102+
write_value(self.dst, self.inner.end())
103+
}
104+
}
105+
106+
impl serde::ser::SerializeStruct for SerializeValueTable<'_> {
107+
type Ok = ();
108+
type Error = Error;
109+
110+
fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
111+
where
112+
T: serde::ser::Serialize + ?Sized,
113+
{
114+
self.inner.serialize_field(key, value).map_err(Error::wrap)
115+
}
116+
117+
fn end(self) -> Result<Self::Ok, Self::Error> {
118+
write_value(self.dst, self.inner.end())
119+
}
120+
}

0 commit comments

Comments
 (0)