Struct BacktestRunner 

pub struct BacktestRunner { /* private fields */ }

Orchestrates a backtest by driving the engine with data and actions.

Implementations

impl BacktestRunner

pub fn run_portfolio_future<F>( self, source_feed: &mut F, instances: Vec<ConfiguredInstance>, supervisor: Option<PortfolioSupervisor>, retention: StrategyRetentionLimits, ) -> Result<PortfolioBacktestResult, PortfolioReplayError<Infallible>>

where F: DataFeed,

Run several configured strategy instances from a materialized data feed against one account.

pub fn run_mixed_portfolio_future<F, E>( self, source_feed: &mut F, configured: Vec<ConfiguredInstance>, direct: Vec<DirectPortfolioInstance<E>>, supervisor: Option<PortfolioSupervisor>, retention: StrategyRetentionLimits, ) -> Result<MixedPortfolioBacktestResult, MixedPortfolioReplayError<Infallible>>

where F: DataFeed, E: Display,

Run configured and caller-compiled strategies against one shared account while preserving their distinct bar timing.

pub fn run_mixed_portfolio_future_streaming_controlled<F, E, C, P>( self, feed: &mut F, primary_eod: Option<NaiveDateTime>, configured: Vec<ConfiguredInstance>, direct: Vec<DirectPortfolioInstance<E>>, supervisor: Option<PortfolioSupervisor>, retention: StrategyRetentionLimits, is_cancelled: C, on_progress: P, ) -> Result<MixedPortfolioBacktestResult, MixedPortfolioReplayError<F::Error>>

where F: FallibleBatchFeed, E: Display, C: FnMut() -> bool, P: FnMut(ReplayProgress),

pub fn run_portfolio_future_streaming_controlled<F, C, P>( self, feed: &mut F, primary_eod: Option<NaiveDateTime>, instances: Vec<ConfiguredInstance>, supervisor: Option<PortfolioSupervisor>, retention: StrategyRetentionLimits, is_cancelled: C, on_progress: P, ) -> Result<PortfolioBacktestResult, PortfolioReplayError<F::Error>>

where F: FallibleBatchFeed, C: FnMut() -> bool, P: FnMut(ReplayProgress),

Run several configured strategy instances from complete ordered timestamp batches against one account, with cooperative cancellation and replay progress.

Each instance keeps its own series, analysis, decisions, and entry profiles; fills, balance, costs, marks, and drawdown are shared. When a supervisor is supplied, every Entry and scale-in an instance generates is reviewed before it is scheduled, and a refused one reaches the instance as a rejected command.

impl BacktestRunner

pub fn new(config: BacktestConfig) -> Self

Create a new runner with the given configuration.

pub fn new_future( config: BacktestConfig, future_config: FutureQuoteConfig, ) -> Self

Create a runner using deterministic FutureQuoteV1 scheduling and pricing.

pub fn with_defaults() -> Self

Create a runner with default configuration.

pub fn with_entry_profiles(self, profiles: PreparedEntryProfiles) -> Self

Apply an immutable per-entry profile routing snapshot.

pub fn with_evaluation_options(self, options: EvaluationOptions) -> Self

Apply typed provider-evaluation options to FutureQuoteV1 results. Legacy execution ignores these options and preserves its existing report.

pub fn with_strategy_research_limits( self, limits: StrategyResearchLimits, ) -> Self

Apply journal bounds to historical strategy replay.

pub fn engine(&self) -> &TradeEngine

Access the underlying engine (e.g. for inspection between runs).

pub fn executor(&self) -> &BacktestExecutor

Access the underlying executor.

pub fn run_strategy<F: DataFeed, S: Strategy>( self, feed: &mut F, strategy: &mut S, ) -> BacktestResult

Run a strategy-driven backtest.

For every event in the data feed:

1. The event is converted to a PriceQuote and fed to the engine (which checks pending fills and evaluates rules).
2. The strategy’s on_event is called; any returned actions are applied to the engine.
3. All resulting effects are forwarded to the executor for P&L tracking.

When the feed is exhausted, Strategy::on_finished is called for any final actions, and (if configured) remaining positions are closed.

pub fn run_raw_signals<F: DataFeed>( self, feed: &mut F, raw_signals: Vec<RawSignal>, profile: Option<&ManagementProfile>, ) -> BacktestResult

Run a raw-signal-replay backtest.

raw_signals must be sorted by timestamp (ascending). Entry signals are optionally transformed through a ManagementProfile, while management signals are resolved against live engine state and passed through directly.

pub fn run_raw_signals_controlled<F, C, P>( self, feed: &mut F, raw_signals: Vec<RawSignal>, profile: Option<&ManagementProfile>, is_cancelled: C, on_progress: P, ) -> Result<BacktestResult, ReplayCancelled>

where F: DataFeed, C: FnMut() -> bool, P: FnMut(ReplayProgress),

Run a raw-signal replay with cooperative cancellation and progress updates.

Cancellation is checked at every market-event and signal boundary. Progress callbacks are rate-limited for long event streams while always reporting the initial and terminal counters.

