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
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176

//! Module containing sensor subfunctions.

use std::fmt::{Display, Formatter, Result};

#[allow(missing_docs)]
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
pub enum SensorSubFunctionType {
    Input,
    Fault,
    Label,
    Type,
    Lowest,
    Highest,
    InputLowest,
    InputHighest,
    Average,
    AverageIntervalMax,
    AverageIntervalMin,
    AverageHighest,
    AverageLowest,
    Accuracy,
    CapMin,
    CapMax,
    Enable,
    Max,
    Min,
    MaxHyst,
    MinHyst,
    Crit,
    CritHyst,
    Emergency,
    EmergencyHyst,
    LowCrit,
    LowCritHyst,
    Offset,
    Div,
    Pulses,
    Target,
    AverageInterval,
    AverageMax,
    AverageMin,
    Cap,
    CapHyst,
    ResetHistory,
    Pwm,
    Mode,
    Freq,
    AutoChannelsTemp,
}

impl SensorSubFunctionType {
    pub(crate) fn read_only_list() -> &'static [SensorSubFunctionType] {
        const ARRAY: [SensorSubFunctionType; 16] = [
            SensorSubFunctionType::Input,
            SensorSubFunctionType::Fault,
            SensorSubFunctionType::Label,
            SensorSubFunctionType::Type,
            SensorSubFunctionType::Lowest,
            SensorSubFunctionType::Highest,
            SensorSubFunctionType::InputLowest,
            SensorSubFunctionType::InputHighest,
            SensorSubFunctionType::Average,
            SensorSubFunctionType::AverageIntervalMax,
            SensorSubFunctionType::AverageIntervalMin,
            SensorSubFunctionType::AverageHighest,
            SensorSubFunctionType::AverageLowest,
            SensorSubFunctionType::Accuracy,
            SensorSubFunctionType::CapMin,
            SensorSubFunctionType::CapMax,
        ];
        &ARRAY
    }

    pub(crate) fn read_write_list() -> &'static [SensorSubFunctionType] {
        const ARRAY: [SensorSubFunctionType; 24] = [
            SensorSubFunctionType::Enable,
            SensorSubFunctionType::Max,
            SensorSubFunctionType::Min,
            SensorSubFunctionType::MaxHyst,
            SensorSubFunctionType::MinHyst,
            SensorSubFunctionType::Crit,
            SensorSubFunctionType::CritHyst,
            SensorSubFunctionType::Emergency,
            SensorSubFunctionType::EmergencyHyst,
            SensorSubFunctionType::LowCrit,
            SensorSubFunctionType::LowCritHyst,
            SensorSubFunctionType::Offset,
            SensorSubFunctionType::Div,
            SensorSubFunctionType::Pulses,
            SensorSubFunctionType::Target,
            SensorSubFunctionType::AverageInterval,
            SensorSubFunctionType::AverageMax,
            SensorSubFunctionType::AverageMin,
            SensorSubFunctionType::Cap,
            SensorSubFunctionType::CapHyst,
            SensorSubFunctionType::Pwm,
            SensorSubFunctionType::Mode,
            SensorSubFunctionType::Freq,
            SensorSubFunctionType::AutoChannelsTemp,
        ];
        &ARRAY
    }

    #[cfg(feature = "writeable")]
    pub(crate) fn write_only_list() -> &'static [SensorSubFunctionType] {
        const ARRAY: [SensorSubFunctionType; 1] = [SensorSubFunctionType::ResetHistory];
        &ARRAY
    }

    pub(crate) fn read_list() -> impl Iterator<Item = Self> {
        Self::read_only_list()
            .iter()
            .chain(Self::read_write_list())
            .copied()
    }

    #[cfg(feature = "writeable")]
    pub(crate) fn write_list() -> impl Iterator<Item = Self> {
        Self::write_only_list()
            .iter()
            .chain(Self::read_write_list())
            .copied()
    }

    pub(crate) fn to_suffix(self) -> &'static str {
        match self {
            SensorSubFunctionType::Input => "_input",
            SensorSubFunctionType::Fault => "_fault",
            SensorSubFunctionType::Label => "_label",
            SensorSubFunctionType::Type => "_type",
            SensorSubFunctionType::Lowest => "_lowest",
            SensorSubFunctionType::Highest => "_highest",
            SensorSubFunctionType::InputLowest => "_input_lowest",
            SensorSubFunctionType::InputHighest => "_input_highest",
            SensorSubFunctionType::Average => "_average",
            SensorSubFunctionType::AverageIntervalMax => "_average_interval_max",
            SensorSubFunctionType::AverageIntervalMin => "_average_interval_min",
            SensorSubFunctionType::AverageHighest => "_average_highest",
            SensorSubFunctionType::AverageLowest => "_average_lowest",
            SensorSubFunctionType::Accuracy => "_accuracy",
            SensorSubFunctionType::CapMin => "_cap_min",
            SensorSubFunctionType::CapMax => "_cap_max",
            SensorSubFunctionType::Enable => "_enable",
            SensorSubFunctionType::Max => "_max",
            SensorSubFunctionType::Min => "_min",
            SensorSubFunctionType::MaxHyst => "_max_hyst",
            SensorSubFunctionType::MinHyst => "_min_hyst",
            SensorSubFunctionType::Crit => "_crit",
            SensorSubFunctionType::CritHyst => "_crit_hyst",
            SensorSubFunctionType::Emergency => "_emergency",
            SensorSubFunctionType::EmergencyHyst => "_emergency_hyst",
            SensorSubFunctionType::LowCrit => "_lcrit",
            SensorSubFunctionType::LowCritHyst => "_lcrit_hyst",
            SensorSubFunctionType::Offset => "_offset",
            SensorSubFunctionType::Div => "_div",
            SensorSubFunctionType::Pulses => "_pulses",
            SensorSubFunctionType::Target => "_target",
            SensorSubFunctionType::AverageInterval => "_average_interval",
            SensorSubFunctionType::AverageMax => "_average_max",
            SensorSubFunctionType::AverageMin => "_average_min",
            SensorSubFunctionType::Cap => "_cap",
            SensorSubFunctionType::CapHyst => "_cap_hyst",
            SensorSubFunctionType::ResetHistory => "_reset_history",
            SensorSubFunctionType::Pwm => "",
            SensorSubFunctionType::Mode => "_mode",
            SensorSubFunctionType::Freq => "_freq",
            SensorSubFunctionType::AutoChannelsTemp => "_auto_channels_temp",
        }
    }
}

impl Display for SensorSubFunctionType {
    fn fmt(&self, f: &mut Formatter) -> Result {
        write!(f, "{:?}", self)
    }
}