bo4e-core 0.1.1

Core types for BO4E (Business Objects for Energy)
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
145

//! Network level (Netzebene) enumeration.

use serde::{Deserialize, Serialize};

/// Network level within electricity and gas energy types.
///
/// Lists possible network levels for electricity (voltage levels) and gas (pressure levels).
///
/// German: Netzebene
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Serialize, Deserialize)]
#[non_exhaustive]
pub enum NetworkLevel {
    // Electricity levels
    /// Low voltage (Niederspannung) - Electricity
    #[serde(rename = "NSP")]
    LowVoltage,

    /// Medium voltage (Mittelspannung) - Electricity
    #[serde(rename = "MSP")]
    MediumVoltage,

    /// High voltage (Hochspannung) - Electricity
    #[serde(rename = "HSP")]
    HighVoltage,

    /// Extra high voltage (Höchstspannung) - Electricity
    #[serde(rename = "HSS")]
    ExtraHighVoltage,

    /// Medium to low voltage transformation (MS/NS Umspannung) - Electricity
    #[serde(rename = "MSP_NSP_UMSP")]
    MediumLowVoltageTransformation,

    /// High to medium voltage transformation (HS/MS Umspannung) - Electricity
    #[serde(rename = "HSP_MSP_UMSP")]
    HighMediumVoltageTransformation,

    /// Extra high to high voltage transformation (HöS/HS Umspannung) - Electricity
    #[serde(rename = "HSS_HSP_UMSP")]
    ExtraHighHighVoltageTransformation,

    // Gas levels
    /// High pressure (Hochdruck) - Gas
    #[serde(rename = "HD")]
    HighPressure,

    /// Medium pressure (Mitteldruck) - Gas
    #[serde(rename = "MD")]
    MediumPressure,

    /// Low pressure (Niederdruck) - Gas
    #[serde(rename = "ND")]
    LowPressure,
}

impl NetworkLevel {
    /// Returns the German name.
    pub fn german_name(&self) -> &'static str {
        match self {
            Self::LowVoltage => "Niederspannung",
            Self::MediumVoltage => "Mittelspannung",
            Self::HighVoltage => "Hochspannung",
            Self::ExtraHighVoltage => "Höchstspannung",
            Self::MediumLowVoltageTransformation => "MS/NS Umspannung",
            Self::HighMediumVoltageTransformation => "HS/MS Umspannung",
            Self::ExtraHighHighVoltageTransformation => "HöS/HS Umspannung",
            Self::HighPressure => "Hochdruck",
            Self::MediumPressure => "Mitteldruck",
            Self::LowPressure => "Niederdruck",
        }
    }

    /// Returns true if this is an electricity network level.
    pub fn is_electricity(&self) -> bool {
        matches!(
            self,
            Self::LowVoltage
                | Self::MediumVoltage
                | Self::HighVoltage
                | Self::ExtraHighVoltage
                | Self::MediumLowVoltageTransformation
                | Self::HighMediumVoltageTransformation
                | Self::ExtraHighHighVoltageTransformation
        )
    }

    /// Returns true if this is a gas network level.
    pub fn is_gas(&self) -> bool {
        matches!(
            self,
            Self::HighPressure | Self::MediumPressure | Self::LowPressure
        )
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_serialize() {
        assert_eq!(
            serde_json::to_string(&NetworkLevel::LowVoltage).unwrap(),
            r#""NSP""#
        );
        assert_eq!(
            serde_json::to_string(&NetworkLevel::HighPressure).unwrap(),
            r#""HD""#
        );
    }

    #[test]
    fn test_roundtrip() {
        for level in [
            NetworkLevel::LowVoltage,
            NetworkLevel::MediumVoltage,
            NetworkLevel::HighVoltage,
            NetworkLevel::ExtraHighVoltage,
            NetworkLevel::MediumLowVoltageTransformation,
            NetworkLevel::HighMediumVoltageTransformation,
            NetworkLevel::ExtraHighHighVoltageTransformation,
            NetworkLevel::HighPressure,
            NetworkLevel::MediumPressure,
            NetworkLevel::LowPressure,
        ] {
            let json = serde_json::to_string(&level).unwrap();
            let parsed: NetworkLevel = serde_json::from_str(&json).unwrap();
            assert_eq!(level, parsed);
        }
    }

    #[test]
    fn test_is_electricity() {
        assert!(NetworkLevel::LowVoltage.is_electricity());
        assert!(NetworkLevel::HighVoltage.is_electricity());
        assert!(!NetworkLevel::HighPressure.is_electricity());
    }

    #[test]
    fn test_is_gas() {
        assert!(NetworkLevel::HighPressure.is_gas());
        assert!(NetworkLevel::LowPressure.is_gas());
        assert!(!NetworkLevel::LowVoltage.is_gas());
    }
}