Revise definitions for ST idx

server/src/engine/idx/mod.rs

@@ -26,8 +26,8 @@
 
 use core::{borrow::Borrow, hash::Hash};
 
-mod stord;
 mod stdhm;
+mod stord;
 #[cfg(test)]
 mod tests;
 
@@ -81,11 +81,7 @@ pub struct DummyMetrics;
 
 /// The base spec for any index. Iterators have meaningless order, and that is intentional and oftentimes
 /// consequential. For more specialized impls, use the [`STIndex`], [`MTIndex`] or [`STIndexSeq`] traits
-pub trait IndexBaseSpec<K, V>
+pub trait IndexBaseSpec<K, V> {
-where
-    K: AsKey,
-    V: AsValue,
-{
     /// Index supports prealloc?
     const PREALLOC: bool;
     #[cfg(debug_assertions)]
@@ -125,11 +121,7 @@ where
 }
 
 /// An unordered MTIndex
-pub trait MTIndex<K, V>: IndexBaseSpec<K, V>
+pub trait MTIndex<K, V>: IndexBaseSpec<K, V> {
-where
-    K: AsKey,
-    V: AsValue,
-{
     /// Attempts to compact the backing storage
     fn mt_compact(&self) {}
     /// Clears all the entries in the MTIndex
@@ -137,50 +129,58 @@ where
     // write
     /// Returns true if the entry was inserted successfully; returns false if the uniqueness constraint is
     /// violated
-    fn mt_insert(&self, key: K, val: V) -> bool;
+    fn mt_insert(&self, key: K, val: V) -> bool
+    where
+        K: AsKey,
+        V: AsValue;
     /// Updates or inserts the given value
-    fn mt_upsert(&self, key: K, val: V);
+    fn mt_upsert(&self, key: K, val: V)
+    where
+        K: AsKey,
+        V: AsValue;
     // read
+    fn mt_contains<Q>(&self, key: &Q) -> bool
+    where
+        K: Borrow<Q> + AsKey,
+        Q: ?Sized + AsKeyRef;
     /// Returns a reference to the value corresponding to the key, if it exists
     fn mt_get<Q>(&self, key: &Q) -> Option<&V>
     where
-        K: Borrow<Q>,
+        K: AsKey + Borrow<Q>,
         Q: ?Sized + AsKeyRef;
     /// Returns a clone of the value corresponding to the key, if it exists
     fn mt_get_cloned<Q>(&self, key: &Q) -> Option<V>
     where
-        K: Borrow<Q>,
+        K: AsKey + Borrow<Q>,
         Q: ?Sized + AsKeyRef;
     // update
     /// Returns true if the entry is updated
     fn mt_update<Q>(&self, key: &Q, val: V) -> bool
     where
-        K: Borrow<Q>,
+        K: AsKey + Borrow<Q>,
+        V: AsValue,
         Q: ?Sized + AsKeyRef;
     /// Updates the entry and returns the old value, if it exists
     fn mt_update_return<Q>(&self, key: &Q, val: V) -> Option<V>
     where
-        K: Borrow<Q>,
+        K: AsKey + Borrow<Q>,
+        V: AsValue,
         Q: ?Sized + AsKeyRef;
     // delete
     /// Returns true if the entry was deleted
     fn mt_delete<Q>(&self, key: &Q) -> bool
     where
-        K: Borrow<Q>,
+        K: AsKey + Borrow<Q>,
         Q: ?Sized + AsKeyRef;
     /// Removes the entry and returns it, if it exists
     fn mt_delete_return<Q>(&self, key: &Q) -> Option<V>
     where
-        K: Borrow<Q>,
+        K: AsKey + Borrow<Q>,
         Q: ?Sized + AsKeyRef;
 }
 
 /// An unordered STIndex
-pub trait STIndex<K, V>: IndexBaseSpec<K, V>
+pub trait STIndex<K, V>: IndexBaseSpec<K, V> {
-where
-    K: AsKey,
-    V: AsValue,
-{
     /// Attempts to compact the backing storage
     fn st_compact(&mut self) {}
     /// Clears all the entries in the STIndex
@@ -188,49 +188,57 @@ where
     // write
     /// Returns true if the entry was inserted successfully; returns false if the uniqueness constraint is
     /// violated
-    fn st_insert(&mut self, key: K, val: V) -> bool;
+    fn st_insert(&mut self, key: K, val: V) -> bool
+    where
+        K: AsKey,
+        V: AsValue;
     /// Updates or inserts the given value
-    fn st_upsert(&mut self, key: K, val: V);
+    fn st_upsert(&mut self, key: K, val: V)
+    where
+        K: AsKey,
+        V: AsValue;
     // read
+    fn st_contains<Q>(&self, key: &Q) -> bool
+    where
+        K: Borrow<Q> + AsKey,
+        Q: ?Sized + AsKeyRef;
     /// Returns a reference to the value corresponding to the key, if it exists
     fn st_get<Q>(&self, key: &Q) -> Option<&V>
     where
-        K: Borrow<Q>,
+        K: AsKey + Borrow<Q>,
         Q: ?Sized + AsKeyRef;
     /// Returns a clone of the value corresponding to the key, if it exists
     fn st_get_cloned<Q>(&self, key: &Q) -> Option<V>
     where
-        K: Borrow<Q>,
+        K: AsKey + Borrow<Q>,
         Q: ?Sized + AsKeyRef;
     // update
     /// Returns true if the entry is updated
     fn st_update<Q>(&mut self, key: &Q, val: V) -> bool
     where
-        K: Borrow<Q>,
+        K: AsKey + Borrow<Q>,
+        V: AsValue,
         Q: ?Sized + AsKeyRef;
     /// Updates the entry and returns the old value, if it exists
     fn st_update_return<Q>(&mut self, key: &Q, val: V) -> Option<V>
     where
-        K: Borrow<Q>,
+        K: AsKey + Borrow<Q>,
+        V: AsValue,
         Q: ?Sized + AsKeyRef;
     // delete
     /// Returns true if the entry was deleted
     fn st_delete<Q>(&mut self, key: &Q) -> bool
     where
-        K: Borrow<Q>,
+        K: AsKey + Borrow<Q>,
         Q: ?Sized + AsKeyRef;
     /// Removes the entry and returns it, if it exists
     fn st_delete_return<Q>(&mut self, key: &Q) -> Option<V>
     where
-        K: Borrow<Q>,
+        K: AsKey + Borrow<Q>,
         Q: ?Sized + AsKeyRef;
 }
 
-pub trait STIndexSeq<K, V>: STIndex<K, V>
+pub trait STIndexSeq<K, V>: STIndex<K, V> {
-where
-    K: AsKey,
-    V: AsValue,
-{
     /// An ordered iterator over the keys and values
     type IterOrdKV<'a>: Iterator<Item = (&'a K, &'a V)> + DoubleEndedIterator<Item = (&'a K, &'a V)>
     where

server/src/engine/idx/stdhm.rs

@@ -24,8 +24,9 @@
  *
 */
 
-use super::{AsKey, AsValue, DummyMetrics, IndexBaseSpec, STIndex};
+use super::{AsKey, AsKeyRef, AsValue, DummyMetrics, IndexBaseSpec, STIndex};
 use std::{
+    borrow::Borrow,
     collections::{
         hash_map::{Entry, Iter as StdMapIterKV, Keys as StdMapIterKey, Values as StdMapIterVal},
         HashMap as StdMap,
@@ -36,8 +37,6 @@ use std::{
 
 impl<K, V, S> IndexBaseSpec<K, V> for StdMap<K, V, S>
 where
-    K: AsKey,
-    V: AsValue,
     S: BuildHasher + Default,
 {
     const PREALLOC: bool = true;
@@ -113,34 +112,42 @@ where
         let _ = self.insert(key, val);
     }
 
+    fn st_contains<Q>(&self, k: &Q) -> bool
+    where
+        K: Borrow<Q>,
+        Q: ?Sized + AsKeyRef,
+    {
+        self.contains_key(k)
+    }
+
     fn st_get<Q>(&self, key: &Q) -> Option<&V>
     where
-        K: std::borrow::Borrow<Q>,
+        K: Borrow<Q>,
-        Q: ?Sized + super::AsKeyRef,
+        Q: ?Sized + AsKeyRef,
     {
         self.get(key)
     }
 
     fn st_get_cloned<Q>(&self, key: &Q) -> Option<V>
     where
-        K: std::borrow::Borrow<Q>,
+        K: Borrow<Q>,
-        Q: ?Sized + super::AsKeyRef,
+        Q: ?Sized + AsKeyRef,
     {
         self.get(key).cloned()
     }
 
     fn st_update<Q>(&mut self, key: &Q, val: V) -> bool
     where
-        K: std::borrow::Borrow<Q>,
+        K: Borrow<Q>,
-        Q: ?Sized + super::AsKeyRef,
+        Q: ?Sized + AsKeyRef,
     {
         self.get_mut(key).map(move |e| *e = val).is_some()
     }
 
     fn st_update_return<Q>(&mut self, key: &Q, val: V) -> Option<V>
     where
-        K: std::borrow::Borrow<Q>,
+        K: Borrow<Q>,
-        Q: ?Sized + super::AsKeyRef,
+        Q: ?Sized + AsKeyRef,
     {
         self.get_mut(key).map(move |e| {
             let mut new = val;
@@ -151,16 +158,16 @@ where
 
     fn st_delete<Q>(&mut self, key: &Q) -> bool
     where
-        K: std::borrow::Borrow<Q>,
+        K: Borrow<Q>,
-        Q: ?Sized + super::AsKeyRef,
+        Q: ?Sized + AsKeyRef,
     {
         self.remove(key).is_some()
     }
 
     fn st_delete_return<Q>(&mut self, key: &Q) -> Option<V>
     where
-        K: std::borrow::Borrow<Q>,
+        K: Borrow<Q>,
-        Q: ?Sized + super::AsKeyRef,
+        Q: ?Sized + AsKeyRef,
     {
         self.remove(key)
     }

server/src/engine/idx/stord.rs

@@ -358,6 +358,39 @@ impl<K, V, S> IndexSTSeqDll<K, V, S> {
     }
 }
 
+impl<K, V, S> IndexSTSeqDll<K, V, S> {
+    #[inline(always)]
+    fn _iter_unord_kv<'a>(&'a self) -> IndexSTSeqDllIterUnordKV<'a, K, V> {
+        IndexSTSeqDllIterUnordKV::new(&self.m)
+    }
+    #[inline(always)]
+    fn _iter_unord_k<'a>(&'a self) -> IndexSTSeqDllIterUnordKey<'a, K, V> {
+        IndexSTSeqDllIterUnordKey::new(&self.m)
+    }
+    #[inline(always)]
+    fn _iter_unord_v<'a>(&'a self) -> IndexSTSeqDllIterUnordValue<'a, K, V> {
+        IndexSTSeqDllIterUnordValue::new(&self.m)
+    }
+    #[inline(always)]
+    fn _iter_ord_kv<'a>(&'a self) -> IndexSTSeqDllIterOrdKV<'a, K, V> {
+        IndexSTSeqDllIterOrdKV {
+            i: IndexSTSeqDllIterOrdBase::new(self),
+        }
+    }
+    #[inline(always)]
+    fn _iter_ord_k<'a>(&'a self) -> IndexSTSeqDllIterOrdKey<'a, K, V> {
+        IndexSTSeqDllIterOrdKey {
+            i: IndexSTSeqDllIterOrdBase::new(self),
+        }
+    }
+    #[inline(always)]
+    fn _iter_ord_v<'a>(&'a self) -> IndexSTSeqDllIterOrdValue<'a, K, V> {
+        IndexSTSeqDllIterOrdValue {
+            i: IndexSTSeqDllIterOrdBase::new(self),
+        }
+    }
+}
+
 impl<K: AsKey, V: AsValue, S: BuildHasher> IndexSTSeqDll<K, V, S> {
     #[inline(always)]
     /// Clean up unused and cached memory
@@ -497,36 +530,6 @@ impl<K: AsKey, V: AsValue, S: BuildHasher> IndexSTSeqDll<K, V, S> {
             }
         }
     }
