Trait xmpp_parsers::TryFrom

pub trait TryFrom<T> {
    type Err;
    fn try_from(T) -> Result<Self, Self::Err>;
}

Associated Types

type Err

Loading content...

Required methods

fn try_from(T) -> Result<Self, Self::Err>

Loading content...

Implementations on Foreign Types

impl TryFrom<isize> for u8

type Err = TryFromIntError

fn try_from(n: isize) -> Result<u8, TryFromIntError>

impl TryFrom<u128> for i16

type Err = TryFromIntError

fn try_from(n: u128) -> Result<i16, TryFromIntError>

impl TryFrom<usize> for i64

type Err = TryFromIntError

fn try_from(n: usize) -> Result<i64, TryFromIntError>

impl TryFrom<usize> for usize

type Err = Void

fn try_from(n: usize) -> Result<usize, Void>

impl TryFrom<u8> for char

type Err = Void

fn try_from(n: u8) -> Result<char, Void>

impl TryFrom<u8> for i8

type Err = TryFromIntError

fn try_from(n: u8) -> Result<i8, TryFromIntError>

impl TryFrom<i32> for u64

type Err = TryFromIntError

fn try_from(n: i32) -> Result<u64, TryFromIntError>

impl TryFrom<i8> for u64

type Err = TryFromIntError

fn try_from(n: i8) -> Result<u64, TryFromIntError>

impl TryFrom<u32> for char

type Err = TryFromIntToCharError

fn try_from(n: u32) -> Result<char, TryFromIntToCharError>

impl TryFrom<u64> for u128

type Err = Void

fn try_from(n: u64) -> Result<u128, Void>

impl TryFrom<i8> for u128

type Err = TryFromIntError

fn try_from(n: i8) -> Result<u128, TryFromIntError>

impl TryFrom<i8> for u16

type Err = TryFromIntError

fn try_from(n: i8) -> Result<u16, TryFromIntError>

impl TryFrom<i64> for u16

type Err = TryFromIntError

fn try_from(n: i64) -> Result<u16, TryFromIntError>

impl TryFrom<u32> for i32

type Err = TryFromIntError

fn try_from(n: u32) -> Result<i32, TryFromIntError>

impl TryFrom<usize> for u32

type Err = TryFromIntError

fn try_from(n: usize) -> Result<u32, TryFromIntError>

impl TryFrom<u16> for i16

type Err = TryFromIntError

fn try_from(n: u16) -> Result<i16, TryFromIntError>

impl TryFrom<u64> for char

type Err = TryFromIntToCharError

fn try_from(n: u64) -> Result<char, TryFromIntToCharError>

impl TryFrom<i32> for i16

type Err = TryFromIntError

fn try_from(n: i32) -> Result<i16, TryFromIntError>

impl TryFrom<i8> for i128

type Err = Void

fn try_from(n: i8) -> Result<i128, Void>

impl TryFrom<i64> for i128

type Err = Void

fn try_from(n: i64) -> Result<i128, Void>

impl TryFrom<i16> for u8

type Err = TryFromIntError

fn try_from(n: i16) -> Result<u8, TryFromIntError>

impl TryFrom<i16> for isize

type Err = Void

fn try_from(n: i16) -> Result<isize, Void>

impl TryFrom<i128> for u64

type Err = TryFromIntError

fn try_from(n: i128) -> Result<u64, TryFromIntError>

impl TryFrom<i128> for usize

type Err = TryFromIntError

fn try_from(n: i128) -> Result<usize, TryFromIntError>

impl TryFrom<u128> for u16

type Err = TryFromIntError

fn try_from(n: u128) -> Result<u16, TryFromIntError>

impl TryFrom<u16> for isize

type Err = Void

fn try_from(n: u16) -> Result<isize, Void>

impl TryFrom<u8> for u8

type Err = Void

fn try_from(n: u8) -> Result<u8, Void>

impl TryFrom<u64> for u32

type Err = TryFromIntError

fn try_from(n: u64) -> Result<u32, TryFromIntError>

impl TryFrom<i32> for i32

type Err = Void

fn try_from(n: i32) -> Result<i32, Void>

impl TryFrom<i64> for usize

type Err = TryFromIntError

fn try_from(n: i64) -> Result<usize, TryFromIntError>

impl TryFrom<i64> for i8

type Err = TryFromIntError

fn try_from(n: i64) -> Result<i8, TryFromIntError>

