Trait Deserializer

pub trait Deserializer<'de, T>: Debug + Sized
where
    T: WithDeserializer<Deserializer = Self>,
{
    // Required methods
    fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, T>
       where R: XmlReader;
    fn next<R>(
        self,
        reader: &R,
        event: Event<'de>,
    ) -> DeserializerResult<'de, T>
       where R: XmlReader;
    fn finish<R>(self, reader: &R) -> Result<T, Error>
       where R: XmlReader;
}

Trait that defines a deserializer that can be used to construct a type from a XML Events.

Required Methods

fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, T>

where R: XmlReader,

Initializes a new deserializer from the passed reader and the initial event.

Errors

Returns an Error if the initialization of the deserializer failed.

fn next<R>(self, reader: &R, event: Event<'de>) -> DeserializerResult<'de, T>

where R: XmlReader,

Processes the next XML Event.

Errors

Returns an Error if processing the event failed.

fn finish<R>(self, reader: &R) -> Result<T, Error>

where R: XmlReader,

Force the deserializer to finish.

Errors

Returns an Error if the deserializer could not finish.

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<'de> Deserializer<'de, AltTypeContent> for Box<AltTypeContentDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, AltTypeContent>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, AltTypeContent>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<AltTypeContent, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, AnnotationContent> for Box<AnnotationContentDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, AnnotationContent>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, AnnotationContent>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<AnnotationContent, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, AttributeGroupTypeContent> for Box<AttributeGroupTypeContentDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, AttributeGroupTypeContent>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, AttributeGroupTypeContent>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<AttributeGroupTypeContent, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, ComplexBaseTypeContent> for Box<ComplexBaseTypeContentDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, ComplexBaseTypeContent>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, ComplexBaseTypeContent>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<ComplexBaseTypeContent, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, ComplexContentContent> for Box<ComplexContentContentDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, ComplexContentContent>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, ComplexContentContent>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<ComplexContentContent, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, ElementTypeContent> for Box<ElementTypeContentDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, ElementTypeContent>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, ElementTypeContent>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<ElementTypeContent, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, ExtensionTypeContent> for Box<ExtensionTypeContentDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, ExtensionTypeContent>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, ExtensionTypeContent>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<ExtensionTypeContent, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, Facet> for Box<FacetDeserializer>

fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, Facet>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, Facet>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<Facet, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, GroupTypeContent> for Box<GroupTypeContentDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, GroupTypeContent>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, GroupTypeContent>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<GroupTypeContent, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, OverrideContent> for Box<OverrideContentDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, OverrideContent>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, OverrideContent>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<OverrideContent, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, RedefineContent> for Box<RedefineContentDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, RedefineContent>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, RedefineContent>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<RedefineContent, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, RestrictionContent> for Box<RestrictionContentDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, RestrictionContent>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, RestrictionContent>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<RestrictionContent, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, RestrictionTypeContent> for Box<RestrictionTypeContentDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, RestrictionTypeContent>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, RestrictionTypeContent>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<RestrictionTypeContent, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, SchemaContent> for Box<SchemaContentDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, SchemaContent>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, SchemaContent>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<SchemaContent, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, SimpleBaseTypeContent> for Box<SimpleBaseTypeContentDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, SimpleBaseTypeContent>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, SimpleBaseTypeContent>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<SimpleBaseTypeContent, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, SimpleContentContent> for Box<SimpleContentContentDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, SimpleContentContent>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, SimpleContentContent>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<SimpleContentContent, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, AltType> for Box<AltTypeDeserializer>

fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, AltType>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, AltType>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<AltType, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, Annotation> for Box<AnnotationDeserializer>

fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, Annotation>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, Annotation>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<Annotation, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, Any> for Box<AnyDeserializer>

fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, Any>

where R: DeserializeReader,

fn next<R>(self, reader: &R, event: Event<'de>) -> DeserializerResult<'de, Any>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<Any, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, AnyAttribute> for Box<AnyAttributeDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, AnyAttribute>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, AnyAttribute>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<AnyAttribute, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, AssertionType> for Box<AssertionTypeDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, AssertionType>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, AssertionType>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<AssertionType, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, AttributeGroupType> for Box<AttributeGroupTypeDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, AttributeGroupType>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, AttributeGroupType>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<AttributeGroupType, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, AttributeType> for Box<AttributeTypeDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, AttributeType>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, AttributeType>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<AttributeType, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, ComplexBaseType> for Box<ComplexBaseTypeDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, ComplexBaseType>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, ComplexBaseType>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<ComplexBaseType, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, ComplexContent> for Box<ComplexContentDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, ComplexContent>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, ComplexContent>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<ComplexContent, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, DefaultOpenContent> for Box<DefaultOpenContentDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, DefaultOpenContent>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, DefaultOpenContent>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<DefaultOpenContent, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, ElementType> for Box<ElementTypeDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, ElementType>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, ElementType>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<ElementType, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, ExtensionType> for Box<ExtensionTypeDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, ExtensionType>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, ExtensionType>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<ExtensionType, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, FacetType> for Box<FacetTypeDeserializer>

fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, FacetType>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, FacetType>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<FacetType, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, Field> for Box<FieldDeserializer>

fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, Field>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, Field>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<Field, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, GroupType> for Box<GroupTypeDeserializer>

fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, GroupType>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, GroupType>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<GroupType, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, Import> for Box<ImportDeserializer>

fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, Import>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, Import>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<Import, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, Include> for Box<IncludeDeserializer>

fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, Include>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, Include>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<Include, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, KeybaseType> for Box<KeybaseTypeDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, KeybaseType>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, KeybaseType>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<KeybaseType, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, KeybaseTypeContent> for Box<KeybaseTypeContentDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, KeybaseTypeContent>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, KeybaseTypeContent>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<KeybaseTypeContent, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, Keyref> for Box<KeyrefDeserializer>

fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, Keyref>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, Keyref>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<Keyref, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, KeyrefContent> for Box<KeyrefContentDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, KeyrefContent>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, KeyrefContent>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<KeyrefContent, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, List> for Box<ListDeserializer>

fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, List>

where R: DeserializeReader,

fn next<R>(self, reader: &R, event: Event<'de>) -> DeserializerResult<'de, List>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<List, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, Notation> for Box<NotationDeserializer>

fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, Notation>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, Notation>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<Notation, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, OpenContent> for Box<OpenContentDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, OpenContent>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, OpenContent>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<OpenContent, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, Override> for Box<OverrideDeserializer>

fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, Override>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, Override>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<Override, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, Redefine> for Box<RedefineDeserializer>

fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, Redefine>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, Redefine>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<Redefine, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, Restriction> for Box<RestrictionDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, Restriction>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, Restriction>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<Restriction, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, RestrictionType> for Box<RestrictionTypeDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, RestrictionType>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, RestrictionType>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<RestrictionType, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, Schema> for Box<SchemaDeserializer>

fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, Schema>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, Schema>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<Schema, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, SimpleBaseType> for Box<SimpleBaseTypeDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, SimpleBaseType>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, SimpleBaseType>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<SimpleBaseType, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, SimpleContent> for Box<SimpleContentDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, SimpleContent>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, SimpleContent>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<SimpleContent, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, Union> for Box<UnionDeserializer>

fn init<R>(reader: &R, event: Event<'de>) -> DeserializerResult<'de, Union>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, Union>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<Union, Error>

where R: DeserializeReader,

impl<'de> Deserializer<'de, WildcardType> for Box<WildcardTypeDeserializer>

fn init<R>( reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, WildcardType>

where R: DeserializeReader,

fn next<R>( self, reader: &R, event: Event<'de>, ) -> DeserializerResult<'de, WildcardType>

where R: DeserializeReader,

fn finish<R>(self, reader: &R) -> Result<WildcardType, Error>

where R: DeserializeReader,

Implementors

impl<'de, T> Deserializer<'de, T> for ContentDeserializer<T>

where T: DeserializeBytes + Debug,