use std::sync::{
Arc,
atomic::{AtomicU64, Ordering},
};
const STATE_BITS: u32 = 8;
const STATE_MASK: u64 = (1 << STATE_BITS) - 1;
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum MqttConnectionState {
Starting,
Connected,
Subscribed,
Disconnected,
Reconnecting,
}
impl MqttConnectionState {
fn as_u8(self) -> u8 {
match self {
Self::Starting => 0,
Self::Connected => 1,
Self::Subscribed => 2,
Self::Disconnected => 3,
Self::Reconnecting => 4,
}
}
fn from_u8(value: u8) -> Self {
match value {
1 => Self::Connected,
2 => Self::Subscribed,
3 => Self::Disconnected,
4 => Self::Reconnecting,
_ => Self::Starting,
}
}
}
#[derive(Debug, Clone)]
pub struct MqttReadiness {
value: Arc<AtomicU64>,
}
impl Default for MqttReadiness {
fn default() -> Self {
Self::new()
}
}
impl MqttReadiness {
pub fn new() -> Self {
Self {
value: Arc::new(AtomicU64::new(pack(0, MqttConnectionState::Starting))),
}
}
pub fn state(&self) -> MqttConnectionState {
unpack_state(self.value.load(Ordering::SeqCst))
}
pub fn generation(&self) -> u64 {
unpack_generation(self.value.load(Ordering::SeqCst))
}
pub fn set_state(&self, state: MqttConnectionState) {
self.value
.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |value| {
Some(pack(unpack_generation(value), state))
})
.expect("readiness state update cannot fail");
}
#[doc(hidden)]
pub fn begin_generation(&self) -> u64 {
let previous = self
.value
.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |value| {
Some(pack(
unpack_generation(value).saturating_add(1),
MqttConnectionState::Starting,
))
})
.expect("readiness generation update cannot fail");
unpack_generation(previous).saturating_add(1)
}
#[doc(hidden)]
pub fn set_state_for_generation(&self, generation: u64, state: MqttConnectionState) -> bool {
let mut current = self.value.load(Ordering::SeqCst);
loop {
if unpack_generation(current) != generation {
return false;
}
match self.value.compare_exchange(
current,
pack(generation, state),
Ordering::SeqCst,
Ordering::SeqCst,
) {
Ok(_) => return true,
Err(updated) => current = updated,
}
}
}
pub fn is_ready(&self) -> bool {
self.state() == MqttConnectionState::Subscribed
}
}
fn pack(generation: u64, state: MqttConnectionState) -> u64 {
(generation << STATE_BITS) | u64::from(state.as_u8())
}
fn unpack_generation(value: u64) -> u64 {
value >> STATE_BITS
}
fn unpack_state(value: u64) -> MqttConnectionState {
MqttConnectionState::from_u8((value & STATE_MASK) as u8)
}