Struct StrategyContext 

pub struct StrategyContext<'a> { /* private fields */ }

What a Strategy sees at a decision: the bars up to it and the open position. It places and cancels working orders by id.

An order placed with the id of a working order replaces it, keeping its original place among orders reached at the same point. Working orders stay until they fill or are cancelled. A quantity must be positive and finite and a price finite; an order with any other is ignored.

Implementations

impl StrategyContext<'_>

pub fn bars(&self) -> &[Bar]

Chart bars through this decision, oldest first. Live tick decisions include the forming bar; intrabar fill callbacks exclude the unfinished bar. See Self::is_forming_bar.

pub fn position(&self) -> f64

The open position: positive when long, negative when short, 0 when flat.

pub fn price(&self) -> f64

The latest close on a bar decision, or the execution price immediately after a fill.

pub fn equity(&self) -> f64

Account equity marked at Self::price, after any fill commission.

pub fn is_after_fill(&self) -> bool

Whether this is a recalculation immediately after a fill rather than a closed bar.

pub fn is_forming_bar(&self) -> bool

Whether the current decision belongs to a still-forming live bar. Fill callbacks continue to exclude that bar from bars, even while this flag is true.

pub fn entry( &mut self, id: impl Into<String>, side: OrderSide, quantity: impl Into<Option<f64>>, order_type: OrderType, )

Places an entry of quantity on side. Against an open position on the other side it closes that position first, then opens quantity on side; on the same side it adds. Pass None to use the settings’ order size, calculated when the order fills.

pub fn exit( &mut self, id: impl Into<String>, quantity: Option<f64>, take_profit: Option<f64>, stop_loss: Option<f64>, )

Places an exit that reduces the open position by quantity, or closes it with None. It fills at the take_profit limit or the stop_loss stop, whichever the price reaches first, or at market without either. An exit only reduces the position open when it is placed or, placed while flat, the position the next entry opens; once that position is closed or reversed, the exit is cancelled.

pub fn cancel(&mut self, id: &str)

Cancels the working order with this id, if any.

pub fn exit_relative( &mut self, id: impl Into<String>, side: OrderSide, take_profit: f64, stop_loss: f64, )

Brackets entries on side at positive price distances from their average fill price. The bracket can precede its entry and protects it on its execution bar, including gaps and slippage. Adding an entry moves the bracket with the position’s average price. It closes the whole position, then protects any queued entries on that side. Without a queued entry it is cancelled when the position closes or reverses.