impl TryFrom<u32> for i16

type Err = TryFromIntError

fn try_from(n: u32) -> Result<i16, TryFromIntError>

impl TryFrom<i8> for i64

type Err = Void

fn try_from(n: i8) -> Result<i64, Void>

impl TryFrom<i32> for usize

type Err = TryFromIntError

fn try_from(n: i32) -> Result<usize, TryFromIntError>

impl TryFrom<u16> for u64

type Err = Void

fn try_from(n: u16) -> Result<u64, Void>

impl TryFrom<i16> for i128

type Err = Void

fn try_from(n: i16) -> Result<i128, Void>

impl TryFrom<u64> for i32

type Err = TryFromIntError

fn try_from(n: u64) -> Result<i32, TryFromIntError>

impl TryFrom<i32> for u128

type Err = TryFromIntError

fn try_from(n: i32) -> Result<u128, TryFromIntError>

impl TryFrom<i64> for i16

type Err = TryFromIntError

fn try_from(n: i64) -> Result<i16, TryFromIntError>

impl TryFrom<u16> for usize

type Err = Void

fn try_from(n: u16) -> Result<usize, Void>

impl TryFrom<u128> for i8

type Err = TryFromIntError

fn try_from(n: u128) -> Result<i8, TryFromIntError>

impl TryFrom<i32> for char

type Err = TryFromIntToCharError

fn try_from(n: i32) -> Result<char, TryFromIntToCharError>

impl TryFrom<isize> for usize

type Err = TryFromIntError

fn try_from(n: isize) -> Result<usize, TryFromIntError>

impl TryFrom<u64> for u8

type Err = TryFromIntError

fn try_from(n: u64) -> Result<u8, TryFromIntError>

impl TryFrom<usize> for isize

type Err = TryFromIntError

fn try_from(n: usize) -> Result<isize, TryFromIntError>

impl TryFrom<u16> for u8

type Err = TryFromIntError

fn try_from(n: u16) -> Result<u8, TryFromIntError>

impl TryFrom<isize> for u32

type Err = TryFromIntError

fn try_from(n: isize) -> Result<u32, TryFromIntError>

impl TryFrom<i32> for i8

type Err = TryFromIntError

fn try_from(n: i32) -> Result<i8, TryFromIntError>

impl TryFrom<u32> for u8

type Err = TryFromIntError

fn try_from(n: u32) -> Result<u8, TryFromIntError>

impl TryFrom<u64> for u64

type Err = Void

fn try_from(n: u64) -> Result<u64, Void>

impl TryFrom<i32> for i128

type Err = Void

fn try_from(n: i32) -> Result<i128, Void>

impl TryFrom<u8> for u16

type Err = Void

fn try_from(n: u8) -> Result<u16, Void>

impl TryFrom<i64> for u32

type Err = TryFromIntError

fn try_from(n: i64) -> Result<u32, TryFromIntError>

impl TryFrom<u128> for i64

type Err = TryFromIntError

fn try_from(n: u128) -> Result<i64, TryFromIntError>

impl TryFrom<u64> for i8

type Err = TryFromIntError

fn try_from(n: u64) -> Result<i8, TryFromIntError>

impl TryFrom<i32> for u16

type Err = TryFromIntError

fn try_from(n: i32) -> Result<u16, TryFromIntError>

impl TryFrom<u16> for u16

type Err = Void

fn try_from(n: u16) -> Result<u16, Void>

impl TryFrom<u32> for u64

type Err = Void

fn try_from(n: u32) -> Result<u64, Void>

impl TryFrom<usize> for i8

type Err = TryFromIntError

fn try_from(n: usize) -> Result<i8, TryFromIntError>

impl TryFrom<i16> for i64

type Err = Void

fn try_from(n: i16) -> Result<i64, Void>

impl TryFrom<u128> for u64

type Err = TryFromIntError

fn try_from(n: u128) -> Result<u64, TryFromIntError>

impl TryFrom<i16> for usize

type Err = TryFromIntError

fn try_from(n: i16) -> Result<usize, TryFromIntError>

impl TryFrom<isize> for i32

type Err = TryFromIntError

fn try_from(n: isize) -> Result<i32, TryFromIntError>

impl TryFrom<i8> for isize

type Err = Void

fn try_from(n: i8) -> Result<isize, Void>

impl TryFrom<usize> for u8

type Err = TryFromIntError

fn try_from(n: usize) -> Result<u8, TryFromIntError>

