Struct Open 

pub struct Open {
    pub id: VenueOrderId,
    pub time_exchange: DateTime<Utc>,
    pub filled_quantity: Decimal,
}

An order the exchange reports as working, in the state the exchange last reported it.

Successive Open values for one order describe that order over time – an acknowledgement, then each partial fill – so consumers keep the later of two and discard the other. Use Open::is_superseded_by to decide which is which; it does not rest on Open::time_exchange alone, because not every venue supplies a usable one. Producers must still stamp that field correctly where they can; see it for the obligation.

Fields

id: VenueOrderId

How the venue addresses this order.

VenueOrderId::ClientAssigned when the venue acknowledged the order without assigning an identifier of its own. A consumer deciding whether two Open values describe the same venue order must go through VenueOrderId::assigned rather than comparing this field directly, because two ClientAssigned values are equal without being evidence of anything.

time_exchange: DateTime<Utc>

When the exchange last reported this state – not when the order was created.

Producer obligation

A client building this from a venue response must use the venue’s last-update field (Binance updateTime, Alpaca updated_at) rather than its creation field. Creation time is identical across every snapshot of one order, so a snapshot stamped with it cannot be ordered against the states that followed it and is discarded as stale by any consumer applying the rule above – silently, and precisely for the partially-filled orders a reconciliation fetch exists to repair.

filled_quantity: Decimal

Cumulative quantity filled across every execution against this order, as the exchange reports it – not the size of the most recent execution.

Implementations

impl Open

pub const fn new( id: VenueOrderId, time_exchange: DateTime<Utc>, filled_quantity: Decimal, ) -> Open

impl Open

pub fn quantity_remaining(&self, initial_quantity: Decimal) -> Decimal

pub fn is_superseded_by(&self, update: &Self) -> bool

Whether update describes a later state of this order than self does, and so should replace it.

Ordering rests on two properties of a single venue order:

1. Open::time_exchange is non-decreasing, where the venue supplies a usable one.
2. Open::filled_quantity is non-decreasing always – cumulative fill is append-only, because an execution against an order cannot be un-executed.

The second is the stronger property, and it is used in both directions. An update reporting strictly less filled is out of sequence whatever its stamp says, so it is refused outright. Otherwise an update is taken as later when it is stamped no earlier or when it reports strictly more filled.

Each direction carries a different class of venue:

• Refusing a lower cumulative is what orders a venue whose stamps are locally applied. IBKR’s orderStatus callback carries no timestamp field at all, so its client stamps Utc::now() on receipt; those rise in arrival order, which makes the stamp admit every snapshot and degrades ordering to last-writer-wins. The fill invariant still rejects a snapshot that overtook a newer one in flight.
• Admitting a higher cumulative is what rescues a venue whose stamps are too old – a reconciliation fetch pinned to the order’s creation time, whose snapshot would otherwise be discarded along with the only accurate cumulative it carried.

Caller obligation

Both values must already be known to describe the same venue order. This orders states, it does not establish identity – check that first with VenueOrderId::contradicts, or a snapshot belonging to a different order will be ordered against this one as though it were a later state of it.

Known limitations

Two snapshots reporting the same cumulative fill are ordered on the stamp alone, so a venue that supplies no usable one is unordered across them. That covers an order’s whole life before its first execution, which is why the producer obligation on Open::time_exchange still stands.

A venue that reduces a reported cumulative – busting or correcting an execution – has its correction refused, since a decrease is indistinguishable from out-of-sequence delivery. The order is left on the higher cumulative until a later snapshot moves it. A venue that reports the bust or correction itself does so as AccountEventKind::TradeAmended.

A caller replacing self with update wholesale adopts update’s time_exchange too, which may be the earlier of the two. That is deliberate: an Open is one state the venue reported, and carrying the newer stamp onto the other’s quantities would synthesise a state the venue never reported.

Trait Implementations

impl Clone for Open

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Open

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Open

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Open

impl From<Open> for ActiveOrderState

fn from(value: Open) -> Self

Converts to this type from the input type.

impl Hash for Open

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 Ord for Open

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

fn clamp_to<R>(self, range: R) -> Self

where Self: Sized, R: ClampBounds<Self>,

🔬This is a nightly-only experimental API. (clamp_to)

Restrict a value to a certain range.

impl PartialEq for Open

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

Equality operator ==.

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

Inequality operator !=.

impl PartialOrd for Open

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Serialize for Open

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 Open