Remove needless traits along with async-trait usage

Cargo.toml

@@ -22,7 +22,7 @@ default = ["atomic64", "quanta"]
 sync = []
 
 # Enable this feature to use `moka::future::Cache`.
-future = ["async-lock", "async-trait", "event-listener", "futures-util"]
+future = ["async-lock", "event-listener", "futures-util"]
 
 # Enable this feature to activate optional logging from caches.
 # Currently cache will emit log only when it encounters a panic in user provided
@@ -60,7 +60,6 @@ quanta = { version = "0.12.2", optional = true }
 
 # Optional dependencies (future)
 async-lock = { version = "3.3", optional = true }
-async-trait = { version = "0.1.58", optional = true }
 event-listener = { version = "5.3", optional = true }
 futures-util = { version = "0.3.17", optional = true }
 

src/future/base_cache.rs

@@ -1,6 +1,6 @@
 use super::{
- housekeeper::{Housekeeper, InnerSync},
- invalidator::{GetOrRemoveEntry, Invalidator, KeyDateLite, PredicateFun},
+ housekeeper::Housekeeper,
+ invalidator::{Invalidator, KeyDateLite, PredicateFun},
  key_lock::{KeyLock, KeyLockMap},
  notifier::RemovalNotifier,
  InterruptedOp, PredicateId,
@@ -36,7 +36,6 @@ use crate::{
 use common::concurrent::debug_counters::CacheDebugStats;
 
 use async_lock::{Mutex, MutexGuard, RwLock};
-use async_trait::async_trait;
 use crossbeam_channel::{Receiver, Sender, TrySendError};
 use crossbeam_utils::atomic::AtomicCell;
 use futures_util::future::BoxFuture;
@@ -384,7 +383,7 @@ where
 
  #[inline]
  pub(crate) async fn apply_reads_writes_if_needed(
- inner: &Arc<impl InnerSync + Send + Sync + 'static>,
+ inner: &Arc<Inner<K, V, S>>,
  ch: &Sender<WriteOp<K, V>>,
  now: Instant,
  housekeeper: Option<&HouseKeeperArc>,
@@ -620,7 +619,7 @@ where
 
  #[inline]
  pub(crate) async fn schedule_write_op(
- inner: &Arc<impl InnerSync + Send + Sync + 'static>,
+ inner: &Arc<Inner<K, V, S>>,
  ch: &Sender<WriteOp<K, V>>,
  ch_ready_event: &event_listener::Event<()>,
  op: WriteOp<K, V>,
@@ -1042,15 +1041,15 @@ pub(crate) struct Inner<K, V, S> {
  max_capacity: Option<u64>,
  entry_count: AtomicCell<u64>,
  weighted_size: AtomicCell<u64>,
- cache: CacheStore<K, V, S>,
+ pub(crate) cache: CacheStore<K, V, S>,
  build_hasher: S,
  deques: Mutex<Deques<K>>,
  timer_wheel: Mutex<TimerWheel<K>>,
  frequency_sketch: RwLock<FrequencySketch>,
  frequency_sketch_enabled: AtomicBool,
  read_op_ch: Receiver<ReadOp<K, V>>,
  write_op_ch: Receiver<WriteOp<K, V>>,
- write_op_ch_ready_event: event_listener::Event,
+ pub(crate) write_op_ch_ready_event: event_listener::Event,
  eviction_policy: EvictionPolicyConfig,
  expiration_policy: ExpirationPolicy<K, V>,
  valid_after: AtomicInstant,
@@ -1101,7 +1100,7 @@ impl<K, V, S> Inner<K, V, S> {
  }
 
  #[inline]
- fn is_removal_notifier_enabled(&self) -> bool {
+ pub(crate) fn is_removal_notifier_enabled(&self) -> bool {
  self.removal_notifier.is_some()
  }
 
@@ -1118,7 +1117,7 @@ impl<K, V, S> Inner<K, V, S> {
  )
  }
 
- fn maybe_key_lock(&self, key: &Arc<K>) -> Option<KeyLock<'_, K, S>>
+ pub(crate) fn maybe_key_lock(&self, key: &Arc<K>) -> Option<KeyLock<'_, K, S>>
  where
  K: Hash + Eq,
  S: BuildHasher,
@@ -1127,7 +1126,7 @@ impl<K, V, S> Inner<K, V, S> {
  }
 
  #[inline]
- fn current_time_from_expiration_clock(&self) -> Instant {
+ pub(crate) fn current_time_from_expiration_clock(&self) -> Instant {
  if self.clocks.has_expiration_clock.load(Ordering::Relaxed) {
  Instant::new(
  self.clocks
@@ -1191,7 +1190,7 @@ impl<K, V, S> Inner<K, V, S>
 where
  K: Hash + Eq + Send + Sync + 'static,
  V: Send + Sync + 'static,
- S: BuildHasher + Clone,
+ S: BuildHasher + Send + Sync + Clone + 'static,
 {
  // Disable a Clippy warning for having more than seven arguments.
  // https://rust-lang.github.io/rust-clippy/master/index.html#too_many_arguments
@@ -1354,83 +1353,14 @@ where
  }
 }
 
-#[async_trait]
-impl<K, V, S> GetOrRemoveEntry<K, V> for Inner<K, V, S>
-where
- K: Hash + Eq,
- S: BuildHasher + Send + Sync + 'static,
-{
- fn get_value_entry(&self, key: &Arc<K>, hash: u64) -> Option<TrioArc<ValueEntry<K, V>>> {
- self.cache.get(hash, |k| k == key)
- }
-
- async fn remove_key_value_if<F>(
- &self,
- key: &Arc<K>,
- hash: u64,
- condition: F,
- ) -> Option<TrioArc<ValueEntry<K, V>>>
- where
- K: Send + Sync + 'static,
- V: Clone + Send + Sync + 'static,
- F: for<'a, 'b> FnMut(&'a Arc<K>, &'b TrioArc<ValueEntry<K, V>>) -> bool + Send,
- {
- // Lock the key for removal if blocking removal notification is enabled.
- let kl = self.maybe_key_lock(key);
- let _klg = if let Some(lock) = &kl {
- Some(lock.lock().await)
- } else {
- None
- };
-
- let maybe_entry = self.cache.remove_if(hash, |k| k == key, condition);
- if let Some(entry) = &maybe_entry {
- if self.is_removal_notifier_enabled() {
- self.notify_single_removal(Arc::clone(key), entry, RemovalCause::Explicit)
- .await;
- }
- }
- maybe_entry
- }
-}
-
-#[async_trait]
-impl<K, V, S> InnerSync for Inner<K, V, S>
-where
- K: Hash + Eq + Send + Sync + 'static,
- V: Clone + Send + Sync + 'static,
- S: BuildHasher + Clone + Send + Sync + 'static,
-{
- /// Runs the pending tasks. Returns `true` if there are more entries to evict.
- async fn run_pending_tasks(
- &self,
- timeout: Option<Duration>,
- max_log_sync_repeats: u32,
- eviction_batch_size: u32,
- ) -> bool {
- self.do_run_pending_tasks(timeout, max_log_sync_repeats, eviction_batch_size)
- .await
- }
-
- /// Notifies all the async tasks waiting in `BaseCache::schedule_write_op` method
- /// for the write op channel to have enough room.
- fn notify_write_op_ch_is_ready(&self) {
- self.write_op_ch_ready_event.notify(usize::MAX);
- }
-
- fn now(&self) -> Instant {
- self.current_time_from_expiration_clock()
- }
-}
-
 impl<K, V, S> Inner<K, V, S>
 where
  K: Hash + Eq + Send + Sync + 'static,
  V: Clone + Send + Sync + 'static,
  S: BuildHasher + Clone + Send + Sync + 'static,
 {
  /// Runs the pending tasks. Returns `true` if there are more entries to evict.
- async fn do_run_pending_tasks(
+ pub(crate) async fn do_run_pending_tasks(
  &self,
  timeout: Option<Duration>,
  max_log_sync_repeats: u32,
@@ -2643,7 +2573,7 @@ where
  K: Send + Sync + 'static,
  V: Clone + Send + Sync + 'static,
 {
- async fn notify_single_removal(
+ pub(crate) async fn notify_single_removal(
  &self,
  key: Arc<K>,
  entry: &TrioArc<ValueEntry<K, V>>,

src/future/cache.rs

@@ -1,6 +1,6 @@
 use super::{
  base_cache::BaseCache,
- value_initializer::{GetOrInsert, InitResult, ValueInitializer},
+ value_initializer::{InitResult, ValueInitializer},
  CacheBuilder, CancelGuard, Iter, OwnedKeyEntrySelector, PredicateId, RefKeyEntrySelector,
  WriteOp,
 };
@@ -15,7 +15,6 @@ use crate::{
 #[cfg(feature = "unstable-debug-counters")]
 use crate::common::concurrent::debug_counters::CacheDebugStats;
 
-use async_trait::async_trait;
 use std::{
  borrow::Borrow,
  collections::hash_map::RandomState,
@@ -631,7 +630,7 @@ use std::sync::atomic::{AtomicBool, Ordering};
 /// [builder-name-method]: ./struct.CacheBuilder.html#method.name
 ///
 pub struct Cache<K, V, S = RandomState> {
- base: BaseCache<K, V, S>,
+ pub(crate) base: BaseCache<K, V, S>,
  value_initializer: Arc<ValueInitializer<K, V, S>>,
 
  #[cfg(test)]
@@ -1806,7 +1805,7 @@ where
  }
  }
 
- async fn insert_with_hash(&self, key: Arc<K>, hash: u64, value: V) {
+ pub(crate) async fn insert_with_hash(&self, key: Arc<K>, hash: u64, value: V) {
  if self.base.is_map_disabled() {
  return;
  }
@@ -1901,7 +1900,12 @@ where
  }
  }
 
- async fn invalidate_with_hash<Q>(&self, key: &Q, hash: u64, need_value: bool) -> Option<V>
+ pub(crate) async fn invalidate_with_hash<Q>(
+ &self,
+ key: &Q,
+ hash: u64,
+ need_value: bool,
+ ) -> Option<V>
  where
  K: Borrow<Q>,
  Q: Hash + Eq + ?Sized,
@@ -2015,44 +2019,6 @@ where
  }
 }
 
-#[async_trait]
-impl<K, V, S> GetOrInsert<K, V> for Cache<K, V, S>
-where
- K: Hash + Eq + Send + Sync + 'static,
- V: Clone + Send + Sync + 'static,
- S: BuildHasher + Clone + Send + Sync + 'static,
-{
- async fn get_without_recording<I>(
- &self,
- key: &Arc<K>,
- hash: u64,
- replace_if: Option<&mut I>,
- ) -> Option<V>
- where
- I: for<'i> FnMut(&'i V) -> bool + Send,
- {
- self.base
- .get_with_hash(key, hash, replace_if, false, false)
- .await
- .map(Entry::into_value)
- }
-
- async fn get_entry(&self, key: &Arc<K>, hash: u64) -> Option<Entry<K, V>> {
- let ignore_if = None as Option<&mut fn(&V) -> bool>;
- self.base
- .get_with_hash(key, hash, ignore_if, true, true)
- .await
- }
-
- async fn insert(&self, key: Arc<K>, hash: u64, value: V) {
- self.insert_with_hash(key.clone(), hash, value).await;
- }
-
- async fn remove(&self, key: &Arc<K>, hash: u64) -> Option<V> {
- self.invalidate_with_hash(key, hash, true).await
- }
-}
-
 // For unit tests.
 // For unit tests.
 #[cfg(test)]