oak_xml/language/
serde.rs

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

oak_xml/language/
serde.rs
