refactor: atualizar versão do pacote quickleaf para 0.4.3 e otimizar operações de filtro

Author: codephi

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "quickleaf"
-version = "0.4.2"
+version = "0.4.3"
 edition = "2021"
 license = "Apache-2.0"
 authors = ["Philippe Assis <codephilippe@gmail.com>"]

Cargo.toml

@@ -1,9 +1,8 @@
 use crate::error::Error;
 use crate::event::Event;
-use crate::fast_filters::apply_filter_fast;
+use crate::filters::apply_filter_fast;
 use crate::list_props::{ListProps, Order, StartAfter};
 use crate::prefetch::{Prefetch, PrefetchExt};
-use crate::string_pool::StringPool;
 use indexmap::IndexMap;
 use std::fmt::Debug;
 use std::sync::mpsc::Sender;
@@ -222,7 +221,6 @@ pub struct Cache {
     capacity: usize,
     default_ttl: Option<Duration>,
     sender: Option<Sender<Event>>,
-    string_pool: StringPool,
     #[cfg(feature = "persist")]
     persist_path: Option<std::path::PathBuf>,
     _phantom: std::marker::PhantomData<Value>,
@@ -254,7 +252,6 @@ impl Cache {
             capacity,
             default_ttl: None,
             sender: None,
-            string_pool: StringPool::new(),
             #[cfg(feature = "persist")]
             persist_path: None,
             _phantom: std::marker::PhantomData,
@@ -285,7 +282,6 @@ impl Cache {
             capacity,
             default_ttl: None,
             sender: Some(sender),
-            string_pool: StringPool::new(),
             #[cfg(feature = "persist")]
             persist_path: None,
             _phantom: std::marker::PhantomData,
@@ -312,7 +308,6 @@ impl Cache {
             capacity,
             default_ttl: Some(default_ttl),
             sender: None,
-            string_pool: StringPool::new(),
             #[cfg(feature = "persist")]
             persist_path: None,
             _phantom: std::marker::PhantomData,
@@ -347,7 +342,6 @@ impl Cache {
             capacity,
             default_ttl: Some(default_ttl),
             sender: Some(sender),
-            string_pool: StringPool::new(),
             #[cfg(feature = "persist")]
             persist_path: None,
             _phantom: std::marker::PhantomData,
@@ -693,42 +687,32 @@ impl Cache {
     /// ```
     pub fn insert<T, V>(&mut self, key: T, value: V)
     where
-        T: Into<String> + Clone + AsRef<str>,
+        T: Into<String>,
         V: ToValueBehavior,
     {
-        let key_str = key.as_ref();
-
-        let interned_key = if key_str.len() < 50 {
-            self.string_pool.get_or_intern(key_str).to_string()
-        } else {
-            key.into()
-        };
-
-        if self.string_pool.len() > 1000 {
-            self.string_pool.clear_if_large();
-        }
+        let key = key.into();
 
         let item = if let Some(default_ttl) = self.default_ttl {
             CacheItem::with_ttl(value.to_value(), default_ttl)
         } else {
             CacheItem::new(value.to_value())
         };
 
-        if let Some(existing_item) = self.map.get(&interned_key) {
+        if let Some(existing_item) = self.map.get(&key) {
             if existing_item.value == item.value {
                 return;
             }
         }
 
-        if self.map.len() >= self.capacity && !self.map.contains_key(&interned_key) {
+        if self.map.len() >= self.capacity && !self.map.contains_key(&key) {
             if let Some((first_key, first_item)) = self.map.shift_remove_index(0) {
                 self.send_remove(first_key, first_item.value);
             }
         }
 
-        self.map.insert(interned_key.clone(), item.clone());
+        self.map.insert(key.clone(), item.clone());
 
-        self.send_insert(interned_key, item.value);
+        self.send_insert(key, item.value);
     }
 
     /// Inserts a key-value pair with a specific TTL.
@@ -806,19 +790,11 @@ impl Cache {
     /// ```
     #[inline]
     pub fn get(&mut self, key: &str) -> Option<&Value> {
-        let pooled_key = if key.len() <= 50 {
-            Some(self.string_pool.get_or_intern(key))
-        } else {
-            None
-        };
-
-        let lookup_key = pooled_key.as_deref().unwrap_or(key);
-
-        if let Some((_, item)) = self.map.get_key_value(lookup_key) {
+        if let Some((_, item)) = self.map.get_key_value(key) {
             item.prefetch_read();
         }
 
-        let is_expired = match self.map.get(lookup_key) {
+        let is_expired = match self.map.get(key) {
             Some(item) => {
                 if let Some(ttl) = item.ttl_millis {
                     (current_time_millis() - item.created_at) > ttl
@@ -830,12 +806,12 @@ impl Cache {
         };
 
         if is_expired {
-            if let Some(expired_item) = self.map.swap_remove(lookup_key) {
-                self.send_remove(lookup_key.to_string(), expired_item.value);
+            if let Some(expired_item) = self.map.swap_remove(key) {
+                self.send_remove(key.to_string(), expired_item.value);
             }
             None
         } else {
-            self.map.get(lookup_key).map(|item| &item.value)
+            self.map.get(key).map(|item| &item.value)
         }
     }
 
@@ -874,16 +850,8 @@ impl Cache {
     }
 
     pub fn remove(&mut self, key: &str) -> Result<(), Error> {
-        let pooled_key = if key.len() <= 50 {
-            Some(self.string_pool.get_or_intern(key))
-        } else {
-            None
-        };
-
-        let lookup_key = pooled_key.as_deref().unwrap_or(key);
-
-        if let Some(item) = self.map.swap_remove(lookup_key) {
-            self.send_remove(lookup_key.to_string(), item.value);
+        if let Some(item) = self.map.swap_remove(key) {
+            self.send_remove(key.to_string(), item.value);
             Ok(())
         } else {
             Err(Error::KeyNotFound)
@@ -892,7 +860,6 @@ impl Cache {
 
     pub fn clear(&mut self) {
         self.map.clear();
-        self.string_pool.clear();
         self.send_clear();
     }
 

src/cache.rs

@@ -0,0 +1,69 @@
+//! Optimized filter operations - simple and fast!
+
+use crate::filter::Filter;
+
+/// Fast and safe prefix matching using Rust's optimized implementation
+#[inline(always)]
+pub fn fast_prefix_match(text: &str, prefix: &str) -> bool {
+    text.starts_with(prefix)
+}
+
+/// Fast and safe suffix matching using Rust's optimized implementation  
+#[inline(always)]
+pub fn fast_suffix_match(text: &str, suffix: &str) -> bool {
+    text.ends_with(suffix)
+}
+
+/// Optimized filter application - same interface, better performance
+#[inline]
+pub fn apply_filter_fast(key: &str, filter: &Filter) -> bool {
+    match filter {
+        Filter::None => true,
+        Filter::StartWith(prefix) => key.starts_with(prefix),
+        Filter::EndWith(suffix) => key.ends_with(suffix),
+        Filter::StartAndEndWith(prefix, suffix) => key.starts_with(prefix) && key.ends_with(suffix),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::filter::Filter;
+
+    #[test]
+    fn test_fast_prefix_match() {
+        assert!(fast_prefix_match("hello_world", "hello"));
+        assert!(fast_prefix_match("hello", "hello"));
+        assert!(!fast_prefix_match("hello", "hello_world"));
+        assert!(fast_prefix_match("test", ""));
+    }
+
+    #[test]
+    fn test_fast_suffix_match() {
+        assert!(fast_suffix_match("hello_world", "world"));
+        assert!(fast_suffix_match("world", "world"));
+        assert!(!fast_suffix_match("world", "hello_world"));
+        assert!(fast_suffix_match("test", ""));
+    }
+
+    #[test]
+    fn test_apply_filter_fast() {
+        assert!(apply_filter_fast("test", &Filter::None));
+        assert!(apply_filter_fast(
+            "hello_world",
+            &Filter::StartWith("hello".to_string())
+        ));
+        assert!(apply_filter_fast(
+            "hello_world",
+            &Filter::EndWith("world".to_string())
+        ));
+        assert!(apply_filter_fast(
+            "hello_world",
+            &Filter::StartAndEndWith("hello".to_string(), "world".to_string())
+        ));
+        assert!(!apply_filter_fast(
+            "hello_world",
+            &Filter::StartWith("goodbye".to_string())
+        ));
+    }
+}

src/fast_filters.rs

@@ -327,8 +327,8 @@
 mod cache;
 mod error;
 mod event;
-mod fast_filters;
 mod filter;
+pub mod filters;
 mod list_props;
 #[cfg(test)]
 #[cfg(feature = "persist")]
@@ -338,7 +338,6 @@ pub mod prelude;
 mod quickleaf;
 #[cfg(feature = "persist")]
 mod sqlite_store;
-mod string_pool;
 #[cfg(test)]
 mod tests;
 #[cfg(test)]