Struct CashFlowsRead 

#[non_exhaustive]
pub struct CashFlowsRead<AssetKey, InstrumentKey> {
    pub flows: Vec<CashFlow<AssetKey, InstrumentKey>>,
    pub resume: Option<DateTime<Utc>>,
    pub held_since: Option<DateTime<Utc>>,
}

What one read of a venue’s cash flows over a span returned.

resume says whether the read stopped before the span’s end:

• None: every flow in the span the venue still holds, and the client reports, is in flows. Each client documents the records it leaves out.
• Some(t): the read stopped at its bound, and flows from t on may be missing from flows. Read on from start = t with the same end. That read can return again flows this one returned at or after t, so match them by CashFlowId.

A venue also keeps its records for a limited time. held_since says when that limit cuts into the span, so a caller can tell flows the venue no longer has from flows 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.

flows: Vec<CashFlow<AssetKey, InstrumentKey>>

The flows read, in the span.

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 read covers, when the span starts before it; flows before it may exist but cannot be read. It is after the span’s end when none of the span can be read. None when the venue’s limit is not known to cut into the span, which is no claim that the venue holds flows without limit.

A caller that needs every flow in the span, such as one adding up a position’s whole interest, 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 read of a span can report it; a caller reading on from resume has nothing to learn from a later read’s.

Implementations

impl<AssetKey, InstrumentKey> CashFlowsRead<AssetKey, InstrumentKey>

pub fn new( flows: Vec<CashFlow<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(flows: Vec<CashFlow<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 CashFlowsRead<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 CashFlowsRead<AssetKey, InstrumentKey>

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

Formats the value using the given formatter.

impl<'de, AssetKey, InstrumentKey> Deserialize<'de> for CashFlowsRead<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 CashFlowsRead<AssetKey, InstrumentKey>

impl<AssetKey: Hash, InstrumentKey: Hash> Hash for CashFlowsRead<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 CashFlowsRead<AssetKey, InstrumentKey>

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

Equality operator ==.

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

Inequality operator !=.

impl<AssetKey, InstrumentKey> Serialize for CashFlowsRead<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 CashFlowsRead<AssetKey, InstrumentKey>