1use crate::serde::error::DataError;
2use crate::serde::serialize_impl::{
3 DataSerializeMap, DataSerializeSeq, DataSerializeTuple, DataSerializeTupleStruct,
4 DataSerializeTupleVariant,
5};
6use crate::Data;
7use anyhow::Result;
8use paste::paste;
9use serde::{Serialize, Serializer};
10
11macro_rules! make_base_serialize {
12 ($($type:ty)+) => {
13 paste!{
14 $(
15 #[inline]
16 fn [<serialize_ $type>] (self, v: $type) -> Result<Self::Ok, Self::Error> {
17 self.write_fixed(v);
18 Ok(())
19 }
20 )*
21 }
22 };
23}
24
25impl<'a> Serializer for &'a mut Data {
26 type Ok = ();
27 type Error = DataError;
28 type SerializeSeq = DataSerializeSeq<'a>;
29 type SerializeTuple = DataSerializeTuple<'a>;
30 type SerializeTupleStruct = DataSerializeTupleStruct<'a>;
31 type SerializeTupleVariant = DataSerializeTupleVariant<'a>;
32 type SerializeMap = DataSerializeMap<'a>;
33 type SerializeStruct = DataSerializeTupleStruct<'a>;
34 type SerializeStructVariant = DataSerializeTupleVariant<'a>;
35
36 make_base_serialize!(bool i8 u8 i16 u16 i32 u32 i64 u64 f32 f64 i128 u128);
37
38 #[inline]
39 fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
40 let mut buf = [0; 4];
41 self.write_fixed(v.encode_utf8(&mut buf).as_bytes());
42 Ok(())
43 }
44
45 #[inline]
46 fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
47 if self.mode == 1 {
48 return Err(DataError::RollBack);
49 }
50 self.write_fixed(v);
51 Ok(())
52 }
53
54 #[inline]
55 fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
56 if self.mode == 1 {
57 return Err(DataError::RollBack);
58 }
59 self.write_fixed(v);
60 Ok(())
61 }
62
63 #[inline]
64 fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
65 if self.mode == 1 {
66 return Err(DataError::RollBack);
67 }
68 self.write_fixed(0u8);
69 Ok(())
70 }
71
72 #[inline]
73 fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
74 where
75 T: Serialize,
76 {
77 if self.mode == 1 {
78 return Err(DataError::RollBack);
79 }
80 self.write_fixed(1u8);
81 value.serialize(self)
82 }
83
84 #[inline]
85 fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
86 if self.mode == 1 {
87 return Err(DataError::RollBack);
88 }
89 self.write_fixed(1u8);
90 Ok(())
91 }
92
93 #[inline]
94 fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
95 if self.mode == 1 {
96 return Err(DataError::RollBack);
97 }
98 self.write_fixed(1u8);
99 Ok(())
100 }
101
102 #[inline]
103 fn serialize_unit_variant(
104 self,
105 _name: &'static str,
106 _variant_index: u32,
107 variant: &'static str,
108 ) -> Result<Self::Ok, Self::Error> {
109 if self.mode == 1 {
110 return Err(DataError::RollBack);
111 }
112 self.write_fixed(variant);
113 Ok(())
114 }
115
116 #[inline]
117 fn serialize_newtype_struct<T: ?Sized>(
118 self,
119 _name: &'static str,
120 value: &T,
121 ) -> Result<Self::Ok, Self::Error>
122 where
123 T: Serialize,
124 {
125 if self.mode == 1 {
126 return Err(DataError::RollBack);
127 }
128 value.serialize(self)
129 }
130
131 #[inline]
132 fn serialize_newtype_variant<T: ?Sized>(
133 self,
134 _name: &'static str,
135 _variant_index: u32,
136 variant: &'static str,
137 value: &T,
138 ) -> Result<Self::Ok, Self::Error>
139 where
140 T: Serialize,
141 {
142 if self.mode == 1 {
143 return Err(DataError::RollBack);
144 }
145 self.write_fixed(variant);
146 value.serialize(self)
147 }
148
149 #[inline]
150 fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
151 if self.mode == 1 {
152 return Err(DataError::RollBack);
153 }
154 Ok(DataSerializeSeq::new(self, len))
155 }
156
157 #[inline]
158 fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
159 if self.mode == 1 {
160 return Err(DataError::RollBack);
161 }
162 Ok(DataSerializeTuple::new(self, len))
163 }
164
165 #[inline]
166 fn serialize_tuple_struct(
167 self,
168 _name: &'static str,
169 len: usize,
170 ) -> Result<Self::SerializeTupleStruct, Self::Error> {
171 if self.mode == 1 {
172 return Err(DataError::RollBack);
173 }
174 Ok(DataSerializeTupleStruct::new(self, len))
175 }
176
177 #[inline]
178 fn serialize_tuple_variant(
179 self,
180 _name: &'static str,
181 _variant_index: u32,
182 variant: &'static str,
183 len: usize,
184 ) -> Result<Self::SerializeTupleVariant, Self::Error> {
185 if self.mode == 1 {
186 return Err(DataError::RollBack);
187 }
188 Ok(DataSerializeTupleVariant::new(self, variant, len))
189 }
190
191 #[inline]
192 fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
193 if self.mode == 1 {
194 return Err(DataError::RollBack);
195 }
196 Ok(DataSerializeMap::new(self, len))
197 }
198
199 #[inline]
200 fn serialize_struct(
201 self,
202 _name: &'static str,
203 len: usize,
204 ) -> Result<Self::SerializeStruct, Self::Error> {
205 if self.mode == 1 {
206 return Err(DataError::RollBack);
207 }
208 Ok(DataSerializeTupleStruct::new(self, len))
209 }
210
211 #[inline]
212 fn serialize_struct_variant(
213 self,
214 _name: &'static str,
215 _variant_index: u32,
216 variant: &'static str,
217 len: usize,
218 ) -> Result<Self::SerializeStructVariant, Self::Error> {
219 if self.mode == 1 {
220 return Err(DataError::RollBack);
221 }
222 Ok(DataSerializeTupleVariant::new(self, variant, len))
223 }
224}