impl TryFrom<i8> for u8

type Err = TryFromIntError

fn try_from(n: i8) -> Result<u8, TryFromIntError>

impl TryFrom<i128> for u16

type Err = TryFromIntError

fn try_from(n: i128) -> Result<u16, TryFromIntError>

impl TryFrom<u128> for isize

type Err = TryFromIntError

fn try_from(n: u128) -> Result<isize, TryFromIntError>

impl TryFrom<i8> for usize

type Err = TryFromIntError

fn try_from(n: i8) -> Result<usize, TryFromIntError>

impl TryFrom<u8> for u32

type Err = Void

fn try_from(n: u8) -> Result<u32, Void>

impl TryFrom<i64> for char

type Err = TryFromIntToCharError

fn try_from(n: i64) -> Result<char, TryFromIntToCharError>

impl TryFrom<u16> for i8

type Err = TryFromIntError

fn try_from(n: u16) -> Result<i8, TryFromIntError>

impl TryFrom<usize> for i32

type Err = TryFromIntError

fn try_from(n: usize) -> Result<i32, TryFromIntError>

impl TryFrom<u64> for usize

type Err = TryFromIntError

fn try_from(n: u64) -> Result<usize, TryFromIntError>

impl TryFrom<isize> for u16

type Err = TryFromIntError

fn try_from(n: isize) -> Result<u16, TryFromIntError>

impl TryFrom<u16> for i64

type Err = Void

fn try_from(n: u16) -> Result<i64, Void>

impl TryFrom<i64> for isize

type Err = TryFromIntError

fn try_from(n: i64) -> Result<isize, TryFromIntError>

impl TryFrom<u32> for u32

type Err = Void

fn try_from(n: u32) -> Result<u32, Void>

impl TryFrom<i64> for u8

type Err = TryFromIntError

fn try_from(n: i64) -> Result<u8, TryFromIntError>

impl TryFrom<i32> for u32

type Err = TryFromIntError

fn try_from(n: i32) -> Result<u32, TryFromIntError>

impl TryFrom<u8> for isize

type Err = Void

fn try_from(n: u8) -> Result<isize, Void>

impl TryFrom<i128> for i32

type Err = TryFromIntError

fn try_from(n: i128) -> Result<i32, TryFromIntError>

impl TryFrom<u32> for u16

type Err = TryFromIntError

fn try_from(n: u32) -> Result<u16, TryFromIntError>

impl TryFrom<i128> for i128

type Err = Void

fn try_from(n: i128) -> Result<i128, Void>

impl TryFrom<u32> for i8

type Err = TryFromIntError

fn try_from(n: u32) -> Result<i8, TryFromIntError>

impl TryFrom<isize> for u128

type Err = TryFromIntError

fn try_from(n: isize) -> Result<u128, TryFromIntError>

impl TryFrom<u16> for u128

type Err = Void

fn try_from(n: u16) -> Result<u128, Void>

impl TryFrom<i64> for i32

type Err = TryFromIntError

fn try_from(n: i64) -> Result<i32, TryFromIntError>

impl TryFrom<u64> for i64

type Err = TryFromIntError

fn try_from(n: u64) -> Result<i64, TryFromIntError>

impl TryFrom<u64> for i16

type Err = TryFromIntError

fn try_from(n: u64) -> Result<i16, TryFromIntError>

impl TryFrom<char> for char

type Err = Void

fn try_from(n: char) -> Result<char, Void>

impl TryFrom<i16> for u128

type Err = TryFromIntError

fn try_from(n: i16) -> Result<u128, TryFromIntError>

impl TryFrom<isize> for char

type Err = TryFromIntToCharError

fn try_from(n: isize) -> Result<char, TryFromIntToCharError>

impl TryFrom<usize> for u16

type Err = TryFromIntError

fn try_from(n: usize) -> Result<u16, TryFromIntError>

impl TryFrom<i8> for i8

type Err = Void

fn try_from(n: i8) -> Result<i8, Void>

impl TryFrom<i16> for i16

type Err = Void

fn try_from(n: i16) -> Result<i16, Void>

impl TryFrom<u32> for u128

type Err = Void

fn try_from(n: u32) -> Result<u128, Void>

impl TryFrom<u64> for isize

type Err = TryFromIntError

fn try_from(n: u64) -> Result<isize, TryFromIntError>

impl TryFrom<i16> for u32

type Err = TryFromIntError

