Struct TileCache 

pub struct TileCache { /* private fields */ }

LRU cache for encoded JPEG tiles with size-based capacity.

This cache stores encoded tile data and evicts least-recently-used entries when the total cached size exceeds capacity.

Thread Safety

The cache is thread-safe and can be shared across async tasks via Arc.

Example

use wsi_streamer::tile::{TileCache, TileCacheKey};
use bytes::Bytes;
use std::sync::Arc;

#[tokio::main]
async fn main() {
    let cache = TileCache::new();

    let key = TileCacheKey::new("slides/sample.svs", 0, 1, 2, 80);
    let tile_data = Bytes::from(vec![0xFF, 0xD8, 0xFF, 0xE0]); // JPEG header

    // Store tile
    cache.put(key.clone(), tile_data.clone()).await;

    // Retrieve tile
    let cached = cache.get(&key).await;
    assert_eq!(cached, Some(tile_data));
}

Implementations

impl TileCache

pub fn new() -> Self

Create a new tile cache with default capacity (100MB).

pub fn with_capacity(max_size: usize) -> Self

Create a new tile cache with the specified capacity in bytes.

Arguments

• max_size - Maximum total size of cached tiles in bytes

pub fn with_capacity_and_entries(max_size: usize, max_entries: usize) -> Self

Create a new tile cache with specified capacity and maximum entries.

Arguments

• max_size - Maximum total size of cached tiles in bytes
• max_entries - Maximum number of entries in the cache

pub async fn get(&self, key: &TileCacheKey) -> Option<Bytes>

Get a tile from the cache.

Returns Some(data) if the tile is cached, None otherwise. This operation marks the entry as recently used.

pub async fn contains(&self, key: &TileCacheKey) -> bool

Check if a tile is in the cache without updating LRU order.

Returns true if the tile is cached, false otherwise.

pub async fn put(&self, key: TileCacheKey, data: Bytes)

Store a tile in the cache.

If the cache is over capacity after insertion, least-recently-used entries are evicted until the cache is within capacity.

If the tile already exists, it is updated and marked as recently used.

pub async fn remove(&self, key: &TileCacheKey) -> Option<Bytes>

Remove a tile from the cache.

Returns the cached data if it existed, None otherwise.

pub async fn clear(&self)

Clear all entries from the cache.

pub async fn len(&self) -> usize

Get the current number of cached tiles.

pub async fn is_empty(&self) -> bool

Check if the cache is empty.

pub async fn size(&self) -> usize

Get the current total size of cached tiles in bytes.

pub fn capacity(&self) -> usize

Get the maximum capacity in bytes.

Trait Implementations

impl Default for TileCache

fn default() -> Self

Returns the “default value” for a type.