Struct Cache 

pub struct Cache {
    pub driver: Box<dyn CacheDriver>,
}

Represents a cache instance

Fields

driver: Box<dyn CacheDriver>

The cache driver used for underlying operations

Implementations

impl Cache

pub fn new(driver: Box<dyn CacheDriver>) -> Self

Creates a new cache instance with the specified cache driver.

pub async fn contains_key(&self, key: &str) -> CacheResult<bool>

Checks if a key exists in the cache.

Example

use loco_rs::cache::{self, CacheResult};
use loco_rs::config::InMemCacheConfig;

pub async fn contains_key() -> CacheResult<bool> {
    let config = InMemCacheConfig { max_capacity: 100 };
    let cache = cache::Cache::new(cache::drivers::inmem::new(&config).driver);
    cache.contains_key("key").await
}

Errors

A CacheResult indicating whether the key exists in the cache.

pub async fn get<T: DeserializeOwned>( &self, key: &str, ) -> CacheResult<Option<T>>

Retrieves a value from the cache based on the provided key and deserializes it.

Example

use loco_rs::cache::{self, CacheResult};
use loco_rs::config::InMemCacheConfig;
use serde::Deserialize;

#[derive(Deserialize)]
struct User {
    name: String,
    age: u32,
}

pub async fn get_user() -> CacheResult<Option<User>> {
    let config = InMemCacheConfig { max_capacity: 100 };
    let cache = cache::Cache::new(cache::drivers::inmem::new(&config).driver);
    cache.get::<User>("user:1").await
}

Example with String

use loco_rs::cache::{self, CacheResult};
use loco_rs::config::InMemCacheConfig;

pub async fn get_string() -> CacheResult<Option<String>> {
    let config = InMemCacheConfig { max_capacity: 100 };
    let cache = cache::Cache::new(cache::drivers::inmem::new(&config).driver);
    cache.get::<String>("key").await
}

Errors

A CacheResult containing an Option representing the retrieved and deserialized value.

pub async fn insert<T: Serialize + Sync + ?Sized>( &self, key: &str, value: &T, ) -> CacheResult<()>

Inserts a serializable value into the cache with the provided key.

Example

use loco_rs::cache::{self, CacheResult};
use loco_rs::config::InMemCacheConfig;
use serde::Serialize;

#[derive(Serialize)]
struct User {
    name: String,
    age: u32,
}

pub async fn insert() -> CacheResult<()> {
    let config = InMemCacheConfig { max_capacity: 100 };
    let cache = cache::Cache::new(cache::drivers::inmem::new(&config).driver);
    let user = User { name: "Alice".to_string(), age: 30 };
    cache.insert("user:1", &user).await
}

Example with String

use loco_rs::cache::{self, CacheResult};
use loco_rs::config::InMemCacheConfig;

pub async fn insert_string() -> CacheResult<()> {
    let config = InMemCacheConfig { max_capacity: 100 };
    let cache = cache::Cache::new(cache::drivers::inmem::new(&config).driver);
    cache.insert("key", &"value".to_string()).await
}

Errors

A CacheResult indicating the success of the operation.

pub async fn insert_with_expiry<T: Serialize + Sync + ?Sized>( &self, key: &str, value: &T, duration: Duration, ) -> CacheResult<()>

Inserts a serializable value into the cache with the provided key and expiry duration.

Example

use std::time::Duration;
use loco_rs::cache::{self, CacheResult};
use loco_rs::config::InMemCacheConfig;
use serde::Serialize;

#[derive(Serialize)]
struct User {
    name: String,
    age: u32,
}

pub async fn insert() -> CacheResult<()> {
    let config = InMemCacheConfig { max_capacity: 100 };
    let cache = cache::Cache::new(cache::drivers::inmem::new(&config).driver);
    let user = User { name: "Alice".to_string(), age: 30 };
    cache.insert_with_expiry("user:1", &user, Duration::from_secs(300)).await
}

Example with String

use std::time::Duration;
use loco_rs::cache::{self, CacheResult};
use loco_rs::config::InMemCacheConfig;