fn try_from(n: i16) -> Result<u32, TryFromIntError>

impl TryFrom<i128> for u32

type Err = TryFromIntError

fn try_from(n: i128) -> Result<u32, TryFromIntError>

impl TryFrom<i32> for isize

type Err = Void

fn try_from(n: i32) -> Result<isize, Void>

impl TryFrom<u8> for i64

type Err = Void

fn try_from(n: u8) -> Result<i64, Void>

impl TryFrom<isize> for u64

type Err = TryFromIntError

fn try_from(n: isize) -> Result<u64, TryFromIntError>

impl TryFrom<u32> for isize

type Err = TryFromIntError

fn try_from(n: u32) -> Result<isize, TryFromIntError>

impl TryFrom<i16> for i32

type Err = Void

fn try_from(n: i16) -> Result<i32, Void>

impl TryFrom<i16> for i8

type Err = TryFromIntError

fn try_from(n: i16) -> Result<i8, TryFromIntError>

impl TryFrom<isize> for i8

type Err = TryFromIntError

fn try_from(n: isize) -> Result<i8, TryFromIntError>

impl TryFrom<usize> for char

type Err = TryFromIntToCharError

fn try_from(n: usize) -> Result<char, TryFromIntToCharError>

impl TryFrom<u16> for u32

type Err = Void

fn try_from(n: u16) -> Result<u32, Void>

impl TryFrom<i64> for i64

type Err = Void

fn try_from(n: i64) -> Result<i64, Void>

impl TryFrom<i32> for i64

type Err = Void

fn try_from(n: i32) -> Result<i64, Void>

impl TryFrom<i128> for i16

type Err = TryFromIntError

fn try_from(n: i128) -> Result<i16, TryFromIntError>

impl TryFrom<i128> for i64

type Err = TryFromIntError

fn try_from(n: i128) -> Result<i64, TryFromIntError>

impl TryFrom<isize> for i64

type Err = Void

fn try_from(n: isize) -> Result<i64, Void>

impl TryFrom<i8> for i32

type Err = Void

fn try_from(n: i8) -> Result<i32, Void>

impl TryFrom<u128> for u128

type Err = Void

fn try_from(n: u128) -> Result<u128, Void>

impl TryFrom<i128> for isize

type Err = TryFromIntError

fn try_from(n: i128) -> Result<isize, TryFromIntError>

impl TryFrom<i128> for u8

type Err = TryFromIntError

fn try_from(n: i128) -> Result<u8, TryFromIntError>

impl TryFrom<u8> for u64

type Err = Void

fn try_from(n: u8) -> Result<u64, Void>

impl TryFrom<u128> for u8

type Err = TryFromIntError

fn try_from(n: u128) -> Result<u8, TryFromIntError>

impl TryFrom<u16> for char

type Err = TryFromIntToCharError

fn try_from(n: u16) -> Result<char, TryFromIntToCharError>

impl TryFrom<isize> for i16

type Err = TryFromIntError

fn try_from(n: isize) -> Result<i16, TryFromIntError>

impl TryFrom<i16> for char

type Err = TryFromIntToCharError

fn try_from(n: i16) -> Result<char, TryFromIntToCharError>

impl TryFrom<i128> for i8

type Err = TryFromIntError

fn try_from(n: i128) -> Result<i8, TryFromIntError>

impl TryFrom<i8> for u32

type Err = TryFromIntError

fn try_from(n: i8) -> Result<u32, TryFromIntError>

impl TryFrom<u128> for usize

type Err = TryFromIntError

fn try_from(n: u128) -> Result<usize, TryFromIntError>

impl TryFrom<u16> for i32

type Err = Void

fn try_from(n: u16) -> Result<i32, Void>

impl TryFrom<u32> for usize

type Err = Void

fn try_from(n: u32) -> Result<usize, Void>

impl TryFrom<i8> for i16

type Err = Void

fn try_from(n: i8) -> Result<i16, Void>

impl TryFrom<i64> for u64

type Err = TryFromIntError

fn try_from(n: i64) -> Result<u64, TryFromIntError>

impl TryFrom<usize> for u64

type Err = Void

fn try_from(n: usize) -> Result<u64, Void>

impl TryFrom<u8> for u128

type Err = Void

fn try_from(n: u8) -> Result<u128, Void>

impl TryFrom<u128> for i32

type Err = TryFromIntError

fn try_from(n: u128) -> Result<i32, TryFromIntError>

