Struct Client 

pub struct Client { /* private fields */ }

Implementations

impl Client

pub fn new(address: &str, client_id: i32) -> Self

Examples found in repository

examples/historical_bars.rs (line 17)

async fn main() -> Result<(), Error> {
    tracing_subscriber::fmt().init();
    let mut client = Client::new("127.0.0.1:14001", 4322);
    let client_ref = client.connect().await?;

    tokio::spawn(async move {
        sleep(Duration::from_secs(5)).await;
        let now = Instant::now();
        let (bars, mut stream) = historical_data(
            &client_ref,
            &Contract::stock("TSLA"),
            None,
            TWSDuration::days(3),
            BarSize::Min3,
            Some(WhatToShow::Trades),
            true,
            true,
        )
        .await
        .unwrap();
        info!("cost {:?}, bars: {:?}", now.elapsed(), bars);//&bars.bars[..3]);

        while let Some(e) = stream.next().await {
            info!("msg {:?}", e);
        }
    });
    let local = LocalSet::new();
    let res = local
        .run_until(async move {
            client.blocking_process().await?;
            sleep(Duration::from_secs(5)).await;
            Result::<(), Error>::Ok(())
        })
        .await;
    info!("{:?}", res);
    Ok(())
}

pub async fn connect(&mut self) -> Result<ClientRef, Error>

Examples found in repository

examples/historical_bars.rs (line 18)

async fn main() -> Result<(), Error> {
    tracing_subscriber::fmt().init();
    let mut client = Client::new("127.0.0.1:14001", 4322);
    let client_ref = client.connect().await?;

    tokio::spawn(async move {
        sleep(Duration::from_secs(5)).await;
        let now = Instant::now();
        let (bars, mut stream) = historical_data(
            &client_ref,
            &Contract::stock("TSLA"),
            None,
            TWSDuration::days(3),
            BarSize::Min3,
            Some(WhatToShow::Trades),
            true,
            true,
        )
        .await
        .unwrap();
        info!("cost {:?}, bars: {:?}", now.elapsed(), bars);//&bars.bars[..3]);

        while let Some(e) = stream.next().await {
            info!("msg {:?}", e);
        }
    });
    let local = LocalSet::new();
    let res = local
        .run_until(async move {
            client.blocking_process().await?;
            sleep(Duration::from_secs(5)).await;
            Result::<(), Error>::Ok(())
        })
        .await;
    info!("{:?}", res);
    Ok(())
}

pub async fn blocking_process(&mut self) -> Result<(), Error>

Examples found in repository

examples/historical_bars.rs (line 44)

async fn main() -> Result<(), Error> {
    tracing_subscriber::fmt().init();
    let mut client = Client::new("127.0.0.1:14001", 4322);
    let client_ref = client.connect().await?;

    tokio::spawn(async move {
        sleep(Duration::from_secs(5)).await;
        let now = Instant::now();
        let (bars, mut stream) = historical_data(
            &client_ref,
            &Contract::stock("TSLA"),
            None,
            TWSDuration::days(3),
            BarSize::Min3,
            Some(WhatToShow::Trades),
            true,
            true,
        )
        .await
        .unwrap();
        info!("cost {:?}, bars: {:?}", now.elapsed(), bars);//&bars.bars[..3]);

        while let Some(e) = stream.next().await {
            info!("msg {:?}", e);
        }
    });
    let local = LocalSet::new();
    let res = local
        .run_until(async move {
            client.blocking_process().await?;
            sleep(Duration::from_secs(5)).await;
            Result::<(), Error>::Ok(())
        })
        .await;
    info!("{:?}", res);
    Ok(())
}

Trait Implementations

impl Debug for Client

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

Formats the value using the given formatter.