use alloc::sync::Arc;
use core::sync::atomic::{AtomicU8, Ordering};
use super::error::ContextError;
use super::{STATE_ACTIVE, STATE_FAILED, STATE_SHUTDOWN, STATE_SHUTTING_DOWN};
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
pub enum DistributedContextState {
Active,
ShuttingDown,
Shutdown,
Failed,
}
impl DistributedContextState {
pub(super) const fn decode(value: u8) -> Self {
match value {
STATE_ACTIVE => Self::Active,
STATE_SHUTTING_DOWN => Self::ShuttingDown,
STATE_SHUTDOWN => Self::Shutdown,
_ => Self::Failed,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
#[repr(u16)]
pub enum ContextFailure {
Transport = 1,
Agreement = 2,
User = 3,
Timeout = 4,
Protocol = 5,
}
impl ContextFailure {
#[cfg(feature = "std")]
pub(super) const fn from_code(code: u16) -> Self {
match code {
1 => Self::Transport,
2 => Self::Agreement,
3 => Self::User,
4 => Self::Timeout,
_ => Self::Protocol,
}
}
}
#[derive(Debug, Clone)]
pub struct DistributedContextHandle {
pub(super) state: Arc<AtomicU8>,
}
impl DistributedContextHandle {
#[must_use]
pub fn state(&self) -> DistributedContextState {
DistributedContextState::decode(self.state.load(Ordering::Acquire))
}
pub fn ensure_active(&self) -> Result<(), ContextError> {
let state = self.state();
if state == DistributedContextState::Active {
Ok(())
} else {
Err(ContextError::ContextNotActive { state })
}
}
pub fn invalidate(&self) {
self.state.store(STATE_FAILED, Ordering::Release);
}
}