tickrs 0.15.0

Realtime ticker data in your terminal 📈
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74

use super::*;
use crate::api::model;
use crate::task::*;

pub struct OptionsService {
    symbol: String,
    expiration_dates_handle: AsyncTaskHandle<Vec<i64>>,
    options_data_handle: Option<AsyncTaskHandle<model::OptionsHeader>>,
}

impl OptionsService {
    pub fn new(symbol: String) -> OptionsService {
        let task = OptionsDates::new(symbol.clone());
        let expiration_dates_handle = task.connect();

        OptionsService {
            symbol,
            expiration_dates_handle,
            options_data_handle: None,
        }
    }

    pub fn set_expiration_date(&mut self, expiration_date: i64) {
        let task = OptionsData::new(self.symbol.clone(), expiration_date);
        let options_data_handle = task.connect();

        self.options_data_handle = Some(options_data_handle);
    }
}

#[derive(Debug)]
pub enum Update {
    ExpirationDates(Vec<i64>),
    OptionsData(model::OptionsHeader),
}

impl Service for OptionsService {
    type Update = Update;

    fn updates(&self) -> Vec<Self::Update> {
        let mut updates = vec![];

        let expiration_dates_updates = self
            .expiration_dates_handle
            .response()
            .try_iter()
            .map(Update::ExpirationDates);
        updates.extend(expiration_dates_updates);

        if let Some(ref options_data_handle) = self.options_data_handle {
            let options_data_updates = options_data_handle
                .response()
                .try_iter()
                .map(Update::OptionsData);
            updates.extend(options_data_updates);
        }

        updates
    }

    fn pause(&self) {
        self.expiration_dates_handle.pause();
        if let Some(handle) = self.options_data_handle.as_ref() {
            handle.pause();
        }
    }

    fn resume(&self) {
        self.expiration_dates_handle.resume();
        if let Some(handle) = self.options_data_handle.as_ref() {
            handle.resume();
        }
    }
}