Deserializing dynamic XML in Rust

Question

I'm trying to parse this kind of XML with serde and an xml crate, but I'm not sure it's possible with serde:

<vm>
    <id>15</id>
    <template>
        <tag1>content</tag1>
        <tag2>content</tag2>
        <vec1>
            <tag3>content</tag3>
            <tag4>content</tag4>
        </vec1>
        <tag2>content</tag2>
        <vec1>
            <tag3>content</tag3>
        </vec1>
        <vec2>
            <tag3>content</tag3>
        </vec2>
    </template>
</vm>

All tag names tagX and vecX keys are dynamic (and not necessarily unique), all others names are static and known.

The content inside template have only two possible forms: Either a representation of a (key, value) "pair": <key>value</key>

Or a a representation of a "vector" (vec_key, collection of pairs): <vec_key><key>value</key><key2>value2</key2> ... </vec_key>

I'm trying to represent the data to something close to this (with tag name in first String):

enum Element {
    Pair(String, String),
    Vector(String, Vec<(String, String)>),
}

pub struct VM {
    id: i64,
    template: Vec<Element>,
}

So the above XML would be deserialized to something like:

[
  Pair("tag1", "content"),
  Pair("tag2", "content"),
  Vector("vec1", [("tag3", "content"),("tag4", "content")]),
  Pair("tag2", "content"),
  Vector("vec1", [("tag3", "content")]),
  Vector("vec2", [("tag3", "content")])
]

I'm open to modify a bit the representation but I just don't want to store the datas in complex nested data structures.

Is it possible with Serde ?

For the context I did the same with Golang and encoding/xml module, and I was able to mix regular structure deserialization with custom deserialization (working directly with the pull parser for the custom part)

Answer 1

From deserialize map example of serde I tried this:

#![allow(dead_code)]

use serde::Deserialize;
use std::{collections::HashMap, fmt};

use serde::de::{self, Deserializer, MapAccess, Visitor};

const XML: &str = r#"
<vm>
    <id>15</id>
    <template>
        <tag1>content1</tag1>
        <tag2>content2</tag2>
        <vec1>
            <tag3>content3</tag3>
            <tag4>content4</tag4>
        </vec1>
        <vec1>
            <tag3>content5</tag3>
        </vec1>
        <tag2>content6</tag2>
        <vec2>
            <tag3>content7</tag3>
        </vec2>
    </template>
</vm>
"#;

#[derive(Debug, Clone)]
struct Pair(String, String);

#[derive(Debug, Clone)]

struct Vector(String, Vec<Pair>);

#[derive(Debug, Clone)]
struct Template {
    pairs: Vec<Pair>,
    vectors: Vec<Vector>,
}

impl Template {
    fn new() -> Self {
        Template {
            pairs: Vec::new(),
            vectors: Vec::new(),
        }
    }
}

#[derive(Debug, Deserialize)]
pub struct VM {
    id: i64,
    template: Template,
}

struct TemplateVisitor;

impl<'de> Visitor<'de> for TemplateVisitor {
    type Value = Template;

    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        formatter.write_str("a very special map")
    }

    fn visit_map<M>(self, mut access: M) -> Result<Self::Value, M::Error>
    where
        M: MapAccess<'de>,
    {
        let mut map = Template::new();

        while let Some(key) = access.next_key::<String>()? {
            let map_value = access.next_value::<HashMap<String, String>>().unwrap();

            if map_value.contains_key("$value") {
                map.pairs
                    .push(Pair(key, map_value.get("$value").unwrap().clone()));
            } else {

                let mut vector = Vec::new();
                for (k, v) in map_value {
                    vector.push(Pair(k, v))
                }
                map.vectors.push(Vector(key, vector));
            }
        }

        Ok(map)
    }
}

impl<'de> Deserialize<'de> for Template {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        deserializer.deserialize_map(TemplateVisitor {})
    }
}

fn main() {
    let obj: VM = serde_xml_rs::from_str(XML).unwrap();
    println!("{:#?}", obj);
}

Result:

VM {
    id: 15,
    template: Template {
        pairs: [
            Pair(
                "tag1",
                "content1",
            ),
            Pair(
                "tag2",
                "content2",
            ),
            Pair(
                "tag2",
                "content6",
            ),
        ],
        vectors: [
            Vector(
                "vec1",
                [
                    Pair(
                        "tag4",
                        "content4",
                    ),
                    Pair(
                        "tag3",
                        "content3",
                    ),
                ],
            ),
            Vector(
                "vec1",
                [
                    Pair(
                        "tag3",
                        "content5",
                    ),
                ],
            ),
            Vector(
                "vec2",
                [
                    Pair(
                        "tag3",
                        "content7",
                    ),
                ],
            ),
        ],
    },
}

However I'm not fully satisfied with the line map_value.contains_key("$value"). Not sure it's a clean way to do, maybe mixing with something like: either string or struct example to distinguish between a pair and a vector when deserializing

I'm still looking for a better solution