Enum MarketOrderTiming 

#[non_exhaustive]
pub enum MarketOrderTiming {
    OnArrival,
    NextBar(NextBarPrice),
}

When a simulated venue fills a market order, as MockExecutionConfig::market_order_timing selects. Defaults to OnArrival.

#[non_exhaustive]: other rules for when a held order is released may be added.

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

OnArrival

Fill the moment the order reaches the venue, against the market it holds then.

On a bar feed with no latency, that market is the close of the bar the sender has just seen: the order trades at exactly the price it decided on, with no time to react, no spread crossed and no impact. A common convention, and an optimistic one — a strategy can come to depend on it. NextBar is the pessimistic comparison.

NextBar(NextBarPrice)

Hold the order until its instrument’s next bar, and fill it at that bar’s price.

For bar data only: the venue must be fed bars, through the bar argument of SimulatedVenue::apply_market. Anything else fails visibly rather than falling back:

• a market order on an instrument the venue has never been fed a bar for is rejected, naming this setting. That includes every market order on a RequestPriced venue, which has no feed at all;
• a tick or quote between two bars moves the market but does not release a held order.

While it is held

The order is accepted as Open, so a cancel takes it back as it would a resting order. The venue holds what the order would cost at its current price, as it holds a limit order’s cost at its limit, so two held orders cannot both spend one balance. An order the account cannot cover at that price is refused on arrival, as it is under OnArrival.

When the next bar arrives

The hold is released and the order filled as a taker, at the reference price NextBarPrice picks, priced by the venue’s FillModel and moved by its slippage like any other taker fill. The fill is costed afresh, and an order the account can no longer afford is cancelled and reported. Its time in force decides the rest as on arrival: immediate-or-cancel keeps what the bar’s size allows and cancels the remainder, fill-or-kill trades all of it or nothing. The fill is stamped at the bar’s instant.

When the data ends first

An order still held when its driver runs out of data is retired as expired, filled nothing, so every accepted order is answered.

Only market orders are held for the bar. A limit order rests and matches as it always does, unless StaleMarketPolicy::Wait holds it on a stale market.

Any bar releases a held order, one reported with zero volume included. To have such a bar release nothing, combine this with StaleMarketPolicy::Wait.

Trait Implementations

impl Clone for MarketOrderTiming

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for MarketOrderTiming

impl Debug for MarketOrderTiming

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

Formats the value using the given formatter.

impl Default for MarketOrderTiming

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for MarketOrderTiming

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for MarketOrderTiming

impl Hash for MarketOrderTiming

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for MarketOrderTiming

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for MarketOrderTiming

fn eq(&self, other: &Self) -> bool

Equality operator ==.

fn ne(&self, other: &Rhs) -> bool

Inequality operator !=.

impl PartialOrd for MarketOrderTiming

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

Tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

Tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

Tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for MarketOrderTiming

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for MarketOrderTiming