pub fn run_raw_signals_future<F: DataFeed>( self, feed: &mut F, raw_signals: Vec<RawSignal>, profile: Option<&ManagementProfile>, ) -> BacktestResult

Run raw signals with FutureQuoteV1 scheduling and execution.

Quotes are validated, required to be nondecreasing per symbol in source order, and then globally stable-sorted by timestamp. Signals are sorted by effective time (signal timestamp + latency).

pub fn run_raw_signals_future_streaming_controlled<F, C, P>( self, feed: &mut F, primary_eod: Option<NaiveDateTime>, raw_signals: Vec<RawSignal>, profile: Option<&ManagementProfile>, is_cancelled: C, on_progress: P, ) -> Result<BacktestResult, StreamingReplayError<F::Error>>

where F: FallibleBatchFeed, C: FnMut() -> bool, P: FnMut(ReplayProgress),

Run FutureQuoteV1 directly from a fallible stream of complete timestamp batches.

primary_eod must be determined before replay from valid primary quotes. The feed must already be globally ordered and preserve all events at a timestamp in one batch. Event totals are unknown until the stream terminates, so terminal progress reports total_events == processed_events.

pub fn run_raw_signals_future_fallible<F: FallibleBatchFeed>( self, feed: &mut F, raw_signals: Vec<RawSignal>, profile: Option<&ManagementProfile>, ) -> Result<BacktestResult, F::Error>

Consume a fallible stream of complete timestamp batches and run FutureQuoteV1.

Feed errors are returned without being converted into a backtest result. Batches are buffered so global ordering and primary EOD semantics remain identical to the compatible DataFeed entry point.

pub fn run_raw_signals_future_fallible_with_config<F: FallibleBatchFeed>( self, feed: &mut F, raw_signals: Vec<RawSignal>, profile: Option<&ManagementProfile>, future: FutureQuoteConfig, ) -> Result<BacktestResult, F::Error>

Consume a fallible timestamp-batch stream with explicit FutureQuote settings.

pub fn run_historical_strategy_future<F, S>( self, source_feed: &mut F, strategy: &mut S, series_specs: Vec<BarSeriesSpec>, analysis: AnalysisPipeline, retention: StrategyRetentionLimits, profile: Option<&ManagementProfile>, ) -> Result<StrategyBacktestResult, StrategyReplayError<Infallible, S::Error>>

where F: DataFeed, S: HistoricalStrategy + ?Sized,

Run a historical strategy from a materialized data feed through FutureQuote.

pub fn run_historical_strategy_future_streaming<F, S>( self, feed: &mut F, primary_eod: Option<NaiveDateTime>, strategy: &mut S, series_specs: Vec<BarSeriesSpec>, analysis: AnalysisPipeline, retention: StrategyRetentionLimits, profile: Option<&ManagementProfile>, ) -> Result<StrategyBacktestResult, StrategyReplayError<F::Error, S::Error>>

where F: FallibleBatchFeed, S: HistoricalStrategy + ?Sized,

Run a historical strategy from complete ordered timestamp batches.

pub fn run_configured_strategy_future<F>( self, source_feed: &mut F, adapter: &mut BacktestConfiguredStrategyAdapter, analysis: AnalysisPipeline, retention: StrategyRetentionLimits, profile: Option<&ManagementProfile>, ) -> Result<StrategyBacktestResult, StrategyReplayError<Infallible, ConfiguredStrategyAdapterError>>

where F: DataFeed,

Run a configured strategy from a materialized data feed through FutureQuote.

pub fn run_configured_strategy_future_streaming<F>( self, feed: &mut F, primary_eod: Option<NaiveDateTime>, adapter: &mut BacktestConfiguredStrategyAdapter, analysis: AnalysisPipeline, retention: StrategyRetentionLimits, profile: Option<&ManagementProfile>, ) -> Result<StrategyBacktestResult, StrategyReplayError<F::Error, ConfiguredStrategyAdapterError>>

where F: FallibleBatchFeed,

Run a configured strategy from complete ordered timestamp batches.

pub fn run_configured_strategy_future_streaming_controlled<F, C, P>( self, feed: &mut F, primary_eod: Option<NaiveDateTime>, adapter: &mut BacktestConfiguredStrategyAdapter, analysis: AnalysisPipeline, retention: StrategyRetentionLimits, profile: Option<&ManagementProfile>, is_cancelled: C, on_progress: P, ) -> Result<StrategyBacktestResult, StrategyReplayError<F::Error, ConfiguredStrategyAdapterError>>

where F: FallibleBatchFeed, C: FnMut() -> bool, P: FnMut(ReplayProgress),

Run a configured strategy from complete ordered timestamp batches with cooperative cancellation and replay progress, as the retained-job service does for raw-signal replay.

pub fn run_raw_signals_future_with_config<F: DataFeed>( self, source_feed: &mut F, raw_signals: Vec<RawSignal>, profile: Option<&ManagementProfile>, future: FutureQuoteConfig, ) -> BacktestResult

Run raw signals using deterministic FutureQuoteV1 execution.

Fill-bearing actions never reuse a quote older than their effective timestamp. Signals are stably ordered by (effective_ts, input_sequence); existing pending orders and rules win ties against signals at the exact quote timestamp.