Enum OrderKind 

#[non_exhaustive]
pub enum OrderKind {
    Market,
    Limit,
    Stop {
        trigger_price: Decimal,
    },
    StopLimit {
        trigger_price: Decimal,
    },
    TakeProfit {
        trigger_price: Decimal,
    },
    TakeProfitLimit {
        trigger_price: Decimal,
    },
    TrailingStop {
        offset: Decimal,
        offset_type: TrailingOffsetType,
        activation_price: Option<Decimal>,
    },
    TrailingStopLimit {
        offset: Decimal,
        offset_type: TrailingOffsetType,
        stop_price: Decimal,
        limit_offset: Decimal,
    },
    TrailingStopFixedLimit {
        offset: Decimal,
        offset_type: TrailingOffsetType,
        activation_price: Option<Decimal>,
    },
}

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.

Market

Limit

Stop

Stop (market) order - triggers a market order when trigger_price is reached.

Fields

trigger_price: Decimal

StopLimit

Stop-limit order - triggers a limit order at Order.price when trigger_price is reached.

Fields

trigger_price: Decimal

TakeProfit

Take-profit (market) order - triggers a market order when trigger_price is reached. Opposite of Stop: triggers when price moves favorably (above for longs, below for shorts).

Fields

trigger_price: Decimal

TakeProfitLimit

Take-profit limit order - triggers a limit order at Order.price when trigger_price is reached.

Fields

trigger_price: Decimal

TrailingStop

Trailing stop order - stop price trails the market by a specified offset.

Fields

offset: Decimal

offset_type: TrailingOffsetType

activation_price: Option<Decimal>

The price the market must reach before the stop starts trailing, or None to trail from the next trade.

Which way the market must reach it is the venue’s. On Binance spot and margin, whose trailing stop is a STOP_LOSS with a stopPrice, a sell starts trailing once the market is at or below it and a buy once at or above it. A client whose venue has no activation price rejects Some with OrderError::UnsupportedOrderType, and one that sends it refuses a price that is not positive.

Read back from a venue, it is the price the venue reports in the same field, which Binance does not document as fixed once the stop activates.

TrailingStopLimit

Trailing stop-limit order - when triggered, submits a limit order offset from the stop.

The limit price follows from the stop and limit_offset, so the order takes no price.

Fields

offset: Decimal

offset_type: TrailingOffsetType

stop_price: Decimal

The stop price at submission; it then trails the market by offset. Must be positive.

The venue may trail it straight away. On IBKR paper, a stop within offset of the market was kept as placed, and one further away moved to offset from the market within seconds of IB accepting the order, for buys and sells, absolute and percentage trails. So an order read back from a venue listing may report the stop after it has trailed, not the one it was placed with.

limit_offset: Decimal

Offset from the triggered stop price to set the limit price.

TrailingStopFixedLimit

Trailing stop whose limit price is fixed when it is placed: only the trigger trails, and once it triggers the order works at OrderRequestOpen’s price, as a StopLimit does. Binance spot and margin’s STOP_LOSS_LIMIT with a trailingDelta.

Unlike TrailingStopLimit, whose limit follows the triggered stop. A client whose venue has no such order rejects it with OrderError::UnsupportedOrderType.

Fields

offset: Decimal

offset_type: TrailingOffsetType

activation_price: Option<Decimal>

As TrailingStop’s activation_price.

Trait Implementations

impl Clone for OrderKind

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 OrderKind

impl Debug for OrderKind

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OrderKind

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for OrderKind

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

Formats the value using the given formatter.

impl Eq for OrderKind

impl Hash for OrderKind

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 OrderKind

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 OrderKind

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for OrderKind

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 OrderKind

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 OrderKind