spyne_encoding/serialization/
serialize.rs1use std::{borrow::Cow, collections::{BTreeMap, BTreeSet, HashMap, HashSet}, marker::PhantomData};
2
3use crate::serialization::Bytes;
4
5pub trait Serializer<'a> {
6 fn write_u8(&mut self, n: u8);
7 fn write_u16(&mut self, n: u16);
8 fn write_u32(&mut self, n: u32);
9 fn write_u64(&mut self, n: u64);
10 fn write_u128(&mut self, n: u128);
11 fn write_i8(&mut self, n: i8);
12 fn write_i16(&mut self, n: i16);
13 fn write_i32(&mut self, n: i32);
14 fn write_i64(&mut self, n: i64);
15 fn write_i128(&mut self, n: i128);
16 fn write_f32(&mut self, n: f32);
17 fn write_f64(&mut self, n: f64);
18 fn write_bool(&mut self, b: bool);
19 fn write_bytes(&mut self, bytes: &[u8]);
20 fn write_string(&mut self, s: &str);
21 fn write_seq<F>(&mut self, len: usize, f: F)
22 where F: FnOnce(&mut Self);
23 fn write_map<F>(&mut self, len: usize, f: F)
24 where F: FnOnce(&mut Self);
25 fn write_tuple<F>(&mut self, len: usize, f: F)
26 where F: FnOnce(&mut Self);
27 fn write_struct<F>(&mut self, name: &'a str, fields: &'a [&'a str], f: F)
28 where F: FnOnce(&mut Self);
29 fn write_enum<F>(&mut self, enum_name: &'a str, variant_index: u32, variant_name: &'a [&'a str], f: F)
30 where F: FnOnce(&mut Self);
31}
32
33pub trait Serialize<'a> {
34 fn serialize(&self, serializer: &mut impl Serializer<'a>);
35}
36
37impl<'a> Serialize<'a> for u8 {
38 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
39 serializer.write_u8(*self);
40 }
41}
42impl<'a> Serialize<'a> for u16 {
43 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
44 serializer.write_u16(*self);
45 }
46}
47impl<'a> Serialize<'a> for u32 {
48 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
49 serializer.write_u32(*self);
50 }
51}
52impl<'a> Serialize<'a> for u64 {
53 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
54 serializer.write_u64(*self);
55 }
56}
57impl<'a> Serialize<'a> for u128 {
58 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
59 serializer.write_u128(*self);
60 }
61}
62impl<'a> Serialize<'a> for usize {
63 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
64 serializer.write_u64(*self as u64);
65 }
66}
67impl<'a> Serialize<'a> for i8 {
68 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
69 serializer.write_i8(*self);
70 }
71}
72impl<'a> Serialize<'a> for i16 {
73 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
74 serializer.write_i16(*self);
75 }
76}
77impl<'a> Serialize<'a> for i32 {
78 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
79 serializer.write_i32(*self);
80 }
81}
82impl<'a> Serialize<'a> for i64 {
83 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
84 serializer.write_i64(*self);
85 }
86}
87impl<'a> Serialize<'a> for i128 {
88 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
89 serializer.write_i128(*self);
90 }
91}
92impl<'a> Serialize<'a> for isize {
93 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
94 serializer.write_i64(*self as i64);
95 }
96}
97impl<'a> Serialize<'a> for f32 {
98 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
99 serializer.write_f32(*self);
100 }
101}
102impl<'a> Serialize<'a> for f64 {
103 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
104 serializer.write_f64(*self);
105 }
106}
107impl<'a> Serialize<'a> for bool {
108 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
109 serializer.write_bool(*self);
110 }
111}
112impl<'a> Serialize<'a> for char {
113 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
114 serializer.write_u32(*self as u32);
115 }
116}
117impl<'a> Serialize<'a> for Bytes<'a> {
118 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
119 serializer.write_bytes(self.0);
120 }
121}
122impl<'a, T: Serialize<'a>> Serialize<'a> for &[T] {
123 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
124 serializer.write_seq(self.len(), |enc| {
125 for item in *self {
126 item.serialize(enc);
127 }
128 });
129 }
130}
131impl<'a, T: Serialize<'a>, const N: usize> Serialize<'a> for &[T; N] {
132 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
133 serializer.write_seq(N, |enc| {
134 for item in *self {
135 item.serialize(enc);
136 }
137 });
138 }
139}
140impl<'a> Serialize<'a> for &str {
141 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
142 serializer.write_string(*self);
143 }
144}
145impl<'a> Serialize<'a> for String {
146 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
147 serializer.write_string(self);
148 }
149}
150impl<'a, T: Serialize<'a>> Serialize<'a> for &T {
151 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
152 (*self).serialize(serializer);
153 }
154}
155impl<'a, T: Serialize<'a>> Serialize<'a> for Vec<T> {
156 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
157 serializer.write_seq(self.len(), |enc| {
158 for item in self {
159 item.serialize(enc);
160 }
161 });
162 }
163}
164impl<'a, T: Serialize<'a>> Serialize<'a> for Option<T> {
165 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
166 match self {
167 Some(data) => serializer.write_enum("Option", 1, &["Some"], |enc| {
168 data.serialize(enc);
169 }),
170 None => serializer.write_enum("Option", 0, &["None"], |_| {}),
171 }
172 }
173}
174impl<'a, T: Serialize<'a>, E: Serialize<'a>> Serialize<'a> for Result<T, E> {
175 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
176 match self {
177 Ok(val) => serializer.write_enum("Result", 0, &["Ok"], |enc| {
178 val.serialize(enc);
179 }),
180 Err(err) => serializer.write_enum("Result", 1, &["Err"], |enc| {
181 err.serialize(enc);
182 })
183 }
184 }
185}
186impl<'a> Serialize<'a> for () {
187 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
188 serializer.write_tuple(0, |_| {});
189 }
190}
191impl<'a, T: Serialize<'a>> Serialize<'a> for PhantomData<T> {
192 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
193 serializer.write_tuple(0, |_| {});
194 }
196}
197impl<'a, T: Serialize<'a>> Serialize<'a> for Box<T> {
198 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
199 (**self).serialize(serializer);
200 }
201}
202impl<'a, B> Serialize<'a> for Cow<'a, B>
203where B: ToOwned + ?Sized, B: Serialize<'a> {
204 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
205 (**self).serialize(serializer);
206 }
207}
208impl<'a, T: Serialize<'a>> Serialize<'a> for HashSet<T> {
209 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
210 serializer.write_seq(self.len(), |enc| {
211 for val in self {
212 val.serialize(enc);
213 }
214 });
215 }
216}
217impl<'a, K: Serialize<'a>, V: Serialize<'a>> Serialize<'a> for HashMap<K, V> {
218 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
219 serializer.write_map(self.len(), |enc| {
220 for (k, v) in self {
221 k.serialize(enc);
222 v.serialize(enc);
223 }
224 });
225 }
226}
227impl<'a, T: Serialize<'a>> Serialize<'a> for BTreeSet<T> {
228 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
229 serializer.write_seq(self.len(), |enc| {
230 for val in self {
231 val.serialize(enc);
232 }
233 });
234 }
235}
236impl<'a, K: Serialize<'a>, V: Serialize<'a>> Serialize<'a> for BTreeMap<K, V> {
237 fn serialize(&self, serializer: &mut impl Serializer<'a>) {
238 serializer.write_map(self.len(), |enc| {
239 for (k, v) in self {
240 k.serialize(enc);
241 v.serialize(enc);
242 }
243 });
244 }
245}
246