#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum Known<T> {
#[default]
Unknown,
Assumed {
value: T,
at: u64,
},
Confirmed {
value: T,
at: u64,
},
}
impl<T> Known<T> {
#[must_use]
pub const fn value(&self) -> Option<&T> {
match self {
Self::Unknown => None,
Self::Assumed { value, .. } | Self::Confirmed { value, .. } => Some(value),
}
}
#[must_use]
pub fn into_value(self) -> Option<T> {
match self {
Self::Unknown => None,
Self::Assumed { value, .. } | Self::Confirmed { value, .. } => Some(value),
}
}
#[must_use]
pub const fn timestamp(&self) -> Option<u64> {
match *self {
Self::Unknown => None,
Self::Assumed { at, .. } | Self::Confirmed { at, .. } => Some(at),
}
}
#[must_use]
pub const fn is_unknown(&self) -> bool {
matches!(self, Self::Unknown)
}
#[must_use]
pub const fn is_assumed(&self) -> bool {
matches!(self, Self::Assumed { .. })
}
#[must_use]
pub const fn is_confirmed(&self) -> bool {
matches!(self, Self::Confirmed { .. })
}
#[must_use]
pub const fn value_mut(&mut self) -> Option<&mut T> {
match self {
Self::Unknown => None,
Self::Assumed { value, .. } | Self::Confirmed { value, .. } => Some(value),
}
}
#[must_use]
pub const fn as_ref(&self) -> Known<&T> {
match self {
Self::Unknown => Known::Unknown,
Self::Assumed { value, at } => Known::Assumed { value, at: *at },
Self::Confirmed { value, at } => Known::Confirmed { value, at: *at },
}
}
#[must_use]
pub fn map<U, F: FnOnce(T) -> U>(self, f: F) -> Known<U> {
match self {
Self::Unknown => Known::Unknown,
Self::Assumed { value, at } => Known::Assumed {
value: f(value),
at,
},
Self::Confirmed { value, at } => Known::Confirmed {
value: f(value),
at,
},
}
}
}
#[cfg(test)]
mod tests {
use super::Known;
#[test]
fn unknown_holds_nothing() {
let known: Known<u8> = Known::default();
assert!(known.is_unknown());
assert_eq!(known.value(), None);
assert_eq!(known.timestamp(), None);
}
#[test]
fn a_claim_carries_its_clock_reading() {
let assumed = Known::Assumed { value: 7u8, at: 12 };
let confirmed = Known::Confirmed { value: 7u8, at: 34 };
assert_eq!(assumed.timestamp(), Some(12));
assert_eq!(confirmed.timestamp(), Some(34));
assert!(assumed.is_assumed());
assert!(confirmed.is_confirmed());
assert_eq!(assumed.value(), confirmed.value());
}
#[test]
fn mapping_keeps_the_claim() {
let mapped = Known::Confirmed { value: 2u8, at: 5 }.map(u16::from);
assert_eq!(mapped, Known::Confirmed { value: 2u16, at: 5 });
assert_eq!(Known::<u8>::Unknown.map(u16::from), Known::Unknown);
}
#[test]
fn borrowing_keeps_the_claim() {
let mut held = Known::Assumed {
value: [1u8, 2, 3],
at: 9,
};
assert_eq!(held.as_ref().value(), Some(&&[1, 2, 3]));
assert_eq!(held.as_ref().timestamp(), Some(9));
if let Some(value) = held.value_mut() {
value[0] = 4;
}
assert_eq!(
held,
Known::Assumed {
value: [4, 2, 3],
at: 9
}
);
}
}