Struct CapturedError

pub struct CapturedError { /* private fields */ }

An instance of an error captured by a descendant component.

Implementations

impl CapturedError

pub fn new(error: impl AnyError + 'static) -> CapturedError

Create a new captured error

pub fn from_display(error: impl Display + 'static) -> CapturedError

Create a new error from a type that only implements Display. If your type implements Error, you can use CapturedError::from instead.

pub fn with_origin(self, scope: ScopeId) -> CapturedError

Mark the error as being thrown from a specific scope

pub fn show(&self) -> Option<Result<VNode, RenderError>>

Get a VNode representation of the error if the error provides one

impl CapturedError

pub fn downcast<T>(&self) -> Option<&T>

where T: 'static,

Downcast the error type into a concrete error type

Trait Implementations

impl Clone for CapturedError

fn clone(&self) -> CapturedError

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T> Context<T, CapturedError> for Option<T>

fn show( self, display_error: impl FnOnce(&CapturedError) -> Result<VNode, RenderError>, ) -> Result<T, CapturedError>

Add a visual representation of the error that the ErrorBoundary may render

fn context<C>(self, context: C) -> Result<T, CapturedError>

where C: Display + 'static,

Wrap the result additional context about the error that occurred.

fn with_context<C>( self, context: impl FnOnce() -> C, ) -> Result<T, CapturedError>

where C: Display + 'static,

Wrap the result with additional context about the error that occurred. The closure will only be run if the Result is an error.

impl Debug for CapturedError

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CapturedError

fn deserialize<D>( deserializer: D, ) -> Result<CapturedError, <D as Deserializer<'de>>::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for CapturedError

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

Formats the value using the given formatter.

impl From<CapturedError> for RenderError

fn from(e: CapturedError) -> RenderError

Converts to this type from the input type.

impl<E> From<E> for CapturedError

where E: AnyError + 'static,

fn from(error: E) -> CapturedError

Converts to this type from the input type.

impl FromStr for CapturedError

type Err = Infallible

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<CapturedError, <CapturedError as FromStr>::Err>

Parses a string s to return a value of this type.

impl PartialEq for CapturedError

fn eq(&self, other: &CapturedError) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for CapturedError

fn serialize<S>( &self, serializer: S, ) -> Result<<S as Serializer>::Ok, <S as Serializer>::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.