-    #[inline(always)]
-    fn _iter_unord_kv<'a>(&'a self) -> IndexSTSeqDllIterUnordKV<'a, K, V> {
-        IndexSTSeqDllIterUnordKV::new(&self.m)
-    }
-    #[inline(always)]
-    fn _iter_unord_k<'a>(&'a self) -> IndexSTSeqDllIterUnordKey<'a, K, V> {
-        IndexSTSeqDllIterUnordKey::new(&self.m)
-    }
-    #[inline(always)]
-    fn _iter_unord_v<'a>(&'a self) -> IndexSTSeqDllIterUnordValue<'a, K, V> {
-        IndexSTSeqDllIterUnordValue::new(&self.m)
-    }
-    #[inline(always)]
-    fn _iter_ord_kv<'a>(&'a self) -> IndexSTSeqDllIterOrdKV<'a, K, V> {
-        IndexSTSeqDllIterOrdKV {
-            i: IndexSTSeqDllIterOrdBase::new(self),
-        }
-    }
-    #[inline(always)]
-    fn _iter_ord_k<'a>(&'a self) -> IndexSTSeqDllIterOrdKey<'a, K, V> {
-        IndexSTSeqDllIterOrdKey {
-            i: IndexSTSeqDllIterOrdBase::new(self),
-        }
-    }
-    #[inline(always)]
-    fn _iter_ord_v<'a>(&'a self) -> IndexSTSeqDllIterOrdValue<'a, K, V> {
-        IndexSTSeqDllIterOrdValue {
-            i: IndexSTSeqDllIterOrdBase::new(self),
-        }
-    }
 }
 
 impl<K, V, S> Drop for IndexSTSeqDll<K, V, S> {
@@ -554,11 +557,7 @@ impl<K: AsKey, V: AsValue, S: BuildHasher + Default> FromIterator<(K, V)>
     }
 }
 
-impl<K, V, S: BuildHasher + Default> IndexBaseSpec<K, V> for IndexSTSeqDll<K, V, S>
+impl<K, V, S: BuildHasher + Default> IndexBaseSpec<K, V> for IndexSTSeqDll<K, V, S> {
-where
-    K: AsKey,
-    V: AsValue,
-{
     const PREALLOC: bool = true;
 
     type Metrics = IndexSTSeqDllMetrics;
@@ -626,6 +625,17 @@ where
         let _ = self._upsert(key, val);
     }
 
+    fn st_contains<Q>(&self, key: &Q) -> bool
+    where
+        K: Borrow<Q> + AsKey,
+        Q: ?Sized + AsKeyRef,
+    {
+        self.m.contains_key(unsafe {
+            // UNSAFE(@ohsayan): Valid ref with correct bounds
+            IndexSTSeqDllQref::from_ref(key)
+        })
+    }
+
     fn st_get<Q>(&self, key: &Q) -> Option<&V>
     where
         K: Borrow<Q>,