Struct IndexedInstruments 

pub struct IndexedInstruments { /* private fields */ }

Indexed collection of exchanges, assets, and instruments.

Initialise incrementally via the IndexedInstrumentsBuilder, or all at once via the constructor.

The indexed collection is useful for creating efficient O(1) constant lookup state management systems where the state is keyed on an instrument, asset, or exchange.

For example uses cases, see the central rustrade crate EngineState design.

Index Relationships

• ExchangeIndex: Unique index for each ExchangeId added during initialisation.
• InstrumentIndex: Unique identifier for each Instrument added during initialisation.
• AssetIndex: Unique identifier for each ExchangeAsset added during initialisation.

Implementations

impl IndexedInstruments

pub fn new<Iter, I>(instruments: Iter) -> Self

where Iter: IntoIterator<Item = I>, I: Into<Instrument<ExchangeId, Asset>>,

Initialises a new IndexedInstruments from an iterator of Instruments.

This method indexes all unique exchanges, assets, and instruments, creating efficient lookup tables for each entity type.

Note that once an IndexedInstruments has been constructed, it cannot be mutated (this could invalidate existing index lookup tables).

For incremental initialisation, see the IndexedInstrumentsBuilder.

pub fn builder() -> IndexedInstrumentsBuilder

Returns a new IndexedInstrumentsBuilder useful for incremental initialisation of IndexedInstruments.

pub fn exchanges(&self) -> &[Keyed<ExchangeIndex, ExchangeId>]

Returns a reference to the ExchangeIndex <–> ExchangeId associations.

pub fn assets(&self) -> &[Keyed<AssetIndex, ExchangeAsset<Asset>>]

Returns a reference to the AssetIndex <–> ExchangeAsset associations.

pub fn instruments( &self, ) -> &[Keyed<InstrumentIndex, Instrument<Keyed<ExchangeIndex, ExchangeId>, AssetIndex>>]

Returns a reference to the InstrumentIndex <–> Instrument associations.

pub fn find_exchange_index( &self, exchange: ExchangeId, ) -> Result<ExchangeIndex, IndexError>

Finds the ExchangeIndex associated with the provided ExchangeId.

Arguments

• exchange - The exchange ID to look up

Returns

• Ok(ExchangeIndex) - exchange found.
• Err(IndexError) - exchange not found.

pub fn find_exchange( &self, index: ExchangeIndex, ) -> Result<ExchangeId, IndexError>

pub fn find_asset_index( &self, exchange: ExchangeId, name: &AssetNameInternal, ) -> Result<AssetIndex, IndexError>

Finds the AssetIndex associated with the provided ExchangeId and AssetNameInterval.

Arguments

• exchange - The ExchangeId associated with the asset.
• name - The AssetNameInternal associated with the asset (eg/ “btc”, “usdt”, etc).

Returns

• Ok(AssetIndex) - exchange asset found.
• Err(IndexError) - exchange asset not found.

pub fn find_asset( &self, index: AssetIndex, ) -> Result<&ExchangeAsset<Asset>, IndexError>

pub fn find_instrument_index( &self, exchange: ExchangeId, name: &InstrumentNameInternal, ) -> Result<InstrumentIndex, IndexError>

Finds the InstrumentIndex associated with the provided ExchangeId and InstrumentNameInternal.

Arguments

• exchange - The ExchangeId associated with the instrument.
• name - The InstrumentNameInternal associated with the instrument (eg/ binance_spot_btc_usdt).

Returns

• Ok(AssetIndex) - instrument found.
• Err(IndexError) - instrument not found.

pub fn find_instrument( &self, index: InstrumentIndex, ) -> Result<&Instrument<Keyed<ExchangeIndex, ExchangeId>, AssetIndex>, IndexError>

Trait Implementations

impl Clone for IndexedInstruments

fn clone(&self) -> IndexedInstruments

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for IndexedInstruments

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for IndexedInstruments

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<I> FromIterator<I> for IndexedInstruments

where I: Into<Instrument<ExchangeId, Asset>>,

fn from_iter<Iter>(iter: Iter) -> Self

where Iter: IntoIterator<Item = I>,

Creates a value from an iterator.

impl PartialEq for IndexedInstruments

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

Tests for self and other values to be equal, and is used by ==.

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

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl PartialOrd for IndexedInstruments

fn partial_cmp(&self, other: &IndexedInstruments) -> 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 IndexedInstruments

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 IndexedInstruments