Enum OrderType 

#[non_exhaustive]
pub enum OrderType {
    Market,
    BuyLimit {
        limit_price: f64,
    },
    BuyStop {
        stop_price: f64,
    },
    SellLimit {
        limit_price: f64,
    },
    SellStop {
        stop_price: f64,
    },
    BuyStopLimit {
        stop_price: f64,
        limit_price: f64,
    },
}

Order type controlling how a signal’s entry is executed.

OrderType::Market (the default) preserves the existing behaviour: fill at the next bar’s open. The limit and stop variants queue the order as a PendingOrder and fill when the bar’s high/low reaches the specified price level.

This enum is #[non_exhaustive] so that adding new order types (e.g. MarketOnClose, TrailingStopLimit) in a future release is not a breaking change for library consumers that match on it exhaustively.

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

Standard market order — fill at next bar’s open (default).

BuyLimit

Limit buy — fill if candle.low ≤ limit_price.

Fields

limit_price: f64

Maximum price accepted for a long entry.

BuyStop

Stop buy (breakout) — fill if candle.high ≥ stop_price.

Fields

stop_price: f64

Price level that triggers a long entry.

SellLimit

Limit sell — fill if candle.high ≥ limit_price.

Fields

limit_price: f64

Minimum price accepted for a short entry.

SellStop

Stop sell (breakdown) — fill if candle.low ≤ stop_price.

Fields

stop_price: f64

Price level that triggers a short entry.

BuyStopLimit

Stop-limit buy — triggered when candle.high ≥ stop_price, filled at the trigger price capped at limit_price.

If the bar opens above limit_price the order cannot fill that bar.

Fields

stop_price: f64

Price that activates the limit order.

limit_price: f64

Maximum acceptable fill price.

Trait Implementations

impl Clone for OrderType

fn clone(&self) -> OrderType

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OrderType

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

Formats the value using the given formatter.

impl Default for OrderType

fn default() -> OrderType

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for OrderType

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for OrderType

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for OrderType

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 OrderType