Struct DeserializerConfig

Source

pub struct DeserializerConfig { /* private fields */ }

Expand description

Configures how XML documents are deserialized.

See the crate documentation for how XML maps onto the data model of deser.

Implementations§

Source §

impl DeserializerConfig

Source

pub const fn new() -> DeserializerConfig

Creates the default configuration.

Source

pub const fn builder() -> DeserializerConfigBuilder

Returns a builder for the configuration (see DeserializerConfigBuilder).

Source

pub const fn into_builder(self) -> DeserializerConfigBuilder

Returns a builder that starts with this configuration.

Source

pub fn set_context(&mut self, context: Context)

Sets the context the values are deserialized in.

The values of the context are the defaults of the extension values of the state (see Context), for instance the variants of open enums. The deserializers and readers created with the configuration use this context. A context set on the driver takes precedence.

Source

pub fn context(&self) -> &Context

Returns the context the values are deserialized in.

Source

pub const fn set_attribute_prefix(&mut self, prefix: &'static str)

Sets the prefix of the keys of attributes.

The default is @: <a href="x"/> is {"@href": "x"}.

Source

pub const fn set_text_key(&mut self, key: &'static str)

Sets the key of the text of elements that are maps.

The default is $text: <a href="x">y</a> is {"@href": "x", "$text": "y"}.

Source

pub const fn namespaces( self, namespaces: &'static [(&'static str, &'static str)], ) -> DeserializerConfig

Sets the prefixes of namespaces.

Names are passed on as written in the document (atom:link), unless their namespace has a prefix here: then they are written with this prefix, whichever prefix the document uses. The empty prefix leaves only the local name. Names in other namespaces are passed on as written or, if namespaces are resolved, as {uri}local. The table can be written with prefixes!.

use deser_xml::DeserializerConfig;

#[derive(deser::Deserialize)]
struct Feed {
    title: String,
    #[deser(rename = "dc:creator")]
    creator: String,
}

const CONFIG: DeserializerConfig = DeserializerConfig::new().namespaces(&[
    ("", "http://www.w3.org/2005/Atom"),
    ("dc", "http://purl.org/dc/elements/1.1/"),
]);
let feed: Feed = CONFIG.from_str(r#"
    <a:feed xmlns:a="http://www.w3.org/2005/Atom"
            xmlns:x="http://purl.org/dc/elements/1.1/">
      <a:title>Example</a:title>
      <x:creator>Jane</x:creator>
    </a:feed>
"#).unwrap();
assert_eq!(feed.title, "Example");
assert_eq!(feed.creator, "Jane");

Source

pub const fn set_resolve_namespaces(&mut self, yes: bool)

Enables or disables resolving namespaces.

By default names are passed on as written in the document. If namespaces are resolved, names in a namespace are passed on as {uri}local (the notation of James Clark, attributes are @{uri}local) unless the namespace has a prefix, so the prefixes of the document do not matter. Names without namespace are their local name, the xml prefix is kept (@xml:lang). Prefixes that are not declared are an error. The default is false.

The names can be written with qname! and namespace!:

use deser_xml::DeserializerConfig;

deser_xml::namespace!(atom = "http://www.w3.org/2005/Atom");

#[derive(deser::Deserialize)]
struct Link {
    #[deser(rename = "@href")]
    href: String,
}

#[derive(deser::Deserialize)]
struct Feed {
    #[deser(rename = atom!("title"))]
    title: String,
    #[deser(rename = atom!("link"))]
    link: Link,
}

const CONFIG: DeserializerConfig =
    DeserializerConfig::builder().resolve_namespaces(true).build();
let xml = r#"
    <feed xmlns="http://www.w3.org/2005/Atom">
      <title>Example</title>
      <link href="/a"/>
    </feed>
"#;
let feed: Feed = CONFIG.from_str(xml).unwrap();
assert_eq!(feed.title, "Example");
assert_eq!(feed.link.href, "/a");