Struct OrderBook 

pub struct OrderBook {

    pub symbol: String,
    pub timestamp: i64,
    pub datetime: Option<String>,
    pub nonce: Option<i64>,
    pub bids: Vec<OrderBookEntry>,
    pub asks: Vec<OrderBookEntry>,
    pub info: HashMap<String, Value>,
    pub buffered_deltas: VecDeque<OrderBookDelta>,
    pub bids_map: BTreeMap<String, Decimal>,
    pub asks_map: BTreeMap<String, Decimal>,
    pub is_synced: bool,
    pub needs_resync: bool,
    pub last_resync_time: i64,
}

Complete order book structure

Fields

symbol: String

Exchange symbol

timestamp: i64

Timestamp in milliseconds

datetime: Option<String>

ISO8601 datetime string

nonce: Option<i64>

Nonce/sequence number for updates

bids: Vec<OrderBookEntry>

Bid side (buyers) - sorted descending by price

asks: Vec<OrderBookEntry>

Ask side (sellers) - sorted ascending by price

info: HashMap<String, Value>

Raw exchange info

buffered_deltas: VecDeque<OrderBookDelta>

Buffered delta messages waiting for snapshot

bids_map: BTreeMap<String, Decimal>

BTree map for efficient bid updates (price -> amount)

asks_map: BTreeMap<String, Decimal>

BTree map for efficient ask updates (price -> amount)

is_synced: bool

Whether orderbook is synchronized

needs_resync: bool

Request resync flag (set when sequence gap detected)

last_resync_time: i64

Last resync timestamp (for rate limiting resync attempts)

Implementations

impl OrderBook

pub fn new(symbol: String, timestamp: i64) -> OrderBook

Create a new empty order book

pub fn best_bid(&self) -> Option<&OrderBookEntry>

Get best bid (highest buy price)

pub fn best_ask(&self) -> Option<&OrderBookEntry>

Get best ask (lowest sell price)

pub fn spread(&self) -> Option<Price>

Calculate bid-ask spread

pub fn spread_percentage(&self) -> Option<Decimal>

Calculate spread percentage

pub fn mid_price(&self) -> Option<Price>

Calculate mid price (average of best bid and ask)

pub fn bid_volume(&self) -> Amount

Get total bid volume

pub fn ask_volume(&self) -> Amount

Get total ask volume

pub fn sort_bids(&mut self)

Sort bids in descending order (highest price first)

pub fn sort_asks(&mut self)

Sort asks in ascending order (lowest price first)

pub fn sort(&mut self)

Sort both sides

pub fn limit(&mut self, depth: usize)

Limit order book to specified depth per side

pub fn update( &mut self, bids: Vec<OrderBookEntry>, asks: Vec<OrderBookEntry>, timestamp: i64, )

Update order book with new entries

pub fn reset_from_snapshot( &mut self, bids: Vec<OrderBookEntry>, asks: Vec<OrderBookEntry>, timestamp: i64, nonce: Option<i64>, )

Reset orderbook from snapshot

pub fn buffer_delta(&mut self, delta: OrderBookDelta)

Buffer a delta update for later processing

pub fn apply_delta( &mut self, delta: &OrderBookDelta, is_futures: bool, ) -> Result<(), String>

Apply a delta update (incremental update)

pub fn process_buffered_deltas( &mut self, is_futures: bool, ) -> Result<usize, String>

Process buffered deltas after receiving snapshot

pub fn clear_buffer(&mut self)

Clear all buffered deltas

pub fn buffered_count(&self) -> usize

Get number of buffered deltas

pub fn reset_for_resync(&mut self)

Reset orderbook state for resync Clears all data but keeps symbol and preserves buffered deltas

pub fn should_resync(&self, current_time: i64) -> bool

Check if resync is needed and rate limit is satisfied Rate limit: minimum 1 second between resyncs

pub fn mark_resync_initiated(&mut self, current_time: i64)

Mark that resync has been initiated

Trait Implementations

impl Clone for OrderBook

fn clone(&self) -> OrderBook

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for OrderBook

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for OrderBook

fn deserialize<__D>( __deserializer: __D, ) -> Result<OrderBook, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for OrderBook

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.