Trait CacheDatabaseAdapter 

pub trait CacheDatabaseAdapter {
    // Required methods
    fn close(&mut self) -> Result<()>;
    fn flush(&mut self) -> Result<()>;
    fn load_all<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<CacheMap>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn load(&self) -> Result<AHashMap<String, Bytes>>;
    fn load_currencies<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<AHashMap<Ustr, Currency>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn load_instruments<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<AHashMap<InstrumentId, InstrumentAny>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn load_instrument_closes<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<AHashMap<InstrumentId, InstrumentClose>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn load_synthetics<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<AHashMap<InstrumentId, SyntheticInstrument>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn load_accounts<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<AHashMap<AccountId, AccountAny>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn load_orders<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<AHashMap<ClientOrderId, OrderAny>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn load_positions<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<AHashMap<PositionId, Position>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn load_index_order_position(
        &self,
    ) -> Result<AHashMap<ClientOrderId, PositionId>>;
    fn load_index_order_client(
        &self,
    ) -> Result<AHashMap<ClientOrderId, ClientId>>;
    fn load_currency<'life0, 'life1, 'async_trait>(
        &'life0 self,
        code: &'life1 Ustr,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Currency>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn load_instrument<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instrument_id: &'life1 InstrumentId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<InstrumentAny>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn load_synthetic<'life0, 'life1, 'async_trait>(
        &'life0 self,
        instrument_id: &'life1 InstrumentId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<SyntheticInstrument>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn load_account<'life0, 'life1, 'async_trait>(
        &'life0 self,
        account_id: &'life1 AccountId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<AccountAny>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn load_order<'life0, 'life1, 'async_trait>(
        &'life0 self,
        client_order_id: &'life1 ClientOrderId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<OrderAny>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn load_position<'life0, 'life1, 'async_trait>(
        &'life0 self,
        position_id: &'life1 PositionId,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Position>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;
    fn load_actor(&self, actor_id: &ActorId) -> Result<AHashMap<String, Bytes>>;
    fn load_strategy(
        &self,
        strategy_id: &StrategyId,
    ) -> Result<AHashMap<String, Bytes>>;
    fn load_signals(&self, name: &str) -> Result<Vec<Signal>>;
    fn load_custom_data(&self, data_type: &DataType) -> Result<Vec<CustomData>>;
    fn load_order_snapshot(
        &self,
        client_order_id: &ClientOrderId,
    ) -> Result<Option<OrderSnapshot>>;
    fn load_position_snapshot(
        &self,
        position_id: &PositionId,
    ) -> Result<Option<PositionSnapshot>>;
    fn load_quotes(
        &self,
        instrument_id: &InstrumentId,
    ) -> Result<Vec<QuoteTick>>;
    fn load_trades(
        &self,
        instrument_id: &InstrumentId,
    ) -> Result<Vec<TradeTick>>;
    fn load_funding_rates(
        &self,
        instrument_id: &InstrumentId,
    ) -> Result<Vec<FundingRateUpdate>>;
    fn load_bars(&self, instrument_id: &InstrumentId) -> Result<Vec<Bar>>;
    fn add(&self, key: String, value: Bytes) -> Result<()>;
    fn add_currency(&self, currency: &Currency) -> Result<()>;
    fn add_instrument(&self, instrument: &InstrumentAny) -> Result<()>;
    fn add_instrument_close(&self, close: &InstrumentClose) -> Result<()>;
    fn add_synthetic(&self, synthetic: &SyntheticInstrument) -> Result<()>;
    fn add_account(&self, account: &AccountAny) -> Result<()>;
    fn add_order(
        &self,
        order: &OrderAny,
        client_id: Option<ClientId>,
    ) -> Result<()>;
    fn add_order_snapshot(&self, snapshot: &OrderSnapshot) -> Result<()>;
    fn add_position(&self, position: &Position) -> Result<()>;
    fn add_position_snapshot(&self, snapshot: &PositionSnapshot) -> Result<()>;
    fn add_order_book(&self, order_book: &OrderBook) -> Result<()>;
    fn add_signal(&self, signal: &Signal) -> Result<()>;
    fn add_custom_data(&self, data: &CustomData) -> Result<()>;
    fn add_quote(&self, quote: &QuoteTick) -> Result<()>;
    fn add_trade(&self, trade: &TradeTick) -> Result<()>;
    fn add_funding_rate(&self, funding_rate: &FundingRateUpdate) -> Result<()>;
    fn add_bar(&self, bar: &Bar) -> Result<()>;
    fn delete_actor(&self, actor_id: &ActorId) -> Result<()>;
    fn delete_strategy(&self, component_id: &StrategyId) -> Result<()>;
    fn delete_order(&self, client_order_id: &ClientOrderId) -> Result<()>;
    fn delete_position(&self, position_id: &PositionId) -> Result<()>;
    fn delete_account_event(
        &self,
        account_id: &AccountId,
        event_id: &str,
    ) -> Result<()>;
    fn index_venue_order_id(
        &self,
        client_order_id: ClientOrderId,
        venue_order_id: VenueOrderId,
    ) -> Result<()>;
    fn index_order_position(
        &self,
        client_order_id: ClientOrderId,
        position_id: PositionId,
    ) -> Result<()>;
    fn update_actor(
        &self,
        actor_id: &ActorId,
        state: &AHashMap<String, Bytes>,
    ) -> Result<()>;
    fn update_strategy(
        &self,
        strategy_id: &StrategyId,
        state: &AHashMap<String, Bytes>,
    ) -> Result<()>;
    fn update_account(&self, account: &AccountAny) -> Result<()>;
    fn update_order(&self, order_event: &OrderEventAny) -> Result<()>;
    fn update_position(&self, position: &Position) -> Result<()>;
    fn snapshot_order_state(&self, order: &OrderAny) -> Result<()>;
    fn snapshot_position_state(
        &self,
        position: &Position,
        ts_snapshot: UnixNanos,
        unrealized_pnl: Option<Money>,
    ) -> Result<()>;
    fn heartbeat(&self, timestamp: UnixNanos) -> Result<()>;

    // Provided methods
    fn load_greeks<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<AHashMap<InstrumentId, GreeksData>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn load_yield_curves<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<AHashMap<String, YieldCurveData>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
    fn add_greeks(&self, _greeks: &GreeksData) -> Result<()> { ... }
    fn add_yield_curve(&self, _yield_curve: &YieldCurveData) -> Result<()> { ... }
    fn index_order_clients(
        &self,
        claims: &[(ClientOrderId, ClientId)],
    ) -> Result<()> { ... }
}

Required Methods

fn close(&mut self) -> Result<()>

Closes the cache database connection.

Errors

Returns an error if the database fails to close properly.

fn flush(&mut self) -> Result<()>

Flushes any pending changes to the database.

Errors

Returns an error if flushing changes fails.

fn load_all<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<CacheMap>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Loads all cached data into memory.

Errors

Returns an error if loading data from the database fails.

fn load(&self) -> Result<AHashMap<String, Bytes>>

Loads raw key-value data from the database.

Errors

Returns an error if the load operation fails.

fn load_currencies<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<AHashMap<Ustr, Currency>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Loads all currencies from the cache.

Errors

Returns an error if loading currencies fails.

fn load_instruments<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<AHashMap<InstrumentId, InstrumentAny>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Loads all instruments from the cache.

Errors

Returns an error if loading instruments fails.

fn load_instrument_closes<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<AHashMap<InstrumentId, InstrumentClose>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Loads all instrument closes from the cache.

Errors

Returns an error if loading instrument closes fails.

fn load_synthetics<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<AHashMap<InstrumentId, SyntheticInstrument>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Loads all synthetic instruments from the cache.

Errors

Returns an error if loading synthetic instruments fails.

fn load_accounts<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<AHashMap<AccountId, AccountAny>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Loads all accounts from the cache.

Errors

Returns an error if loading accounts fails.

fn load_orders<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<AHashMap<ClientOrderId, OrderAny>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Loads all orders from the cache.

Errors

Returns an error if loading orders fails.

fn load_positions<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<AHashMap<PositionId, Position>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Loads all positions from the cache.

Errors

Returns an error if loading positions fails.

fn load_index_order_position( &self, ) -> Result<AHashMap<ClientOrderId, PositionId>>

Loads mapping from order IDs to position IDs.

Errors

Returns an error if loading the index order-position mapping fails.

fn load_index_order_client(&self) -> Result<AHashMap<ClientOrderId, ClientId>>

Loads mapping from order IDs to client IDs.

Errors

Returns an error if loading the index order-client mapping fails.

fn load_currency<'life0, 'life1, 'async_trait>( &'life0 self, code: &'life1 Ustr, ) -> Pin<Box<dyn Future<Output = Result<Option<Currency>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Loads a single currency by code.

Errors

Returns an error if loading a single currency fails.

fn load_instrument<'life0, 'life1, 'async_trait>( &'life0 self, instrument_id: &'life1 InstrumentId, ) -> Pin<Box<dyn Future<Output = Result<Option<InstrumentAny>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Loads a single instrument by ID.

Errors

Returns an error if loading a single instrument fails.

fn load_synthetic<'life0, 'life1, 'async_trait>( &'life0 self, instrument_id: &'life1 InstrumentId, ) -> Pin<Box<dyn Future<Output = Result<Option<SyntheticInstrument>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Loads a single synthetic instrument by ID.

Errors

Returns an error if loading a single synthetic instrument fails.

fn load_account<'life0, 'life1, 'async_trait>( &'life0 self, account_id: &'life1 AccountId, ) -> Pin<Box<dyn Future<Output = Result<Option<AccountAny>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Loads a single account by ID.

Errors

Returns an error if loading a single account fails.

fn load_order<'life0, 'life1, 'async_trait>( &'life0 self, client_order_id: &'life1 ClientOrderId, ) -> Pin<Box<dyn Future<Output = Result<Option<OrderAny>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Loads a single order by client order ID.

Errors

Returns an error if loading a single order fails.

fn load_position<'life0, 'life1, 'async_trait>( &'life0 self, position_id: &'life1 PositionId, ) -> Pin<Box<dyn Future<Output = Result<Option<Position>>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Loads a single position by position ID.

Errors

Returns an error if loading a single position fails.

fn load_actor(&self, actor_id: &ActorId) -> Result<AHashMap<String, Bytes>>

Loads actor state by actor ID.

Errors

Returns an error if loading actor state fails.

fn load_strategy( &self, strategy_id: &StrategyId, ) -> Result<AHashMap<String, Bytes>>

Loads strategy state by strategy ID.

Errors

Returns an error if loading strategy state fails.

fn load_signals(&self, name: &str) -> Result<Vec<Signal>>

Loads signals by name.

Errors

Returns an error if loading signals fails.

fn load_custom_data(&self, data_type: &DataType) -> Result<Vec<CustomData>>

Loads custom data by data type.

Errors

Returns an error if loading custom data fails.

fn load_order_snapshot( &self, client_order_id: &ClientOrderId, ) -> Result<Option<OrderSnapshot>>

Loads an order snapshot by client order ID.

Errors

Returns an error if loading the order snapshot fails.

fn load_position_snapshot( &self, position_id: &PositionId, ) -> Result<Option<PositionSnapshot>>

Loads a position snapshot by position ID.

Errors

Returns an error if loading the position snapshot fails.

fn load_quotes(&self, instrument_id: &InstrumentId) -> Result<Vec<QuoteTick>>

Loads quote ticks by instrument ID.

Errors

Returns an error if loading quotes fails.

fn load_trades(&self, instrument_id: &InstrumentId) -> Result<Vec<TradeTick>>

Loads trade ticks by instrument ID.

Errors

Returns an error if loading trades fails.

fn load_funding_rates( &self, instrument_id: &InstrumentId, ) -> Result<Vec<FundingRateUpdate>>

Loads funding rate updates by instrument ID.

Errors

Returns an error if loading funding rates fails.

fn load_bars(&self, instrument_id: &InstrumentId) -> Result<Vec<Bar>>

Loads bars by instrument ID.

Errors

Returns an error if loading bars fails.

fn add(&self, key: String, value: Bytes) -> Result<()>

Adds a generic key-value pair to the cache.

Errors

Returns an error if adding a generic key/value fails.

fn add_currency(&self, currency: &Currency) -> Result<()>

Adds a currency to the cache.

Errors

Returns an error if adding a currency fails.

fn add_instrument(&self, instrument: &InstrumentAny) -> Result<()>

Adds an instrument to the cache.

Errors

Returns an error if adding an instrument fails.

fn add_instrument_close(&self, close: &InstrumentClose) -> Result<()>

Adds an instrument close to the cache, replacing any existing value for the instrument. Implementations must queue persistence without waiting for the database operation to complete.

Errors

Returns an error if the instrument close cannot be queued for persistence.

fn add_synthetic(&self, synthetic: &SyntheticInstrument) -> Result<()>

Adds a synthetic instrument to the cache.

Errors

Returns an error if adding a synthetic instrument fails.

fn add_account(&self, account: &AccountAny) -> Result<()>

Adds an account to the cache.

Errors

Returns an error if adding an account fails.

fn add_order(&self, order: &OrderAny, client_id: Option<ClientId>) -> Result<()>

Adds an order to the cache.

Errors

Returns an error if adding an order fails.

fn add_order_snapshot(&self, snapshot: &OrderSnapshot) -> Result<()>

Adds an order snapshot to the cache.

Errors

Returns an error if adding an order snapshot fails.

fn add_position(&self, position: &Position) -> Result<()>

Adds a position to the cache.

Errors

Returns an error if adding a position fails.

fn add_position_snapshot(&self, snapshot: &PositionSnapshot) -> Result<()>

Adds a position snapshot to the cache.

Errors

Returns an error if adding a position snapshot fails.

fn add_order_book(&self, order_book: &OrderBook) -> Result<()>

Adds an order book to the cache.

Errors

Returns an error if adding an order book fails.

fn add_signal(&self, signal: &Signal) -> Result<()>

Adds a signal to the cache.

Errors

Returns an error if adding a signal fails.

fn add_custom_data(&self, data: &CustomData) -> Result<()>

Adds custom data to the cache.

Errors

Returns an error if adding custom data fails.

fn add_quote(&self, quote: &QuoteTick) -> Result<()>

Adds a quote tick to the cache.

Errors

Returns an error if adding a quote tick fails.

fn add_trade(&self, trade: &TradeTick) -> Result<()>

Adds a trade tick to the cache.

Errors

Returns an error if adding a trade tick fails.

fn add_funding_rate(&self, funding_rate: &FundingRateUpdate) -> Result<()>

Adds a funding rate update to the cache.

Errors

Returns an error if adding a funding rate update fails.

fn add_bar(&self, bar: &Bar) -> Result<()>

Adds a bar to the cache.

Errors

Returns an error if adding a bar fails.

fn delete_actor(&self, actor_id: &ActorId) -> Result<()>

Deletes actor state from the cache.

Errors

Returns an error if deleting actor state fails.

fn delete_strategy(&self, component_id: &StrategyId) -> Result<()>

Deletes strategy state from the cache.

Errors

Returns an error if deleting strategy state fails.

fn delete_order(&self, client_order_id: &ClientOrderId) -> Result<()>

Deletes an order from the cache.

Errors

Returns an error if deleting an order fails.

fn delete_position(&self, position_id: &PositionId) -> Result<()>

Deletes a position from the cache.

Errors

Returns an error if deleting a position fails.

fn delete_account_event( &self, account_id: &AccountId, event_id: &str, ) -> Result<()>

Deletes an account event from the cache.

Errors

Returns an error if deleting account events fails.

fn index_venue_order_id( &self, client_order_id: ClientOrderId, venue_order_id: VenueOrderId, ) -> Result<()>

Indexes a venue order ID with its client order ID.

Errors

Returns an error if indexing venue order ID fails.

fn index_order_position( &self, client_order_id: ClientOrderId, position_id: PositionId, ) -> Result<()>

Indexes an order-position mapping.

Errors

Returns an error if indexing order-position mapping fails.

fn update_actor( &self, actor_id: &ActorId, state: &AHashMap<String, Bytes>, ) -> Result<()>

Updates actor state in the cache.

Errors

Returns an error if updating actor state fails.

fn update_strategy( &self, strategy_id: &StrategyId, state: &AHashMap<String, Bytes>, ) -> Result<()>

Updates strategy state in the cache.

Errors

Returns an error if updating strategy state fails.

fn update_account(&self, account: &AccountAny) -> Result<()>

Updates an account in the cache.

Errors

Returns an error if updating an account fails.

fn update_order(&self, order_event: &OrderEventAny) -> Result<()>

Updates an order in the cache with an order event.

Errors

Returns an error if updating an order fails.

fn update_position(&self, position: &Position) -> Result<()>

Updates a position in the cache.

Errors

Returns an error if updating a position fails.

fn snapshot_order_state(&self, order: &OrderAny) -> Result<()>

Creates a snapshot of order state.

Errors

Returns an error if snapshotting order state fails.

fn snapshot_position_state( &self, position: &Position, ts_snapshot: UnixNanos, unrealized_pnl: Option<Money>, ) -> Result<()>

Creates a snapshot of position state.

Errors

Returns an error if snapshotting position state fails.

fn heartbeat(&self, timestamp: UnixNanos) -> Result<()>

Records a heartbeat timestamp.

Errors

Returns an error if heartbeat recording fails.

Provided Methods

fn load_greeks<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<AHashMap<InstrumentId, GreeksData>>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Loads all GreeksData from the cache.

Errors

Returns an error if loading greeks data fails.

fn load_yield_curves<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<AHashMap<String, YieldCurveData>>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Loads all YieldCurveData from the cache.

Errors

Returns an error if loading yield curve data fails.

fn add_greeks(&self, _greeks: &GreeksData) -> Result<()>

Adds greeks data to the cache.

Errors

Returns an error if adding greeks data fails.

fn add_yield_curve(&self, _yield_curve: &YieldCurveData) -> Result<()>

Adds yield curve data to the cache.

Errors

Returns an error if adding yield curve data fails.

fn index_order_clients( &self, claims: &[(ClientOrderId, ClientId)], ) -> Result<()>

Indexes order-client mappings as one batch operation.

Errors

Returns an error if batch order-client indexing is unsupported or cannot be enqueued.

Dyn Compatibility

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors