stock-trek 0.4.1

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

use crate::values::{
    asset_in_exchange_value::AssetInExchangeValue,
    asset_total_value::AssetTotalValue,
    binary_calculation_value::{BinaryCalculationValue, BinaryOperator},
    literal_value::{
        LiteralAssetValue, LiteralExchangeValue, LiteralFlagValue, LiteralNumberValue,
    },
    scratch_pad_value::{
        ScratchPadAssetValue, ScratchPadExchangeValue, ScratchPadFlagValue, ScratchPadNumberValue,
    },
    unary_calculation_value::{UnaryCalculationValue, UnaryOperator},
    value::{AssetValue, ExchangeValue, FlagValue, NumberValue},
};
use digdigdig3::ExchangeId;

pub struct PortfolioValuesFactory {}
pub struct CalculationValuesFactory {}
pub struct LiteralValuesFactory {}
pub struct ScratchPadValuesFactory {}

impl PortfolioValuesFactory {
    pub fn asset_in_exchange(&self, exchange: ExchangeValue, asset: AssetValue) -> NumberValue {
        AssetInExchangeValue::new(exchange, asset)
    }
    pub fn asset_total(&self, asset: AssetValue) -> NumberValue {
        AssetTotalValue::new(asset)
    }
}

impl CalculationValuesFactory {
    pub fn binary(
        &self,
        left: NumberValue,
        operator: BinaryOperator,
        right: NumberValue,
    ) -> NumberValue {
        BinaryCalculationValue::new(left, operator, right)
    }
    pub fn unary(&self, number: NumberValue, operator: UnaryOperator) -> NumberValue {
        UnaryCalculationValue::new(number, operator)
    }
}

impl LiteralValuesFactory {
    pub fn asset(&self, literal: impl AsRef<str>) -> AssetValue {
        LiteralAssetValue::new(literal.as_ref().to_string())
    }
    pub fn exchange(&self, literal: ExchangeId) -> ExchangeValue {
        LiteralExchangeValue::new(literal)
    }
    pub fn flag(&self, literal: bool) -> FlagValue {
        LiteralFlagValue::new(literal)
    }
    pub fn number(&self, literal: f64) -> NumberValue {
        LiteralNumberValue::new(literal)
    }
}

impl ScratchPadValuesFactory {
    pub fn asset(&self, key: impl AsRef<str>) -> AssetValue {
        ScratchPadAssetValue::new(key.as_ref().to_string())
    }
    pub fn exchange(&self, key: impl AsRef<str>) -> ExchangeValue {
        ScratchPadExchangeValue::new(key.as_ref().to_string())
    }
    pub fn flag(&self, key: impl AsRef<str>) -> FlagValue {
        ScratchPadFlagValue::new(key.as_ref().to_string())
    }
    pub fn number(&self, key: impl AsRef<str>) -> NumberValue {
        ScratchPadNumberValue::new(key.as_ref().to_string())
    }
}