stock-trek 0.6.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

use crate::{
    asset_id::AssetId,
    exchange_id::ExchangeId,
    scratch::key::ScratchKey,
    values::{
        asset_in_exchange_value::AssetInExchangeValue,
        asset_total_value::AssetTotalValue,
        binary_calculation_value::{BinaryCalculationValue, BinaryOperator},
        literal_value::{
            LiteralAssetIdValue, LiteralExchangeIdValue, LiteralFlagValue, LiteralNumberValue,
        },
        unary_calculation_value::{UnaryCalculationValue, UnaryOperator},
        value::{AssetIdValue, ExchangeIdValue, FlagValue, NumberValue},
    },
};

pub struct PortfolioValuesFactory;
pub struct CalculationValuesFactory;
pub struct LiteralValuesFactory;
pub struct ScratchPadValuesFactory;

impl PortfolioValuesFactory {
    pub fn asset_in_exchange(
        &self,
        exchange_id_value: ExchangeIdValue,
        asset_id_value: AssetIdValue,
    ) -> NumberValue {
        AssetInExchangeValue::new(exchange_id_value, asset_id_value)
    }
    pub fn asset_total(&self, asset_id_value: AssetIdValue) -> NumberValue {
        AssetTotalValue::new(asset_id_value)
    }
}

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 exchange_id(&self, literal: ExchangeId) -> ExchangeIdValue {
        LiteralExchangeIdValue::new(literal)
    }
    pub fn asset_id(&self, literal: AssetId) -> AssetIdValue {
        LiteralAssetIdValue::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 exchange_id(&self, key: &ScratchKey<ExchangeId>) -> ExchangeIdValue {
        Box::new(key.clone())
    }
    pub fn asset_id(&self, key: &ScratchKey<AssetId>) -> AssetIdValue {
        Box::new(key.clone())
    }
    pub fn flag(&self, key: &ScratchKey<bool>) -> FlagValue {
        Box::new(key.clone())
    }
    pub fn number(&self, key: &ScratchKey<f64>) -> NumberValue {
        Box::new(key.clone())
    }
}