]>
Commit | Line | Data |
---|---|---|
8bb4bdeb XL |
1 | use core::marker::PhantomData; |
2 | ||
3 | #[cfg(all(not(feature = "std"), feature = "collections"))] | |
4 | use collections::{String, Vec}; | |
5 | ||
6 | #[cfg(all(feature = "alloc", not(feature = "std")))] | |
7 | use alloc::boxed::Box; | |
8 | ||
9 | #[cfg(feature = "collections")] | |
10 | use collections::borrow::ToOwned; | |
11 | ||
12 | use ser::{self, Serialize, Serializer}; | |
13 | ||
14 | pub struct SerializeTupleVariantAsMapValue<M> { | |
15 | map: M, | |
16 | name: &'static str, | |
17 | fields: Vec<Content>, | |
18 | } | |
19 | ||
20 | impl<M> SerializeTupleVariantAsMapValue<M> { | |
21 | pub fn new(map: M, name: &'static str, len: usize) -> Self { | |
22 | SerializeTupleVariantAsMapValue { | |
23 | map: map, | |
24 | name: name, | |
25 | fields: Vec::with_capacity(len), | |
26 | } | |
27 | } | |
28 | } | |
29 | ||
30 | impl<M> ser::SerializeTupleVariant for SerializeTupleVariantAsMapValue<M> | |
31 | where M: ser::SerializeMap | |
32 | { | |
33 | type Ok = M::Ok; | |
34 | type Error = M::Error; | |
35 | ||
36 | fn serialize_field<T: ?Sized + Serialize>(&mut self, | |
37 | value: &T) | |
38 | -> Result<(), M::Error> | |
39 | { | |
40 | let value = try!(value.serialize(ContentSerializer::<M::Error>::new())); | |
41 | self.fields.push(value); | |
42 | Ok(()) | |
43 | } | |
44 | ||
45 | fn end(mut self) -> Result<M::Ok, M::Error> { | |
46 | try!(self.map.serialize_value(&Content::TupleStruct(self.name, self.fields))); | |
47 | self.map.end() | |
48 | } | |
49 | } | |
50 | ||
51 | pub struct SerializeStructVariantAsMapValue<M> { | |
52 | map: M, | |
53 | name: &'static str, | |
54 | fields: Vec<(&'static str, Content)>, | |
55 | } | |
56 | ||
57 | impl<M> SerializeStructVariantAsMapValue<M> { | |
58 | pub fn new(map: M, name: &'static str, len: usize) -> Self { | |
59 | SerializeStructVariantAsMapValue { | |
60 | map: map, | |
61 | name: name, | |
62 | fields: Vec::with_capacity(len), | |
63 | } | |
64 | } | |
65 | } | |
66 | ||
67 | impl<M> ser::SerializeStructVariant for SerializeStructVariantAsMapValue<M> | |
68 | where M: ser::SerializeMap | |
69 | { | |
70 | type Ok = M::Ok; | |
71 | type Error = M::Error; | |
72 | ||
73 | fn serialize_field<T: ?Sized + Serialize>(&mut self, | |
74 | key: &'static str, | |
75 | value: &T) | |
76 | -> Result<(), M::Error> | |
77 | { | |
78 | let value = try!(value.serialize(ContentSerializer::<M::Error>::new())); | |
79 | self.fields.push((key, value)); | |
80 | Ok(()) | |
81 | } | |
82 | ||
83 | fn end(mut self) -> Result<M::Ok, M::Error> { | |
84 | try!(self.map.serialize_value(&Content::Struct(self.name, self.fields))); | |
85 | self.map.end() | |
86 | } | |
87 | } | |
88 | ||
89 | #[derive(Debug)] | |
90 | enum Content { | |
91 | Bool(bool), | |
92 | ||
93 | U8(u8), | |
94 | U16(u16), | |
95 | U32(u32), | |
96 | U64(u64), | |
97 | ||
98 | I8(i8), | |
99 | I16(i16), | |
100 | I32(i32), | |
101 | I64(i64), | |
102 | ||
103 | F32(f32), | |
104 | F64(f64), | |
105 | ||
106 | Char(char), | |
107 | String(String), | |
108 | Bytes(Vec<u8>), | |
109 | ||
110 | None, | |
111 | Some(Box<Content>), | |
112 | ||
113 | Unit, | |
114 | UnitStruct(&'static str), | |
115 | UnitVariant(&'static str, usize, &'static str), | |
116 | NewtypeStruct(&'static str, Box<Content>), | |
117 | NewtypeVariant(&'static str, usize, &'static str, Box<Content>), | |
118 | ||
119 | Seq(Vec<Content>), | |
120 | SeqFixedSize(Vec<Content>), | |
121 | Tuple(Vec<Content>), | |
122 | TupleStruct(&'static str, Vec<Content>), | |
123 | TupleVariant(&'static str, usize, &'static str, Vec<Content>), | |
124 | Map(Vec<(Content, Content)>), | |
125 | Struct(&'static str, Vec<(&'static str, Content)>), | |
126 | StructVariant(&'static str, usize, &'static str, Vec<(&'static str, Content)>), | |
127 | } | |
128 | ||
129 | impl Serialize for Content { | |
130 | fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> | |
131 | where S: Serializer | |
132 | { | |
133 | match *self { | |
134 | Content::Bool(b) => serializer.serialize_bool(b), | |
135 | Content::U8(u) => serializer.serialize_u8(u), | |
136 | Content::U16(u) => serializer.serialize_u16(u), | |
137 | Content::U32(u) => serializer.serialize_u32(u), | |
138 | Content::U64(u) => serializer.serialize_u64(u), | |
139 | Content::I8(i) => serializer.serialize_i8(i), | |
140 | Content::I16(i) => serializer.serialize_i16(i), | |
141 | Content::I32(i) => serializer.serialize_i32(i), | |
142 | Content::I64(i) => serializer.serialize_i64(i), | |
143 | Content::F32(f) => serializer.serialize_f32(f), | |
144 | Content::F64(f) => serializer.serialize_f64(f), | |
145 | Content::Char(c) => serializer.serialize_char(c), | |
146 | Content::String(ref s) => serializer.serialize_str(s), | |
147 | Content::Bytes(ref b) => serializer.serialize_bytes(b), | |
148 | Content::None => serializer.serialize_none(), | |
149 | Content::Some(ref c) => serializer.serialize_some(&**c), | |
150 | Content::Unit => serializer.serialize_unit(), | |
151 | Content::UnitStruct(n) => serializer.serialize_unit_struct(n), | |
152 | Content::UnitVariant(n, i, v) => serializer.serialize_unit_variant(n, i, v), | |
153 | Content::NewtypeStruct(n, ref c) => serializer.serialize_newtype_struct(n, &**c), | |
154 | Content::NewtypeVariant(n, i, v, ref c) => serializer.serialize_newtype_variant(n, i, v, &**c), | |
155 | Content::Seq(ref elements) => elements.serialize(serializer), | |
156 | Content::SeqFixedSize(ref elements) => { | |
157 | use ser::SerializeSeq; | |
158 | let mut seq = try!(serializer.serialize_seq_fixed_size(elements.len())); | |
159 | for e in elements { | |
160 | try!(seq.serialize_element(e)); | |
161 | } | |
162 | seq.end() | |
163 | } | |
164 | Content::Tuple(ref elements) => { | |
165 | use ser::SerializeTuple; | |
166 | let mut tuple = try!(serializer.serialize_tuple(elements.len())); | |
167 | for e in elements { | |
168 | try!(tuple.serialize_element(e)); | |
169 | } | |
170 | tuple.end() | |
171 | } | |
172 | Content::TupleStruct(n, ref fields) => { | |
173 | use ser::SerializeTupleStruct; | |
174 | let mut ts = try!(serializer.serialize_tuple_struct(n, fields.len())); | |
175 | for f in fields { | |
176 | try!(ts.serialize_field(f)); | |
177 | } | |
178 | ts.end() | |
179 | } | |
180 | Content::TupleVariant(n, i, v, ref fields) => { | |
181 | use ser::SerializeTupleVariant; | |
182 | let mut tv = try!(serializer.serialize_tuple_variant(n, i, v, fields.len())); | |
183 | for f in fields { | |
184 | try!(tv.serialize_field(f)); | |
185 | } | |
186 | tv.end() | |
187 | } | |
188 | Content::Map(ref entries) => { | |
189 | use ser::SerializeMap; | |
190 | let mut map = try!(serializer.serialize_map(Some(entries.len()))); | |
191 | for &(ref k, ref v) in entries { | |
192 | try!(map.serialize_entry(k, v)); | |
193 | } | |
194 | map.end() | |
195 | } | |
196 | Content::Struct(n, ref fields) => { | |
197 | use ser::SerializeStruct; | |
198 | let mut s = try!(serializer.serialize_struct(n, fields.len())); | |
199 | for &(k, ref v) in fields { | |
200 | try!(s.serialize_field(k, v)); | |
201 | } | |
202 | s.end() | |
203 | } | |
204 | Content::StructVariant(n, i, v, ref fields) => { | |
205 | use ser::SerializeStructVariant; | |
206 | let mut sv = try!(serializer.serialize_struct_variant(n, i, v, fields.len())); | |
207 | for &(k, ref v) in fields { | |
208 | try!(sv.serialize_field(k, v)); | |
209 | } | |
210 | sv.end() | |
211 | } | |
212 | } | |
213 | } | |
214 | } | |
215 | ||
216 | struct ContentSerializer<E> { | |
217 | error: PhantomData<E>, | |
218 | } | |
219 | ||
220 | impl<E> ContentSerializer<E> { | |
221 | fn new() -> Self { | |
222 | ContentSerializer { | |
223 | error: PhantomData, | |
224 | } | |
225 | } | |
226 | } | |
227 | ||
228 | impl<E> Serializer for ContentSerializer<E> | |
229 | where E: ser::Error | |
230 | { | |
231 | type Ok = Content; | |
232 | type Error = E; | |
233 | ||
234 | type SerializeSeq = SerializeSeq<E>; | |
235 | type SerializeTuple = SerializeTuple<E>; | |
236 | type SerializeTupleStruct = SerializeTupleStruct<E>; | |
237 | type SerializeTupleVariant = SerializeTupleVariant<E>; | |
238 | type SerializeMap = SerializeMap<E>; | |
239 | type SerializeStruct = SerializeStruct<E>; | |
240 | type SerializeStructVariant = SerializeStructVariant<E>; | |
241 | ||
242 | fn serialize_bool(self, v: bool) -> Result<Content, E> { | |
243 | Ok(Content::Bool(v)) | |
244 | } | |
245 | ||
246 | fn serialize_i8(self, v: i8) -> Result<Content, E> { | |
247 | Ok(Content::I8(v)) | |
248 | } | |
249 | ||
250 | fn serialize_i16(self, v: i16) -> Result<Content, E> { | |
251 | Ok(Content::I16(v)) | |
252 | } | |
253 | ||
254 | fn serialize_i32(self, v: i32) -> Result<Content, E> { | |
255 | Ok(Content::I32(v)) | |
256 | } | |
257 | ||
258 | fn serialize_i64(self, v: i64) -> Result<Content, E> { | |
259 | Ok(Content::I64(v)) | |
260 | } | |
261 | ||
262 | fn serialize_u8(self, v: u8) -> Result<Content, E> { | |
263 | Ok(Content::U8(v)) | |
264 | } | |
265 | ||
266 | fn serialize_u16(self, v: u16) -> Result<Content, E> { | |
267 | Ok(Content::U16(v)) | |
268 | } | |
269 | ||
270 | fn serialize_u32(self, v: u32) -> Result<Content, E> { | |
271 | Ok(Content::U32(v)) | |
272 | } | |
273 | ||
274 | fn serialize_u64(self, v: u64) -> Result<Content, E> { | |
275 | Ok(Content::U64(v)) | |
276 | } | |
277 | ||
278 | fn serialize_f32(self, v: f32) -> Result<Content, E> { | |
279 | Ok(Content::F32(v)) | |
280 | } | |
281 | ||
282 | fn serialize_f64(self, v: f64) -> Result<Content, E> { | |
283 | Ok(Content::F64(v)) | |
284 | } | |
285 | ||
286 | fn serialize_char(self, v: char) -> Result<Content, E> { | |
287 | Ok(Content::Char(v)) | |
288 | } | |
289 | ||
290 | fn serialize_str(self, value: &str) -> Result<Content, E> { | |
291 | Ok(Content::String(value.to_owned())) | |
292 | } | |
293 | ||
294 | fn serialize_bytes(self, value: &[u8]) -> Result<Content, E> { | |
295 | Ok(Content::Bytes(value.to_owned())) | |
296 | } | |
297 | ||
298 | fn serialize_none(self) -> Result<Content, E> { | |
299 | Ok(Content::None) | |
300 | } | |
301 | ||
302 | fn serialize_some<T: ?Sized + Serialize>(self, | |
303 | value: &T) | |
304 | -> Result<Content, E> { | |
305 | Ok(Content::Some(Box::new(try!(value.serialize(self))))) | |
306 | } | |
307 | ||
308 | fn serialize_unit(self) -> Result<Content, E> { | |
309 | Ok(Content::Unit) | |
310 | } | |
311 | ||
312 | fn serialize_unit_struct(self, | |
313 | name: &'static str) | |
314 | -> Result<Content, E> { | |
315 | Ok(Content::UnitStruct(name)) | |
316 | } | |
317 | ||
318 | fn serialize_unit_variant(self, | |
319 | name: &'static str, | |
320 | variant_index: usize, | |
321 | variant: &'static str) | |
322 | -> Result<Content, E> { | |
323 | Ok(Content::UnitVariant(name, variant_index, variant)) | |
324 | } | |
325 | ||
326 | fn serialize_newtype_struct<T: ?Sized + Serialize>(self, | |
327 | name: &'static str, | |
328 | value: &T) | |
329 | -> Result<Content, E> { | |
330 | Ok(Content::NewtypeStruct(name, Box::new(try!(value.serialize(self))))) | |
331 | } | |
332 | ||
333 | fn serialize_newtype_variant<T: ?Sized + Serialize>(self, | |
334 | name: &'static str, | |
335 | variant_index: usize, | |
336 | variant: &'static str, | |
337 | value: &T) | |
338 | -> Result<Content, E> { | |
339 | Ok(Content::NewtypeVariant(name, variant_index, variant, Box::new(try!(value.serialize(self))))) | |
340 | } | |
341 | ||
342 | fn serialize_seq(self, | |
343 | len: Option<usize>) | |
344 | -> Result<Self::SerializeSeq, E> { | |
345 | Ok(SerializeSeq { | |
346 | fixed_size: false, | |
347 | elements: Vec::with_capacity(len.unwrap_or(0)), | |
348 | error: PhantomData, | |
349 | }) | |
350 | } | |
351 | ||
352 | fn serialize_seq_fixed_size(self, | |
353 | size: usize) | |
354 | -> Result<Self::SerializeSeq, E> { | |
355 | Ok(SerializeSeq { | |
356 | fixed_size: true, | |
357 | elements: Vec::with_capacity(size), | |
358 | error: PhantomData, | |
359 | }) | |
360 | } | |
361 | ||
362 | fn serialize_tuple(self, | |
363 | len: usize) | |
364 | -> Result<Self::SerializeTuple, E> { | |
365 | Ok(SerializeTuple { | |
366 | elements: Vec::with_capacity(len), | |
367 | error: PhantomData, | |
368 | }) | |
369 | } | |
370 | ||
371 | fn serialize_tuple_struct(self, | |
372 | name: &'static str, | |
373 | len: usize) | |
374 | -> Result<Self::SerializeTupleStruct, E> { | |
375 | Ok(SerializeTupleStruct { | |
376 | name: name, | |
377 | fields: Vec::with_capacity(len), | |
378 | error: PhantomData, | |
379 | }) | |
380 | } | |
381 | ||
382 | fn serialize_tuple_variant(self, | |
383 | name: &'static str, | |
384 | variant_index: usize, | |
385 | variant: &'static str, | |
386 | len: usize) | |
387 | -> Result<Self::SerializeTupleVariant, E> { | |
388 | Ok(SerializeTupleVariant { | |
389 | name: name, | |
390 | variant_index: variant_index, | |
391 | variant: variant, | |
392 | fields: Vec::with_capacity(len), | |
393 | error: PhantomData, | |
394 | }) | |
395 | } | |
396 | ||
397 | fn serialize_map(self, | |
398 | len: Option<usize>) | |
399 | -> Result<Self::SerializeMap, E> { | |
400 | Ok(SerializeMap { | |
401 | entries: Vec::with_capacity(len.unwrap_or(0)), | |
402 | key: None, | |
403 | error: PhantomData, | |
404 | }) | |
405 | } | |
406 | ||
407 | fn serialize_struct(self, | |
408 | name: &'static str, | |
409 | len: usize) | |
410 | -> Result<Self::SerializeStruct, E> { | |
411 | Ok(SerializeStruct { | |
412 | name: name, | |
413 | fields: Vec::with_capacity(len), | |
414 | error: PhantomData, | |
415 | }) | |
416 | } | |
417 | ||
418 | fn serialize_struct_variant(self, | |
419 | name: &'static str, | |
420 | variant_index: usize, | |
421 | variant: &'static str, | |
422 | len: usize) | |
423 | -> Result<Self::SerializeStructVariant, E> { | |
424 | Ok(SerializeStructVariant { | |
425 | name: name, | |
426 | variant_index: variant_index, | |
427 | variant: variant, | |
428 | fields: Vec::with_capacity(len), | |
429 | error: PhantomData, | |
430 | }) | |
431 | } | |
432 | } | |
433 | ||
434 | struct SerializeSeq<E> { | |
435 | fixed_size: bool, | |
436 | elements: Vec<Content>, | |
437 | error: PhantomData<E>, | |
438 | } | |
439 | ||
440 | impl<E> ser::SerializeSeq for SerializeSeq<E> | |
441 | where E: ser::Error | |
442 | { | |
443 | type Ok = Content; | |
444 | type Error = E; | |
445 | ||
446 | fn serialize_element<T: ?Sized + Serialize>(&mut self, | |
447 | value: &T) | |
448 | -> Result<(), E> { | |
449 | let value = try!(value.serialize(ContentSerializer::<E>::new())); | |
450 | self.elements.push(value); | |
451 | Ok(()) | |
452 | } | |
453 | ||
454 | fn end(self) -> Result<Content, E> { | |
455 | Ok(if self.fixed_size { | |
456 | Content::SeqFixedSize(self.elements) | |
457 | } else { | |
458 | Content::Seq(self.elements) | |
459 | }) | |
460 | } | |
461 | } | |
462 | ||
463 | struct SerializeTuple<E> { | |
464 | elements: Vec<Content>, | |
465 | error: PhantomData<E>, | |
466 | } | |
467 | ||
468 | impl<E> ser::SerializeTuple for SerializeTuple<E> | |
469 | where E: ser::Error | |
470 | { | |
471 | type Ok = Content; | |
472 | type Error = E; | |
473 | ||
474 | fn serialize_element<T: ?Sized + Serialize>(&mut self, | |
475 | value: &T) | |
476 | -> Result<(), E> { | |
477 | let value = try!(value.serialize(ContentSerializer::<E>::new())); | |
478 | self.elements.push(value); | |
479 | Ok(()) | |
480 | } | |
481 | ||
482 | fn end(self) -> Result<Content, E> { | |
483 | Ok(Content::Tuple(self.elements)) | |
484 | } | |
485 | } | |
486 | ||
487 | struct SerializeTupleStruct<E> { | |
488 | name: &'static str, | |
489 | fields: Vec<Content>, | |
490 | error: PhantomData<E>, | |
491 | } | |
492 | ||
493 | impl<E> ser::SerializeTupleStruct for SerializeTupleStruct<E> | |
494 | where E: ser::Error | |
495 | { | |
496 | type Ok = Content; | |
497 | type Error = E; | |
498 | ||
499 | fn serialize_field<T: ?Sized + Serialize>(&mut self, | |
500 | value: &T) | |
501 | -> Result<(), E> { | |
502 | let value = try!(value.serialize(ContentSerializer::<E>::new())); | |
503 | self.fields.push(value); | |
504 | Ok(()) | |
505 | } | |
506 | ||
507 | fn end(self) -> Result<Content, E> { | |
508 | Ok(Content::TupleStruct(self.name, self.fields)) | |
509 | } | |
510 | } | |
511 | ||
512 | struct SerializeTupleVariant<E> { | |
513 | name: &'static str, | |
514 | variant_index: usize, | |
515 | variant: &'static str, | |
516 | fields: Vec<Content>, | |
517 | error: PhantomData<E>, | |
518 | } | |
519 | ||
520 | impl<E> ser::SerializeTupleVariant for SerializeTupleVariant<E> | |
521 | where E: ser::Error | |
522 | { | |
523 | type Ok = Content; | |
524 | type Error = E; | |
525 | ||
526 | fn serialize_field<T: ?Sized + Serialize>(&mut self, | |
527 | value: &T) | |
528 | -> Result<(), E> { | |
529 | let value = try!(value.serialize(ContentSerializer::<E>::new())); | |
530 | self.fields.push(value); | |
531 | Ok(()) | |
532 | } | |
533 | ||
534 | fn end(self) -> Result<Content, E> { | |
535 | Ok(Content::TupleVariant(self.name, self.variant_index, self.variant, self.fields)) | |
536 | } | |
537 | } | |
538 | ||
539 | struct SerializeMap<E> { | |
540 | entries: Vec<(Content, Content)>, | |
541 | key: Option<Content>, | |
542 | error: PhantomData<E>, | |
543 | } | |
544 | ||
545 | impl<E> ser::SerializeMap for SerializeMap<E> | |
546 | where E: ser::Error | |
547 | { | |
548 | type Ok = Content; | |
549 | type Error = E; | |
550 | ||
551 | fn serialize_key<T: ?Sized + Serialize>(&mut self, | |
552 | key: &T) | |
553 | -> Result<(), E> { | |
554 | let key = try!(key.serialize(ContentSerializer::<E>::new())); | |
555 | self.key = Some(key); | |
556 | Ok(()) | |
557 | } | |
558 | ||
559 | fn serialize_value<T: ?Sized + Serialize>(&mut self, | |
560 | value: &T) | |
561 | -> Result<(), E> { | |
562 | let key = self.key.take().expect("serialize_value called before serialize_key"); | |
563 | let value = try!(value.serialize(ContentSerializer::<E>::new())); | |
564 | self.entries.push((key, value)); | |
565 | Ok(()) | |
566 | } | |
567 | ||
568 | fn end(self) -> Result<Content, E> { | |
569 | Ok(Content::Map(self.entries)) | |
570 | } | |
571 | ||
572 | fn serialize_entry<K: ?Sized + Serialize, V: ?Sized + Serialize>(&mut self, | |
573 | key: &K, | |
574 | value: &V) | |
575 | -> Result<(), E> { | |
576 | let key = try!(key.serialize(ContentSerializer::<E>::new())); | |
577 | let value = try!(value.serialize(ContentSerializer::<E>::new())); | |
578 | self.entries.push((key, value)); | |
579 | Ok(()) | |
580 | } | |
581 | } | |
582 | ||
583 | struct SerializeStruct<E> { | |
584 | name: &'static str, | |
585 | fields: Vec<(&'static str, Content)>, | |
586 | error: PhantomData<E>, | |
587 | } | |
588 | ||
589 | impl<E> ser::SerializeStruct for SerializeStruct<E> | |
590 | where E: ser::Error | |
591 | { | |
592 | type Ok = Content; | |
593 | type Error = E; | |
594 | ||
595 | fn serialize_field<T: ?Sized + Serialize>(&mut self, | |
596 | key: &'static str, | |
597 | value: &T) | |
598 | -> Result<(), E> { | |
599 | let value = try!(value.serialize(ContentSerializer::<E>::new())); | |
600 | self.fields.push((key, value)); | |
601 | Ok(()) | |
602 | } | |
603 | ||
604 | fn end(self) -> Result<Content, E> { | |
605 | Ok(Content::Struct(self.name, self.fields)) | |
606 | } | |
607 | } | |
608 | ||
609 | struct SerializeStructVariant<E> { | |
610 | name: &'static str, | |
611 | variant_index: usize, | |
612 | variant: &'static str, | |
613 | fields: Vec<(&'static str, Content)>, | |
614 | error: PhantomData<E>, | |
615 | } | |
616 | ||
617 | impl<E> ser::SerializeStructVariant for SerializeStructVariant<E> | |
618 | where E: ser::Error | |
619 | { | |
620 | type Ok = Content; | |
621 | type Error = E; | |
622 | ||
623 | fn serialize_field<T: ?Sized + Serialize>(&mut self, | |
624 | key: &'static str, | |
625 | value: &T) | |
626 | -> Result<(), E> { | |
627 | let value = try!(value.serialize(ContentSerializer::<E>::new())); | |
628 | self.fields.push((key, value)); | |
629 | Ok(()) | |
630 | } | |
631 | ||
632 | fn end(self) -> Result<Content, E> { | |
633 | Ok(Content::StructVariant(self.name, self.variant_index, self.variant, self.fields)) | |
634 | } | |
635 | } |