pub async fn insert_string() -> CacheResult<()> {
    let config = InMemCacheConfig { max_capacity: 100 };
    let cache = cache::Cache::new(cache::drivers::inmem::new(&config).driver);
    cache.insert_with_expiry("key", &"value".to_string(), Duration::from_secs(300)).await
}

Errors

A CacheResult indicating the success of the operation.

pub async fn get_or_insert<T, F>(&self, key: &str, f: F) -> LocoResult<T>

where T: Serialize + DeserializeOwned + Send + Sync, F: Future<Output = LocoResult<T>> + Send,

Retrieves and deserializes the value associated with the given key from the cache, or inserts it if it does not exist, using the provided closure to generate the value.

Example

use loco_rs::{app::AppContext};
use loco_rs::tests_cfg::app::*;
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct User {
    name: String,
    age: u32,
}

pub async fn get_or_insert(){
   let app_ctx = get_app_context().await;
   let user = app_ctx.cache.get_or_insert::<User, _>("user:1", async {
           Ok(User { name: "Alice".to_string(), age: 30 })
    }).await.unwrap();
   assert_eq!(user.name, "Alice");
}

Example with String

use loco_rs::{app::AppContext};
use loco_rs::tests_cfg::app::*;

pub async fn get_or_insert_string(){
   let app_ctx = get_app_context().await;
   let res = app_ctx.cache.get_or_insert::<String, _>("key", async {
           Ok("value".to_string())
    }).await.unwrap();
   assert_eq!(res, "value");
}

Errors

A LocoResult indicating the success of the operation.

pub async fn get_or_insert_with_expiry<T, F>( &self, key: &str, duration: Duration, f: F, ) -> LocoResult<T>

where T: Serialize + DeserializeOwned + Send + Sync, F: Future<Output = LocoResult<T>> + Send,

Retrieves and deserializes the value associated with the given key from the cache, or inserts it (with expiry after provided duration) if it does not exist, using the provided closure to generate the value.

Example

use std::time::Duration;
use loco_rs::{app::AppContext};
use loco_rs::tests_cfg::app::*;
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct User {
    name: String,
    age: u32,
}

pub async fn get_or_insert(){
   let app_ctx = get_app_context().await;
   let user = app_ctx.cache.get_or_insert_with_expiry::<User, _>("user:1", Duration::from_secs(300), async {
           Ok(User { name: "Alice".to_string(), age: 30 })
    }).await.unwrap();
   assert_eq!(user.name, "Alice");
}

Example with String

use std::time::Duration;
use loco_rs::{app::AppContext};
use loco_rs::tests_cfg::app::*;

pub async fn get_or_insert_string(){
   let app_ctx = get_app_context().await;
   let res = app_ctx.cache.get_or_insert_with_expiry::<String, _>("key", Duration::from_secs(300), async {
           Ok("value".to_string())
    }).await.unwrap();
   assert_eq!(res, "value");
}

Errors

A LocoResult indicating the success of the operation.

pub async fn remove(&self, key: &str) -> CacheResult<()>

Removes a key-value pair from the cache.

Example

use loco_rs::cache::{self, CacheResult};
use loco_rs::config::InMemCacheConfig;

pub async fn remove() -> CacheResult<()> {
    let config = InMemCacheConfig { max_capacity: 100 };
    let cache = cache::Cache::new(cache::drivers::inmem::new(&config).driver);
    cache.remove("key").await
}

Errors

A CacheResult indicating the success of the operation.

pub async fn clear(&self) -> CacheResult<()>

Clears all key-value pairs from the cache.

Example

use loco_rs::cache::{self, CacheResult};
use loco_rs::config::InMemCacheConfig;

pub async fn clear() -> CacheResult<()> {
    let config = InMemCacheConfig { max_capacity: 100 };
    let cache = cache::Cache::new(cache::drivers::inmem::new(&config).driver);
    cache.clear().await
}

Errors

A CacheResult indicating the success of the operation.