Struct RithmicModifyOrder 

#[non_exhaustive]
pub struct RithmicModifyOrder {
    pub id: String,
    pub exchange: String,
    pub symbol: String,
    pub quantity: i32,
    pub price: Option<f64>,
    pub price_type: OrderType,
    pub trigger_price: Option<f64>,
    pub manual_or_auto: ManualOrAutoEntry,
    pub window_name: Option<String>,
    pub trail_by_ticks: Option<i32>,
    pub if_touched: Option<RithmicIfTouchedTrigger>,
}

Modify an existing order’s price, quantity, or type.

Example

use rithmic_rs::{OrderType, RithmicModifyOrder};
// "123456" is the basket_id from the order notification.
let modification = RithmicModifyOrder::new()
    .id("123456")
    .symbol("ESH6")
    .exchange("CME")
    .quantity(2)
    .price(5005.0)
    .price_type(OrderType::Limit)
    .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.

id: String

The basket_id from the order notification

exchange: String

Exchange code

symbol: String

Trading symbol

quantity: i32

New quantity

price: Option<f64>

New price, omitted from the request when unset. A modify restates the order, so set this to the order’s current price when only the quantity is changing.

price_type: OrderType

Order type

trigger_price: Option<f64>

Trigger price. Left unset, the four triggering price types — the stop and if-touched pairs — send price in its place.

manual_or_auto: ManualOrAutoEntry

Whether the modification was made by a human or automatically.

window_name: Option<String>

Originating window name reported to Rithmic.

trail_by_ticks: Option<i32>

Ticks to trail behind the market price.

A bare distance, not a TrailingStop — a modify takes no price-id.

if_touched: Option<RithmicIfTouchedTrigger>

Conditional trigger on the resulting order.

Implementations

impl RithmicModifyOrder

pub fn new() -> Self

Start from the defaults.

A modify restates the order rather than patching it, so every field that describes the resulting order has to be set.

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

The basket_id of the order being modified.

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

The order’s size after the modification.

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

The order’s price after the modification.

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

The order’s type after the modification.

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

Trigger price distinct from the limit price. Left unset, the triggering price types send price in its place.

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 modification under.

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

Trail the resulting order this many ticks behind the market price.

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

Attach a conditional trigger to the resulting order.

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

Check the modification carries the prices its Self::price_type requires: Limit, StopLimit and LimitIfTouched need Self::price; StopMarket, StopLimit, MarketIfTouched and LimitIfTouched need a trigger, which is Self::trigger_price or the Self::price that stands in for it. Market needs neither.

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

Requires the basket_id, the instrument, and the prices the price type needs.

Trait Implementations

impl Clone for RithmicModifyOrder

fn clone(&self) -> RithmicModifyOrder

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RithmicModifyOrder

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

Formats the value using the given formatter.

impl Default for RithmicModifyOrder

fn default() -> RithmicModifyOrder

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for RithmicModifyOrder

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for RithmicModifyOrder

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for RithmicModifyOrder

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 RithmicModifyOrder