impl TryFrom<u8> for i16

type Err = Void

fn try_from(n: u8) -> Result<i16, Void>

impl TryFrom<u8> for i32

type Err = Void

fn try_from(n: u8) -> Result<i32, Void>

impl TryFrom<u128> for u32

type Err = TryFromIntError

fn try_from(n: u128) -> Result<u32, TryFromIntError>

impl TryFrom<u8> for usize

type Err = Void

fn try_from(n: u8) -> Result<usize, Void>

impl TryFrom<i32> for u8

type Err = TryFromIntError

fn try_from(n: i32) -> Result<u8, TryFromIntError>

impl TryFrom<i8> for char

type Err = TryFromIntToCharError

fn try_from(n: i8) -> Result<char, TryFromIntToCharError>

impl TryFrom<i64> for u128

type Err = TryFromIntError

fn try_from(n: i64) -> Result<u128, TryFromIntError>

impl TryFrom<u32> for i64

type Err = Void

fn try_from(n: u32) -> Result<i64, Void>

impl TryFrom<u64> for u16

type Err = TryFromIntError

fn try_from(n: u64) -> Result<u16, TryFromIntError>

impl TryFrom<i128> for u128

type Err = TryFromIntError

fn try_from(n: i128) -> Result<u128, TryFromIntError>

impl TryFrom<usize> for i16

type Err = TryFromIntError

fn try_from(n: usize) -> Result<i16, TryFromIntError>

impl TryFrom<i16> for u64

type Err = TryFromIntError

fn try_from(n: i16) -> Result<u64, TryFromIntError>

impl TryFrom<i16> for u16

type Err = TryFromIntError

fn try_from(n: i16) -> Result<u16, TryFromIntError>

impl TryFrom<isize> for isize

type Err = Void

fn try_from(n: isize) -> Result<isize, Void>

Loading content...

Implementors

impl TryFrom<Element> for Bind

type Err = Error

fn try_from(elem: Element) -> Result<Bind, Error>

impl TryFrom<Element> for ChatState

type Err = Error

fn try_from(elem: Element) -> Result<ChatState, Error>

impl TryFrom<Element> for JingleMI

type Err = Error

fn try_from(elem: Element) -> Result<JingleMI, Error>

impl TryFrom<Element> for MoodEnum

type Err = Error

fn try_from(elem: Element) -> Result<MoodEnum, Error>

impl TryFrom<Element> for Actor

type Err = Error

fn try_from(elem: Element) -> Result<Actor, Error>

impl TryFrom<Element> for Status

type Err = Error

fn try_from(elem: Element) -> Result<Status, Error>

impl TryFrom<Element> for PubSubEvent

type Err = Error

fn try_from(elem: Element) -> Result<PubSubEvent, Error>

impl TryFrom<Element> for PubSub

type Err = Error

fn try_from(elem: Element) -> Result<PubSub, Error>

impl TryFrom<Element> for xmpp_parsers::sasl::DefinedCondition

type Err = Error

fn try_from(elem: Element) -> Result<DefinedCondition, Error>

impl TryFrom<Element> for xmpp_parsers::stanza_error::DefinedCondition

type Err = Error

fn try_from(elem: Element) -> Result<DefinedCondition, Error>

impl TryFrom<Element> for Attention

type Err = Error

fn try_from(elem: Element) -> Result<Attention, Error>

impl TryFrom<Element> for Block

type Err = Error

fn try_from(elem: Element) -> Result<Block, Error>

impl TryFrom<Element> for Blocked

type Err = Error

fn try_from(elem: Element) -> Result<Blocked, Error>

impl TryFrom<Element> for BlocklistRequest

type Err = Error

fn try_from(elem: Element) -> Result<BlocklistRequest, Error>

impl TryFrom<Element> for BlocklistResult

type Err = Error

fn try_from(elem: Element) -> Result<BlocklistResult, Error>

impl TryFrom<Element> for Unblock

type Err = Error

fn try_from(elem: Element) -> Result<Unblock, Error>

impl TryFrom<Element> for Conference

type Err = Error

fn try_from(elem: Element) -> Result<Conference, Error>

impl TryFrom<Element> for Storage

type Err = Error

fn try_from(elem: Element) -> Result<Storage, Error>

impl TryFrom<Element> for Url

type Err = Error

fn try_from(elem: Element) -> Result<Url, Error>

impl TryFrom<Element> for Caps

