Struct Trade 

#[non_exhaustive]
pub struct Trade {
    pub price: f64,
    pub size: f64,
    pub side: Side,
    pub timestamp: i64,
}

A single executed trade with an aggressor side.

Construction and the limits of its guarantee

The struct is #[non_exhaustive], so code outside this crate cannot build one from a field literal and must go through new, which validates, or new_unchecked, which is an explicit opt-out for values already known to be sound.

The fields stay public because reading them is by far the common operation and an accessor on each would buy nothing. That does mean a validated value can still be written into an invalid state afterwards, and nothing detects it: the indicators that consume this type rely on the constructor’s guarantee rather than re-checking every bar. Treat a mutation the way you would treat new_unchecked — you are asserting the invariants still hold.

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.

price: f64

Execution price (strictly positive).

size: f64

Executed size / quantity (non-negative).

side: Side

Aggressor side.

timestamp: i64

Trade timestamp (caller-defined epoch / resolution).

Implementations

impl Trade

pub fn new(price: f64, size: f64, side: Side, timestamp: i64) -> Result<Self>

Construct a trade, validating that price is finite and strictly positive and size is finite and non-negative.

Errors

Returns Error::InvalidTrade if the price is not a finite positive number, or the size is not a finite non-negative number.

pub const fn new_unchecked( price: f64, size: f64, side: Side, timestamp: i64, ) -> Self

Construct a trade without validation. The caller asserts that price is finite and positive and size is finite and non-negative.

Trait Implementations

impl Clone for Trade

fn clone(&self) -> Trade

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for Trade

impl Debug for Trade

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

Formats the value using the given formatter.

impl PartialEq for Trade

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for Trade