Struct RiCacheManager 

pub struct RiCacheManager { /* private fields */ }

Cache manager that coordinates different cache backends with consistency support

This struct provides a unified interface for cache operations while ensuring cache consistency across multiple instances through event-driven architecture. It wraps any backend implementing the RiCache trait and adds consistency guarantees.

Implementations

impl RiCacheManager

pub fn new(backend: Arc<dyn RiCache + Send + Sync>) -> Self

Create a new cache manager with the specified backend

Parameters:

• backend: The underlying cache backend implementation

Returns:

• A new instance of RiCacheManager

pub async fn start_consistency_listener(&mut self) -> JoinHandle<()>

Start the cache consistency event listener

This method starts a background task that listens for cache consistency events and applies them to the underlying cache backend. This ensures that all cache instances remain consistent across the system.

Returns:

• A JoinHandle for the background task

pub fn subscribe(&self) -> Receiver<RiCacheEvent>

Subscribe to cache consistency events

This method allows external components to subscribe to cache consistency events, enabling them to react to cache changes in real-time.

Returns:

• A broadcast receiver for cache events

pub fn publish_event(&self, event: RiCacheEvent)

Publish a cache consistency event

This method publishes a cache event to all subscribers, ensuring cache consistency across all instances.

Parameters:

• event: The cache event to publish

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

Get a value from cache

This method retrieves a value from the cache using the specified key. If the key exists and the value is valid, it is deserialized and returned. Otherwise, None is returned.

Parameters:

• key: The cache key to retrieve

Returns:

• Ok(Some(T)) if the key exists and the value is valid
• Ok(None) if the key does not exist
• Err(RiError) if an error occurs during retrieval or deserialization

pub async fn set<T: Serialize>( &self, key: &str, value: &T, ttl_seconds: Option<u64>, ) -> RiResult<()>

Set a value in cache with optional TTL

This method stores a value in the cache with the specified key and optional TTL. It also publishes an invalidate event to ensure cache consistency across all instances.

Parameters:

• key: The cache key to set
• value: The value to store (must implement Serialize)
• ttl_seconds: Optional time-to-live in seconds

Returns:

• Ok(()) if the value was successfully stored
• Err(RiError) if an error occurs during serialization or storage

pub async fn delete(&self, key: &str) -> RiResult<bool>

Delete a value from cache

This method deletes a value from the cache using the specified key. It also publishes an invalidate event to ensure cache consistency across all instances.

Parameters:

• key: The cache key to delete

Returns:

• Ok(true) if the key was found and deleted
• Ok(false) if the key didn’t exist
• Err(RiError) if an error occurs during deletion

pub async fn exists(&self, key: &str) -> bool

Check if a key exists in cache

This method checks if the specified key exists in the cache.

Parameters:

• key: The cache key to check

Returns:

• true if the key exists, false otherwise

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

Clear all cache entries

This method clears all entries from the cache. It also publishes a clear event to ensure cache consistency across all instances.

Returns:

• Ok(()) if the cache was successfully cleared
• Err(RiError) if an error occurs during clearing

pub async fn invalidate_pattern(&self, pattern: &str) -> RiResult<()>

Invalidate cache entries matching a pattern

This method invalidates all cache entries matching the specified pattern. It publishes an invalidate pattern event to ensure cache consistency across all instances.

Parameters:

• pattern: The pattern to match cache keys (supports wildcards depending on backend)

Returns:

• Ok(()) if the invalidation event was successfully published

pub async fn stats(&self) -> RiCacheStats

Get cache statistics

This method retrieves statistics about the cache, including hit rate, miss rate, and the number of entries.

Returns:

• A RiCacheStats struct containing the cache statistics

pub async fn cleanup_expired(&self) -> RiResult<usize>

Cleanup expired cache entries

This method removes all expired entries from the cache.

Returns:

• Ok(usize) with the number of expired entries cleaned up
• Err(RiError) if an error occurs during cleanup

pub async fn get_or_set<T, F>( &self, key: &str, ttl_seconds: Option<u64>, factory: F, ) -> RiResult<T>

where T: Serialize + DeserializeOwned + Clone, F: FnOnce() -> RiResult<T>,

Get a value from cache or set it if it doesn’t exist

This method retrieves a value from the cache using the specified key. If the key exists and the value is valid, it is returned. Otherwise, the provided factory function is called to generate the value, which is then stored in the cache and returned.

Parameters:

• key: The cache key to retrieve or set
• ttl_seconds: Optional time-to-live in seconds for the new value
• factory: A function that generates the value if it doesn’t exist in cache

Returns:

• Ok(T) with the retrieved or generated value
• Err(RiError) if an error occurs during retrieval, generation, or storage

Trait Implementations

impl<'py> IntoPyObject<'py> for RiCacheManager

type Target = RiCacheManager

The Python output type

type Output = Bound<'py, <RiCacheManager as IntoPyObject<'py>>::Target>

The smart pointer type to use.

type Error = PyErr

The type returned in the event of a conversion error.

fn into_pyobject( self, py: Python<'py>, ) -> Result<<Self as IntoPyObject<'_>>::Output, <Self as IntoPyObject<'_>>::Error>

Performs the conversion.

impl PyClass for RiCacheManager

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for RiCacheManager

const IS_BASETYPE: bool = false

#[pyclass(subclass)]

const IS_SUBCLASS: bool = false

#[pyclass(extends=…)]

const IS_MAPPING: bool = false

#[pyclass(mapping)]

const IS_SEQUENCE: bool = false

#[pyclass(sequence)]

const IS_IMMUTABLE_TYPE: bool = false

#[pyclass(immutable_type)]

const RAW_DOC: &'static CStr = /// any backend implementing the RiCache trait and adds consistency guarantees.

Docstring for the class provided on the struct or enum.

const DOC: &'static CStr

Fully rendered class doc, including the text_signature if a constructor is defined.

type BaseType = PyAny

Base class

type ThreadChecker = SendablePyClass<RiCacheManager>

This handles following two situations:

type PyClassMutability = <<PyAny as PyClassBaseType>::PyClassMutability as PyClassMutability>::MutableChild

Immutable or mutable

type Dict = PyClassDummySlot

Specify this class has #[pyclass(dict)] or not.

type WeakRef = PyClassDummySlot

Specify this class has #[pyclass(weakref)] or not.

type BaseNativeType = PyAny

The closest native ancestor. This is PyAny by default, and when you declare #[pyclass(extends=PyDict)], it’s PyDict.

fn items_iter() -> PyClassItemsIter

fn lazy_type_object() -> &'static LazyTypeObject<Self>

fn dict_offset() -> Option<isize>

fn weaklist_offset() -> Option<isize>

impl PyClassNewTextSignature for RiCacheManager

const TEXT_SIGNATURE: &'static str = "()"

impl PyMethods<RiCacheManager> for PyClassImplCollector<RiCacheManager>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for RiCacheManager

const NAME: &'static str = "RiCacheManager"

Class name.

const MODULE: Option<&'static str> = ::core::option::Option::None

Module name, if any.

fn type_object_raw(py: Python<'_>) -> *mut PyTypeObject

Returns the PyTypeObject instance for this type.

fn type_object(py: Python<'_>) -> Bound<'_, PyType>

Returns the safe abstraction over the type object.

fn is_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type or a subclass of this type.

fn is_exact_type_of(object: &Bound<'_, PyAny>) -> bool

Checks if object is an instance of this type.

impl DerefToPyAny for RiCacheManager

impl ExtractPyClassWithClone for RiCacheManager