Struct FifoCache 

pub struct FifoCache<K, V> { /* private fields */ }

A FIFO cache with TTL support.

This cache maintains insertion order and evicts the oldest entries when the maximum size is reached. Entries also expire after the specified TTL.

Note that:

• reinserting an existing entry will not move it back to the front
• the maximum capacity may very briefly be exceeded by 1

Implementations

impl<K, V> FifoCache<K, V>

where K: Clone + Eq + Hash, V: Clone,

pub fn new(max_size: usize, default_ttl: Duration) -> Self

Creates a new FIFO cache with the specified maximum size and default TTL.

Arguments

• max_size - Maximum number of entries the cache can hold
• default_ttl - Default time-to-live for cache entries

Examples found in repository

examples/basic_usage.rs (lines 7-11)

fn main() {
  // Create a cache with capacity 1000 and 5-minute TTL
  let mut cache = FifoCache::new(
    1000,
    #[cfg(feature = "ttl")]
    Duration::from_secs(300)
  );
  
  // Insert some values
  cache.insert("user:123", "John Doe");
  cache.insert("user:456", "Jane Smith");
  cache.insert("config:timeout", "30");
  
  // Retrieve values
  if let Some(name) = cache.get(&"user:123") {
    println!("Found user: {}", name);
  }
  
  // Cache will automatically evict oldest entries when full
  // and expire entries after 5 minutes
  
  println!("Cache size: {}/{}", cache.len(), cache.max_size());
  
  #[cfg(feature = "ttl")]
  // Manual cleanup of expired entries
  cache.cleanup_expired();
}

pub fn get<Q>(&self, key: &Q) -> Option<&V>

where K: Borrow<Q>, Q: ?Sized + Hash + Eq,

Retrieves a value from the cache if it exists and hasn’t expired.

Arguments

• key - The key to look up

Returns

Some(&V) if the key exists and hasn’t expired, None otherwise.

Example

With TTL enabled:

use fifo_cache::FifoCache;
use std::time::Duration;

let mut cache = FifoCache::new(100, Duration::from_secs(60));
cache.insert("my_key", "my_value");
let value = cache.get(&"my_key");
assert_eq!(value, Some(&"my_value"));

Without TTL:

use fifo_cache::FifoCache;

let mut cache = FifoCache::new(100);
cache.insert("my_key", "my_value");
assert_eq!(cache.get(&"my_key"), Some(&"my_value"));

Examples found in repository

examples/basic_usage.rs (line 19)

fn main() {
  // Create a cache with capacity 1000 and 5-minute TTL
  let mut cache = FifoCache::new(
    1000,
    #[cfg(feature = "ttl")]
    Duration::from_secs(300)
  );
  
  // Insert some values
  cache.insert("user:123", "John Doe");
  cache.insert("user:456", "Jane Smith");
  cache.insert("config:timeout", "30");
  
  // Retrieve values
  if let Some(name) = cache.get(&"user:123") {
    println!("Found user: {}", name);
  }
  
  // Cache will automatically evict oldest entries when full
  // and expire entries after 5 minutes
  
  println!("Cache size: {}/{}", cache.len(), cache.max_size());
  
  #[cfg(feature = "ttl")]
  // Manual cleanup of expired entries
  cache.cleanup_expired();
}

pub fn insert(&mut self, key: K, value: V)

Inserts a key-value pair into the cache.

If the key already exists, its value is updated and TTL is refreshed. If the cache is at capacity, the oldest entry is evicted.

Arguments

• key - The key to insert
• value - The value to associate with the key

Examples found in repository

examples/basic_usage.rs (line 14)

fn main() {
  // Create a cache with capacity 1000 and 5-minute TTL
  let mut cache = FifoCache::new(
    1000,
    #[cfg(feature = "ttl")]
    Duration::from_secs(300)
  );
  
  // Insert some values
  cache.insert("user:123", "John Doe");
  cache.insert("user:456", "Jane Smith");
  cache.insert("config:timeout", "30");
  
  // Retrieve values
  if let Some(name) = cache.get(&"user:123") {
    println!("Found user: {}", name);
  }
  
  // Cache will automatically evict oldest entries when full
  // and expire entries after 5 minutes
  
  println!("Cache size: {}/{}", cache.len(), cache.max_size());
  
  #[cfg(feature = "ttl")]
  // Manual cleanup of expired entries
  cache.cleanup_expired();
}

pub fn insert_lazy<Kinto: Into<K>, Vinto: Into<V>>( &mut self, key: Kinto, value: Vinto, )

Inserts a key-value pair into the cache using types that can be converted into the key and value types.

This is a convenience wrapper around insert that accepts any types implementing Into<K> and Into<V>. Note that using only insert_lazy prevents type inference, so you’ll need to explicitly specify the cache types:

