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

use rust_decimal::RoundingStrategy;
use serde::de::Error;
use serde::{ser::SerializeStruct, Deserialize, Deserializer, Serialize, Serializer};
use strum::Display;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Preferences {
    pub rounding: Rounding,
    pub multi_leg: MultiLeg,
}

#[derive(Debug, Clone)]
pub struct Rounding {
    pub price: RoundingStrategy,
    pub quantity: RoundingStrategy,
    pub callback_rate: RoundingStrategy,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct MultiLeg {
    pub if_different_symbol_unsupported: OnDifferent,
    pub if_different_price_unsupported: OnDifferent,
}

#[derive(Debug, Display, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
pub enum OnDifferent {
    UseDataFromPrimary,
    SkipThisOrder,
    CancelEntireIteration,
}

impl Serialize for Rounding {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: Serializer,
    {
        let Rounding {
            price,
            quantity,
            callback_rate,
        } = self;
        let mut state = serializer.serialize_struct("Rounding", 3)?;
        state.serialize_field("price", &serialize_rounding(price))?;
        state.serialize_field("quantity", &serialize_rounding(quantity))?;
        state.serialize_field("callback_rate", &serialize_rounding(callback_rate))?;
        state.end()
    }
}

impl<'de> Deserialize<'de> for Rounding {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: Deserializer<'de>,
    {
        #[derive(Deserialize)]
        struct RoundingHelper {
            price: String,
            quantity: String,
            callback_rate: String,
        }

        let helper = RoundingHelper::deserialize(deserializer)?;

        Ok(Rounding {
            price: deserialize_rounding(&helper.price)
                .map_err(|e| D::Error::custom(format!("Invalid price rounding: {}", e)))?,
            quantity: deserialize_rounding(&helper.quantity)
                .map_err(|e| D::Error::custom(format!("Invalid quantity rounding: {}", e)))?,
            callback_rate: deserialize_rounding(&helper.callback_rate)
                .map_err(|e| D::Error::custom(format!("Invalid callback_rate rounding: {}", e)))?,
        })
    }
}

#[allow(deprecated)]
fn deserialize_rounding(text: &str) -> Result<RoundingStrategy, String> {
    match text {
        "AwayFromZero" => Ok(RoundingStrategy::AwayFromZero),
        "MidpointAwayFromZero" => Ok(RoundingStrategy::MidpointAwayFromZero),
        "MidpointNearestEven" => Ok(RoundingStrategy::MidpointNearestEven),
        "MidpointTowardZero" => Ok(RoundingStrategy::MidpointTowardZero),
        "ToNegativeInfinity" => Ok(RoundingStrategy::ToNegativeInfinity),
        "ToPositiveInfinity" => Ok(RoundingStrategy::ToPositiveInfinity),
        "ToZero" => Ok(RoundingStrategy::ToZero),
        "BankersRounding" => Ok(RoundingStrategy::BankersRounding),
        "RoundDown" => Ok(RoundingStrategy::RoundDown),
        "RoundHalfDown" => Ok(RoundingStrategy::RoundHalfDown),
        "RoundHalfUp" => Ok(RoundingStrategy::RoundHalfUp),
        "RoundUp" => Ok(RoundingStrategy::RoundUp),
        _ => Err(text.to_string()),
    }
}

#[allow(deprecated)]
fn serialize_rounding(strategy: &RoundingStrategy) -> &str {
    match *strategy {
        RoundingStrategy::AwayFromZero => "AwayFromZero",
        RoundingStrategy::MidpointAwayFromZero => "MidpointAwayFromZero",
        RoundingStrategy::MidpointNearestEven => "MidpointNearestEven",
        RoundingStrategy::MidpointTowardZero => "MidpointTowardZero",
        RoundingStrategy::ToNegativeInfinity => "ToNegativeInfinity",
        RoundingStrategy::ToPositiveInfinity => "ToPositiveInfinity",
        RoundingStrategy::ToZero => "ToZero",
        RoundingStrategy::BankersRounding => "BankersRounding",
        RoundingStrategy::RoundDown => "RoundDown",
        RoundingStrategy::RoundHalfDown => "RoundHalfDown",
        RoundingStrategy::RoundHalfUp => "RoundHalfUp",
        RoundingStrategy::RoundUp => "RoundUp",
    }
}