Struct UdCore 

pub struct UdCore { /* private fields */ }

User data core: turns stream frames into order, execution and portfolio events.

It resolves the client order id of every order echo through the OrderIndex and advances the local lifecycle of orders this process placed (so order_state and the stream agree).

Implements BrokerCore from brokapi-sansio.

Examples

use std::sync::Arc;
use std::time::Instant;
use brokapi_core::{Event, SubscriptionId};
use brokapi_finam::core::ud::UdSubKind;
use brokapi_finam::core::{SubStatus, UdCore, UdEvent, UdFrame};
use brokapi_finam::index::OrderIndex;
use brokapi_sansio::{BrokerCore, EventSink};
use brokapi_finam_protocol::pb::grpc::tradeapi::v1::orders as po;

let sub = SubscriptionId::new(1000);
let mut core = UdCore::new(Arc::new(OrderIndex::new()));
core.register(sub, UdSubKind::Orders);
assert_eq!(core.status(sub), Some(SubStatus::Connecting));

// An order that this process did not place: it still reaches the consumer, under a made-up cid.
let echo = po::OrderState { order_id: "ORD-7".into(), ..Default::default() };
let mut out = EventSink::new();
core.on_frame(
    UdFrame { sub, event: UdEvent::Orders(po::SubscribeOrdersResponse { orders: vec![echo] }) },
    Instant::now(),
    &mut out,
);
assert_eq!(core.status(sub), Some(SubStatus::Active));
assert!(matches!(out.drain()[0].payload, Event::Order(_)));

Implementations

impl UdCore

pub fn new(index: Arc<OrderIndex>) -> UdCore

A core with no subscriptions. index is shared with the connector.

pub fn orders(&mut self) -> &mut OrderRuntime

Local lifecycle of orders placed through this connector.

pub fn take_forgotten(&mut self) -> Vec<Uuid>

Takes the cids the core forgot since the last call: orders that finished long ago (see the memory window of [OrderRuntime]). The connector drops what else it keeps for them.

pub fn index(&self) -> &Arc<OrderIndex>

The order index shared with the connector.

pub fn register(&mut self, sub: SubscriptionId, kind: UdSubKind)

Adds a subscription of kind (status Connecting). Executions need this call because the shared SubscriptionKind has no variant for them.

pub fn unregister(&mut self, sub: SubscriptionId)

Forgets subscription sub and its status. Late frames for it are ignored.

pub fn status(&self, sub: SubscriptionId) -> Option<SubStatus>

Stream status of subscription sub. None for an id the core does not know.

pub fn ingest_order(&mut self, os: &OrderState, now: Instant) -> OrderSnapshot

Maps one order echo and advances the local lifecycle of orders we placed.

Trait Implementations

impl BrokerCore for UdCore

fn apply(&mut self, desired: &SubscriptionSet)

Order-state and portfolio subscriptions. Executions are registered with register because SubscriptionKind has no variant for them.

type Frame = UdFrame

The inbound frame type: for example String for WebSocket text, or a decoded message.

fn on_frame(&mut self, frame: UdFrame, now: Instant, out: &mut EventSink)

Handles one inbound transport frame received at now.

fn poll_transmit(&mut self) -> Option<Outbound>

Takes the next outbound wire message, if any. Call it until it returns None.

fn poll_timeout(&self) -> Option<Instant>

When the core wants on_timeout to be called next, or None if it has no timer pending.

fn on_timeout(&mut self, _now: Instant, _out: &mut EventSink)

Handles a timer that fired. now is the time the timer was due.