Struct DataCache 

pub struct DataCache { /* private fields */ }

Data cache with prefetched historical and live data buffers

The cache provides:

• Async prefetch of historical data (called before execution)
• Sync access to cached data (during execution)
• Live data streaming via background tasks

Thread Safety

The live buffer uses Arc<RwLock<...>> to allow concurrent reads during execution while background tasks write new bars.

Subscriptions use Arc<Mutex<...>> to allow shared ownership across clones.

Implementations

impl DataCache

pub fn new(provider: SharedAsyncProvider, runtime: Handle) -> Self

Create a new data cache

Arguments

• provider - Async data provider for loading data
• runtime - Tokio runtime handle for spawning background tasks

pub async fn prefetch( &self, queries: Vec<DataQuery>, ) -> Result<(), AsyncDataError>

Prefetch historical data for given queries (async)

This loads all queries concurrently and populates the cache. Should be called before execution starts.

Arguments

• queries - List of data queries to prefetch

Returns

Ok if all queries loaded successfully, error otherwise.

Example

let queries = vec![
    DataQuery::new("AAPL", Timeframe::d1()).limit(1000),
    DataQuery::new("MSFT", Timeframe::d1()).limit(1000),
];
cache.prefetch(queries).await?;

pub fn get_row( &self, id: &str, timeframe: &Timeframe, index: usize, ) -> Option<OwnedDataRow>

Get row at index (sync - reads from cache)

This is the hot path - called frequently during execution. Reads are lock-free for historical data, read-locked for live data.

Arguments

• symbol - Symbol to query
• timeframe - Timeframe
• index - Absolute row index

Returns

The row if available, None otherwise.

pub fn get_row_range( &self, id: &str, timeframe: &Timeframe, start: usize, end: usize, ) -> Vec<OwnedDataRow>

Get row range (sync - reads from cache)

Arguments

• symbol - Symbol to query
• timeframe - Timeframe
• start - Start index (inclusive)
• end - End index (exclusive)

Returns

Vector of rows in the range. May be shorter than requested if data unavailable.

pub fn subscribe_live( &self, id: &str, timeframe: &Timeframe, ) -> Result<(), AsyncDataError>

Start live data subscription (spawns background task)

This subscribes to live bar updates and spawns a background task that appends new bars to the live buffer as they arrive.

Arguments

• symbol - Symbol to subscribe to
• timeframe - Timeframe for bars

Returns

Ok if subscription started, error otherwise. Returns Ok without action if already subscribed.

pub fn unsubscribe_live(&self, symbol: &str, timeframe: &Timeframe)

Stop live data subscription

Cancels the background task and unsubscribes from the provider.

Arguments

• symbol - Symbol to unsubscribe from
• timeframe - Timeframe

pub fn row_count(&self, id: &str, timeframe: &Timeframe) -> usize

Get total row count (historical + live)

Arguments

• symbol - Symbol to query
• timeframe - Timeframe

Returns

Total number of rows available (historical + live).

pub fn has_cached(&self, symbol: &str, timeframe: &Timeframe) -> bool

Check if data is cached

Arguments

• symbol - Symbol to check
• timeframe - Timeframe to check

Returns

true if historical data is cached for this key.

pub fn cached_keys(&self) -> Vec<(String, Timeframe)>

Get list of cached symbols

Returns

Vector of (symbol, timeframe) pairs that are cached.

pub fn clear(&self)

Clear all cached data

Stops all subscriptions and clears all cached data.

pub fn provider(&self) -> SharedAsyncProvider

Get the async provider

Returns a clone of the SharedAsyncProvider for use in other components.

pub fn snapshot(&self, store: &SnapshotStore) -> AnyResult<DataCacheSnapshot>

Create a snapshot of the data cache (historical + live buffers).

pub fn restore_from_snapshot( &self, snapshot: DataCacheSnapshot, store: &SnapshotStore, ) -> AnyResult<()>

Restore data cache contents from a snapshot.

Trait Implementations

impl Clone for DataCache

fn clone(&self) -> DataCache

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Drop for DataCache

fn drop(&mut self)

Executes the destructor for this type.