1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
use super::{plain::to_plain_string, Serializer};
use crate::error::{Error, Result};
use log::debug;
use serde::ser::Serialize;
use std::io::Write;
pub struct MapSerializer<'ser, W: 'ser + Write> {
ser: &'ser mut Serializer<W>,
must_close_tag: bool,
}
impl<'ser, W: 'ser + Write> MapSerializer<'ser, W> {
pub fn new(ser: &'ser mut Serializer<W>, must_close_tag: bool) -> Self {
MapSerializer {
ser,
must_close_tag,
}
}
}
impl<'ser, W: Write> serde::ser::SerializeMap for MapSerializer<'ser, W> {
type Ok = ();
type Error = Error;
fn serialize_key<T>(&mut self, key: &T) -> Result<()>
where
T: ?Sized + Serialize,
{
self.ser.open_tag(&to_plain_string(key)?)?;
Ok(())
}
fn serialize_value<T>(&mut self, value: &T) -> Result<()>
where
T: ?Sized + Serialize,
{
value.serialize(&mut *self.ser)?;
Ok(())
}
fn end(self) -> Result<()> {
if self.must_close_tag {
self.ser.end_tag()?;
}
Ok(())
}
}
pub struct StructSerializer<'ser, W: 'ser + Write> {
ser: &'ser mut Serializer<W>,
must_close_tag: bool,
}
impl<'ser, W: 'ser + Write> StructSerializer<'ser, W> {
pub fn new(ser: &'ser mut Serializer<W>, must_close_tag: bool) -> Self {
StructSerializer {
ser,
must_close_tag,
}
}
fn serialize_struct_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
where
T: ?Sized + Serialize,
{
if key.starts_with("@") {
debug!("attribute {}", key);
self.ser.add_attr(&key[1..], to_plain_string(value)?)
} else if key == "$value" {
self.ser.build_start_tag()?;
debug!("body");
value.serialize(&mut *self.ser)?;
Ok(())
} else {
self.ser.build_start_tag()?;
self.ser.open_tag(key)?;
debug!("field {}", key);
value.serialize(&mut *self.ser)?;
debug!("end field");
Ok(())
}
}
fn after_fields(self) -> Result<()> {
self.ser.build_start_tag()?;
self.ser.end_tag()?;
if self.must_close_tag {
self.ser.end_tag()?;
}
Ok(())
}
}
impl<'ser, W: 'ser + Write> serde::ser::SerializeStruct for StructSerializer<'ser, W> {
type Ok = ();
type Error = Error;
fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
where
T: ?Sized + Serialize,
{
self.serialize_struct_field(key, value)
}
fn end(self) -> Result<()> {
self.after_fields()
}
}
impl<'ser, W: 'ser + Write> serde::ser::SerializeStructVariant for StructSerializer<'ser, W> {
type Ok = ();
type Error = Error;
fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
where
T: ?Sized + Serialize,
{
self.serialize_struct_field(key, value)
}
fn end(self) -> Result<()> {
self.after_fields()
}
}
|
