Trait Visitor

pub trait Visitor<'de, C: ?Sized + Context>: Sized {
    type Ok;
    type String: UnsizedVisitor<'de, C, str, Ok = Self::Ok>;
    type Bytes: UnsizedVisitor<'de, C, [u8], Ok = Self::Ok>;

    // Required method
    fn expecting(&self, f: &mut Formatter<'_>) -> Result;

    // Provided methods
    fn visit_empty(self, cx: &C) -> Result<Self::Ok, C::Error> { ... }
    fn visit_bool(self, cx: &C, _: bool) -> Result<Self::Ok, C::Error> { ... }
    fn visit_char(self, cx: &C, _: char) -> Result<Self::Ok, C::Error> { ... }
    fn visit_u8(self, cx: &C, _: u8) -> Result<Self::Ok, C::Error> { ... }
    fn visit_u16(self, cx: &C, _: u16) -> Result<Self::Ok, C::Error> { ... }
    fn visit_u32(self, cx: &C, _: u32) -> Result<Self::Ok, C::Error> { ... }
    fn visit_u64(self, cx: &C, _: u64) -> Result<Self::Ok, C::Error> { ... }
    fn visit_u128(self, cx: &C, _: u128) -> Result<Self::Ok, C::Error> { ... }
    fn visit_i8(self, cx: &C, _: i8) -> Result<Self::Ok, C::Error> { ... }
    fn visit_i16(self, cx: &C, _: i16) -> Result<Self::Ok, C::Error> { ... }
    fn visit_i32(self, cx: &C, _: i32) -> Result<Self::Ok, C::Error> { ... }
    fn visit_i64(self, cx: &C, _: i64) -> Result<Self::Ok, C::Error> { ... }
    fn visit_i128(self, cx: &C, _: i128) -> Result<Self::Ok, C::Error> { ... }
    fn visit_usize(self, cx: &C, _: usize) -> Result<Self::Ok, C::Error> { ... }
    fn visit_isize(self, cx: &C, _: isize) -> Result<Self::Ok, C::Error> { ... }
    fn visit_f32(self, cx: &C, _: f32) -> Result<Self::Ok, C::Error> { ... }
    fn visit_f64(self, cx: &C, _: f64) -> Result<Self::Ok, C::Error> { ... }
    fn visit_option<D>(self, cx: &C, _: Option<D>) -> Result<Self::Ok, C::Error>
       where D: Decoder<'de, Cx = C, Error = C::Error, Mode = C::Mode> { ... }
    fn visit_sequence<D>(
        self,
        cx: &C,
        decoder: &mut D,
    ) -> Result<Self::Ok, C::Error>
       where D: ?Sized + SequenceDecoder<'de, Cx = C> { ... }
    fn visit_map<D>(
        self,
        cx: &C,
        decoder: &mut D,
    ) -> Result<Self::Ok, <D::Cx as Context>::Error>
       where D: ?Sized + MapDecoder<'de, Cx = C> { ... }
    fn visit_string(
        self,
        cx: &C,
        hint: SizeHint,
    ) -> Result<Self::String, C::Error> { ... }
    fn visit_bytes(
        self,
        cx: &C,
        hint: SizeHint,
    ) -> Result<Self::Bytes, C::Error> { ... }
    fn visit_variant<D>(self, cx: &C, _: &mut D) -> Result<Self::Ok, C::Error>
       where D: VariantDecoder<'de, Cx = C> { ... }
    fn visit_unknown<D>(self, cx: &D::Cx, _: D) -> Result<Self::Ok, D::Error>
       where D: Decoder<'de, Cx = C, Error = C::Error, Mode = C::Mode> { ... }
}

Visitor capable of decoding any type into a value Visitor::Ok.

Each callback on this visitor indicates the type that should be decoded from the passed in decoder. A typical implementation would simply call the corresponding decoder function for the type being visited.

Required Associated Types

type Ok

The value produced by the visitor.

type String: UnsizedVisitor<'de, C, str, Ok = Self::Ok>

String decoder to use.

