ocpi-tariffs 0.20.0

OCPI tariff calculations
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
135
136
137
138
139
140
141
142
143
144

use std::fmt;

use rust_decimal::Decimal;
use serde::{Deserialize, Serialize};

use crate::{json, number, Number};

/// A value of kilo watt hours.
#[derive(Debug, Deserialize, Serialize, PartialEq, Eq, Clone, Copy, PartialOrd, Ord, Default)]
#[serde(transparent)]
pub struct Kwh(Number);

impl json::FromJson<'_, '_> for Kwh {
    type WarningKind = number::WarningKind;

    fn from_json(elem: &'_ json::Element<'_>) -> crate::Verdict<Self, Self::WarningKind> {
        Ok(Number::from_json(elem)?.map(Kwh))
    }
}

impl Kwh {
    pub(crate) fn from_decimal(d: Decimal) -> Self {
        Self(Number::from_decimal(d))
    }

    pub fn zero() -> Self {
        Self(Number::default())
    }

    /// Saturating addition
    #[must_use]
    pub fn saturating_add(self, other: Self) -> Self {
        Self(self.0.saturating_add(other.0))
    }

    /// Saturating subtraction
    #[must_use]
    pub fn saturating_sub(self, other: Self) -> Self {
        Self(self.0.saturating_sub(other.0))
    }

    pub fn watt_hours(self) -> Number {
        self.0.saturating_mul(Number::from(1000))
    }

    pub fn from_watt_hours(num: Number) -> Self {
        Self(
            num.checked_div(Number::from(1000))
                .expect("divisor is non-zero"),
        )
    }

    /// Round this number to the OCPI specified amount of decimals.
    #[must_use]
    pub fn rescale(self) -> Self {
        Self(self.0.rescale())
    }

    #[must_use]
    pub fn round_dp(self, digits: u32) -> Self {
        Self(self.0.round_dp(digits))
    }
}

impl From<Kwh> for Decimal {
    fn from(value: Kwh) -> Self {
        value.0.into()
    }
}

impl From<Kwh> for Number {
    fn from(value: Kwh) -> Self {
        value.0
    }
}

impl fmt::Display for Kwh {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{:.4}", self.0)
    }
}

/// A value of kilo watts.
#[derive(Debug, Deserialize, Serialize, PartialEq, Eq, Clone, Copy, PartialOrd, Ord)]
#[serde(transparent)]
pub struct Kw(Number);

impl json::FromJson<'_, '_> for Kw {
    type WarningKind = number::WarningKind;

    fn from_json(elem: &'_ json::Element<'_>) -> crate::Verdict<Self, Self::WarningKind> {
        Ok(Number::from_json(elem)?.map(Kw))
    }
}

impl From<Kw> for Decimal {
    fn from(value: Kw) -> Self {
        value.0.into()
    }
}

/// A value of amperes.
#[derive(Debug, Deserialize, Serialize, PartialEq, Eq, Clone, Copy, PartialOrd, Ord)]
#[serde(transparent)]
pub struct Ampere(Number);

impl json::FromJson<'_, '_> for Ampere {
    type WarningKind = number::WarningKind;

    fn from_json(elem: &'_ json::Element<'_>) -> crate::Verdict<Self, Self::WarningKind> {
        Ok(Number::from_json(elem)?.map(Ampere))
    }
}

impl From<Ampere> for Decimal {
    fn from(value: Ampere) -> Self {
        value.0.into()
    }
}

#[cfg(test)]
mod test {
    use crate::Number;

    use super::{Ampere, Kw, Kwh};

    impl From<u64> for Kw {
        fn from(value: u64) -> Self {
            Self(value.into())
        }
    }

    impl From<u64> for Kwh {
        fn from(value: u64) -> Self {
            Self(value.into())
        }
    }

    impl From<Number> for Ampere {
        fn from(value: Number) -> Self {
            Self(value)
        }
    }
}