pub struct DisplayGroupSubscription { /* private fields */ }Expand description
A subscription to display group events with the ability to update the displayed contract.
Created by Client::subscribe_to_group_events.
Derefs to Subscription<DisplayGroupUpdate> for next(), cancel(), etc.
The canonical pattern-match form works through Deref with no extra ceremony:
while let Some(item) = subscription.next().await { /* match on SubscriptionItem */ }§filter_data and the reborrow gotcha
Subscription::filter_data (from SubscriptionItemStreamExt) takes self,
and method resolution through DerefMut is not allowed to move the
dereferenced value. So subscription.filter_data() on a
DisplayGroupSubscription fails with cannot move out of dereference.
Reborrow first:
let inner = &mut *subscription; // `&mut Subscription<_>`
while let Some(item) = inner.filter_data().next().await { /* ... */ }This is a Rust language quirk, not a subscription-shape issue. The same reborrow applies to any Deref-wrapping subscription type.
Implementations§
Source§impl DisplayGroupSubscription
impl DisplayGroupSubscription
Sourcepub async fn update(&self, contract_info: &str) -> Result<(), Error>
pub async fn update(&self, contract_info: &str) -> Result<(), Error>
Updates the contract displayed in the TWS display group.
§Arguments
contract_info- Contract to display:"contractID@exchange"for individual contracts (e.g., “265598@SMART”)"none"for empty selection"combo"for combination contracts
§Examples
use ibapi::prelude::*;
#[tokio::main]
async fn main() {
let client = Client::connect("127.0.0.1:7497", 100).await.expect("connection failed");
let subscription = client.subscribe_to_group_events(1).await.expect("subscription failed");
subscription.update("265598@SMART").await.expect("update failed");
}Methods from Deref<Target = Subscription<DisplayGroupUpdate>>§
Sourcepub fn request_id(&self) -> Option<i32>
pub fn request_id(&self) -> Option<i32>
Get the request ID associated with this subscription
Sourcepub async fn collect_for(&mut self, timeout: Duration) -> Vec<T>
pub async fn collect_for(&mut self, timeout: Duration) -> Vec<T>
Collects data items into a Vec, bounded by a total wall-clock timeout.
Drives the subscription until the first of: the timeout elapses, the
stream ends, a snapshot-end sentinel arrives (e.g.
TickTypes::SnapshotEnd),
or a terminal error occurs. Notices are filtered (logged at warn!); the
snapshot-end sentinel is not included in the returned Vec. On a terminal
error the items collected so far are returned (the error is logged at
warn!).
This is the one-shot snapshot terminal: combined with
MarketDataBuilder::snapshot,
the request returns one round of data ending in a snapshot sentinel, so
timeout acts only as a safety bound. Equivalent to
collect_until with a predicate that never fires.
§Examples
use ibapi::prelude::*;
use std::time::Duration;
#[tokio::main]
async fn main() {
let client = Client::connect("127.0.0.1:4002", 100).await.expect("connection failed");
let contract = Contract::stock("AAPL").build();
let mut subscription = client.market_data(&contract).snapshot().subscribe().await.expect("request failed");
let ticks = subscription.collect_for(Duration::from_secs(5)).await;
println!("collected {} ticks", ticks.len());
}Sourcepub async fn collect_until(
&mut self,
timeout: Duration,
stop: impl FnMut(&[T]) -> bool,
) -> Vec<T>
pub async fn collect_until( &mut self, timeout: Duration, stop: impl FnMut(&[T]) -> bool, ) -> Vec<T>
Collects data items into a Vec, stopping early once stop is satisfied.
Like collect_for, but after each item is appended
the stop predicate is called with the full accumulated slice; returning
true ends collection (the triggering item is included). Use it to stop
as soon as the fields of interest are populated, rather than waiting out
the whole timeout. The same timeout / stream-end / snapshot-end /
terminal-error bounds as collect_for still apply.
§Examples
use ibapi::market_data::realtime::TickTypes;
use ibapi::prelude::*;
use std::time::Duration;
#[tokio::main]
async fn main() {
let client = Client::connect("127.0.0.1:4002", 100).await.expect("connection failed");
let contract = Contract::stock("AAPL").build();
let mut subscription = client.market_data(&contract).snapshot().subscribe().await.expect("request failed");
// Stop as soon as a price tick has arrived.
let ticks = subscription
.collect_until(Duration::from_secs(5), |ticks| {
ticks.iter().any(|t| matches!(t, TickTypes::Price(_) | TickTypes::PriceSize(_)))
})
.await;
println!("collected {} ticks", ticks.len());
}