Struct ReplayDriver 

pub struct ReplayDriver { /* private fields */ }

A recording-backed feed and playback driver for every symbol in one session.

Attach the same Arc<ReplayDriver> to each chart with ChartBuilder::with_feed. Call advance outside egui context locks before drawing, even while paused, to publish the shared time to quiet symbols. Zero speed pauses; seeking is inclusive. Hosts own capture, storage and scheduling. Bar aggregation, book gaps and trade deduplication use the live sink’s rules. A new subscription reconstructs the current position, including when its interval changes. No history request can return events beyond the playback position.

use egui_charts::data::{MarketEvent, RecordingWriter, ReplayDriver, ReplayEvent};
use egui_charts::model::{Instrument, Tick};
use std::time::Duration;
let time = chrono::Utc::now();
let mut capture = RecordingWriter::new(Vec::new())?;
capture.write(&ReplayEvent::new("A", time, 0,
    MarketEvent::Trade(Tick::new(time, 100.0, 2.0, None))))?;
let bytes = capture.finish()?;
let replay = ReplayDriver::load(bytes.as_slice(), vec![Instrument::new("A")])?;
replay.advance(Duration::ZERO)?;
replay.set_speed(0.0)?;
replay.seek(time);

Implementations

impl ReplayDriver

pub fn new( events: Vec<ReplayEvent>, instruments: Vec<Instrument>, ) -> Result<Self, FeedError>

Validates a complete recording and its host-supplied instrument metadata. Every recorded symbol must have exactly one instrument; its tick size is needed for price-based bars. Playback starts at the first event, with none consumed, at normal speed.

pub fn load(reader: impl Read, instruments: Vec<Instrument>) -> Result<Self>

Loads the same stream that super::RecordingWriter writes. Read errors retain their original kind; malformed recordings and duplicate merge keys report InvalidData.

pub fn time(&self) -> DateTime<Utc>

The inclusive playback position shared by all subscriptions.

pub fn time_range(&self) -> Option<(DateTime<Utc>, DateTime<Utc>)>

First and last recorded observation instants, for transport bounds; None when empty.

pub fn speed(&self) -> f64

Playback multiplier; zero pauses.

pub fn set_speed(&self, speed: f64) -> Result<(), FeedError>

Sets a finite, non-negative playback multiplier.

pub fn is_finished(&self) -> bool

Whether every event has been published.

pub fn advance(&self, elapsed: Duration) -> Result<(), FeedError>

Advances once by wall-clock elapsed time and routes due events by symbol. Publishes the resulting time to every sink, including quiet symbols and paused frames. Clock errors leave the position and subscriptions unchanged.

pub fn seek(&self, time: DateTime<Utc>)

Reconstructs every active subscription through time, clearing all later state first. Replays book history from the beginning as well as trades: starting at the latest book snapshot would lose earlier heatmap columns. No later snapshot or execution is exposed. Call outside egui context locks, as with live pushes.

Trait Implementations

impl Datafeed for ReplayDriver

fn resolve(&self, symbol: &str, reply: Reply<Instrument>)

Describes symbol. The default reports Instrument::new of the symbol. Fill Instrument::profile_resolutions to suggest the bars volume profile studies and drawings read.

fn history(&self, _: HistoryRequest, reply: Reply<HistoryPage>)

Up to request.count bars of the range [request.since, request.before), the newest ones when there are more. Either end left None is unbounded: without before the range reaches the latest bar.

fn subscribe(&self, subscription: Subscription)

Starts pushing live updates into subscription.sink until unsubscribe. The default does nothing, which gives a history-only chart.

fn unsubscribe(&self, id: SubscriptionId)

Stops what subscribe started. Pushes that arrive afterwards are ignored. The default does nothing; a producer can then poll Sink::is_active to know when to stop.

fn depth_history(&self, request: DepthRequest, reply: Reply<DepthPage>)

One page of recorded depth on the requested grid. The default answers FeedError::NotSupported; live-only feeds need not implement this method.

fn capabilities(&self, reply: Reply<FeedCapabilities>)

What the feed offers as a whole, before any symbol is resolved: the intervals, exchanges and symbol classes its selectors may offer, and the optional services it supplies. The chart asks once when it attaches the feed and keeps the answer in Chart::feed_capabilities (requires widget). The default answers FeedCapabilities::default, which reports nothing and so restricts nothing.

fn resolve_converted( &self, symbol: &str, conversion: &str, reply: Reply<Instrument>, )

Describes symbol with its prices converted to conversion, the currency or unit the host chose with Chart::set_conversion (requires widget). Label the instrument with the converted currency and unit. The library converts nothing: the default answers FeedError::NotSupported, which shows no data rather than unconverted data under a converted choice.

