Trait FromXml 

pub trait FromXml<'xml>: Sized {
    type Accumulator: Accumulate<Self>;

    const KIND: Kind;

    // Required methods
    fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool;
    fn deserialize<'cx>(
        into: &mut Self::Accumulator,
        field: &'static str,
        deserializer: &mut Deserializer<'cx, 'xml>,
    ) -> Result<(), Error>;
}

Deserialize a type from XML

Required Associated Constants

const KIND: Kind

The kind of XML node this type represents

Required Associated Types

type Accumulator: Accumulate<Self>

The accumulator type used during deserialization

Required Methods

fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool

Check if an element or attribute matches this type

fn deserialize<'cx>( into: &mut Self::Accumulator, field: &'static str, deserializer: &mut Deserializer<'cx, 'xml>, ) -> Result<(), Error>

Deserialize from XML into an accumulator

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementations on Foreign Types

impl<'xml, 'a> FromXml<'xml> for Cow<'a, str>

const KIND: Kind = Kind::Scalar

type Accumulator = CowStrAccumulator<'xml, 'a>

fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool

fn deserialize( into: &mut Self::Accumulator, field: &'static str, deserializer: &mut Deserializer<'_, 'xml>, ) -> Result<(), Error>

impl<'xml, T: FromXml<'xml>> FromXml<'xml> for Box<T>

const KIND: Kind = T::KIND

type Accumulator = Option<Box<T>>

fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool

fn deserialize<'cx>( into: &mut Self::Accumulator, field: &'static str, deserializer: &mut Deserializer<'cx, 'xml>, ) -> Result<(), Error>

impl<'xml, T: FromXml<'xml>> FromXml<'xml> for Cow<'_, [T]>

where [T]: ToOwned<Owned = Vec<T>>,

const KIND: Kind = Kind::Scalar

type Accumulator = Vec<T>

fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool

fn deserialize( into: &mut Self::Accumulator, field: &'static str, deserializer: &mut Deserializer<'_, 'xml>, ) -> Result<(), Error>

impl<'xml, T: FromXml<'xml>> FromXml<'xml> for Option<T>

const KIND: Kind = T::KIND

type Accumulator = OptionAccumulator<T, <T as FromXml<'xml>>::Accumulator>

fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool

fn deserialize<'cx>( into: &mut Self::Accumulator, field: &'static str, deserializer: &mut Deserializer<'cx, 'xml>, ) -> Result<(), Error>

impl<'xml, T: FromXml<'xml>> FromXml<'xml> for Vec<T>

const KIND: Kind = T::KIND

type Accumulator = Vec<T>

fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool

fn deserialize<'cx>( into: &mut Self::Accumulator, field: &'static str, deserializer: &mut Deserializer<'cx, 'xml>, ) -> Result<(), Error>

impl<'xml> FromXml<'xml> for ()

const KIND: Kind = Kind::Scalar

type Accumulator = Option<()>

fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool

fn deserialize<'cx>( into: &mut Self::Accumulator, _: &'static str, _: &mut Deserializer<'cx, 'xml>, ) -> Result<(), Error>

impl<'xml> FromXml<'xml> for IpAddr

const KIND: Kind = Kind::Scalar

type Accumulator = Option<IpAddr>

fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool

fn deserialize<'cx>( into: &mut Self::Accumulator, field: &'static str, deserializer: &mut Deserializer<'cx, 'xml>, ) -> Result<(), Error>

impl<'xml> FromXml<'xml> for String

const KIND: Kind = Kind::Scalar

type Accumulator = Option<String>

fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool

fn deserialize<'cx>( into: &mut Self::Accumulator, field: &'static str, deserializer: &mut Deserializer<'cx, 'xml>, ) -> Result<(), Error>

impl<'xml> FromXml<'xml> for bool

const KIND: Kind = Kind::Scalar

type Accumulator = Option<bool>

fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool

fn deserialize<'cx>( into: &mut Self::Accumulator, field: &'static str, deserializer: &mut Deserializer<'cx, 'xml>, ) -> Result<(), Error>

impl<'xml> FromXml<'xml> for char

const KIND: Kind = Kind::Scalar

type Accumulator = Option<char>

fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool

