dd4650a
use std::future::Future;
use std::time::Duration;
use serde::Serialize;
use serde::de::DeserializeOwned;
use crate::kvcache::error::{CacheError, CacheResult};
use crate::kvcache::kv::Cache;
impl Cache {
pub async fn get_json<T: DeserializeOwned>(&self, key: &str) -> CacheResult<Option<T>> {
match self.get_bytes(key).await? {
Some(bytes) => Ok(Some(decode(key, &bytes)?)),
None => Ok(None),
}
}
pub async fn get_del_json<T: DeserializeOwned>(&self, key: &str) -> CacheResult<Option<T>> {
match self.get_del::<Vec<u8>>(key).await? {
Some(bytes) => Ok(Some(decode(key, &bytes)?)),
None => Ok(None),
}
}
pub async fn set_json<T: Serialize>(&self, key: &str, value: &T) -> CacheResult<()> {
self.set(key, encode(key, value)?).await
}
pub async fn set_json_ex<T: Serialize>(
&self,
key: &str,
value: &T,
ttl: Duration,
) -> CacheResult<()> {
self.set_ex(key, encode(key, value)?, ttl).await
}
pub async fn set_json_default<T: Serialize>(&self, key: &str, value: &T) -> CacheResult<()> {
self.set_default(key, encode(key, value)?).await
}
pub async fn set_json_nx<T: Serialize>(&self, key: &str, value: &T) -> CacheResult<bool> {
self.set_nx(key, encode(key, value)?).await
}
pub async fn set_json_nx_ex<T: Serialize>(
&self,
key: &str,
value: &T,
ttl: Duration,
) -> CacheResult<bool> {
self.set_nx_ex(key, encode(key, value)?, ttl).await
}
pub async fn get_or_set_json<T, F, Fut>(
&self,
key: &str,
ttl: Option<Duration>,
fill: F,
) -> CacheResult<T>
where
T: Serialize + DeserializeOwned,
F: FnOnce() -> Fut,
Fut: Future<Output = CacheResult<T>>,
{
if let Some(value) = self.get_json::<T>(key).await? {
return Ok(value);
}
let value = fill().await?;
match ttl {
Some(ttl) => self.set_json_ex(key, &value, ttl).await?,
None => self.set_json(key, &value).await?,
}
Ok(value)
}
pub async fn mget_json<T: DeserializeOwned>(
&self,
keys: Vec<String>,
) -> CacheResult<Vec<Option<T>>> {
let raw: Vec<Option<Vec<u8>>> = self.mget(keys.clone()).await?;
raw.iter()
.enumerate()
.map(|(index, item)| match item {
Some(bytes) => {
let key = keys.get(index).map(String::as_str).unwrap_or_default();
Ok(Some(decode(key, bytes)?))
}
None => Ok(None),
})
.collect()
}
}
pub(crate) fn encode<T: Serialize>(key: &str, value: &T) -> CacheResult<Vec<u8>> {
serde_json::to_vec(value).map_err(|error| CacheError::encode(key, error))
}
pub(crate) fn decode<T: DeserializeOwned>(key: &str, bytes: &[u8]) -> CacheResult<T> {
serde_json::from_slice(bytes).map_err(|error| CacheError::decode(key, error))
}