Struct FillContext 

#[non_exhaustive]
pub struct FillContext<'a> {
    pub side: Side,
    pub quantity: Decimal,
    pub market: &'a MarketSnapshot,
}

Everything a FillModel may price from.

Fields are added, never removed

An implementation only ever reads this, so every increase in the simulated venue’s fidelity — sizes at the touch, depth, a queue position — arrives as a new field rather than as a new parameter on fill_price. That is what #[non_exhaustive] is for here: constructing one outside this crate would turn each such addition back into a breaking change, which is the churn this type exists to end.

The order’s limit price is deliberately absent — see FillModel.

Fields (Non-exhaustive)

Non-exhaustive structs could have additional fields added in future. Therefore, non-exhaustive structs cannot be constructed in external crates using the traditional Struct { .. } syntax; cannot be matched against without a wildcard ..; and struct update syntax will not work.

side: Side

Which way the order trades.

quantity: Decimal

How much the order asks to trade, which a size-aware impact model prices from.

This is the order’s whole quantity. Where the book shows less size than that, the venue fills only what the book has and prices that part at what the model returns, so a model reading this prices the order as if all of it traded.

market: &'a MarketSnapshot

The venue’s view of the instrument. Every field is optional and absence is ordinary; see MarketSnapshot.

Implementations

impl<'a> FillContext<'a>

pub fn new(side: Side, quantity: Decimal, market: &'a MarketSnapshot) -> Self

Trait Implementations

impl<'a> Clone for FillContext<'a>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Copy for FillContext<'a>

impl<'a> Debug for FillContext<'a>

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

Formats the value using the given formatter.

impl<'a> Eq for FillContext<'a>

impl<'a> PartialEq for FillContext<'a>

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

Equality operator ==.

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

Inequality operator !=.

impl<'a> StructuralPartialEq for FillContext<'a>