type Err = Error

fn try_from(elem: Element) -> Result<Caps, Error>

impl TryFrom<Element> for Handshake

type Err = Error

fn try_from(elem: Element) -> Result<Handshake, Error>

impl TryFrom<Element> for DataForm

type Err = Error

fn try_from(elem: Element) -> Result<DataForm, Error>

impl TryFrom<Element> for Field

type Err = Error

fn try_from(elem: Element) -> Result<Field, Error>

impl TryFrom<Element> for Option_

type Err = Error

fn try_from(elem: Element) -> Result<Option_, Error>

impl TryFrom<Element> for Delay

type Err = Error

fn try_from(elem: Element) -> Result<Delay, Error>

impl TryFrom<Element> for DiscoInfoQuery

type Err = Error

fn try_from(elem: Element) -> Result<DiscoInfoQuery, Error>

impl TryFrom<Element> for DiscoInfoResult

type Err = Error

fn try_from(elem: Element) -> Result<DiscoInfoResult, Error>

impl TryFrom<Element> for DiscoItemsQuery

type Err = Error

fn try_from(elem: Element) -> Result<DiscoItemsQuery, Error>

impl TryFrom<Element> for DiscoItemsResult

type Err = Error

fn try_from(elem: Element) -> Result<DiscoItemsResult, Error>

impl TryFrom<Element> for Feature

type Err = Error

fn try_from(elem: Element) -> Result<Feature, Error>

impl TryFrom<Element> for Identity

type Err = Error

fn try_from(elem: Element) -> Result<Identity, Error>

impl TryFrom<Element> for xmpp_parsers::disco::Item

type Err = Error

fn try_from(elem: Element) -> Result<Item, Error>

impl TryFrom<Element> for ECaps2

type Err = Error

fn try_from(elem: Element) -> Result<ECaps2, Error>

impl TryFrom<Element> for ExplicitMessageEncryption

type Err = Error

fn try_from(elem: Element) -> Result<ExplicitMessageEncryption, Error>

impl TryFrom<Element> for Forwarded

type Err = Error

fn try_from(elem: Element) -> Result<Forwarded, Error>

impl TryFrom<Element> for Hash

type Err = Error

fn try_from(elem: Element) -> Result<Hash, Error>

impl TryFrom<Element> for Close

type Err = Error

fn try_from(elem: Element) -> Result<Close, Error>

impl TryFrom<Element> for Data

type Err = Error

fn try_from(elem: Element) -> Result<Data, Error>

impl TryFrom<Element> for xmpp_parsers::ibb::Open

type Err = Error

fn try_from(elem: Element) -> Result<Open, Error>

impl TryFrom<Element> for xmpp_parsers::ibr::Query

type Err = Error

fn try_from(elem: Element) -> Result<Query, Error>

impl TryFrom<Element> for Idle

type Err = Error

fn try_from(elem: Element) -> Result<Idle, Error>

impl TryFrom<Element> for Iq

type Err = Error

fn try_from(root: Element) -> Result<Iq, Error>

impl TryFrom<Element> for Content

type Err = Error

fn try_from(elem: Element) -> Result<Content, Error>

impl TryFrom<Element> for Jingle

type Err = Error

fn try_from(root: Element) -> Result<Jingle, Error>

impl TryFrom<Element> for ReasonElement

type Err = Error

fn try_from(elem: Element) -> Result<ReasonElement, Error>

impl TryFrom<Element> for Checksum

type Err = Error

fn try_from(elem: Element) -> Result<Checksum, Error>

impl TryFrom<Element> for Description

type Err = Error

fn try_from(elem: Element) -> Result<Description, Error>

impl TryFrom<Element> for File

type Err = Error

fn try_from(elem: Element) -> Result<File, Error>

impl TryFrom<Element> for Range

type Err = Error

fn try_from(elem: Element) -> Result<Range, Error>

impl TryFrom<Element> for xmpp_parsers::jingle_ft::Received

type Err = Error

fn try_from(elem: Element) -> Result<Received, Error>

impl TryFrom<Element> for xmpp_parsers::jingle_ibb::Transport

type Err = Error

fn try_from(elem: Element) -> Result<Transport, Error>

impl TryFrom<Element> for Candidate

type Err = Error

fn try_from(elem: Element) -> Result<Candidate, Error>

impl TryFrom<Element> for xmpp_parsers::jingle_s5b::Transport

type Err = Error

