Struct Root 

pub struct Root<T> {
    pub name: Option<String>,
    pub namespaces: Vec<(String, String)>,
    pub value: T,
}

A document: the value of the root element with its name and the namespaces declared on it.

When deserialized the name of the root element and its namespace declarations are captured, when serialized the root element is written with them. The name is kept as the deserializer passes on names: as written, with the configured prefix of its namespace or as {uri}local if namespaces are resolved (see DeserializerConfig). The prefixes of the namespaces are the ones the names use (the configured prefixes for namespaces that have one).

use std::collections::BTreeMap;
use deser_xml::Root;

let doc: Root<BTreeMap<String, String>> =
    deser_xml::from_str(r#"<rss xmlns:dc="urn:dc"><dc:creator>Jane</dc:creator></rss>"#)
        .unwrap();
assert_eq!(doc.name.as_deref(), Some("rss"));
assert_eq!(doc.namespaces, [("dc".to_string(), "urn:dc".to_string())]);
assert_eq!(doc.value["dc:creator"], "Jane");

// values without a name (like maps) are named by the root
let doc = Root::new("r", BTreeMap::from([("@a", 1), ("b", 2)]));
assert_eq!(deser_xml::to_string(&doc).unwrap(), r#"<r a="1"><b>2</b></r>"#);

The name of the root is used over the name of the type of the value and the configured name, its namespaces are declared before the configured ones (which are left out if their prefix is taken). Only documents have a root: in other places, and when serializing to other formats, the name and the namespaces are ignored, when deserializing from other formats the name is None and there are no namespaces.

Fields

name: Option<String>

The name of the root element.

namespaces: Vec<(String, String)>

The namespaces declared on the root element as prefix and URI (the empty prefix is the default namespace).

value: T

The value of the root element.

Implementations

impl<T> Root<T>

pub fn new<S: Into<String>>(name: S, value: T) -> Root<T>

Creates a root element with a name.

pub fn with_namespace<P: Into<String>, U: Into<String>>( self, prefix: P, uri: U, ) -> Root<T>

Declares a namespace on the root element.

use deser_xml::Root;

let doc = Root::new("{urn:a}doc", "x").with_namespace("a", "urn:a");
assert_eq!(
    deser_xml::to_string(&doc).unwrap(),
    r#"<a:doc xmlns:a="urn:a">x</a:doc>"#
);

pub fn into_inner(self) -> T

Returns the value of the root element.

Trait Implementations

impl<T: Clone> Clone for Root<T>

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Root<T>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<T: Default> Default for Root<T>

fn default() -> Self

Returns the “default value” for a type.

impl<'de, T: Deserialize<'de>> Deserialize<'de> for Root<T>

fn deserialize_into<'out>( out: &'out mut Option<Self>, state: &mut State, ) -> SinkHandle<'out, 'de>

Creates a sink that deserializes the value into the given slot.

fn expecting() -> Cow<'static, str>

Returns what the value expects, for error messages.

fn describe_type(d: &mut dyn Describe)

Describes the Rust shape of the type.

fn deserialize_atom( slot: &mut Slot<T, Self>, atom: Atom<'_>, state: &mut State, ) -> Result<(), Error>

Deserializes an atom into the slot.

fn deserialize_borrowed_atom( slot: &mut Slot<T, Self>, atom: Atom<'de>, state: &mut State, ) -> Result<(), Error>

Deserializes an atom that borrows from the data being deserialized into the slot.

fn initial_value() -> Option<T>

Provides the value of a missing struct field.

fn deserialize_update<'out>( value: &'out mut T, state: &mut State, ) -> SinkHandle<'out, 'de>

Creates a sink that updates an existing value.

impl<T: Eq> Eq for Root<T>

impl<T: Hash> Hash for Root<T>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T: PartialEq> PartialEq for Root<T>

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl<T: Serialize> Serialize for Root<T>

fn serialize<'a>(this: &'a Self, state: &mut State) -> Result<Emit<'a>, Error>

Serializes the value.

fn finish(this: &Self, state: &mut State) -> Result<(), Error>

Invoked after the serialization finished.

fn is_optional(this: &Self) -> bool

Checks if the value represents an optional value.

fn container_shape(this: &Self) -> ContainerShape

Returns the shape of the value if it’s a map or sequence.

fn describe(this: &Self, d: &mut dyn Describe)

Describes the Rust shape of the value.

impl<T: PartialEq> StructuralPartialEq for Root<T>