Struct Ignore 

pub struct Ignore<A, M, E> { /* private fields */ }

A simple non-diagnostical capturing context which ignores the error and loses all information about it (except that it happened).

Implementations

impl<A, M, E> Ignore<A, M, E>

pub fn new(alloc: A) -> Self

Construct a new ignoring context.

impl<A, M, E> Ignore<A, M, E>

where E: Error,

pub fn unwrap(self) -> E

Construct an error or panic.

Trait Implementations

impl<A, M, E: 'static> Context for Ignore<A, M, E>

where A: Allocator,

type Mode = M

Mode of the context.

type Error = ErrorMarker

Error produced by context.

type Mark = ()

A mark during processing.

type Buf<'this> = <A as Allocator>::Buf<'this> where Self: 'this

A growable buffer.

type BufString<'this> = BufString<<A as Allocator>::Buf<'this>> where Self: 'this

An allocated buffer containing a valid string.

fn clear(&self)

Clear the state of the context, allowing it to be re-used.

fn alloc(&self) -> Option<Self::Buf<'_>>

Allocate a buffer.

fn collect_string<T>( &self, value: &T, ) -> Result<Self::BufString<'_>, Self::Error>

where T: ?Sized + Display,

Collect and allocate a string from a Display implementation.

fn custom<T>(&self, _: T) -> ErrorMarker

where T: 'static + Send + Sync + Display + Debug,

Report a custom error, which is not encapsulated by the error type expected by the context. This is essentially a type-erased way of reporting error-like things out from the context.

fn message<T>(&self, _: T) -> ErrorMarker

where T: Display,

Report a message as an error.

fn decode<'de, T, D>(&self, decoder: D) -> Result<T, Self::Error>

where T: Decode<'de, Self::Mode>, D: Decoder<'de, Cx = Self, Mode = Self::Mode, Error = Self::Error>,

Decode the given input using the associated mode.

fn decode_unsized<'de, T, D, F, O>( &self, decoder: D, f: F, ) -> Result<O, Self::Error>

where T: DecodeUnsized<'de, Self::Mode> + ?Sized, D: Decoder<'de, Cx = Self, Mode = Self::Mode, Error = Self::Error>, F: FnOnce(&T) -> Result<O, <D as Decoder<'de>>::Error>,

Decode the given unsized value using the associated mode.

fn decode_bytes<'de, T, D>(&self, decoder: D) -> Result<T, Self::Error>

where T: DecodeBytes<'de, Self::Mode>, D: Decoder<'de, Cx = Self, Mode = Self::Mode, Error = Self::Error>,

Decode the given input as bytes using the associated mode.

fn decode_unsized_bytes<'de, T, D, F, O>( &self, decoder: D, f: F, ) -> Result<O, Self::Error>

where T: DecodeUnsizedBytes<'de, Self::Mode> + ?Sized, D: Decoder<'de, Cx = Self, Mode = Self::Mode, Error = Self::Error>, F: FnOnce(&T) -> Result<O, <D as Decoder<'de>>::Error>,

Decode the given unsized value as bytes using the associated mode.

fn map<T>(&self) -> impl FnOnce(T) -> Self::Error

where T: 'static + Send + Sync + Error,

Generate a map function which maps an error using the custom function.

fn map_message<T>(&self) -> impl FnOnce(T) -> Self::Error

where T: Display,

Generate a map function which maps an error using the message function.

fn marked_message<T>(&self, mark: Self::Mark, message: T) -> Self::Error

where T: Display,

Report an error based on a mark.

fn marked_custom<T>(&self, mark: Self::Mark, message: T) -> Self::Error

where T: 'static + Send + Sync + Error,

Report an error based on a mark.

fn advance(&self, n: usize)

Advance the context by n bytes of input.

fn mark(&self) -> Self::Mark

Return a mark which acts as a checkpoint at the current encoding state.

fn invalid_variant_tag<T>(&self, _: &'static str, tag: &T) -> Self::Error

where T: Debug + ?Sized,

Report that an invalid variant tag was encountered.

fn expected_tag<T>(&self, _: &'static str, tag: &T) -> Self::Error

where T: Debug + ?Sized,

The value for the given tag could not be collected.

fn uninhabitable(&self, _: &'static str) -> Self::Error

Trying to decode an uninhabitable type.

fn invalid_field_tag<T>(&self, _: &'static str, tag: &T) -> Self::Error

where T: Debug + ?Sized,

Encountered an unsupported field tag.

fn expected_field_adjacent<T, C>( &self, _: &'static str, tag: &T, content: &C, ) -> Self::Error

where T: Debug + ?Sized, C: Debug + ?Sized,

Expected another field to decode.

fn missing_adjacent_tag<T>(&self, _: &'static str, tag: &T) -> Self::Error

where T: Debug + ?Sized,

Missing adjacent tag when decoding.

fn invalid_field_string_tag( &self, _: &'static str, field: Self::Buf<'_>, ) -> Self::Error

Encountered an unsupported field tag.

fn missing_variant_field<T>(&self, name: &'static str, tag: &T) -> Self::Error

where T: Debug + ?Sized,

Missing variant field required to decode.

fn missing_variant_tag(&self, name: &'static str) -> Self::Error

Indicate that a variant tag could not be determined.

fn invalid_variant_field_tag<V, T>( &self, name: &'static str, variant: &V, tag: &T, ) -> Self::Error

where V: Debug + ?Sized, T: Debug + ?Sized,

Encountered an unsupported variant field.

fn alloc_failed(&self) -> Self::Error

Missing variant field required to decode.

fn enter_struct(&self, name: &'static str)

Indicate that we’ve entered a struct with the given name.

fn leave_struct(&self)

Trace that we’ve left the last struct that was entered.

fn enter_enum(&self, name: &'static str)

Indicate that we’ve entered an enum with the given name.

fn leave_enum(&self)

Trace that we’ve left the last enum that was entered.

fn enter_named_field<T>(&self, name: &'static str, tag: &T)

where T: Display + ?Sized,

Trace that we’ve entered the given named field.

fn enter_unnamed_field<T>(&self, index: u32, name: &T)

where T: Display + ?Sized,

Trace that we’ve entered the given unnamed field.

fn leave_field(&self)

Trace that we’ve left the last field that was entered.

fn enter_variant<T>(&self, name: &'static str, tag: T)

where T: Display,

Trace that we’ve entered the given variant in an enum.

fn leave_variant(&self)

Trace that we’ve left the last variant that was entered.

fn enter_map_key<T>(&self, field: T)

where T: Display,

Trace a that a map key has been entered.

fn leave_map_key(&self)

Trace that we’ve left the last map field that was entered.

fn enter_sequence_index(&self, index: usize)

Trace a sequence field.

fn leave_sequence_index(&self)

Trace that we’ve left the last sequence index that was entered.

impl<A, M, E> Default for Ignore<A, M, E>

where A: Default,

fn default() -> Self

Returns the “default value” for a type.