use std::marker::PhantomData;
use serde::{Serialize, de::DeserializeOwned};
use crate::backend::Backend;
use crate::codec::Codec;
use crate::error::StoreError;
pub struct SlotStore<B, C> {
backend: B,
_codec: PhantomData<fn() -> C>,
}
impl<B: Backend, C: Codec> SlotStore<B, C> {
pub fn new(backend: B) -> Self {
Self {
backend,
_codec: PhantomData,
}
}
pub fn backend(&self) -> &B {
&self.backend
}
pub async fn save<T: Serialize>(&self, key: &str, value: &T) -> Result<(), StoreError> {
let bytes = C::encode(value)?;
self.backend.put(key, &bytes).await
}
pub async fn load<T: DeserializeOwned>(&self, key: &str) -> Result<Option<T>, StoreError> {
match self.backend.get(key).await? {
Some(bytes) => Ok(Some(C::decode(&bytes)?)),
None => Ok(None),
}
}
pub async fn delete(&self, key: &str) -> Result<(), StoreError> {
self.backend.delete(key).await
}
pub async fn keys(&self, prefix: &str) -> Result<Vec<String>, StoreError> {
self.backend.list(prefix).await
}
}
#[cfg(all(test, feature = "json"))]
mod tests {
use super::*;
use crate::backend::MemoryBackend;
use crate::codec::JsonCodec;
use serde::Deserialize;
#[derive(Debug, PartialEq, Serialize, Deserialize)]
struct Session {
tab: String,
bpm: f32,
}
fn store() -> SlotStore<MemoryBackend, JsonCodec> {
SlotStore::new(MemoryBackend::new())
}
#[test]
fn save_then_load_round_trips() {
pollster::block_on(async {
let s = store();
let session = Session {
tab: "Practice".into(),
bpm: 96.0,
};
s.save("session", &session).await.unwrap();
let back: Option<Session> = s.load("session").await.unwrap();
assert_eq!(back, Some(session));
});
}
#[test]
fn missing_slot_is_none() {
pollster::block_on(async {
let s = store();
let back: Option<Session> = s.load("absent").await.unwrap();
assert_eq!(back, None);
});
}
#[test]
fn save_overwrites() {
pollster::block_on(async {
let s = store();
s.save("k", &1u32).await.unwrap();
s.save("k", &2u32).await.unwrap();
assert_eq!(s.load::<u32>("k").await.unwrap(), Some(2));
});
}
#[test]
fn delete_clears() {
pollster::block_on(async {
let s = store();
s.save("k", &1u32).await.unwrap();
s.delete("k").await.unwrap();
assert_eq!(s.load::<u32>("k").await.unwrap(), None);
});
}
#[test]
fn keys_lists_by_prefix() {
pollster::block_on(async {
let s = store();
s.save("note/a", &1u32).await.unwrap();
s.save("note/b", &2u32).await.unwrap();
s.save("other", &3u32).await.unwrap();
let mut keys = s.keys("note/").await.unwrap();
keys.sort();
assert_eq!(keys, vec!["note/a".to_string(), "note/b".to_string()]);
});
}
}