type Bytes: UnsizedVisitor<'de, C, [u8], Ok = Self::Ok>

Bytes decoder to use.

Required Methods

fn expecting(&self, f: &mut Formatter<'_>) -> Result

Format the human-readable message that should occur if the decoder was expecting to decode some specific kind of value.

Provided Methods

fn visit_empty(self, cx: &C) -> Result<Self::Ok, C::Error>

Indicates that the visited type is empty.

fn visit_bool(self, cx: &C, _: bool) -> Result<Self::Ok, C::Error>

Indicates that the visited type is a bool.

fn visit_char(self, cx: &C, _: char) -> Result<Self::Ok, C::Error>

Indicates that the visited type is a char.

fn visit_u8(self, cx: &C, _: u8) -> Result<Self::Ok, C::Error>

Indicates that the visited type is a u8.

fn visit_u16(self, cx: &C, _: u16) -> Result<Self::Ok, C::Error>

Indicates that the visited type is a u16.

fn visit_u32(self, cx: &C, _: u32) -> Result<Self::Ok, C::Error>

Indicates that the visited type is a u32.

fn visit_u64(self, cx: &C, _: u64) -> Result<Self::Ok, C::Error>

Indicates that the visited type is a u64.

fn visit_u128(self, cx: &C, _: u128) -> Result<Self::Ok, C::Error>

Indicates that the visited type is a u128.

fn visit_i8(self, cx: &C, _: i8) -> Result<Self::Ok, C::Error>

Indicates that the visited type is a i8.

fn visit_i16(self, cx: &C, _: i16) -> Result<Self::Ok, C::Error>

Indicates that the visited type is a i16.

fn visit_i32(self, cx: &C, _: i32) -> Result<Self::Ok, C::Error>

Indicates that the visited type is a i32.

fn visit_i64(self, cx: &C, _: i64) -> Result<Self::Ok, C::Error>

Indicates that the visited type is a i64.

fn visit_i128(self, cx: &C, _: i128) -> Result<Self::Ok, C::Error>

Indicates that the visited type is a i128.

fn visit_usize(self, cx: &C, _: usize) -> Result<Self::Ok, C::Error>

Indicates that the visited type is a usize.

fn visit_isize(self, cx: &C, _: isize) -> Result<Self::Ok, C::Error>

Indicates that the visited type is a isize.

fn visit_f32(self, cx: &C, _: f32) -> Result<Self::Ok, C::Error>

Indicates that the visited type is a f32.

fn visit_f64(self, cx: &C, _: f64) -> Result<Self::Ok, C::Error>

Indicates that the visited type is a f64.

fn visit_option<D>(self, cx: &C, _: Option<D>) -> Result<Self::Ok, C::Error>

where D: Decoder<'de, Cx = C, Error = C::Error, Mode = C::Mode>,

Indicates that the visited type is an optional type.

fn visit_sequence<D>( self, cx: &C, decoder: &mut D, ) -> Result<Self::Ok, C::Error>

where D: ?Sized + SequenceDecoder<'de, Cx = C>,

Indicates that the visited type is a sequence.

fn visit_map<D>( self, cx: &C, decoder: &mut D, ) -> Result<Self::Ok, <D::Cx as Context>::Error>

where D: ?Sized + MapDecoder<'de, Cx = C>,

Indicates that the visited type is a map.

fn visit_string(self, cx: &C, hint: SizeHint) -> Result<Self::String, C::Error>

Indicates that the visited type is string.

fn visit_bytes(self, cx: &C, hint: SizeHint) -> Result<Self::Bytes, C::Error>

Indicates that the visited type is bytes.

fn visit_variant<D>(self, cx: &C, _: &mut D) -> Result<Self::Ok, C::Error>

where D: VariantDecoder<'de, Cx = C>,

Indicates that the visited type is a variant.

fn visit_unknown<D>(self, cx: &D::Cx, _: D) -> Result<Self::Ok, D::Error>

where D: Decoder<'de, Cx = C, Error = C::Error, Mode = C::Mode>,

Indicates that the encoding does not support dynamic types.

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.

Implementors