Enum rand_core::ErrorKind

pub enum ErrorKind {
    Unavailable,
    Unexpected,
    Transient,
    NotReady,
    // some variants omitted
}

Error kind which can be matched over.

Variants

Unavailable

Feature is not available; not recoverable.

This is the most permanent failure type and implies the error cannot be resolved simply by retrying (e.g. the feature may not exist in this build of the application or on the current platform).

Unexpected

General failure; there may be a chance of recovery on retry.

This is the catch-all kind for errors from known and unknown sources which do not have a more specific kind / handling method.

It is suggested to retry a couple of times or retry later when handling; some error sources may be able to resolve themselves, although this is not likely.

Transient

A transient failure which likely can be resolved or worked around.

This error kind exists for a few specific cases where it is known that the error likely can be resolved internally, but is reported anyway.

NotReady

Not ready yet: recommended to try again a little later.

This error kind implies the generator needs more time or needs some other part of the application to do something else first before it is ready for use; for example this may be used by external generators which require time for initialization.

Implementations

impl ErrorKind

pub fn should_retry(self) -> bool

True if this kind of error may resolve itself on retry.

See also should_wait().

pub fn should_wait(self) -> bool

True if we should retry but wait before retrying

This implies should_retry() is true.

pub fn description(self) -> &'static str

A description of this error kind

Trait Implementations

impl Clone for ErrorKind

fn clone(&self) -> ErrorKind

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Copy for ErrorKind

impl Debug for ErrorKind

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

Formats the value using the given formatter.

impl Eq for ErrorKind

impl PartialEq<ErrorKind> for ErrorKind

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.