libmedium 0.3.0

Library to interface with lm_sensors
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
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 = "writable")]
    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 = "writable")]
    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)
    }
}