spodes_rs/classes/
register_table.rs1use crate::interface::InterfaceClass;
2use crate::obis::ObisCode;
3use crate::types::attrs::ScalerUnit;
4use crate::types::{BerError, CosemDataType};
5use serde::{Deserialize, Serialize};
6use std::any::Any;
7
8#[derive(Clone, Serialize, Deserialize, Debug)]
10pub struct RegisterTableConfig {
11 pub logical_name: ObisCode,
13 pub table_cell_values: Vec<CosemDataType>,
15 pub table_cell_definition: CosemDataType,
17 pub scaler_unit: ScalerUnit,
19}
20
21#[derive(Clone, Serialize, Deserialize, Debug)]
25pub struct RegisterTable {
26 logical_name: ObisCode,
27 table_cell_values: Vec<CosemDataType>,
28 table_cell_definition: CosemDataType,
29 scaler_unit: ScalerUnit,
30}
31
32impl RegisterTable {
33 pub fn new(config: RegisterTableConfig) -> Self {
35 RegisterTable {
36 logical_name: config.logical_name,
37 table_cell_values: config.table_cell_values,
38 table_cell_definition: config.table_cell_definition,
39 scaler_unit: config.scaler_unit,
40 }
41 }
42
43 fn reset(&mut self) -> CosemDataType {
45 self.table_cell_values.clear();
46 CosemDataType::Null
47 }
48
49 pub fn table_cell_values(&self) -> &[CosemDataType] {
51 &self.table_cell_values
52 }
53}
54
55impl InterfaceClass for RegisterTable {
56 fn class_id(&self) -> u16 {
57 61
58 }
59
60 fn version(&self) -> u8 {
61 0
62 }
63
64 fn logical_name(&self) -> &ObisCode {
65 &self.logical_name
66 }
67
68 fn attributes(&self) -> Vec<(u8, CosemDataType)> {
69 vec![
70 (1, CosemDataType::OctetString(self.logical_name.to_bytes())),
71 (2, CosemDataType::Array(self.table_cell_values.clone())),
72 (3, self.table_cell_definition.clone()),
73 (4, self.scaler_unit.clone().into()),
74 ]
75 }
76
77 fn methods(&self) -> Vec<(u8, String)> {
78 vec![(1, "reset".to_string()), (2, "capture".to_string())]
79 }
80
81 fn serialize_ber(&self, buf: &mut Vec<u8>) -> Result<(), BerError> {
82 let mut seq_buf = Vec::new();
83 CosemDataType::LongUnsigned(self.class_id()).serialize_ber(&mut seq_buf)?;
84 for (_, attr) in self.attributes() {
85 attr.serialize_ber(&mut seq_buf)?;
86 }
87 buf.push(0x02); write_length(1 + self.attributes().len(), buf);
89 buf.extend_from_slice(&seq_buf);
90 Ok(())
91 }
92
93 fn deserialize_ber(&mut self, data: &[u8]) -> Result<(), BerError> {
94 let (tlv, rest) = CosemDataType::deserialize_ber(data)?;
95 if !rest.is_empty() {
96 return Err(BerError::InvalidTag);
97 }
98 let CosemDataType::Structure(seq) = tlv else {
99 return Err(BerError::InvalidTag);
100 };
101 if seq.len() != 5 {
102 return Err(BerError::InvalidLength);
103 }
104 if let CosemDataType::LongUnsigned(class_id) = seq[0] {
105 if class_id != self.class_id() {
106 return Err(BerError::InvalidValue);
107 }
108 } else {
109 return Err(BerError::InvalidTag);
110 }
111 if let CosemDataType::OctetString(obis) = &seq[1] {
112 if obis.len() == 6 {
113 self.logical_name = ObisCode::new(obis[0], obis[1], obis[2], obis[3], obis[4], obis[5]);
114 } else {
115 return Err(BerError::InvalidLength);
116 }
117 } else {
118 return Err(BerError::InvalidTag);
119 }
120 self.table_cell_values = match &seq[2] {
121 CosemDataType::Array(v) => v.clone(),
122 _ => return Err(BerError::InvalidTag),
123 };
124 self.table_cell_definition = seq[3].clone();
125 self.scaler_unit = ScalerUnit::try_from(&seq[4]).map_err(|_| BerError::InvalidValue)?;
126 Ok(())
127 }
128
129 fn invoke_method(&mut self, method_id: u8, _params: Option<CosemDataType>) -> Result<CosemDataType, String> {
130 match method_id {
131 1 => Ok(self.reset()),
132 2 => Ok(CosemDataType::Null),
135 _ => Err(format!("Method {method_id} not supported for Register table class")),
136 }
137 }
138
139 fn as_any(&self) -> &dyn Any {
140 self
141 }
142}
143
144#[allow(clippy::cast_possible_truncation)] fn write_length(length: usize, buf: &mut Vec<u8>) {
147 if length < 128 {
148 buf.push(length as u8);
149 } else {
150 let bytes = (length as u64).to_be_bytes();
151 let first_non_zero = bytes.iter().position(|&b| b != 0).unwrap_or(7);
152 let num_octets = 8 - first_non_zero;
153 buf.push(0x80 | num_octets as u8);
154 buf.extend_from_slice(&bytes[first_non_zero..]);
155 }
156}
157
158#[cfg(test)]
159mod tests {
160 use super::*;
161
162 fn sample() -> RegisterTable {
163 RegisterTable::new(RegisterTableConfig {
164 logical_name: ObisCode::new(1, 0, 98, 10, 0, 255),
165 table_cell_values: vec![CosemDataType::DoubleLongUnsigned(100), CosemDataType::DoubleLongUnsigned(200)],
166 table_cell_definition: CosemDataType::Structure(vec![
167 CosemDataType::LongUnsigned(3),
168 CosemDataType::OctetString(vec![1, 0, 1, 8, 0, 255]),
169 CosemDataType::Integer(2),
170 ]),
171 scaler_unit: ScalerUnit { scaler: 0, unit: 30 },
172 })
173 }
174
175 #[test]
176 fn class_id_and_attributes() {
177 let obj = sample();
178 assert_eq!(obj.class_id(), 61);
179 assert_eq!(obj.attributes().len(), 4);
180 assert_eq!(obj.methods().len(), 2);
181 }
182
183 #[test]
184 fn reset_clears_values() {
185 let mut obj = sample();
186 obj.invoke_method(1, None).unwrap();
187 assert!(obj.table_cell_values().is_empty());
188 }
189
190 #[test]
191 fn round_trip() {
192 let obj = sample();
193 let mut buf = Vec::new();
194 obj.serialize_ber(&mut buf).unwrap();
195 let mut decoded = sample();
196 decoded.deserialize_ber(&buf).unwrap();
197 assert_eq!(decoded.attributes(), obj.attributes());
198 }
199}