use cachekit::prelude::{CacheBuilder, DynCache};
use pib_client::PibClient;
use pib_service_core_types::{DataItem, Entity};
use crate::{
CACHE_POLICY, CACHE_SIZE, ClearableCache, CreateableItem,
item::{GetableItem, PlaceableItem, UpdatableItem},
};
#[derive(Debug)]
pub(super) struct ItemCache<
PARENTID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
ID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
T: Entity<PARENTID, ID> + std::fmt::Debug + Clone,
> {
items: DynCache<ID, DataItem<PARENTID, ID, T>>,
}
impl<
PARENTID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
ID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
T: Entity<PARENTID, ID> + std::fmt::Debug + Clone,
> ItemCache<PARENTID, ID, T>
{
pub fn new() -> Self {
let items = CacheBuilder::new(CACHE_SIZE).build(CACHE_POLICY);
Self { items }
}
pub fn clear(&mut self) {
self.items.clear()
}
pub fn insert(&mut self, item: DataItem<PARENTID, ID, T>) {
self.items.insert(item.id, item);
}
pub async fn create<C: PibClient, NEWPARENTID, NEW>(
&mut self,
client: &C,
caches_to_clear: Vec<&mut dyn ClearableCache>,
parent_id: NEWPARENTID,
new_item: NEW,
) -> Result<DataItem<NEWPARENTID, ID, T>, C::ClientError>
where
T: CreateableItem<PARENTID, ID, T, NEWPARENTID, NEW> + Entity<NEWPARENTID, ID>,
PARENTID: From<NEWPARENTID>,
NEWPARENTID: Clone,
{
let created_item = T::create(client, parent_id.clone(), new_item).await?;
let cache_item = DataItem {
id: created_item.id,
parent_id: PARENTID::from(parent_id),
metadata: created_item.metadata.clone(),
value: created_item.value.clone(),
};
self.insert(cache_item);
for cache in caches_to_clear {
cache.clear_cache();
}
Ok(created_item)
}
pub async fn update<C: PibClient, UPDATE>(
&mut self,
client: &C,
parent_id: PARENTID,
id: ID,
update_item: UPDATE,
) -> Result<DataItem<PARENTID, ID, T>, C::ClientError>
where
T: UpdatableItem<PARENTID, ID, T, UPDATE>,
{
let updated_item = T::update(client, parent_id, id, update_item).await?;
self.insert(updated_item.clone());
Ok(updated_item)
}
}
impl<
PARENTID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
ID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
T: GetableItem<PARENTID, ID, T> + Entity<PARENTID, ID> + std::fmt::Debug + Clone,
> ItemCache<PARENTID, ID, T>
{
pub async fn get<C: PibClient>(
&mut self,
client: &C,
parent_id: PARENTID,
id: ID,
) -> Result<DataItem<PARENTID, ID, T>, C::ClientError> {
if let Some(item) = self.items.get(&id) {
return Ok(item.clone());
}
let item = T::get(client, parent_id, id).await?;
self.items.insert(id, item.clone());
Ok(item)
}
}
impl<
PARENTID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
ID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
T: PlaceableItem<PARENTID, ID, T> + Entity<PARENTID, ID> + std::fmt::Debug + Clone,
> ItemCache<PARENTID, ID, T>
{
pub async fn place<C: PibClient, NEWPARENTID, NEW>(
&mut self,
client: &C,
caches_to_clear: Vec<&mut dyn ClearableCache>,
parent_id: NEWPARENTID,
id: ID,
new_item: NEW,
) -> Result<DataItem<NEWPARENTID, ID, T>, C::ClientError>
where
T: PlaceableItem<PARENTID, ID, T, NEWPARENTID, NEW> + Entity<NEWPARENTID, ID>,
PARENTID: From<NEWPARENTID>,
NEWPARENTID: Clone,
{
let placed_item = T::place(client, parent_id.clone(), id, new_item).await?;
let cache_item = DataItem {
id: placed_item.id,
parent_id: PARENTID::from(parent_id),
metadata: placed_item.metadata.clone(),
value: placed_item.value.clone(),
};
self.insert(cache_item);
for cache in caches_to_clear {
cache.clear_cache();
}
Ok(placed_item)
}
}
impl<
PARENTID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
ID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
T: Entity<PARENTID, ID> + std::fmt::Debug + Clone,
> ClearableCache for ItemCache<PARENTID, ID, T>
{
fn clear_cache(&mut self) {
self.clear();
}
}