Trait Visitor 

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

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

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

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 Error

The error produced by the visitor.

type Allocator: Allocator

The allocator associated with the visitor.

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

String decoder to use.

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

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, Self::Error>

Indicates that the visited type is empty.

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

Indicates that the visited type is a bool.

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

Indicates that the visited type is a char.

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

Indicates that the visited type is a u8.

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

Indicates that the visited type is a u16.

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

Indicates that the visited type is a u32.

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

Indicates that the visited type is a u64.

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

Indicates that the visited type is a u128.

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

Indicates that the visited type is a i8.

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

Indicates that the visited type is a i16.

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

Indicates that the visited type is a i32.

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

Indicates that the visited type is a i64.

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

Indicates that the visited type is a i128.

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

Indicates that the visited type is a usize.

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

Indicates that the visited type is a isize.

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

Indicates that the visited type is a f32.

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

Indicates that the visited type is a f64.

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

Indicates that the visited type is an optional value that is absent.

fn visit_some<D>(self, decoder: D) -> Result<Self::Ok, Self::Error>

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

Indicates that the visited type is an optional value that is present.

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

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

Indicates that the visited type is a sequence.

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

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

Indicates that the visited type is a map.

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

Indicates that the visited type is string.

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

Indicates that the visited type is bytes.

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

where D: ?Sized + VariantDecoder<'de, Cx = C, Error = C::Error, Allocator = C::Allocator>,

Indicates that the visited type is a variant.

fn visit_unknown<D>(self, decoder: D) -> Result<Self::Ok, D::Error>

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

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