Struct OrderRules 

#[non_exhaustive]
pub struct OrderRules {
    pub price: ValueRule,
    pub quantity: ValueRule,
    pub market_quantity: ValueRule,
    pub notional: ValueRule,
    pub market_notional: ValueRule,
    pub trailing_offset_above: ValueRule,
    pub trailing_offset_below: ValueRule,
}

One instrument’s order rules.

Venue-agnostic: a client fills it from its venue’s rules and calls check. Default is no rules at all, which passes every order.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

price: ValueRule

The grid and range of a limit, stop and trigger price, and of a trailing order’s activation price.

quantity: ValueRule

The grid and range of every order’s quantity.

market_quantity: ValueRule

The grid and range of a market order’s quantity, on top of quantity.

notional: ValueRule

The range of the notional, a price times a quantity. Its step is not used.

market_notional: ValueRule

The part of notional the venue also applies to a market order: off where the venue exempts market orders. Its step is not used.

check never applies it: a market order has no price of its own, and the venue measures its notional at a price of its own choosing, such as a reference price or an average of recent trades, that the check cannot know. A caller that holds a price it trusts can compare that price times the quantity with this rule’s min and max.

trailing_offset_above: ValueRule

The range of a trailing order’s offset, in basis points, when its trigger trails above the market and fires on a rise: a buy trailing stop. Its step is not used.

trailing_offset_below: ValueRule

The range of a trailing order’s offset, in basis points, when its trigger trails below the market and fires on a fall: a sell trailing stop. Its step is not used.

Implementations

impl OrderRules

pub fn new( price: ValueRule, quantity: ValueRule, market_quantity: ValueRule, notional: ValueRule, ) -> Self

Rules with price, quantity, market_quantity and notional as given, and the rest off: add them with with_market_notional and with_trailing_offsets.

pub fn with_market_notional(self, market_notional: ValueRule) -> Self

These rules with market_notional as given.

pub fn with_trailing_offsets(self, above: ValueRule, below: ValueRule) -> Self

These rules with trailing_offset_above and trailing_offset_below as given.

pub fn is_off(&self) -> bool

Whether these rules check nothing.

pub fn round_quantity_down( &self, kind: OrderKind, quantity: Decimal, ) -> Option<Decimal>

The largest quantity at or below quantity that an order of kind may have on the grid: a multiple of quantity’s step and, for a market order, of market_quantity’s too, so a multiple of the smallest step both grids share. As ValueRule::round_down otherwise: it does not clamp to either rule’s range, so check the result before sending it.

Returns None when a Decimal cannot hold the result, as for ValueRule::round_down, or cannot hold the step of the grid the two steps share.

pub fn round_quantity_up( &self, kind: OrderKind, quantity: Decimal, ) -> Option<Decimal>

The smallest quantity at or above quantity that an order of kind may have on the grid. As round_quantity_down otherwise.

pub fn check<AssetKey, InstrumentKey>( &self, side: Side, kind: OrderKind, price: Option<Decimal>, quantity: Decimal, ) -> Result<(), OrderError<AssetKey, InstrumentKey>>

Check an order on side of kind, with its limit price and quantity, against the rules.

Returns the first rule the order breaks, or Ok if it breaks none, checking in this order:

• Prices, the grid and then the range, each on its own value: the limit price of a limit, stop-limit, take-profit-limit or fixed-limit trailing order; the trigger price of a stop, stop-limit, take-profit or take-profit-limit order; and a trailing order’s activation price when it has one. A market order has no price to check.
• Trailing offset, of a trailing stop of any kind: a buy’s against trailing_offset_above, a sell’s against trailing_offset_below. An offset in Percentage is compared in percent, the limits divided by 100, so a refusal names both in the order’s own unit. An Absolute offset is not checked: its size in basis points depends on a price the check does not have.
• Quantity, against quantity and, for a market order, then market_quantity.
• Notional, price × quantity, only where the price is the order’s own limit: a limit, stop-limit, take-profit-limit or fixed-limit trailing order. Never a market, plain stop or trailing-stop order: the venue prices them at a reference price this check cannot know, which is also why market_notional is never checked. An order with no price skips it.

A closing order is checked like any other: a venue that enforces a minimum notional enforces it on a close too, so an exemption would move the refusal to the venue.

Errors

OrderError::InvalidPrecision with PrecisionLimit::NotOnGrid for a value off its grid, OrderError::OutOfBounds for one outside its range.

Trait Implementations

impl Clone for OrderRules

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 OrderRules

impl Debug for OrderRules

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

Formats the value using the given formatter.

impl Default for OrderRules

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for OrderRules

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for OrderRules

impl Hash for OrderRules

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 PartialEq for OrderRules

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for OrderRules

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 OrderRules