fn try_from(elem: Element) -> Result<Transport, Error>

impl TryFrom<Element> for Fin

type Err = Error

fn try_from(elem: Element) -> Result<Fin, Error>

impl TryFrom<Element> for Prefs

type Err = Error

fn try_from(elem: Element) -> Result<Prefs, Error>

impl TryFrom<Element> for xmpp_parsers::mam::Query

type Err = Error

fn try_from(elem: Element) -> Result<Query, Error>

impl TryFrom<Element> for Result_

type Err = Error

fn try_from(elem: Element) -> Result<Result_, Error>

impl TryFrom<Element> for MediaElement

type Err = Error

fn try_from(elem: Element) -> Result<MediaElement, Error>

impl TryFrom<Element> for URI

type Err = Error

fn try_from(elem: Element) -> Result<URI, Error>

impl TryFrom<Element> for Body

type Err = Error

fn try_from(elem: Element) -> Result<Body, Error>

impl TryFrom<Element> for Message

type Err = Error

fn try_from(root: Element) -> Result<Message, Error>

impl TryFrom<Element> for Subject

type Err = Error

fn try_from(elem: Element) -> Result<Subject, Error>

impl TryFrom<Element> for Thread

type Err = Error

fn try_from(elem: Element) -> Result<Thread, Error>

impl TryFrom<Element> for Replace

type Err = Error

fn try_from(elem: Element) -> Result<Replace, Error>

impl TryFrom<Element> for Text

type Err = Error

fn try_from(elem: Element) -> Result<Text, Error>

impl TryFrom<Element> for History

type Err = Error

fn try_from(elem: Element) -> Result<History, Error>

impl TryFrom<Element> for Muc

type Err = Error

fn try_from(elem: Element) -> Result<Muc, Error>

impl TryFrom<Element> for Continue

type Err = Error

fn try_from(elem: Element) -> Result<Continue, Error>

impl TryFrom<Element> for xmpp_parsers::muc::user::Item

type Err = Error

fn try_from(elem: Element) -> Result<Item, Error>

impl TryFrom<Element> for MucUser

type Err = Error

fn try_from(elem: Element) -> Result<MucUser, Error>

impl TryFrom<Element> for Reason

type Err = Error

fn try_from(elem: Element) -> Result<Reason, Error>

impl TryFrom<Element> for Nick

type Err = Error

fn try_from(elem: Element) -> Result<Nick, Error>

impl TryFrom<Element> for Ping

type Err = Error

fn try_from(elem: Element) -> Result<Ping, Error>

impl TryFrom<Element> for Presence

type Err = Error

fn try_from(root: Element) -> Result<Presence, Error>

impl TryFrom<Element> for xmpp_parsers::pubsub::event::Item

type Err = Error

fn try_from(elem: Element) -> Result<Item, Error>

impl TryFrom<Element> for Affiliation

type Err = Error

fn try_from(elem: Element) -> Result<Affiliation, Error>

impl TryFrom<Element> for Affiliations

type Err = Error

fn try_from(elem: Element) -> Result<Affiliations, Error>

impl TryFrom<Element> for Configure

type Err = Error

fn try_from(elem: Element) -> Result<Configure, Error>

impl TryFrom<Element> for Create

type Err = Error

fn try_from(elem: Element) -> Result<Create, Error>

impl TryFrom<Element> for Default

type Err = Error

fn try_from(elem: Element) -> Result<Default, Error>

impl TryFrom<Element> for xmpp_parsers::pubsub::pubsub::Item

type Err = Error

fn try_from(elem: Element) -> Result<Item, Error>

impl TryFrom<Element> for Items

type Err = Error

fn try_from(elem: Element) -> Result<Items, Error>

impl TryFrom<Element> for Options

type Err = Error

fn try_from(elem: Element) -> Result<Options, Error>

impl TryFrom<Element> for Publish

type Err = Error

fn try_from(elem: Element) -> Result<Publish, Error>

impl TryFrom<Element> for PublishOptions

type Err = Error

fn try_from(elem: Element) -> Result<PublishOptions, Error>

impl TryFrom<Element> for Retract

type Err = Error

fn try_from(elem: Element) -> Result<Retract, Error>

impl TryFrom<Element> for Subscribe

type Err = Error

fn try_from(elem: Element) -> Result<Subscribe, Error>

impl TryFrom<Element> for SubscribeOptions

type Err = Error

