atelier_data 0.0.15

Data Artifacts and I/O for the atelier-rs engine
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
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129

use serde::Deserialize;

#[derive(Debug, Deserialize, Clone)]
pub struct ExchangeConfig {
    pub id: String,
    pub region: String,
    pub name: String,
    pub category: String,
    pub orderbook: Option<OrderbookConfig>,
}

// TODO refactor
#[derive(Debug, Deserialize, Clone)]
pub struct OrderbookConfig {
    pub update_freq: Option<u64>,
    pub bid_price: Option<f64>,
    pub bid_levels: Option<Vec<u32>>,
    pub bid_orders: Option<Vec<u32>>,
    pub ticksize: Option<Vec<f64>>,
    pub ask_price: Option<f64>,
    pub ask_levels: Option<Vec<u32>>,
    pub ask_orders: Option<Vec<u32>>,
    pub rands: Option<Vec<f64>>,
}

impl OrderbookConfig {
    pub fn builder() -> OrderbookConfigBuilder {
        OrderbookConfigBuilder::new()
    }
}

#[derive(Debug, Deserialize, Clone)]
pub struct OrderbookConfigBuilder {
    pub update_freq: Option<u64>,
    pub bid_price: Option<f64>,
    pub bid_levels: Option<Vec<u32>>,
    pub bid_orders: Option<Vec<u32>>,
    pub ticksize: Option<Vec<f64>>,
    pub ask_price: Option<f64>,
    pub ask_levels: Option<Vec<u32>>,
    pub ask_orders: Option<Vec<u32>>,
    pub rands: Option<Vec<f64>>,
}

impl Default for OrderbookConfigBuilder {
    fn default() -> Self {
        Self::new()
    }
}

impl OrderbookConfigBuilder {
    pub fn new() -> Self {
        OrderbookConfigBuilder {
            update_freq: None,
            bid_price: None,
            bid_levels: None,
            bid_orders: None,
            ticksize: None,
            ask_price: None,
            ask_levels: None,
            ask_orders: None,
            rands: None,
        }
    }

    pub fn update_freq(mut self, update_freq: u64) -> Self {
        self.update_freq = Some(update_freq);
        self
    }

    pub fn bid_price(mut self, bid_price: f64) -> Self {
        self.bid_price = Some(bid_price);
        self
    }

    pub fn bid_levels(mut self, bid_levels: Vec<u32>) -> Self {
        self.bid_levels = Some(bid_levels);
        self
    }

    pub fn bid_orders(mut self, bid_orders: Vec<u32>) -> Self {
        self.bid_orders = Some(bid_orders);
        self
    }

    pub fn ask_price(mut self, ask_price: f64) -> Self {
        self.ask_price = Some(ask_price);
        self
    }

    pub fn ask_levels(mut self, ask_levels: Vec<u32>) -> Self {
        self.ask_levels = Some(ask_levels);
        self
    }

    pub fn ask_orders(mut self, ask_orders: Vec<u32>) -> Self {
        self.ask_orders = Some(ask_orders);
        self
    }

    pub fn ticksize(mut self, ticksize: Vec<f64>) -> Self {
        self.ticksize = Some(ticksize);
        self
    }

    pub fn build(self) -> Result<OrderbookConfig, &'static str> {
        let update_freq = self.update_freq.ok_or("Missing initial update freq")?;
        let bid_price = self.bid_price.ok_or("Missing initial bid price")?;
        let bid_levels = self.bid_levels.ok_or("Missing initial bid levels")?;
        let bid_orders = self.bid_orders.ok_or("Missing initial bid orders")?;
        let ticksize = self.ticksize.ok_or("Missing initial tick size")?;
        let ask_price = self.ask_price.ok_or("Missing initial ask price")?;
        let ask_levels = self.ask_levels.ok_or("Missing initial ask levels")?;
        let ask_orders = self.ask_orders.ok_or("Missing initial ask orders")?;
        let rands = self.rands.ok_or("Missing initial random numbers")?;

        Ok(OrderbookConfig {
            update_freq: Some(update_freq),
            bid_price: Some(bid_price),
            bid_levels: Some(bid_levels),
            bid_orders: Some(bid_orders),
            ticksize: Some(ticksize),
            ask_price: Some(ask_price),
            ask_levels: Some(ask_levels),
            ask_orders: Some(ask_orders),
            rands: Some(rands),
        })
    }
}