Enum OrderType 

#[non_exhaustive]
pub enum OrderType {
    Market,
    Limit,
    Stop,
    StopLimit,
    TrailingStop,
    Cabinet,
    NonMarketable,
    MarketOnClose,
    Exercise,
    TrailingStopLimit,
    NetDebit,
    NetCredit,
    NetZero,
    LimitOnClose,
    UnknownSchwab,
    Unknown(String),
}

How the order’s fill price is determined.

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

Fill at the best available market price.

Limit

Fill at the specified price or better.

Stop

Becomes a market order once the stop is touched.

StopLimit

Becomes a limit order once the stop is touched.

TrailingStop

Stop that follows the market at a fixed offset.

Cabinet

Cabinet (zero-premium) options trade.

NonMarketable

Limit order priced away from the inside market.

MarketOnClose

Market order executed in the closing auction.

Exercise

Exercise of a long option.

TrailingStopLimit

Trailing stop that becomes a limit order once triggered.

NetDebit

Multi-leg order with a net debit price.

NetCredit

Multi-leg order with a net credit price.

NetZero

Multi-leg order with a net price of zero.

LimitOnClose

Limit order executed in the closing auction.

UnknownSchwab

Schwab sent the literal string "UNKNOWN".

Unknown(String)

A wire value Schwab sent that this crate does not recognize. The raw string is preserved so callers can still route on it.

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<'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 Display for OrderType

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

Formats the value using the given formatter.

impl From<&str> for OrderType

fn from(s: &str) -> OrderType

Converts to this type from the input type.

impl From<OrderType> for String

fn from(v: OrderType) -> Self

Converts to this type from the input type.

impl From<String> for OrderType

fn from(v: String) -> Self

Converts to this type from the input type.

impl FromStr for OrderType

type Err = Infallible

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<OrderType, <Self as FromStr>::Err>

Parses a string s to return a value of this type.

impl Hash for OrderType

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 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 Eq for OrderType

impl StructuralPartialEq for OrderType