use crate::snapshot::Snapshot;
pub type LoadResult<C, X, H, E> = Result<Option<Snapshot<C, X, H>>, E>;
#[inline]
pub fn record_shallow<D>(slot: &mut Option<D>, disc: D) {
*slot = Some(disc);
}
#[inline]
pub fn record_deep<T: Clone>(slot: &mut Option<T>, value: &T) {
*slot = Some(value.clone());
}
#[inline]
pub fn restore_shallow<D, T>(last: Option<D>, default: T, restore: impl FnOnce(D) -> T) -> T {
match last {
Some(disc) => restore(disc),
None => default,
}
}
#[inline]
pub fn restore_deep<T: Clone>(last: Option<&T>, default: T) -> T {
last.cloned().unwrap_or(default)
}
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
#[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
pub enum HistoryKind {
#[default]
None,
Shallow,
Deep,
}
pub trait HistoryStore {
type Config;
type Context;
type History;
type Error;
fn load(&self) -> LoadResult<Self::Config, Self::Context, Self::History, Self::Error>;
fn save(
&mut self,
snap: &Snapshot<Self::Config, Self::Context, Self::History>,
) -> Result<(), Self::Error>;
}
pub type StoreError = core::convert::Infallible;
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct MemoryStore<C, X, H> {
snap: Option<Snapshot<C, X, H>>,
}
impl<C, X, H> MemoryStore<C, X, H> {
#[inline]
pub const fn new() -> Self {
Self { snap: None }
}
}
impl<C, X, H> HistoryStore for MemoryStore<C, X, H>
where
C: Clone,
X: Clone,
H: Clone,
{
type Config = C;
type Context = X;
type History = H;
type Error = StoreError;
fn load(&self) -> LoadResult<C, X, H, StoreError> {
Ok(self.snap.clone())
}
fn save(&mut self, snap: &Snapshot<C, X, H>) -> Result<(), StoreError> {
self.snap = Some(snap.clone());
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::{HistoryStore, MemoryStore};
use crate::snapshot::Snapshot;
#[test]
fn save_then_load() {
let mut store = MemoryStore::new();
store
.save(&Snapshot::new(1u8, 2u8, 3u8))
.expect("memory store");
let loaded = store.load().expect("memory store");
assert_eq!(loaded, Some(Snapshot::new(1, 2, 3)));
}
}