Trait mz_avro::AvroDecode

pub trait AvroDecode: Sized {
    type Out;

    // Required methods
    fn record<R: AvroRead, A: AvroRecordAccess<R>>(
        self,
        _a: &mut A,
    ) -> Result<Self::Out, AvroError>;
    fn union_branch<'a, R: AvroRead, D: AvroDeserializer>(
        self,
        _idx: usize,
        _n_variants: usize,
        _null_variant: Option<usize>,
        _deserializer: D,
        _reader: &'a mut R,
    ) -> Result<Self::Out, AvroError>;
    fn array<A: AvroArrayAccess>(
        self,
        _a: &mut A,
    ) -> Result<Self::Out, AvroError>;
    fn map<M: AvroMapAccess>(self, _m: &mut M) -> Result<Self::Out, AvroError>;
    fn enum_variant(
        self,
        _symbol: &str,
        _idx: usize,
    ) -> Result<Self::Out, AvroError>;
    fn scalar(self, _scalar: Scalar) -> Result<Self::Out, AvroError>;
    fn decimal<'a, R: AvroRead>(
        self,
        _precision: usize,
        _scale: usize,
        _r: ValueOrReader<'a, &'a [u8], R>,
    ) -> Result<Self::Out, AvroError>;
    fn bytes<'a, R: AvroRead>(
        self,
        _r: ValueOrReader<'a, &'a [u8], R>,
    ) -> Result<Self::Out, AvroError>;
    fn string<'a, R: AvroRead>(
        self,
        _r: ValueOrReader<'a, &'a str, R>,
    ) -> Result<Self::Out, AvroError>;
    fn json<'a, R: AvroRead>(
        self,
        _r: ValueOrReader<'a, &'a Value, R>,
    ) -> Result<Self::Out, AvroError>;
    fn uuid<'a, R: AvroRead>(
        self,
        _r: ValueOrReader<'a, &'a [u8], R>,
    ) -> Result<Self::Out, AvroError>;
    fn fixed<'a, R: AvroRead>(
        self,
        _r: ValueOrReader<'a, &'a [u8], R>,
    ) -> Result<Self::Out, AvroError>;

    // Provided method
    fn map_decoder<T, F: FnMut(Self::Out) -> Result<T, AvroError>>(
        self,
        f: F,
    ) -> MappingDecoder<T, Self::Out, Self, F> { ... }
}

Required Associated Types

type Out

Required Methods

fn record<R: AvroRead, A: AvroRecordAccess<R>>( self, _a: &mut A, ) -> Result<Self::Out, AvroError>

fn union_branch<'a, R: AvroRead, D: AvroDeserializer>( self, _idx: usize, _n_variants: usize, _null_variant: Option<usize>, _deserializer: D, _reader: &'a mut R, ) -> Result<Self::Out, AvroError>

fn array<A: AvroArrayAccess>(self, _a: &mut A) -> Result<Self::Out, AvroError>

fn map<M: AvroMapAccess>(self, _m: &mut M) -> Result<Self::Out, AvroError>

fn enum_variant( self, _symbol: &str, _idx: usize, ) -> Result<Self::Out, AvroError>

fn scalar(self, _scalar: Scalar) -> Result<Self::Out, AvroError>

fn decimal<'a, R: AvroRead>( self, _precision: usize, _scale: usize, _r: ValueOrReader<'a, &'a [u8], R>, ) -> Result<Self::Out, AvroError>

fn bytes<'a, R: AvroRead>( self, _r: ValueOrReader<'a, &'a [u8], R>, ) -> Result<Self::Out, AvroError>

fn string<'a, R: AvroRead>( self, _r: ValueOrReader<'a, &'a str, R>, ) -> Result<Self::Out, AvroError>

fn json<'a, R: AvroRead>( self, _r: ValueOrReader<'a, &'a Value, R>, ) -> Result<Self::Out, AvroError>

fn uuid<'a, R: AvroRead>( self, _r: ValueOrReader<'a, &'a [u8], R>, ) -> Result<Self::Out, AvroError>

fn fixed<'a, R: AvroRead>( self, _r: ValueOrReader<'a, &'a [u8], R>, ) -> Result<Self::Out, AvroError>

Provided Methods

fn map_decoder<T, F: FnMut(Self::Out) -> Result<T, AvroError>>( self, f: F, ) -> MappingDecoder<T, Self::Out, Self, F>

Object Safety

This trait is not object safe.

Implementors

impl AvroDecode for I32Decoder

type Out = i32

impl AvroDecode for I64Decoder

type Out = i64

impl AvroDecode for IsizeDecoder

type Out = isize

impl AvroDecode for TrivialDecoder

type Out = ()

impl AvroDecode for U64Decoder

type Out = u64

impl AvroDecode for UsizeDecoder

type Out = usize

impl AvroDecode for ValueDecoder

type Out = Value

impl<InnerOut, Inner: AvroDecode<Out = InnerOut>, Ctor: FnMut() -> Inner> AvroDecode for ArrayAsVecDecoder<InnerOut, Inner, Ctor>

type Out = Vec<InnerOut>

impl<T, InnerOut, Inner: AvroDecode<Out = InnerOut>, Conv: FnMut(InnerOut) -> Result<T, Error>> AvroDecode for MappingDecoder<T, InnerOut, Inner, Conv>

type Out = T

impl<T: AvroDecodable> AvroDecode for DefaultArrayAsVecDecoder<T>

type Out = Vec<T>