Struct Ignore 

pub struct Ignore<A, 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, E> Ignore<A, E>

where A: Allocator,

pub fn new(alloc: A) -> Ignore<A, E>

Construct a new ignoring context.

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

where A: Allocator, E: Error,

pub fn unwrap(self) -> E

Construct an error or panic.

Trait Implementations

impl<A, E> Context for Ignore<A, E>

where A: Allocator,

type Input = E

The error type which is collected by the context.

type Error = Error

Error produced by context.

type Mark = ()

A mark during processing.

type Buf = <A as Allocator>::Buf

A growable buffer.

fn alloc(&mut self) -> <Ignore<A, E> as Context>::Buf

Allocate a buffer.

fn report<T>(&mut self, _: T) -> Error

where E: From<T>,

Report the given context error.

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

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>(&mut self, _: T) -> Error

where T: Display,

Report a message as an error.

fn adapt<E>(&mut self) -> &mut Adapt<Self, E>

where Self::Input: From<E>,

Adapt the current context so that it can convert an error from a different type convertible to the current input

fn marked_report<T>(&mut self, mark: Self::Mark, error: T) -> Self::Error

where Self::Input: From<T>,

Report the given encoding error from the given mark.

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

where T: Display,

Report an error based on a mark.

fn advance(&mut self, n: usize)

Advance the context by n bytes of input.

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

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

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

where T: Debug,

Report that an invalid variant tag was encountered.

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

where T: Debug,

The value for the given tag could not be collected.

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

Trying to decode an uninhabitable type.

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

where T: Debug,

Encountered an unsupported field tag.

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

Encountered an unsupported field tag.

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

where T: Debug,

Missing variant field required to decode.

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

Indicate that a variant tag could not be determined.

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

where V: Debug, T: Debug,

Encountered an unsupported variant field.

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

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

fn leave_struct(&mut self)

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

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

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

fn leave_enum(&mut self)

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

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

where T: Display,

Trace that we’ve entered the given named field.

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

where T: Display,

Trace that we’ve entered the given unnamed field.

fn leave_field(&mut self)

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

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

where T: Display,

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

fn leave_variant(&mut self)

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

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

where T: Display,

Trace a that a map key has been entered.

fn leave_map_key(&mut self)

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

fn enter_sequence_index(&mut self, index: usize)

Trace a sequence field.

fn leave_sequence_index(&mut self)

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

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

where A: Default,

fn default() -> Ignore<A, E>

Returns the “default value” for a type.