Struct RithmicOrder 

#[non_exhaustive]
pub struct RithmicOrder {

    pub symbol: String,
    pub exchange: String,
    pub quantity: i32,
    pub price: Option<f64>,
    pub transaction_type: OrderSide,
    pub price_type: OrderType,
    pub user_tag: String,
    pub duration: TimeInForce,
    pub trigger_price: Option<f64>,
    pub trailing_stop: Option<TrailingStop>,
    pub trade_route: Option<String>,
    pub manual_or_auto: ManualOrAutoEntry,
    pub window_name: Option<String>,
    pub release_at_ssboe: Option<i32>,
    pub release_at_usecs: Option<i32>,
    pub cancel_at_ssboe: Option<i32>,
    pub cancel_at_usecs: Option<i32>,
    pub cancel_after_secs: Option<i32>,
    pub if_touched: Option<RithmicIfTouchedTrigger>,
}

A standalone order (not a bracket order).

For orders with automatic profit targets and stop losses, use RithmicBracketOrder instead.

Example: limit order

use rithmic_rs::{OrderSide, OrderType, RithmicOrder};
let order = RithmicOrder::new()
    .symbol("ESH6")
    .exchange("CME")
    .quantity(1)
    .transaction_type(OrderSide::Buy)
    .price_type(OrderType::Limit)
    .price(5000.0)
    .user_tag("my-order-1")
    .build()?;

Example: market order

A market order has no price. Leaving price unset omits the field rather than pricing the order at zero.

use rithmic_rs::{OrderSide, OrderType, RithmicOrder};
let order = RithmicOrder::new()
    .symbol("ESH6")
    .exchange("CME")
    .quantity(1)
    .transaction_type(OrderSide::Buy)
    .price_type(OrderType::Market)
    .user_tag("market-order")
    .build()?;

assert_eq!(order.price, None);

Example: stop-limit with a trailing stop

use rithmic_rs::{OrderSide, OrderType, RithmicOrder};
let order = RithmicOrder::new()
    .symbol("ESH6")
    .exchange("CME")
    .quantity(1)
    .transaction_type(OrderSide::Sell)
    .price_type(OrderType::StopLimit)
    .price(4980.0)
    .trigger_price(4985.0)
    .trailing_stop_by(20, 1)
    .build()?;

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.

symbol: String

Trading symbol (e.g., “ESH6”)

exchange: String

Exchange code (e.g., “CME”)

quantity: i32

Number of contracts

price: Option<f64>

Order price. A market order does not need one.

transaction_type: OrderSide

Buy or Sell

price_type: OrderType

Order type (Limit, Market, StopLimit, StopMarket, etc.)

user_tag: String

Your identifier for tracking this order

duration: TimeInForce

Order duration

trigger_price: Option<f64>

Trigger price. Only a stop or if-touched order needs one.

trailing_stop: Option<TrailingStop>

Trailing stop configuration

trade_route: Option<String>

Route to send on. None uses the route the server published for exchange.

manual_or_auto: ManualOrAutoEntry

Whether the order was placed by a human or automatically.

window_name: Option<String>

Originating window name reported to Rithmic.

release_at_ssboe: Option<i32>

Release the order at this second-since-beginning-of-epoch value.

release_at_usecs: Option<i32>

Microsecond component for Self::release_at_ssboe.

cancel_at_ssboe: Option<i32>

Cancel the order at this second-since-beginning-of-epoch value.

cancel_at_usecs: Option<i32>

Microsecond component for Self::cancel_at_ssboe.

cancel_after_secs: Option<i32>

Cancel the order after this many seconds.

if_touched: Option<RithmicIfTouchedTrigger>

Conditional trigger that releases this order once touched.

Implementations

impl RithmicOrder

pub fn new() -> Self

Start from the defaults.

pub fn symbol(self, symbol: impl Into<String>) -> Self

Instrument symbol.

pub fn exchange(self, exchange: impl Into<String>) -> Self

Exchange the instrument trades on.

pub fn quantity(self, quantity: i32) -> Self

Number of contracts.

pub fn transaction_type(self, transaction_type: OrderSide) -> Self

Buy or sell.

pub fn price_type(self, price_type: OrderType) -> Self

Market, limit, stop, or if-touched.

pub fn price(self, price: f64) -> Self

Order price.

pub fn trigger_price(self, trigger_price: f64) -> Self

Trigger price for stop and if-touched order types.

pub fn user_tag(self, user_tag: impl Into<String>) -> Self

Your identifier for this order.

pub fn duration(self, duration: TimeInForce) -> Self

How long the order stays working.

pub fn trailing_stop(self, trailing_stop: TrailingStop) -> Self

Trailing stop configuration.

pub fn trailing_stop_by( self, trail_by_ticks: i32, trail_by_price_id: i32, ) -> Self

Trail by trail_by_ticks against Rithmic’s trail_by_price_id.

pub fn trade_route(self, trade_route: impl Into<String>) -> Self

Route to send on, overriding the route published for the exchange.

pub fn manual_or_auto(self, manual_or_auto: ManualOrAutoEntry) -> Self

Whether this was done by a human or automatically.

pub fn window_name(self, window_name: impl Into<String>) -> Self

Window name to report this order under.

pub fn release_at_ssboe(self, ssboe: i32) -> Self

Release the order at this second-since-beginning-of-epoch value.

pub fn release_at_usecs(self, usecs: i32) -> Self

Microsecond component of the release time.

pub fn release_at(self, ssboe: i32, usecs: i32) -> Self

Set both halves of the release time.

pub fn cancel_at_ssboe(self, ssboe: i32) -> Self

Cancel the order at this second-since-beginning-of-epoch value.

pub fn cancel_at_usecs(self, usecs: i32) -> Self

Microsecond component of the cancel time.

pub fn cancel_at(self, ssboe: i32, usecs: i32) -> Self

Set both halves of the cancel time.

pub fn cancel_after_secs(self, secs: i32) -> Self

Cancel the order after this many seconds.

pub fn if_touched(self, if_touched: RithmicIfTouchedTrigger) -> Self

Conditional trigger that releases this order once touched.

pub fn validate(&self) -> Result<(), RithmicError>

Check the order names an instrument (symbol, exchange, a positive quantity) and carries the prices its Self::price_type requires: Limit, StopLimit and LimitIfTouched need Self::price; StopMarket, StopLimit, MarketIfTouched and LimitIfTouched need Self::trigger_price. Market needs neither. An embedded TrailingStop or RithmicIfTouchedTrigger is deliberately not re-validated — build() on those types is the opt-in strict path.

pub fn build(self) -> Result<Self, RithmicError>

Requires an instrument and the prices the price type needs.

Trait Implementations

impl Clone for RithmicOrder

fn clone(&self) -> RithmicOrder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RithmicOrder

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

Formats the value using the given formatter.

impl Default for RithmicOrder

fn default() -> RithmicOrder

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RithmicOrder

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RithmicOrder

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for RithmicOrder

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 RithmicOrder