use fifo_cache::FifoCache;
use std::time::Duration;
 
// With insert - types are inferred
let mut cache = FifoCache::new(100, Duration::from_secs(60));
cache.insert("key", "value");  // FifoCache<&str, &str>

// With insert_lazy - types must be specified  
let mut cache: FifoCache<String, String> = FifoCache::new(100, Duration::from_secs(60));
cache.insert_lazy("key", "value");  // &str -> String conversion

pub fn remove<Q>(&mut self, key: &Q) -> Option<V>

where K: Borrow<Q>, Q: ?Sized + Hash + Eq,

Removes a key from the cache.

Arguments

• key - The key to remove

Returns

Some(V) if the key existed, None otherwise.

pub fn len(&self) -> usize

Returns the current number of entries in the cache.

Examples found in repository

examples/basic_usage.rs (line 26)

fn main() {
  // Create a cache with capacity 1000 and 5-minute TTL
  let mut cache = FifoCache::new(
    1000,
    #[cfg(feature = "ttl")]
    Duration::from_secs(300)
  );
  
  // Insert some values
  cache.insert("user:123", "John Doe");
  cache.insert("user:456", "Jane Smith");
  cache.insert("config:timeout", "30");
  
  // Retrieve values
  if let Some(name) = cache.get(&"user:123") {
    println!("Found user: {}", name);
  }
  
  // Cache will automatically evict oldest entries when full
  // and expire entries after 5 minutes
  
  println!("Cache size: {}/{}", cache.len(), cache.max_size());
  
  #[cfg(feature = "ttl")]
  // Manual cleanup of expired entries
  cache.cleanup_expired();
}

pub fn is_empty(&self) -> bool

Returns true if the cache is empty.

pub fn cleanup_expired(&mut self)

Removes all expired entries from the cache.

Examples found in repository

examples/basic_usage.rs (line 30)

fn main() {
  // Create a cache with capacity 1000 and 5-minute TTL
  let mut cache = FifoCache::new(
    1000,
    #[cfg(feature = "ttl")]
    Duration::from_secs(300)
  );
  
  // Insert some values
  cache.insert("user:123", "John Doe");
  cache.insert("user:456", "Jane Smith");
  cache.insert("config:timeout", "30");
  
  // Retrieve values
  if let Some(name) = cache.get(&"user:123") {
    println!("Found user: {}", name);
  }
  
  // Cache will automatically evict oldest entries when full
  // and expire entries after 5 minutes
  
  println!("Cache size: {}/{}", cache.len(), cache.max_size());
  
  #[cfg(feature = "ttl")]
  // Manual cleanup of expired entries
  cache.cleanup_expired();
}

pub fn clear(&mut self)

Clears all entries from the cache.

pub fn max_size(&self) -> usize

Returns the maximum capacity of the cache.

Examples found in repository

examples/basic_usage.rs (line 26)

fn main() {
  // Create a cache with capacity 1000 and 5-minute TTL
  let mut cache = FifoCache::new(
    1000,
    #[cfg(feature = "ttl")]
    Duration::from_secs(300)
  );
  
  // Insert some values
  cache.insert("user:123", "John Doe");
  cache.insert("user:456", "Jane Smith");
  cache.insert("config:timeout", "30");
  
  // Retrieve values
  if let Some(name) = cache.get(&"user:123") {
    println!("Found user: {}", name);
  }
  
  // Cache will automatically evict oldest entries when full
  // and expire entries after 5 minutes
  
  println!("Cache size: {}/{}", cache.len(), cache.max_size());
  
  #[cfg(feature = "ttl")]
  // Manual cleanup of expired entries
  cache.cleanup_expired();
}

pub fn set_max_size(&mut self, max_size: usize, prune: bool)

Sets the maximum capacity of the cache.

Arguments

• max_size - The new maximum number of entries the cache can hold
• prune - Whether or not to immediately prune the excess number of entries, in case the update causes the cache to be above capacity

pub fn default_ttl(&self) -> Duration

Returns the default TTL for cache entries.

pub fn set_default_ttl(&mut self, default_ttl: Duration)

Sets the default TTL for cache entries. Note that this will only affect entries that get inserted or updated after the change. Existing entries will keep their TTL until they expire.

Arguments

• default_ttl - The new default time-to-live for cache entries

Trait Implementations

impl<K: Debug, V: Debug> Debug for FifoCache<K, V>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<K, V> Default for FifoCache<K, V>

where K: Clone + Eq + Hash, V: Clone,

fn default() -> Self

Creates a cache with capacity 1000 and TTL of 5 minutes. This is extremely arbitrary and you most likely want to use your own, use-case-adjusted settings rather than this default.