fn trades(&self, request: TradeRequest, reply: Reply<TradePage>)

Up to request.count trades of the range [request.since, request.before), the newest ones when there are more, so order flow survives a reload and follows the view back in time. The default answers FeedError::NotSupported.

fn options_volume(&self, query: OptionsVolumeQuery, sink: OptionsVolumeSink)

Push complete options-volume snapshots for the underlying and inclusive expiry range. Each push replaces the previous figures, including an empty snapshot. Sum contracts across the requested expiries at each strike. Stop when sink.is_active() is false. The default supplies none; the library never fetches options data itself.

fn option_expiries(&self, underlying: &str, reply: Reply<Vec<NaiveDate>>)

Listed expiry dates for underlying, in ascending order with no duplicates. The default answers FeedError::NotSupported. Both options methods are declared by FeedService::OptionChain; the host supplies the data.

fn option_chain(&self, query: OptionChainQuery, sink: OptionChainSink)

Push complete snapshots of the listed contracts in query’s inclusive expiry range. Without as_of, keep pushing until the sink is inactive. With it, push one snapshot for that instant or report FeedError::NotSupported. Unknown figures stay absent. See OptionQuote for units and OptionChainSink::push for validation. The default reports FeedError::NotSupported to the sink.

fn option_exposure(&self, query: OptionExposureQuery, sink: OptionExposureSink)

Push complete exposure snapshots for the underlying, inclusive expiry range and kind. Without as_of, keep pushing until the sink is inactive; with it, answer once for that instant or report FeedError::NotSupported (the default). Declared by FeedService::OptionExposure. The host supplies the data and model.

fn metrics(&self, symbol: &str, reply: Reply<Vec<MetricSeries>>)

Metrics offered for symbol, in display order. The default offers none. The host publishes the values; the library computes no instrument metrics.

fn metric_history(&self, request: MetricRequest, reply: Reply<MetricPage>)

Metric history. The default answers FeedError::NotSupported.

fn subscribe_metric(&self, subscription: MetricSubscription)

Start publishing metric points until Self::unsubscribe. The default does nothing.

fn price_targets(&self, symbol: &str, reply: Reply<PriceTargets>)

Analyst price targets for symbol. The default answers FeedError::NotSupported, which leaves the chart without targets and shows no error.

fn symbol_details(&self, symbol: &str, reply: Reply<SymbolDetails>)

Key statistics and the company or contract profile of symbol, for the symbol details panel. The default answers FeedError::NotSupported, and the panel then shows neither.

fn news(&self, query: NewsQuery, reply: Reply<Vec<NewsStory>>)

Up to query.limit stories, newest first, for the news and highlights panels. Answer FeedError::NotSupported (the default) to have the panels say the feed has none.

fn calendar(&self, query: CalendarQuery, reply: Reply<Vec<CalendarEvent>>)

The events of one calendar that pass query’s filters, in time order, for the calendar panel. Answer FeedError::NotSupported (the default) to have the panel say the feed has none.

fn screen(&self, query: ScreenerQuery, reply: Reply<Vec<ScreenerRow>>)

Up to query.limit symbols that meet every filter of query, sorted as it asks, each with the values of its columns, for the screener. The feed does the screening. Answer FeedError::InvalidData for a filter it cannot apply, and FeedError::NotSupported (the default) to have the panel say the feed has none.

fn hotlist(&self, query: HotlistQuery, reply: Reply<Vec<HotlistEntry>>)

Up to query.limit symbols of the hotlist query.list, in the list’s order, for the hotlists panel. Answer FeedError::NotSupported (the default) to have the panel say the feed has none.

fn screen_text(&self, query: ScreenerQuery, reply: Reply<ScreenerTextAnswer>)

As screen, for a query whose text describes the screen in words. The feed interprets the text with the other criteria and answers the rows with an explanation of how it understood them. Answer FeedError::NotSupported (the default) to have the panel say the feed takes no descriptions, and FeedError::InvalidData for one it cannot interpret.

fn request_depth_snapshot(&self, id: SubscriptionId)

The order book of subscription id was lost to a gap, an unusable update or a book deeper than the limit: push a new snapshot with Sink::push_depth_snapshot, and keep pushing deltas while it is fetched. The snapshot may be older than the latest delta: the chart holds the deltas pushed while the book waits and applies those numbered above the snapshot. Called once per loss: after an unusable snapshot the chart does not ask again, and the book stays empty until the feed pushes a usable one or the subscription restarts. The default does nothing, for feeds without depth.