fn deserialize<'cx>( into: &mut Self::Accumulator, field: &'static str, deserializer: &mut Deserializer<'cx, 'xml>, ) -> Result<(), Error>

impl<'xml> FromXml<'xml> for f32

const KIND: Kind = Kind::Scalar

type Accumulator = Option<f32>

fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool

fn deserialize<'cx>( into: &mut Self::Accumulator, field: &'static str, deserializer: &mut Deserializer<'cx, 'xml>, ) -> Result<(), Error>

impl<'xml> FromXml<'xml> for f64

const KIND: Kind = Kind::Scalar

type Accumulator = Option<f64>

fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool

fn deserialize<'cx>( into: &mut Self::Accumulator, field: &'static str, deserializer: &mut Deserializer<'cx, 'xml>, ) -> Result<(), Error>

impl<'xml> FromXml<'xml> for i8

const KIND: Kind = Kind::Scalar

type Accumulator = Option<i8>

fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool

fn deserialize<'cx>( into: &mut Self::Accumulator, field: &'static str, deserializer: &mut Deserializer<'cx, 'xml>, ) -> Result<(), Error>

impl<'xml> FromXml<'xml> for i16

const KIND: Kind = Kind::Scalar

type Accumulator = Option<i16>

fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool

fn deserialize<'cx>( into: &mut Self::Accumulator, field: &'static str, deserializer: &mut Deserializer<'cx, 'xml>, ) -> Result<(), Error>

impl<'xml> FromXml<'xml> for i32

const KIND: Kind = Kind::Scalar

type Accumulator = Option<i32>

fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool

fn deserialize<'cx>( into: &mut Self::Accumulator, field: &'static str, deserializer: &mut Deserializer<'cx, 'xml>, ) -> Result<(), Error>

impl<'xml> FromXml<'xml> for i64

const KIND: Kind = Kind::Scalar

type Accumulator = Option<i64>

fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool

fn deserialize<'cx>( into: &mut Self::Accumulator, field: &'static str, deserializer: &mut Deserializer<'cx, 'xml>, ) -> Result<(), Error>

impl<'xml> FromXml<'xml> for isize

const KIND: Kind = Kind::Scalar

type Accumulator = Option<isize>

fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool

fn deserialize<'cx>( into: &mut Self::Accumulator, field: &'static str, deserializer: &mut Deserializer<'cx, 'xml>, ) -> Result<(), Error>

impl<'xml> FromXml<'xml> for u8

const KIND: Kind = Kind::Scalar

type Accumulator = Option<u8>

fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool

fn deserialize<'cx>( into: &mut Self::Accumulator, field: &'static str, deserializer: &mut Deserializer<'cx, 'xml>, ) -> Result<(), Error>

impl<'xml> FromXml<'xml> for u16

const KIND: Kind = Kind::Scalar

type Accumulator = Option<u16>

fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool

fn deserialize<'cx>( into: &mut Self::Accumulator, field: &'static str, deserializer: &mut Deserializer<'cx, 'xml>, ) -> Result<(), Error>

impl<'xml> FromXml<'xml> for u32

const KIND: Kind = Kind::Scalar

type Accumulator = Option<u32>

fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool

fn deserialize<'cx>( into: &mut Self::Accumulator, field: &'static str, deserializer: &mut Deserializer<'cx, 'xml>, ) -> Result<(), Error>

impl<'xml> FromXml<'xml> for u64

const KIND: Kind = Kind::Scalar

type Accumulator = Option<u64>

fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool

fn deserialize<'cx>( into: &mut Self::Accumulator, field: &'static str, deserializer: &mut Deserializer<'cx, 'xml>, ) -> Result<(), Error>

impl<'xml> FromXml<'xml> for usize

const KIND: Kind = Kind::Scalar

type Accumulator = Option<usize>

fn matches(id: Id<'_>, field: Option<Id<'_>>) -> bool

fn deserialize<'cx>( into: &mut Self::Accumulator, field: &'static str, deserializer: &mut Deserializer<'cx, 'xml>, ) -> Result<(), Error>

Implementors

impl<'xml, 'a> FromXml<'xml> for AnyElement<'a>

where 'xml: 'a,

const KIND: Kind = Kind::Element

type Accumulator = Option<AnyElement<'a>>