Struct EngineContext 

pub struct EngineContext<'a> {

    pub place_orders: Vec<PlaceOrder>,
    pub batch_orders: Vec<Vec<PlaceOrder>>,
    pub cancel_orders: Vec<CancelOrder>,
    pub cancel_alls: Vec<CancelAll>,
    pub stop_requests: Vec<StopStrategy>,
    pub timers: Vec<PendingTimer>,
    pub canceled_timers: Vec<TimerId>,
    pub quotes: &'a HashMap<InstrumentId, Quote>,
    pub instruments: &'a HashMap<InstrumentId, InstrumentMeta>,
    pub orders: &'a OrderManager,
    pub inventory: &'a InventoryLedger,
    pub positions: &'a HashMap<InstrumentId, Position>,
    pub exchange_health: &'a HashMap<ExchangeInstance, ExchangeHealth>,
    pub now_ms: i64,
}

Concrete implementation of StrategyContext

Fields

place_orders: Vec<PlaceOrder>

Single-order commands emitted during the current callback.

batch_orders: Vec<Vec<PlaceOrder>>

Batch order commands emitted during the current callback.

cancel_orders: Vec<CancelOrder>

Cancel-one commands emitted during the current callback.

cancel_alls: Vec<CancelAll>

Cancel-all commands emitted during the current callback.

stop_requests: Vec<StopStrategy>

Strategy stop requests emitted during the current callback.

timers: Vec<PendingTimer>

Timer registrations emitted during the current callback.

canceled_timers: Vec<TimerId>

Timer cancellations emitted during the current callback.

quotes: &'a HashMap<InstrumentId, Quote>

Latest quotes by instrument.

instruments: &'a HashMap<InstrumentId, InstrumentMeta>

Instrument metadata by instrument.

orders: &'a OrderManager

Order manager snapshot.

inventory: &'a InventoryLedger

Inventory ledger snapshot.

positions: &'a HashMap<InstrumentId, Position>

Current positions by instrument.

exchange_health: &'a HashMap<ExchangeInstance, ExchangeHealth>

Exchange health by exchange instance.

now_ms: i64

Engine clock in milliseconds since the Unix epoch.

Implementations

impl<'a> EngineContext<'a>

pub fn new( quotes: &'a HashMap<InstrumentId, Quote>, instruments: &'a HashMap<InstrumentId, InstrumentMeta>, orders: &'a OrderManager, inventory: &'a InventoryLedger, positions: &'a HashMap<InstrumentId, Position>, exchange_health: &'a HashMap<ExchangeInstance, ExchangeHealth>, now_ms: i64, ) -> Self

Create an engine context for one strategy callback.

pub fn take_commands( &mut self, ) -> (Vec<PlaceOrder>, Vec<Vec<PlaceOrder>>, Vec<CancelOrder>, Vec<CancelAll>, Vec<StopStrategy>)

Drain all collected commands

pub fn take_timers(&mut self) -> (Vec<PendingTimer>, Vec<TimerId>)

Drain all timer registrations

Trait Implementations

impl<'a> StrategyContext for EngineContext<'a>

fn place_order(&mut self, cmd: PlaceOrder)

Place a new order. Returns immediately; acceptance/rejection comes via events.

fn place_orders(&mut self, cmds: Vec<PlaceOrder>)

Place multiple orders in a single batch. Returns immediately; acceptance/rejection comes via events.

fn cancel_order(&mut self, cmd: CancelOrder)

Cancel an existing order by client_id.

fn cancel_all(&mut self, cmd: CancelAll)

Cancel all open orders (optionally for an instrument).

fn stop_strategy(&mut self, strategy_id: StrategyId, reason: &str)

Request strategy stop. This will trigger on_stop callback after current event processing.

fn set_timer(&mut self, delay: Duration) -> TimerId

Register a one-shot timer that fires after delay.

fn set_interval(&mut self, interval: Duration) -> TimerId

Register a repeating timer that fires every interval.

fn cancel_timer(&mut self, timer_id: TimerId)

Cancel a previously set timer.

fn mid_price(&self, instrument: &InstrumentId) -> Option<Price>

Get the current mid price for an instrument (if available from quote poller)

fn quote(&self, instrument: &InstrumentId) -> Option<Quote>

Get the current best bid/ask quote for an instrument

fn instrument_meta(&self, instrument: &InstrumentId) -> Option<&InstrumentMeta>

Get instrument metadata

fn balance(&self, asset: &AssetId) -> Balance

Get this strategy’s current balance for an asset

fn position(&self, instrument: &InstrumentId) -> Position

Get the current position for an instrument

fn exchange_health(&self, exchange: &ExchangeInstance) -> ExchangeHealth

Check if exchange is Active or Halted

fn order(&self, client_id: &ClientOrderId) -> Option<&LiveOrder>

Get an order by client_id (if tracked)

fn now_ms(&self) -> i64

Current time in milliseconds (deterministic in backtests)

fn log_info(&self, msg: &str)

Log an info message

fn log_warn(&self, msg: &str)

Log a warning message

fn log_error(&self, msg: &str)

Log an error message

fn log_debug(&self, msg: &str)

Log a debug message