Struct MarketDepth 

pub struct MarketDepth {
    pub best_bid: Option<Decimal>,
    pub best_ask: Option<Decimal>,
}

How much is on offer at each side’s best price, where the feed says.

Carried alongside a MarketSnapshot rather than inside it. A snapshot is the view a FillModel prices from and the view RequestOpen::market persists, and a size is neither: a fill model answers where a taker prints, while how much that price can absorb is the venue’s own arithmetic — and only the venue tracks what is left of it as its orders eat into it.

Absent size means unlimited, not unfillable

None says this feed supplies no size information. That is the ordinary case, not a degenerate one: a trades-only feed, a candle feed, a bulk price export and a venue with no market feed at all every one of them report it on every observation. A venue reading None therefore caps nothing. The opposite reading — no size information means no size — would silently stop every price-only backtest from filling anything.

Some(amount) is a size that was actually reported, and Some(Decimal::ZERO) is a reported absence of size: there is nothing to take, so an aggressor takes nothing. Whoever derives this from a feed owns that distinction — a feed publishing prices with a zero amount on every row is stating the former, not the latter, and must say None.

Fields

best_bid: Option<Decimal>

Size resting at MarketSnapshot::best_bid, if the feed supplies one.

best_ask: Option<Decimal>

Size resting at MarketSnapshot::best_ask, if the feed supplies one.

Implementations

impl MarketDepth

pub const UNKNOWN: Self

Neither side’s size is known, so nothing consulting this is capped.

What a feed carrying no book reports, and what every MarketDepth::default() is.

pub fn new(best_bid: Option<Decimal>, best_ask: Option<Decimal>) -> Self

Construct a MarketDepth from the size on each side.

pub fn available_to(&self, side: Side) -> Option<Decimal>

What an aggressor on side can take: the ask for a buy, the bid for a sell.

The far side of the book, because that is the side an order on this one trades against — the same rule that decides whether a limit order crosses at all.

pub fn consume(&mut self, side: Side, quantity: Decimal)

Reduces what an aggressor on side can still take by quantity, never below zero.

A side whose size is unknown stays unknown: there is nothing to draw down, and an unbounded quantity less a finite one is still unbounded.

Trait Implementations

impl Clone for MarketDepth

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for MarketDepth

impl Debug for MarketDepth

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

Formats the value using the given formatter.

impl Default for MarketDepth

fn default() -> Self

Returns the “default value” for a type.

impl Eq for MarketDepth

impl PartialEq for MarketDepth

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for MarketDepth