fn try_from(elem: Element) -> Result<Self, Error>

impl TryFrom<Element> for SubscriptionElem

type Err = Error

fn try_from(elem: Element) -> Result<SubscriptionElem, Error>

impl TryFrom<Element> for Subscriptions

type Err = Error

fn try_from(elem: Element) -> Result<Subscriptions, Error>

impl TryFrom<Element> for Unsubscribe

type Err = Error

fn try_from(elem: Element) -> Result<Unsubscribe, Error>

impl TryFrom<Element> for xmpp_parsers::receipts::Received

type Err = Error

fn try_from(elem: Element) -> Result<Received, Error>

impl TryFrom<Element> for Request

type Err = Error

fn try_from(elem: Element) -> Result<Request, Error>

impl TryFrom<Element> for Group

type Err = Error

fn try_from(elem: Element) -> Result<Group, Error>

impl TryFrom<Element> for xmpp_parsers::roster::Item

type Err = Error

fn try_from(elem: Element) -> Result<Item, Error>

impl TryFrom<Element> for Roster

type Err = Error

fn try_from(elem: Element) -> Result<Roster, Error>

impl TryFrom<Element> for SetQuery

type Err = Error

fn try_from(elem: Element) -> Result<SetQuery, Error>

impl TryFrom<Element> for SetResult

type Err = Error

fn try_from(elem: Element) -> Result<SetResult, Error>

impl TryFrom<Element> for Abort

type Err = Error

fn try_from(elem: Element) -> Result<Abort, Error>

impl TryFrom<Element> for Auth

type Err = Error

fn try_from(elem: Element) -> Result<Auth, Error>

impl TryFrom<Element> for Challenge

type Err = Error

fn try_from(elem: Element) -> Result<Challenge, Error>

impl TryFrom<Element> for Failure

type Err = Error

fn try_from(root: Element) -> Result<Failure, Error>

impl TryFrom<Element> for Response

type Err = Error

fn try_from(elem: Element) -> Result<Response, Error>

impl TryFrom<Element> for Success

type Err = Error

fn try_from(elem: Element) -> Result<Success, Error>

impl TryFrom<Element> for A

type Err = Error

fn try_from(elem: Element) -> Result<A, Error>

impl TryFrom<Element> for Enable

type Err = Error

fn try_from(elem: Element) -> Result<Enable, Error>

impl TryFrom<Element> for Enabled

type Err = Error

fn try_from(elem: Element) -> Result<Enabled, Error>

impl TryFrom<Element> for Failed

type Err = Error

fn try_from(elem: Element) -> Result<Failed, Error>

impl TryFrom<Element> for R

type Err = Error

fn try_from(elem: Element) -> Result<R, Error>

impl TryFrom<Element> for Resume

type Err = Error

fn try_from(elem: Element) -> Result<Resume, Error>

impl TryFrom<Element> for Resumed

type Err = Error

fn try_from(elem: Element) -> Result<Resumed, Error>

impl TryFrom<Element> for StreamManagement

type Err = Error

fn try_from(elem: Element) -> Result<StreamManagement, Error>

impl TryFrom<Element> for StanzaError

type Err = Error

fn try_from(elem: Element) -> Result<StanzaError, Error>

impl TryFrom<Element> for OriginId

type Err = Error

fn try_from(elem: Element) -> Result<OriginId, Error>

impl TryFrom<Element> for StanzaId

type Err = Error

fn try_from(elem: Element) -> Result<StanzaId, Error>

impl TryFrom<Element> for Stream

type Err = Error

fn try_from(elem: Element) -> Result<Stream, Error>

impl TryFrom<Element> for VersionQuery

type Err = Error

fn try_from(elem: Element) -> Result<VersionQuery, Error>

impl TryFrom<Element> for VersionResult

type Err = Error

fn try_from(elem: Element) -> Result<VersionResult, Error>

impl TryFrom<Element> for xmpp_parsers::websocket::Open

type Err = Error

fn try_from(elem: Element) -> Result<Open, Error>

impl<'a, T> TryFrom<&'a str> for T where     T: FromStr,

type Err = <T as FromStr>::Err

fn try_from(string: &'a str) -> Result<T, <T as TryFrom<&'a str>>::Err>

impl<T> TryFrom<char> for T where     T: TryFrom<u32, Err = TryFromIntError>,

type Err = TryFromIntError

fn try_from(c: char) -> Result<T, TryFromIntError>

Loading content...