oak_xml/
serde.rs

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

oak_xml/
serde.rs
