stock-trek 0.4.0

Stock Trek time-series analysis
Documentation 
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
130
131
132
133
134

use crate::portfolios::portfolio::{Portfolio, PortfolioTrait};
use anyhow::{anyhow, bail, Result};
use digdigdig3::{Asset, ExchangeId};
use std::collections::HashMap;

pub struct InMemoryPortfolio {
    exchange_assets: HashMap<ExchangeId, Assets>,
}

impl InMemoryPortfolio {
    pub fn new() -> Portfolio {
        Box::new(Self {
            exchange_assets: HashMap::new(),
        })
    }
    pub fn add_cash(&mut self, exchange_id: ExchangeId, cash: f64) {
        let exchange = self
            .exchange_assets
            .entry(exchange_id)
            .or_insert(Assets::new());
        exchange.cash += cash;
    }
    pub fn remove_cash(&mut self, exchange_id: ExchangeId, cash: f64) -> Result<()> {
        let exchange = self.exchange_assets.get_mut(&exchange_id);
        match exchange {
            None => bail!("Portfolio has not used exchange {:?}", exchange_id),
            Some(assets) => {
                if assets.cash < cash {
                    bail!(
                        "Exchange {:?} has cash {} and cannot remove {}",
                        exchange_id,
                        assets.cash,
                        cash
                    )
                }
                assets.cash -= cash;
                Ok(())
            }
        }
    }
    pub fn add_tokens(&mut self, exchange_id: ExchangeId, asset: Asset, quantity: f64) {
        let exchange = self
            .exchange_assets
            .entry(exchange_id)
            .or_insert(Assets::new());
        exchange
            .tokens
            .entry(asset)
            .and_modify(|previous| *previous += quantity)
            .or_insert(quantity);
    }
    pub fn remove_tokens(
        &mut self,
        exchange_id: ExchangeId,
        asset: Asset,
        quantity: f64,
    ) -> Result<()> {
        let exchange = self
            .exchange_assets
            .get_mut(&exchange_id)
            .ok_or_else(|| anyhow!("Portfolio has not used exchange {:?}", exchange_id))?;
        let token_quantity = exchange
            .tokens
            .get_mut(&asset)
            .ok_or_else(|| anyhow!("Exchange {:?} does not have asset {:?}", exchange_id, asset))?;
        if *token_quantity < quantity {
            bail!(
                "Exchange {:?} has {} of asset {:?} and cannot remove {}",
                exchange_id,
                token_quantity,
                asset,
                quantity
            );
        }
        *token_quantity -= quantity;
        if *token_quantity == 0.0 {
            exchange.tokens.remove(&asset);
        }
        Ok(())
    }
}

impl PortfolioTrait for InMemoryPortfolio {
    fn cash_total(&self) -> f64 {
        self.exchange_assets.values().map(|e| e.cash).sum()
    }
    fn cash_in_exchange(&self, exchange: ExchangeId) -> f64 {
        self.exchange_assets
            .get(&exchange)
            .map(|e| e.cash)
            .unwrap_or(0.0)
    }
    fn has_account_in_exchange(&self, exchange: ExchangeId) -> bool {
        self.exchange_assets.contains_key(&exchange)
    }
    fn owns_asset(&self, asset: &Asset) -> bool {
        self.exchange_assets
            .values()
            .any(|assets| assets.tokens.contains_key(asset))
    }
    fn owns_asset_in_exchange(&self, asset: &Asset, exchange: &ExchangeId) -> bool {
        self.exchange_assets
            .get(exchange)
            .map(|assets| assets.tokens.contains_key(asset))
            .unwrap_or(false)
    }
    fn asset_total(&self, asset: Asset) -> f64 {
        self.exchange_assets
            .values()
            .map(|assets| assets.tokens.get(&asset).unwrap_or(&0.0))
            .sum()
    }
    fn asset_in_exchange(&self, asset: Asset, exchange: ExchangeId) -> f64 {
        self.exchange_assets
            .get(&exchange)
            .and_then(|assets| assets.tokens.get(&asset))
            .copied()
            .unwrap_or(0.0)
    }
}

struct Assets {
    cash: f64,
    tokens: HashMap<Asset, f64>,
}

impl Assets {
    fn new() -> Self {
        Self {
            cash: 0.0,
            tokens: HashMap::new(),
        }
    }
}