Enum BackendState 

pub enum BackendState {
    Uninitialized,
    Initializing,
    Ready,
    Closing,
    Closed,
    Error,
}

Backend lifecycle state.

Represents the current state of a backend in its lifecycle. Backends transition through these states during initialization, operation, and shutdown.

State Transitions

Uninitialized -> Initializing -> Ready -> Closing -> Closed
                      ↓            ↓
                    Error ←--------┘

Examples

use canlink_hal::BackendState;

let state = BackendState::Uninitialized;
assert!(!state.is_ready());

let state = BackendState::Ready;
assert!(state.is_ready());

Variants

Uninitialized

Backend has not been initialized

Initializing

Backend is currently initializing

Ready

Backend is ready for operations

Closing

Backend is closing

Closed

Backend has been closed

Error

Backend encountered an error

Implementations

impl BackendState

pub const fn is_ready(&self) -> bool

Check if the backend is ready for operations.

Examples

use canlink_hal::BackendState;

assert!(BackendState::Ready.is_ready());
assert!(!BackendState::Uninitialized.is_ready());

pub const fn is_error(&self) -> bool

Check if the backend is in an error state.

Examples

use canlink_hal::BackendState;

assert!(BackendState::Error.is_error());
assert!(!BackendState::Ready.is_error());

pub const fn is_closed(&self) -> bool

Check if the backend is closed.

Examples

use canlink_hal::BackendState;

assert!(BackendState::Closed.is_closed());
assert!(!BackendState::Ready.is_closed());

pub const fn can_operate(&self) -> bool

Check if the backend can accept operations.

Returns true only if the backend is in the Ready state.

Examples

use canlink_hal::BackendState;

assert!(BackendState::Ready.can_operate());
assert!(!BackendState::Initializing.can_operate());
assert!(!BackendState::Error.can_operate());

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

Get a human-readable description of the state.

Examples

use canlink_hal::BackendState;

assert_eq!(BackendState::Ready.description(), "Ready");
assert_eq!(BackendState::Error.description(), "Error");

Trait Implementations

impl Clone for BackendState

fn clone(&self) -> BackendState

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BackendState

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

Formats the value using the given formatter.

impl Default for BackendState

fn default() -> BackendState

Returns the “default value” for a type.

impl Display for BackendState

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

Formats the value using the given formatter.

impl Hash for BackendState

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for BackendState

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

impl Eq for BackendState

impl StructuralPartialEq for BackendState