use std::{
hash::{DefaultHasher, Hasher as _},
marker::PhantomData,
};
use cachekit::builder::{CacheBuilder, DynCache};
use pib_client::PibClient;
use pib_service_core_types::{DataItem, Entity};
use crate::{
CACHE_POLICY, CACHE_SIZE, ClearableCache, ItemCache,
item::{AliasGetableItem, AliasUpdatableItem, GetableItem},
};
#[derive(Debug)]
pub(super) struct AliasCache<
PARENTID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
ALIAS: std::fmt::Debug + std::hash::Hash,
ID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
> {
aliases: DynCache<(PARENTID, u128), ID>,
_phantom: PhantomData<ALIAS>,
}
impl<
PARENTID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
ALIAS: std::fmt::Debug + std::hash::Hash,
ID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
> AliasCache<PARENTID, ALIAS, ID>
{
pub fn new() -> Self {
let aliases = CacheBuilder::new(CACHE_SIZE).build(CACHE_POLICY);
Self {
aliases,
_phantom: PhantomData,
}
}
pub fn clear(&mut self) {
self.aliases.clear()
}
}
fn calculate_alias_hash<ALIAS: std::hash::Hash>(alias: &ALIAS) -> u128 {
let hash_1 = {
let mut hasher = DefaultHasher::new();
alias.hash(&mut hasher);
hasher.finish()
};
let hash_2 = {
let mut hasher = DefaultHasher::new();
hasher.write_u64(0x8d82_ff44_919d_67e2);
alias.hash(&mut hasher);
hasher.finish()
};
(u128::from(hash_1) << 64) | u128::from(hash_2)
}
impl<
PARENTID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
ALIAS: std::fmt::Debug + std::hash::Hash,
ID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
> AliasCache<PARENTID, ALIAS, ID>
{
pub async fn get_by_alias<
C: PibClient,
T: AliasGetableItem<PARENTID, ID, T, ALIAS>
+ Entity<PARENTID, ID>
+ GetableItem<PARENTID, ID, T>
+ std::fmt::Debug
+ Clone,
>(
&mut self,
client: &C,
parent_id: PARENTID,
alias: ALIAS,
item_cache: &mut ItemCache<PARENTID, ID, T>,
) -> Result<DataItem<PARENTID, ID, T>, C::ClientError> {
let alias_hash = calculate_alias_hash(&alias);
let item = if let Some(id) = self.aliases.get(&(parent_id, alias_hash)) {
item_cache.get(client, parent_id, *id).await?
} else {
let item = T::get_by_alias(client, parent_id, alias).await?;
item_cache.insert(item.clone());
item
};
self.insert(&item);
Ok(item)
}
pub async fn update_by_alias<
C: PibClient,
T: AliasUpdatableItem<PARENTID, ID, T, UPDATE, ALIAS>
+ AliasGetableItem<PARENTID, ID, T, ALIAS>
+ Entity<PARENTID, ID>
+ GetableItem<PARENTID, ID, T>
+ std::fmt::Debug
+ Clone,
UPDATE,
>(
&mut self,
client: &C,
parent_id: PARENTID,
alias: ALIAS,
update_item: UPDATE,
item_cache: &mut ItemCache<PARENTID, ID, T>,
) -> Result<DataItem<PARENTID, ID, T>, C::ClientError> {
let item = T::update_by_alias(client, parent_id, alias, update_item).await?;
item_cache.insert(item.clone());
self.aliases.clear();
self.insert(&item);
Ok(item)
}
pub fn insert<
T: AliasGetableItem<PARENTID, ID, T, ALIAS>
+ Entity<PARENTID, ID>
+ GetableItem<PARENTID, ID, T>
+ std::fmt::Debug
+ Clone,
>(
&mut self,
item: &DataItem<PARENTID, ID, T>,
) {
for alias in <T as AliasGetableItem<PARENTID, ID, T, ALIAS>>::get_aliases(item) {
let alias_hash = calculate_alias_hash(&alias);
self.aliases.insert((item.parent_id, alias_hash), item.id);
}
}
}
impl<
PARENTID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
ALIAS: std::fmt::Debug + std::hash::Hash,
ID: std::fmt::Debug + Copy + Ord + std::hash::Hash,
> ClearableCache for AliasCache<PARENTID, ALIAS, ID>
{
fn clear_cache(&mut self) {
self.clear();
}
}