Struct SimpleCache

pub struct SimpleCache<T: Clone> { /* private fields */ }

A simple cache implementation that stores a single optional value.

This cache can hold at most one value at a time. When a value is set, it replaces any previously stored value. When retrieved, it returns a clone of the stored value.

Type Parameters

• T - The type of value to cache. Must implement Clone.

Example

use zed::SimpleCache;
use zed::capsule::Cache;

let mut cache = SimpleCache::<i32>::new();

// Initially empty
assert_eq!(cache.get(), None);

// Set a value
cache.set(42);
assert_eq!(cache.get(), Some(42));

// Set another value (replaces the first)
cache.set(100);
assert_eq!(cache.get(), Some(100));

Implementations

impl<T: Clone> SimpleCache<T>

pub fn new() -> Self

Creates a new empty SimpleCache.

Returns

A new SimpleCache instance with no stored value.

Example

use zed::SimpleCache;
use zed::capsule::Cache;

let cache: SimpleCache<String> = SimpleCache::new();
assert_eq!(cache.get(), None);

Trait Implementations

impl<T: Clone> Cache<T> for SimpleCache<T>

fn get(&self) -> Option<T>

Retrieves a clone of the cached value, if any.

Returns

Some(value) if a value is cached, None if the cache is empty.

fn set(&mut self, value: T)

Stores a value in the cache.

If the cache already contains a value, it will be replaced.

Arguments

• value - The value to store in the cache

impl<T: Clone + Clone> Clone for SimpleCache<T>

fn clone(&self) -> SimpleCache<T>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<T: Clone> Default for SimpleCache<T>

fn default() -> Self

Creates a default (empty) SimpleCache.

This is equivalent to calling SimpleCache::new().