Struct RiCachedValue 

pub struct RiCachedValue {
    pub value: String,
    pub expires_at: Option<u64>,
    pub last_accessed: Option<u64>,
}

Cached value wrapper with TTL and LRU support.

This struct encapsulates a cached value along with metadata for cache management:

• value: The actual cached data as a string
• expires_at: Optional TTL-based expiration timestamp (UNIX epoch seconds)
• last_accessed: Optional last access timestamp for LRU eviction policies

Examples

use ri::cache::RiCachedValue;

let cached = RiCachedValue::new("test_data".to_string(), Some(3600));
assert!(!cached.is_expired());
cached.touch();
assert!(!cached.is_stale(300));

Fields

value: String

The cached value as a string

expires_at: Option<u64>

Optional expiration timestamp (UNIX epoch seconds) If None, the value never expires based on TTL

last_accessed: Option<u64>

Optional last access timestamp (UNIX epoch seconds) Used for LRU-based cache eviction policies

Implementations

impl RiCachedValue

pub fn new(value: String, ttl_seconds: Option<u64>) -> Self

Creates a new cached value with optional TTL.

Parameters

• value: The string value to cache
• ttl_seconds: Optional time-to-live in seconds
  • If Some(seconds), the value will expire after the specified duration
  • If None, the value never expires based on TTL

Behavior

• Initializes last_accessed to current timestamp for LRU tracking
• Calculates expires_at as current_time + ttl_seconds if TTL is provided

Examples

use ri::cache::RiCachedValue;
 
// Create a value that expires in 1 hour
let cached = RiCachedValue::new("data".to_string(), Some(3600));
 
// Create a value that never expires
let persistent = RiCachedValue::new("persistent".to_string(), None);

pub fn deserialize<T: DeserializeOwned>(&self) -> RiResult<T>

pub fn is_expired(&self) -> bool

pub fn touch(&mut self)

Updates the last access timestamp to current time.

This method should be called each time the cached value is accessed to support LRU (Least Recently Used) cache eviction policies.

Behavior

• Sets last_accessed to the current UNIX timestamp
• Does not modify expires_at or value

Use Cases

• LRU cache implementations tracking access order
• Cache warming strategies based on access patterns
• Usage analytics and cache performance monitoring

pub fn is_stale(&self, max_idle_secs: u64) -> bool

Checks if the cached value is stale based on idle time.

A value is considered stale if it has not been accessed for longer than the specified maximum idle time. This is useful for LRU eviction.

Parameters

• max_idle_secs: Maximum idle time in seconds before considering stale

Returns

• true if the value is stale (not accessed within max_idle_secs)
• false if the value is still fresh or has no access timestamp

Examples

use ri::cache::RiCachedValue;
 
let mut cached = RiCachedValue::new("data".to_string(), None);
 
// Immediately after creation, not stale
assert!(!cached.is_stale(300));
 
cached.touch();
assert!(!cached.is_stale(300));

Trait Implementations

impl Clone for RiCachedValue

fn clone(&self) -> RiCachedValue

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RiCachedValue

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for RiCachedValue

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<'py> IntoPyObject<'py> for RiCachedValue

type Target = RiCachedValue

The Python output type

type Output = Bound<'py, <RiCachedValue 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 RiCachedValue

type Frozen = False

Whether the pyclass is frozen.

impl PyClassImpl for RiCachedValue

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 = /// ```

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<RiCachedValue>

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 RiCachedValue

const TEXT_SIGNATURE: &'static str = "(value, ttl_seconds)"

impl PyMethods<RiCachedValue> for PyClassImplCollector<RiCachedValue>

fn py_methods(self) -> &'static PyClassItems

impl PyTypeInfo for RiCachedValue

const NAME: &'static str = "RiCachedValue"

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 Serialize for RiCachedValue

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl DerefToPyAny for RiCachedValue

impl ExtractPyClassWithClone for RiCachedValue