Struct TileService 

pub struct TileService<S: SlideSource> { /* private fields */ }

Service for generating and caching tiles.

The TileService orchestrates the full tile pipeline:

1. Validates request parameters
2. Checks the tile cache for existing results
3. Fetches the slide from the registry
4. Reads raw tile data from the slide
5. Decodes and re-encodes at the requested quality
6. Caches and returns the result

Type Parameters

• S - The slide source type (e.g., S3-based source)

Example

use wsi_streamer::tile::{TileService, TileRequest};
use wsi_streamer::slide::SlideRegistry;

// Create registry and service
let registry = SlideRegistry::new(source);
let service = TileService::new(registry);

// Request a tile
let request = TileRequest::new("slides/sample.svs", 0, 1, 2);
let response = service.get_tile(request).await?;

println!("Tile size: {} bytes, cache hit: {}", response.data.len(), response.cache_hit);

Implementations

impl<S: SlideSource> TileService<S>

pub fn new(registry: SlideRegistry<S>) -> Self

Create a new tile service with default cache settings.

Uses default tile cache capacity (100MB).

pub fn with_shared_registry(registry: Arc<SlideRegistry<S>>) -> Self

Create a new tile service with a shared registry.

This allows multiple services or components to share the same registry.

pub fn with_cache_capacity( registry: SlideRegistry<S>, cache_capacity: usize, ) -> Self

Create a new tile service with custom cache capacity.

Arguments

• registry - The slide registry
• cache_capacity - Maximum tile cache size in bytes

pub async fn get_tile( &self, request: TileRequest, ) -> Result<TileResponse, TileError>

Get a tile, using cache when available.

This is the main entry point for tile requests. It:

1. Validates the request parameters
2. Checks the cache for an existing tile
3. If not cached, fetches from the slide and encodes
4. Caches and returns the result

Errors

Returns an error if:

• The slide cannot be found or opened
• The level is out of range
• The tile coordinates are out of bounds
• The tile data cannot be decoded or encoded

pub async fn generate_tile( &self, request: &TileRequest, quality: u8, ) -> Result<Bytes, TileError>

Generate a tile without caching.

This is useful for one-off requests or when you want to bypass the cache.

pub async fn cache_stats(&self) -> (usize, usize, usize)

Get tile cache statistics.

Returns (current_size, capacity, entry_count).

pub async fn clear_cache(&self)

Clear the tile cache.

pub async fn invalidate_slide(&self, _slide_id: &str)

Invalidate cached tiles for a specific slide.

This removes all cached tiles for the given slide from the tile cache. Note: This is O(n) where n is the number of cached tiles.

pub fn registry(&self) -> &Arc<SlideRegistry<S>>

Get a reference to the underlying registry.

pub async fn generate_thumbnail( &self, slide_id: &str, max_dimension: u32, quality: u8, ) -> Result<TileResponse, TileError>

Generate a thumbnail for a slide.

This finds the lowest resolution level that fits within the requested max dimension and returns a tile or composited image.

Arguments

• slide_id - The slide identifier
• max_dimension - Maximum width or height for the thumbnail
• quality - JPEG quality (1-100)

Returns

A JPEG-encoded thumbnail image.