Struct TradesRead 

#[non_exhaustive]
pub struct TradesRead<AssetKey, InstrumentKey> {
    pub trades: Vec<Trade<AssetKey, InstrumentKey>>,
    pub resume: Option<DateTime<Utc>>,
    pub held_since: Option<DateTime<Utc>>,
}

What one ExecutionClient::fetch_trades call read of the span it was asked for.

A venue reads a span in bounded calls, so one call may stop before the span’s end. resume says whether this one did:

• None: every fill in the span the venue still holds is in trades.
• Some(t): the call stopped at its bound, and fills from t on may be missing from trades. Read on from start = t with the same end. That read can return again fills this one returned at or after t, so match them by instrument and TradeId.

trades can be empty while resume is Some: a venue that reads every instrument’s fills and filters them afterwards can spend a whole call on other instruments’. A caller that takes trades without reading on from resume can miss fills.

A venue also keeps fills for a limited time or count. held_since says when that limit cuts into the span, so a caller can tell fills the venue no longer has from fills that never happened.

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.

trades: Vec<Trade<AssetKey, InstrumentKey>>

The fills read, in the span and for the requested instruments.

resume: Option<DateTime<Utc>>

Where to read on from, or None when the read reached the span’s end.

held_since: Option<DateTime<Utc>>

The earliest moment the venue still holds fills from, when that is inside the span; fills before it may exist but cannot be read. None when the venue’s limit is not known to cut into the span, which is no claim that the venue holds fills without limit.

A caller that needs every fill in the span treats the part before held_since as a gap: resume: None covers what the venue holds, not what it held. The limit cuts into the span from its start, so only the first call of a span can report it; a caller reading on from resume has nothing to learn from a later call’s.

Implementations

impl<AssetKey, InstrumentKey> TradesRead<AssetKey, InstrumentKey>

pub fn new( trades: Vec<Trade<AssetKey, InstrumentKey>>, resume: Option<DateTime<Utc>>, ) -> Self

A read that stopped at resume (None: it reached the span’s end), with no venue limit cutting into the span.

pub fn complete(trades: Vec<Trade<AssetKey, InstrumentKey>>) -> Self

A read that reached the span’s end.

pub fn with_held_since(self, held_since: Option<DateTime<Utc>>) -> Self

Sets held_since.

Trait Implementations

impl<AssetKey: Clone, InstrumentKey: Clone> Clone for TradesRead<AssetKey, InstrumentKey>

fn clone(&self) -> Self

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<AssetKey: Debug, InstrumentKey: Debug> Debug for TradesRead<AssetKey, InstrumentKey>

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

Formats the value using the given formatter.

impl<'de, AssetKey, InstrumentKey> Deserialize<'de> for TradesRead<AssetKey, InstrumentKey>

where AssetKey: Deserialize<'de>, InstrumentKey: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<AssetKey: Eq, InstrumentKey: Eq> Eq for TradesRead<AssetKey, InstrumentKey>

impl<AssetKey: Hash, InstrumentKey: Hash> Hash for TradesRead<AssetKey, InstrumentKey>

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<AssetKey: PartialEq, InstrumentKey: PartialEq> PartialEq for TradesRead<AssetKey, InstrumentKey>

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

Equality operator ==.

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

Inequality operator !=.

impl<AssetKey, InstrumentKey> Serialize for TradesRead<AssetKey, InstrumentKey>

where AssetKey: Serialize, InstrumentKey: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<AssetKey: PartialEq, InstrumentKey: PartialEq> StructuralPartialEq for TradesRead<AssetKey, InstrumentKey>