Enum Severity 

pub enum Severity {
    Ignore,
    Trace,
    Debug,
    Info,
    Warning,
    Error,
    Panic,
}

Indicates how severe a BevyError is.

These levels correspond to traditional logging levels, but the severity is advisory metadata used by error handlers to decide how to react (for example: ignore, log, or panic).

To change the behavior of unhandled errors returned from systems, you can modify the fallback error handler, and read the Severity stored inside of each BevyError.

You can change the severity of an error (including assigning an error severity) to an ordinary result by calling with_severity or map_severity.

Variants

Ignore

The error can be safely ignored, and can be completely discarded.

Trace

The error can be ignored, unless verbose debugging is required.

Debug

The error can be safely ignored, but may need to be surfaced during debugging.

Info

Nothing has gone wrong, but the error is useful to the user and should be reported.

Warning

Something unexpected but recoverable happened.

Something has probably gone wrong.

Error

A real error occurred, but the program may continue.

Panic

A fatal error; the program cannot continue.

Trait Implementations

impl Clone for Severity

fn clone(&self) -> Severity

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Severity

impl Debug for Severity

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

Formats the value using the given formatter.

impl Eq for Severity

impl Ord for Severity

fn cmp(&self, other: &Severity) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Severity

fn eq(&self, other: &Severity) -> 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 PartialOrd for Severity

fn partial_cmp(&self, other: &Severity) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl StructuralPartialEq for Severity