Struct OpenOrders 

pub struct OpenOrders { /* private fields */ }

A venue’s open orders, indexed for lookup by id and for matching in price-time order.

Why two indices

The two accesses want opposite things. Cancelling an order, and answering a snapshot, address one order by ClientOrderId. Matching a tick walks an instrument’s orders from the best price down, and must stop as soon as the price stops crossing.

Holding only the map makes matching a sort of every open order on every tick. Holding only the queues makes a cancel a scan. The map owns the orders, the queues hold ids.

Why price-time and not “whatever the map yields”

A tick that crosses two resting orders with only enough balance to fill one fills whichever comes first. Read off a hash map, that is an arbitrary choice which a rebuild or a different ClientOrderId can silently reverse, so two runs of one backtest need not agree. Price-time priority is both the reproducible rule and the one real venues use.

Orders with no price

An order resting without a limit price cannot be ranked against one, and is not a thing a venue holds: an order with no price to wait at has nothing to wait for. Such an order is kept in the map — a snapshot must report everything the account holds — but is absent from the queues, so matching can never reach it. It arrives one of two ways:

• through a configured initial_state, and then nothing matches it, ever;
• through hold: a market order the venue is holding until its instrument’s next bar, or its next fresh observation. Those are kept in a fourth index, per instrument and in arrival order, which take_held empties when what they wait for arrives.

Why a third index for deadlines

A TimeInForce::GoodTillDate order retires at a stated instant, and the venue sweeps for such orders on every clock advance and every market tick. Neither of the other two indices can answer “which orders are past their deadline”: a deadline is unrelated to price, so the price-time queues cannot be walked with a take_while the way matching walks them, and the map is unordered. Answering from either would mean scanning every open order on every tick.

A third index therefore holds only the orders that have a deadline, keyed by it. A sweep is a range query that stops at the first order still working, so it costs nothing when nothing can expire — which is every venue whose orders are all GoodUntilCancelled, including every market-order-only backtest.

Reservations, and the ones that are not there

An order the venue booked itself carries the Reservation the venue took for it, so a fill settles and a cancel releases the same amount that was held — see RestingOrder.

An order seeded by a configured initial_state carries None, because the venue never took anything for it. Cancelling such an order therefore releases nothing and restates no balance. That is the honest answer rather than a convenient one: the snapshot says an order is resting and says what the balances are, but not which order any held portion belongs to, so a venue that credited a release would be inventing the amount.

Implementations

impl OpenOrders

pub fn insert( &mut self, order: OpenOrder, reservation: Option<Reservation>, ) -> Result<(), AlreadyResting>

Inserts order holding reservation against it, unless an order is already resting under its ClientOrderId.

Errors

AlreadyResting, carrying order and reservation back untouched, if an order is already held under its id. The book is left exactly as it was: the order already resting keeps its queue position, its deadline and its own reservation. reservation is handed back rather than dropped because it may already be held against the account, and only the caller knows the ledger to give it back to.

reservation is None only for an order the venue did not book itself — see the type’s note on reservations. It is a parameter rather than a later setter so that an order cannot reach the book in a state where what is held against it has not yet been decided.

pub fn hold( &mut self, order: OpenOrder, reservation: Option<Reservation>, ) -> Result<(), AlreadyResting>

Holds order, a market order with no price, until its venue releases it, with reservation held against it.

Kept in the map like any open order, so a snapshot reports it and a cancel finds it, and queued behind every order already held on its instrument. Matching never reaches it: only take_held does.

Errors

AlreadyResting, as for insert, leaving the book exactly as it was.

Panics

Panics if order carries a price. A priced order is queued for matching, which a held one must never be, and would leave the held index out of step with the book.

pub fn holds(&self, instrument: &InstrumentNameExchange) -> bool

Whether any order is held on instrument.

pub fn held_on(&self, instrument: &InstrumentNameExchange) -> &[ClientOrderId]

The orders held on instrument, earliest arrival first, still held.

For a caller that releases some of them and leaves the rest waiting: it removes those it releases, which takes them out of the hold too.

pub fn take_held( &mut self, instrument: &InstrumentNameExchange, ) -> Vec<ClientOrderId>

The orders held on instrument, earliest arrival first, no longer held.

Each stays in the map until its caller removes it, which is what lets the caller take its reservation with it.

pub fn held(&self) -> Vec<ClientOrderId>

Every order held, on any instrument: by instrument, then earliest arrival first. A total order, so whatever a caller does with them happens in the same order on every run.

pub fn contains(&self, cid: &ClientOrderId) -> bool

Whether an order is resting under cid.

pub fn remove(&mut self, cid: &ClientOrderId) -> Option<RestingOrder>

Removes and returns the order held under cid, with whatever is held against it.

pub fn expired_as_of(&self, now: DateTime<Utc>) -> Vec<ClientOrderId>

Every order whose deadline has been reached by now, earliest deadline first.

“Reached” is inclusive: an order with a deadline of exactly now is returned, because a TimeInForce::GoodTillDate order stops working at its stated instant rather than after it. The venue relies on this to make a deadline an unconditional cutoff — see SimulatedVenue::advance_time.

Returned rather than iterated because the caller retires each one, which borrows self mutably. The walk stops at the first order still working, so it costs a single comparison when nothing is due, whatever the size of the book.

pub fn next_expiry(&self) -> Option<DateTime<Utc>>

The earliest deadline of any open order, or None if none has one.

pub fn get(&self, cid: &ClientOrderId) -> Option<&OpenOrder>

pub fn len(&self) -> usize

pub fn is_empty(&self) -> bool

pub fn iter(&self) -> impl Iterator<Item = &OpenOrder> + '_

Every open order, in no particular order.

Callers that need a reproducible sequence must impose one — resting for matching, or an explicit sort for a snapshot.

pub fn resting( &self, instrument: &InstrumentNameExchange, side: Side, ) -> impl Iterator<Item = &OpenOrder> + '_

One instrument’s resting orders on one side, best price first and earliest first within a price.

This is the order a venue matches in, so a caller filling against a crossing tick takes them as they come and stops at the first that does not cross.

Trait Implementations

impl Debug for OpenOrders

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

Formats the value using the given formatter.

impl Default for OpenOrders

fn default() -> Self

Returns the “default value” for a type.