Struct Order

#[repr(align(64))]
pub struct Order {

    pub id: OrderId,
    pub exchange_order_id: Option<String>,
    pub venue: Venue,
    pub symbol: String,
    pub side: OrderSide,
    pub order_type: OrderType,
    pub price: Option<Decimal>,
    pub stop_price: Option<Decimal>,
    pub quantity: Decimal,
    pub filled_quantity: Decimal,
    pub average_fill_price: Option<Decimal>,
    pub status: OrderStatus,
    pub creation_time_ns: u64,
    pub update_time_ns: u64,
    pub client_id: ClientId,
    pub time_in_force: TimeInForce,
    pub metadata: Value,
}

Represents an order in the system

Fields

id: OrderId

Unique order ID

exchange_order_id: Option<String>

Exchange-specific order ID (once assigned)

venue: Venue

Exchange identifier

symbol: String

Trading symbol (e.g. “BTCUSDT”)

side: OrderSide

Order side (buy or sell)

order_type: OrderType

Order type

price: Option<Decimal>

Limit price (required for limit orders)

stop_price: Option<Decimal>

Stop price (required for stop orders)

quantity: Decimal

Order quantity

filled_quantity: Decimal

Filled quantity

average_fill_price: Option<Decimal>

Average fill price

status: OrderStatus

Current order status

creation_time_ns: u64

Order creation time in nanoseconds

update_time_ns: u64

Order update time in nanoseconds

client_id: ClientId

Strategy or client ID that created this order

time_in_force: TimeInForce

Time in force for the order

metadata: Value

Additional order metadata

Implementations

impl Order

pub fn new( venue: Venue, symbol: impl AsRef<str>, side: OrderSide, order_type: OrderType, quantity: Decimal, price: Option<Decimal>, client_id: ClientId, ) -> Self

Create a new order

pub fn with_time_in_force( venue: Venue, symbol: impl AsRef<str>, side: OrderSide, order_type: OrderType, quantity: Decimal, price: Option<Decimal>, client_id: ClientId, time_in_force: TimeInForce, ) -> Self

Create a new order with specific time in force

pub fn is_filled(&self) -> bool

Determine if order is completely filled

pub fn remaining_quantity(&self) -> Decimal

Calculate remaining quantity

pub fn update_status(&mut self, status: OrderStatus)

Update order status

Trait Implementations

impl Clone for Order

fn clone(&self) -> Order

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Order

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

Formats the value using the given formatter.

impl Default for Order

Default implementation using Poolable for object pool compatibility

This implementation uses the safe Poolable trait to provide Default behavior for object pools while maintaining the security benefits of removing the original Default implementation that could create accidentally valid orders.

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Order

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Poolable for Order

Poolable implementation for safe object pool usage

This implementation provides safe pool initialization without the risks of the Default trait. Objects created through this trait are obviously invalid and safe for pool pre-allocation.

fn new_for_pool() -> Self

Create a poolable object with invalid/empty state

fn reset_for_pool(&mut self)

Reset the object to poolable state

impl Serialize for Order

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.