Trait mz_avro::AvroDecode

pub trait AvroDecode: Sized {
    type Out;

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

    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>

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

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

type Out = T

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

type Out = Vec<T, Global>