Struct ReplayClock 

pub struct ReplayClock { /* private fields */ }

A deterministic clock merging all instruments by time, sequence, then symbol. Advancing uses wall-clock elapsed time times the speed, never a bar index. Hosts own the input and scheduling. Seek rebuilds trades from the start and depth from the latest preceding snapshot per symbol.

use egui_charts::data::{MarketEvent, ReplayClock, ReplayEvent};
use egui_charts::model::Tick;
use std::time::Duration;
let time = chrono::Utc::now();
let event = ReplayEvent::new("A", time, 0,
    MarketEvent::Trade(Tick::new(time, 100.0, 2.0, None)));
let mut clock = ReplayClock::new(vec![event]).unwrap();
clock.set_speed(2.0).unwrap();
assert_eq!(clock.advance(Duration::ZERO).unwrap().len(), 1);
assert!(clock.is_finished());

Implementations

impl ReplayClock

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

Sorts events into deterministic replay order. Duplicate time/sequence keys within one symbol or disagreeing payload timestamps/symbols are invalid; equal keys across symbols are ordered by symbol. Start at the first event, with no events consumed yet.

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

Current market time.

pub fn speed(&self) -> f64

Playback multiplier; zero pauses the clock.

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

Sets a finite non-negative multiplier, preserving sub-nanosecond elapsed time.

pub fn is_finished(&self) -> bool

Whether every recorded event has been consumed.

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

Advances by real elapsed time at the selected speed, returning newly due events once, including events at the new time. A paused clock consumes nothing. Overflow is an error without changing the cursor or time. Sub-nanosecond progress is retained between calls.

pub fn seek(&mut self, time: DateTime<Utc>) -> impl Iterator<Item = ReplayEvent>

Seeks inclusively to time. Before pushing these events, call Sink::reset_replay on every participating sink. Trades rebuild bars from the beginning; book messages before each symbol’s latest snapshot are skipped. A symbol without a snapshot starts empty and follows normal gap/resync rules. Subsequent advance returns only events after the seek.

Trait Implementations

impl Clone for ReplayClock

fn clone(&self) -> ReplayClock

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for ReplayClock

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.