Struct architect_api::client::orderflow::Client

pub struct Client { /* private fields */ }

This is the low level orderflow channel. This is the fastest way to interact with the core short of being in it’s address space.

Implementations

impl Client

pub async fn new(common: &Common, chanid: Option<ChanId>) -> Result<Self>

Connect to the specified order flow channel. If you drop the channel it will disconnect. Disconnecting causes all open orders sent by the channel to be canceled.

pub fn id(&self) -> ChanId

get the channel id of this channel, should you wish to use OrderId::new directly.

pub fn orderid(&self) -> OrderId

Generate a new order id valid only on this client session.

pub fn send_one(&self, m: &ToOms) -> Result<()>

Send one message. It’s recommended to send batches of messages using start_batch and send, but if you have just one, you can use this. If you wish to wait for the message to be flushed to the OS call flush.

pub fn start_batch(&self) -> Batch

Start a new batch of messages. Once you’ve queued all the messages you’d like to send you can call send to send the batch.

pub fn send(&self, batch: Batch) -> Result<()>

Send a batch of messages. If you wish to wait for the batch to be flushed to the OS you may call flush.

pub async fn flush(&self) -> Result<()>

Wait for previously sent message to be flushed to OS channels. This is not required, it is only necessary if you have a high message rate and you want pushback.

pub async fn recv_one(&self) -> Result<FromOms>

Receive one message from the core. If no message is currently available, wait for one to arrive. It is recommended to use recv instead for better efficiencly.

pub async fn try_recv_one(&self) -> Result<Option<FromOms>>

Receive one message from the core, but if no messages are available, don’t wait, instead return None. This will only block if another receive is in progress concurrently.

pub async fn recv(&self) -> Result<Pooled<Vec<FromOms>>>

Receive all available messages from the core. Wait for at least one message to be available.

pub async fn try_recv(&self) -> Result<Pooled<Vec<FromOms>>>

Receive all available messages from the core, but if none are available do not wait for one to arrive. This will only block if another receive is in progress concurrently.

pub async fn get_halts(&self) -> Result<Pooled<Vec<Halt>>>

Return the list of halts