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", so this trait is not object safe.

Implementations on Foreign Types

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 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 ()

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 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>

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, '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 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 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 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>

Implementors

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

where 'xml: 'a,

const KIND: Kind = Kind::Element

type Accumulator = Option<AnyElement<'a>>