oak_xml/
serde.rs

1#![cfg(feature = "serde")]
2use crate::ast::{XmlAttribute, XmlElement, XmlValue};
3use serde::{
4    de::{self, Visitor},
5    ser::{self, Serialize},
6};
7use std::fmt;
8
9#[derive(Debug)]
10pub struct Error(String);
11
12impl fmt::Display for Error {
13    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
14        write!(f, "{}", self.0);
15        Ok(())
16    }
17}
18
19impl std::error::Error for Error {}
20
21impl From<Error> for String {
22    fn from(e: Error) -> Self {
23        e.0
24    }
25}
26
27impl ser::Error for Error {
28    fn custom<T: fmt::Display>(msg: T) -> Self {
29        Error(msg.to_string())
30    }
31}
32
33impl de::Error for Error {
34    fn custom<T: fmt::Display>(msg: T) -> Self {
35        Error(msg.to_string())
36    }
37}
38
39pub struct Serializer;
40
41pub fn to_value<T: Serialize>(value: &T) -> Result<XmlValue, Error> {
42    value.serialize(Serializer)
43}
44
45pub fn from_value<T: de::DeserializeOwned>(value: XmlValue) -> Result<T, Error> {
46    T::deserialize(value)
47}
48
49impl ser::Serializer for Serializer {
50    type Ok = XmlValue;
51    type Error = Error;
52
53    type SerializeSeq = SerializeArray;
54    type SerializeTuple = SerializeArray;
55    type SerializeTupleStruct = SerializeArray;
56    type SerializeTupleVariant = SerializeVariant;
57    type SerializeMap = SerializeObject;
58    type SerializeStruct = SerializeObject;
59    type SerializeStructVariant = SerializeVariant;
60
61    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
62        Ok(XmlValue::Text(v.to_string()))
63    }
64
65    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
66        self.serialize_f64(v as f64)
67    }
68    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
69        self.serialize_f64(v as f64)
70    }
71    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
72        self.serialize_f64(v as f64)
73    }
74    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
75        self.serialize_f64(v as f64)
76    }
77    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
78        self.serialize_f64(v as f64)
79    }
80    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
81        self.serialize_f64(v as f64)
82    }
83    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
84        self.serialize_f64(v as f64)
85    }
86    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
87        self.serialize_f64(v as f64)
88    }
89    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
90        self.serialize_f64(v as f64)
91    }
92    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
93        Ok(XmlValue::Text(v.to_string()))
94    }
95
96    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
97        self.serialize_str(&v.to_string())
98    }
99
100    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
101        Ok(XmlValue::Text(v.to_string()))
102    }
103
104    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
105        let elements = v.iter().map(|&b| XmlValue::Text(b.to_string())).collect();
106        Ok(XmlValue::Element(XmlElement { name: "bytes".to_string(), attributes: Vec::new(), children: elements, span: (0..0).into() }))
107    }
108
109    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
110        // In XML, None is usually just an absent element.
111        // But if we are serializing to a Value, maybe an empty string or special marker?
112        // Let's use an empty text for now.
113        Ok(XmlValue::Text(String::new()))
114    }
115
116    fn serialize_some<T: ?Sized + Serialize>(self, value: &T) -> Result<Self::Ok, Self::Error> {
117        value.serialize(self)
118    }
119
120    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
121        self.serialize_none()
122    }
123
124    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
125        self.serialize_unit()
126    }
127
128    fn serialize_unit_variant(self, _name: &'static str, _variant_index: u32, variant: &'static str) -> Result<Self::Ok, Self::Error> {
129        self.serialize_str(variant)
130    }
131
132    fn serialize_newtype_struct<T: ?Sized + Serialize>(self, _name: &'static str, value: &T) -> Result<Self::Ok, Self::Error> {
133        value.serialize(self)
134    }
135
136    fn serialize_newtype_variant<T: ?Sized + Serialize>(self, _name: &'static str, _variant_index: u32, variant: &'static str, value: &T) -> Result<Self::Ok, Self::Error> {
137        let mut children = Vec::new();
138        children.push(value.serialize(self)?);
139        Ok(XmlValue::Element(XmlElement { name: variant.to_string(), attributes: Vec::new(), children, span: (0..0).into() }))
140    }
141
142    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
143        Ok(SerializeArray { elements: Vec::new() })
144    }
145
146    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
147        self.serialize_seq(Some(len))
148    }
149
150    fn serialize_tuple_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeTupleStruct, Self::Error> {
151        self.serialize_seq(Some(len))
152    }
153
154    fn serialize_tuple_variant(self, _name: &'static str, _variant_index: u32, variant: &'static str, _len: usize) -> Result<Self::SerializeTupleVariant, Self::Error> {
155        Ok(SerializeVariant { name: variant.to_string(), elements: Vec::new() })
156    }
157
158    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
159        Ok(SerializeObject {
160            name: "root".to_string(), // Default name, should be overridden by struct name
161            attributes: Vec::new(),
162            children: Vec::new(),
163            current_key: None,
164        })
165    }
166
167    fn serialize_struct(self, name: &'static str, _len: usize) -> Result<Self::SerializeStruct, Self::Error> {
168        Ok(SerializeObject { name: name.to_string(), attributes: Vec::new(), children: Vec::new(), current_key: None })
169    }
170
171    fn serialize_struct_variant(self, _name: &'static str, _variant_index: u32, variant: &'static str, _len: usize) -> Result<Self::SerializeStructVariant, Self::Error> {
172        Ok(SerializeVariant { name: variant.to_string(), elements: Vec::new() })
173    }
174}
175
176pub struct SerializeArray {
177    elements: Vec<XmlValue>,
178}
179
180impl ser::SerializeSeq for SerializeArray {
181    type Ok = XmlValue;
182    type Error = Error;
183
184    fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
185        self.elements.push(value.serialize(Serializer)?);
186        Ok(())
187    }
188
189    fn end(self) -> Result<Self::Ok, Self::Error> {
190        Ok(XmlValue::Fragment(self.elements))
191    }
192}
193
194impl ser::SerializeTuple for SerializeArray {
195    type Ok = XmlValue;
196    type Error = Error;
197    fn serialize_element<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
198        ser::SerializeSeq::serialize_element(self, value)
199    }
200    fn end(self) -> Result<Self::Ok, Self::Error> {
201        ser::SerializeSeq::end(self)
202    }
203}
204
205impl ser::SerializeTupleStruct for SerializeArray {
206    type Ok = XmlValue;
207    type Error = Error;
208    fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
209        ser::SerializeSeq::serialize_element(self, value)
210    }
211    fn end(self) -> Result<Self::Ok, Self::Error> {
212        ser::SerializeSeq::end(self)
213    }
214}
215
216pub struct SerializeVariant {
217    name: String,
218    elements: Vec<XmlValue>,
219}
220
221impl ser::SerializeTupleVariant for SerializeVariant {
222    type Ok = XmlValue;
223    type Error = Error;
224
225    fn serialize_field<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
226        self.elements.push(value.serialize(Serializer)?);
227        Ok(())
228    }
229
230    fn end(self) -> Result<Self::Ok, Self::Error> {
231        Ok(XmlValue::Element(XmlElement { name: self.name, attributes: Vec::new(), children: self.elements, span: (0..0).into() }))
232    }
233}
234
235impl ser::SerializeStructVariant for SerializeVariant {
236    type Ok = XmlValue;
237    type Error = Error;
238
239    fn serialize_field<T: ?Sized + Serialize>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error> {
240        let val = value.serialize(Serializer)?;
241        self.elements.push(XmlValue::Element(XmlElement { name: key.to_string(), attributes: Vec::new(), children: vec![val], span: (0..0).into() }));
242        Ok(())
243    }
244
245    fn end(self) -> Result<Self::Ok, Self::Error> {
246        Ok(XmlValue::Element(XmlElement { name: self.name, attributes: Vec::new(), children: self.elements, span: (0..0).into() }))
247    }
248}
249
250pub struct SerializeObject {
251    name: String,
252    attributes: Vec<XmlAttribute>,
253    children: Vec<XmlValue>,
254    current_key: Option<String>,
255}
256
257impl ser::SerializeMap for SerializeObject {
258    type Ok = XmlValue;
259    type Error = Error;
260
261    fn serialize_key<T: ?Sized + Serialize>(&mut self, key: &T) -> Result<(), Self::Error> {
262        self.current_key = Some(key.serialize(StringSerializer)?);
263        Ok(())
264    }
265
266    fn serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error> {
267        let key = self.current_key.take().unwrap();
268        let val = value.serialize(Serializer)?;
269
270        if key.starts_with('↯') {
271            self.attributes.push(XmlAttribute {
272                name: key[1..].to_string(),
273                value: match val {
274                    XmlValue::Text(t) => t,
275                    XmlValue::Fragment(_) => return Err(ser::Error::custom("Cannot use fragment as attribute value")),
276                    _ => val.as_str().unwrap_or("").to_string(),
277                },
278                span: (0..0).into(),
279            })
280        }
281        else if key == "$value" {
282            match val {
283                XmlValue::Fragment(elements) => self.children.extend(elements),
284                _ => self.children.push(val),
285            }
286        }
287        else {
288            match val {
289                XmlValue::Fragment(elements) => {
290                    for element in elements {
291                        match element {
292                            XmlValue::Element(mut e) => {
293                                e.name = key.clone();
294                                self.children.push(XmlValue::Element(e));
295                            }
296                            _ => {
297                                self.children.push(XmlValue::Element(XmlElement { name: key.clone(), attributes: Vec::new(), children: vec![element], span: (0..0).into() }));
298                            }
299                        }
300                    }
301                }
302                XmlValue::Element(mut e) => {
303                    e.name = key;
304                    self.children.push(XmlValue::Element(e));
305                }
306                _ => {
307                    self.children.push(XmlValue::Element(XmlElement { name: key, attributes: Vec::new(), children: vec![val], span: (0..0).into() }));
308                }
309            }
310        }
311        Ok(())
312    }
313
314    fn end(self) -> Result<Self::Ok, Self::Error> {
315        Ok(XmlValue::Element(XmlElement { name: self.name, attributes: self.attributes, children: self.children, span: (0..0).into() }))
316    }
317}
318
319impl ser::SerializeStruct for SerializeObject {
320    type Ok = XmlValue;
321    type Error = Error;
322
323    fn serialize_field<T: ?Sized + Serialize>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error> {
324        ser::SerializeMap::serialize_key(self, key)?;
325        ser::SerializeMap::serialize_value(self, value)
326    }
327
328    fn end(self) -> Result<Self::Ok, Self::Error> {
329        ser::SerializeMap::end(self)
330    }
331}
332
333struct StringSerializer;
334
335impl ser::Serializer for StringSerializer {
336    type Ok = String;
337    type Error = Error;
338    type SerializeSeq = ser::Impossible<String, Error>;
339    type SerializeTuple = ser::Impossible<String, Error>;
340    type SerializeTupleStruct = ser::Impossible<String, Error>;
341    type SerializeTupleVariant = ser::Impossible<String, Error>;
342    type SerializeMap = ser::Impossible<String, Error>;
343    type SerializeStruct = ser::Impossible<String, Error>;
344    type SerializeStructVariant = ser::Impossible<String, Error>;
345
346    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error> {
347        Ok(v.to_string())
348    }
349    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error> {
350        Ok(v.to_string())
351    }
352    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error> {
353        Ok(v.to_string())
354    }
355    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error> {
356        Ok(v.to_string())
357    }
358    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
359        Ok(v.to_string())
360    }
361    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error> {
362        Ok(v.to_string())
363    }
364    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error> {
365        Ok(v.to_string())
366    }
367    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error> {
368        Ok(v.to_string())
369    }
370    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error> {
371        Ok(v.to_string())
372    }
373    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error> {
374        Ok(v.to_string())
375    }
376    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error> {
377        Ok(v.to_string())
378    }
379    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error> {
380        Ok(v.to_string())
381    }
382    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error> {
383        Ok(v.to_string())
384    }
385    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error> {
386        Ok(format!("{:?}", v))
387    }
388    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
389        Ok(String::new())
390    }
391    fn serialize_some<T: ?Sized + Serialize>(self, value: &T) -> Result<Self::Ok, Self::Error> {
392        value.serialize(self)
393    }
394    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
395        Ok(String::new())
396    }
397    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
398        Ok(String::new())
399    }
400    fn serialize_unit_variant(self, _name: &'static str, _variant_index: u32, variant: &'static str) -> Result<Self::Ok, Self::Error> {
401        Ok(variant.to_string())
402    }
403    fn serialize_newtype_struct<T: ?Sized + Serialize>(self, _name: &'static str, value: &T) -> Result<Self::Ok, Self::Error> {
404        value.serialize(self)
405    }
406    fn serialize_newtype_variant<T: ?Sized + Serialize>(self, _name: &'static str, _variant_index: u32, variant: &'static str, _value: &T) -> Result<Self::Ok, Self::Error> {
407        Ok(variant.to_string())
408    }
409    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
410        Err(ser::Error::custom("Impossible"))
411    }
412    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, Self::Error> {
413        Err(ser::Error::custom("Impossible"))
414    }
415    fn serialize_tuple_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeTupleStruct, Self::Error> {
416        Err(ser::Error::custom("Impossible"))
417    }
418    fn serialize_tuple_variant(self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize) -> Result<Self::SerializeTupleVariant, Self::Error> {
419        Err(ser::Error::custom("Impossible"))
420    }
421    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
422        Err(ser::Error::custom("Impossible"))
423    }
424    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct, Self::Error> {
425        Err(ser::Error::custom("Impossible"))
426    }
427    fn serialize_struct_variant(self, _name: &'static str, _variant_index: u32, _variant: &'static str, _len: usize) -> Result<Self::SerializeStructVariant, Self::Error> {
428        Err(ser::Error::custom("Impossible"))
429    }
430}
431
432impl<'de> de::Deserializer<'de> for XmlValue {
433    type Error = Error;
434
435    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
436    where
437        V: Visitor<'de>,
438    {
439        match self {
440            XmlValue::Text(t) => visitor.visit_string(t),
441            XmlValue::Element(e) => visitor.visit_map(MapDeserializer::new(e)),
442            XmlValue::Fragment(fs) => visitor.visit_seq(SeqDeserializer::new(fs)),
443            _ => Err(de::Error::custom("Unsupported XML value type for deserialize_any")),
444        }
445    }
446
447    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
448    where
449        V: Visitor<'de>,
450    {
451        match self {
452            XmlValue::Text(ref t) if t.is_empty() => visitor.visit_none(),
453            _ => visitor.visit_some(self),
454        }
455    }
456
457    fn deserialize_enum<V>(self, _name: &'static str, _variants: &'static [&'static str], visitor: V) -> Result<V::Value, Self::Error>
458    where
459        V: Visitor<'de>,
460    {
461        match self {
462            XmlValue::Text(t) => visitor.visit_enum(EnumDeserializer::new(t, None)),
463            XmlValue::Element(e) => visitor.visit_enum(EnumDeserializer::new(e.name.clone(), Some(XmlValue::Element(e)))),
464            _ => Err(de::Error::custom("Expected text or element for enum")),
465        }
466    }
467
468    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
469    where
470        V: Visitor<'de>,
471    {
472        visitor.visit_newtype_struct(self)
473    }
474
475    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
476    where
477        V: Visitor<'de>,
478    {
479        self.deserialize_any(visitor)
480    }
481    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
482    where
483        V: Visitor<'de>,
484    {
485        self.deserialize_any(visitor)
486    }
487    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
488    where
489        V: Visitor<'de>,
490    {
491        self.deserialize_any(visitor)
492    }
493    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
494    where
495        V: Visitor<'de>,
496    {
497        self.deserialize_any(visitor)
498    }
499    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
500    where
501        V: Visitor<'de>,
502    {
503        self.deserialize_any(visitor)
504    }
505    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
506    where
507        V: Visitor<'de>,
508    {
509        self.deserialize_any(visitor)
510    }
511    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
512    where
513        V: Visitor<'de>,
514    {
515        self.deserialize_any(visitor)
516    }
517    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
518    where
519        V: Visitor<'de>,
520    {
521        self.deserialize_any(visitor)
522    }
523    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
524    where
525        V: Visitor<'de>,
526    {
527        self.deserialize_any(visitor)
528    }
529    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
530    where
531        V: Visitor<'de>,
532    {
533        self.deserialize_any(visitor)
534    }
535    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
536    where
537        V: Visitor<'de>,
538    {
539        self.deserialize_any(visitor)
540    }
541    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
542    where
543        V: Visitor<'de>,
544    {
545        self.deserialize_any(visitor)
546    }
547    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
548    where
549        V: Visitor<'de>,
550    {
551        match self {
552            XmlValue::Text(t) => visitor.visit_string(t),
553            XmlValue::Element(e) => {
554                if e.attributes.is_empty() && e.children.iter().all(|c| matches!(c, XmlValue::Text(_))) {
555                    let mut text = String::new();
556                    for child in e.children {
557                        if let XmlValue::Text(t) = child {
558                            text.push_str(&t)
559                        }
560                    }
561                    visitor.visit_string(text)
562                }
563                else {
564                    XmlValue::Element(e).deserialize_any(visitor)
565                }
566            }
567            XmlValue::Fragment(fs) => {
568                let mut text = String::new();
569                for f in fs {
570                    text.push_str(&f.to_string())
571                }
572                visitor.visit_string(text)
573            }
574            other => other.deserialize_any(visitor),
575        }
576    }
577
578    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
579    where
580        V: Visitor<'de>,
581    {
582        self.deserialize_str(visitor)
583    }
584    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
585    where
586        V: Visitor<'de>,
587    {
588        self.deserialize_any(visitor)
589    }
590    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
591    where
592        V: Visitor<'de>,
593    {
594        self.deserialize_any(visitor)
595    }
596    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
597    where
598        V: Visitor<'de>,
599    {
600        self.deserialize_any(visitor)
601    }
602    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value, Self::Error>
603    where
604        V: Visitor<'de>,
605    {
606        self.deserialize_any(visitor)
607    }
608    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
609    where
610        V: Visitor<'de>,
611    {
612        match self {
613            XmlValue::Element(e) => visitor.visit_seq(SeqDeserializer::new(e.children)),
614            XmlValue::Fragment(fs) => visitor.visit_seq(SeqDeserializer::new(fs)),
615            _ => Err(de::Error::custom("Expected element or fragment for seq")),
616        }
617    }
618    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
619    where
620        V: Visitor<'de>,
621    {
622        self.deserialize_seq(visitor)
623    }
624    fn deserialize_tuple_struct<V>(self, _name: &'static str, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
625    where
626        V: Visitor<'de>,
627    {
628        self.deserialize_seq(visitor)
629    }
630    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
631    where
632        V: Visitor<'de>,
633    {
634        self.deserialize_any(visitor)
635    }
636    fn deserialize_struct<V>(self, _name: &'static str, _fields: &'static [&'static str], visitor: V) -> Result<V::Value, Self::Error>
637    where
638        V: Visitor<'de>,
639    {
640        self.deserialize_any(visitor)
641    }
642    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
643    where
644        V: Visitor<'de>,
645    {
646        self.deserialize_any(visitor)
647    }
648    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
649    where
650        V: Visitor<'de>,
651    {
652        self.deserialize_any(visitor)
653    }
654}
655
656struct MapDeserializer {
657    entries: std::vec::IntoIter<(String, XmlValue)>,
658    current_value: Option<XmlValue>,
659}
660
661impl MapDeserializer {
662    fn new(element: XmlElement) -> Self {
663        let mut entries: Vec<(String, Vec<XmlValue>)> = Vec::new();
664
665        for attr in element.attributes {
666            let key = "↯".to_string() + &attr.name;
667            entries.push((key, vec![XmlValue::Text(attr.value)]))
668        }
669
670        for child in element.children {
671            match child {
672                XmlValue::Element(e) => {
673                    if let Some(entry) = entries.iter_mut().find(|(k, _)| k == &e.name) {
674                        entry.1.push(XmlValue::Element(e))
675                    }
676                    else {
677                        let name = e.name.clone();
678                        entries.push((name, vec![XmlValue::Element(e)]))
679                    }
680                }
681                XmlValue::Text(t) => {
682                    if let Some(entry) = entries.iter_mut().find(|(k, _)| k == "$value") {
683                        entry.1.push(XmlValue::Text(t.clone()))
684                    }
685                    else {
686                        entries.push(("$value".to_string(), vec![XmlValue::Text(t.clone())]))
687                    }
688                }
689                _ => {}
690            }
691        }
692
693        let final_entries = entries
694            .into_iter()
695            .map(|(k, mut v)| {
696                let val = if k == "$value" {
697                    if v.len() == 1 { v.remove(0) } else { XmlValue::Fragment(v) }
698                }
699                else if v.len() == 1 {
700                    v.remove(0)
701                }
702                else {
703                    XmlValue::Fragment(v)
704                };
705                println!("MapEntry: key={}, value={:?}", k, val);
706                (k, val)
707            })
708            .collect::<Vec<_>>();
709
710        Self { entries: final_entries.into_iter(), current_value: None }
711    }
712}
713
714impl<'de> de::MapAccess<'de> for MapDeserializer {
715    type Error = Error;
716
717    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Self::Error>
718    where
719        K: de::DeserializeSeed<'de>,
720    {
721        if let Some((key, value)) = self.entries.next() {
722            self.current_value = Some(value);
723            return seed.deserialize(de::value::StrDeserializer::<Error>::new(&key)).map(Some);
724        }
725
726        Ok(None)
727    }
728
729    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Self::Error>
730    where
731        V: de::DeserializeSeed<'de>,
732    {
733        match self.current_value.take() {
734            Some(value) => seed.deserialize(value),
735            None => Err(de::Error::custom("next_value_seed called before next_key_seed")),
736        }
737    }
738}
739
740struct SeqDeserializer {
741    iter: std::vec::IntoIter<XmlValue>,
742}
743
744impl SeqDeserializer {
745    fn new(elements: Vec<XmlValue>) -> Self {
746        Self { iter: elements.into_iter() }
747    }
748}
749
750impl<'de> de::SeqAccess<'de> for SeqDeserializer {
751    type Error = Error;
752
753    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
754    where
755        T: de::DeserializeSeed<'de>,
756    {
757        match self.iter.next() {
758            Some(value) => seed.deserialize(value).map(Some),
759            None => Ok(None),
760        }
761    }
762}
763
764struct EnumDeserializer {
765    variant: String,
766    value: Option<XmlValue>,
767}
768
769impl EnumDeserializer {
770    fn new(variant: String, value: Option<XmlValue>) -> Self {
771        Self { variant, value }
772    }
773}
774
775impl<'de> de::EnumAccess<'de> for EnumDeserializer {
776    type Error = Error;
777    type Variant = VariantDeserializer;
778
779    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
780    where
781        V: de::DeserializeSeed<'de>,
782    {
783        let variant = seed.deserialize(de::value::StrDeserializer::<Error>::new(&self.variant))?;
784        Ok((variant, VariantDeserializer { value: self.value }))
785    }
786}
787
788struct VariantDeserializer {
789    value: Option<XmlValue>,
790}
791
792impl<'de> de::VariantAccess<'de> for VariantDeserializer {
793    type Error = Error;
794
795    fn unit_variant(self) -> Result<(), Self::Error> {
796        Ok(())
797    }
798
799    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
800    where
801        T: de::DeserializeSeed<'de>,
802    {
803        match self.value {
804            Some(value) => seed.deserialize(value),
805            None => Err(de::Error::custom("Expected newtype variant")),
806        }
807    }
808
809    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
810    where
811        V: Visitor<'de>,
812    {
813        match self.value {
814            Some(XmlValue::Element(e)) => visitor.visit_seq(SeqDeserializer::new(e.children)),
815            _ => Err(de::Error::custom("Expected element for tuple variant")),
816        }
817    }
818
819    fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value, Self::Error>
820    where
821        V: Visitor<'de>,
822    {
823        match self.value {
824            Some(XmlValue::Element(e)) => visitor.visit_map(MapDeserializer::new(e)),
825            _ => Err(de::Error::custom("Expected element for struct variant")),
826        }
827    }
828}
oak_xml/serde.rs

oak_xml/
serde.rs
