Struct ReduceOnlyBook 

pub struct ReduceOnlyBook { /* private fields */ }

One instrument’s record of which orders were sent reduce-only. Plain data with no locking and no I/O, so the owner keeps it behind whatever synchronisation it already has, one book for each instrument.

The owner calls, for each order:

1. register when the open request is sent,
2. acknowledge when the venue reports the order’s id, and
3. retire when the order ends. Every order must be retired, or the book keeps it for good.

Then lookup finds the flag of a fill’s order.

A retired order stays findable only if it was reduce-only, and only the last RETIRED_CAPACITY of those, oldest dropped first, so that a late fill of one is still recognised and ordinary orders do not push them out. A late fill of any other retired order is not found: read that as not reduce-only.

Serialised form

{"live": {<cid>: {"reduce_only": bool, "venue_id": <id>|null}}, "retired": {<cid>: <id>|null}}, each map in order, either part optional. It is stored as part of its owner’s state, so a change to it is a breaking change. A book loaded with more retired orders than RETIRED_CAPACITY keeps the latest.

Implementations

impl ReduceOnlyBook

pub const RETIRED_CAPACITY: usize = 64

How many retired reduce-only orders the book keeps.

pub fn new() -> Self

An empty book.

pub fn is_empty(&self) -> bool

Whether the book holds no order, live or retired.

pub fn live_len(&self) -> usize

How many orders are live: registered and not yet retired. An owner that retires every order sees this fall back to the number it has open.

pub fn has_reduce_only(&self) -> bool

Whether any order the book holds is reduce-only, live or retired. When it is not, every lookup finds no reduce-only order, so a caller can skip it. O(1).

pub fn register(&mut self, cid: &ClientOrderId, reduce_only: bool)

Record that the open request cid is being sent, reduce-only or not.

A client order id reused for a new order replaces everything an earlier order under it left, live or retired, so its flag does not outlive the order. The new order counts as the latest registered. Registering a client order id that is still live replaces that order, dropping the venue order id it was acknowledged with, so register once for each order sent.

pub fn acknowledge(&mut self, cid: &ClientOrderId, venue_id: &OrderId)

Record the venue’s order id for cid, live or retired, so a fill that names only that id finds the order. Replaces an id given before. Does nothing for an order the book does not hold.

An order can end before its id is known, such as one filled on its acknowledgement, so a retired order takes it too.

pub fn retire(&mut self, cid: &ClientOrderId)

Record that the order cid ended. Does nothing for an order the book does not hold.

A reduce-only order moves to the retired orders, dropping the oldest of them when there are RETIRED_CAPACITY. Any other order is forgotten.

pub fn retire_untracked( &mut self, is_tracked: impl FnMut(&ClientOrderId) -> bool, )

retire every live order for which is_tracked is false, in the order they were registered, so which retirement is dropped first never depends on hashing.

One pass over the live orders, so O(live orders), and it allocates only when a reduce-only order ended.

pub fn lookup<AssetKey, InstrumentKey>( &self, trade: &Trade<AssetKey, InstrumentKey>, ) -> Option<BookedOrder<'_>>

Find the order a fill belongs to.

By the fill’s client order id if it has one, and else by its venue order id: a live order first, then a retired one. A client order id the book does not hold finds nothing, and does not fall back to the venue’s id.

pub fn lookup_ids( &self, cid: Option<&ClientOrderId>, order_id: &OrderId, ) -> Option<BookedOrder<'_>>

lookup for the ids of a fill, for a caller that resolved the client order id itself. A cid the book does not hold finds nothing and does not fall back to order_id; pass None to look up by the venue’s id alone.

pub fn is_reduce_only<AssetKey, InstrumentKey>( &self, trade: &Trade<AssetKey, InstrumentKey>, ) -> bool

Whether trade is a fill of an order sent reduce-only: lookup with an order the book does not hold counted as not.

pub fn clear(&mut self)

Forget every order, for when the orders the book records are dropped wholesale.

Trait Implementations

impl Clone for ReduceOnlyBook

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 ReduceOnlyBook

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

Formats the value using the given formatter.

impl Default for ReduceOnlyBook

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for ReduceOnlyBook

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for ReduceOnlyBook

impl PartialEq for ReduceOnlyBook

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

Equality operator ==.

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

Inequality operator !=.

impl Serialize for ReduceOnlyBook

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 ReduceOnlyBook