spodes_rs/classes/
register_activation.rs1use crate::interface::InterfaceClass;
2use crate::obis::ObisCode;
3use crate::types::attrs::{ObjectDefinition, RegisterActMask};
4use crate::types::{BerError, CosemDataType};
5use serde::{Deserialize, Serialize};
6use std::any::Any;
7
8#[derive(Clone, Serialize, Deserialize, Debug)]
10pub struct RegisterActivationConfig {
11 pub logical_name: ObisCode,
13 pub register_assignment: Vec<ObjectDefinition>,
15 pub mask_list: Vec<RegisterActMask>,
17 pub active_mask: Vec<u8>,
19}
20
21#[derive(Clone, Serialize, Deserialize, Debug)]
24pub struct RegisterActivation {
25 logical_name: ObisCode,
26 register_assignment: Vec<ObjectDefinition>,
27 mask_list: Vec<RegisterActMask>,
28 active_mask: Vec<u8>,
29}
30
31impl RegisterActivation {
32 pub fn new(config: RegisterActivationConfig) -> Self {
40 RegisterActivation {
41 logical_name: config.logical_name,
42 register_assignment: config.register_assignment,
43 mask_list: config.mask_list,
44 active_mask: config.active_mask,
45 }
46 }
47
48 fn add_mask(&mut self, params: Option<CosemDataType>) -> Result<CosemDataType, String> {
57 let param = params.ok_or("Invalid mask parameter".to_string())?;
58 let mask = RegisterActMask::try_from(¶m).map_err(|e| format!("Invalid mask parameter: {e}"))?;
59 if self.mask_list.iter().any(|m| m.mask_name == mask.mask_name) {
60 return Err("Mask with this name already exists".to_string());
61 }
62 self.mask_list.push(mask);
63 Ok(CosemDataType::Null)
64 }
65
66 fn delete_mask(&mut self, params: Option<CosemDataType>) -> Result<CosemDataType, String> {
75 let Some(CosemDataType::OctetString(mask_name)) = params else {
76 return Err("Invalid mask name parameter".to_string());
77 };
78 let initial_len = self.mask_list.len();
79 self.mask_list.retain(|m| m.mask_name != mask_name);
80 if self.mask_list.len() < initial_len {
81 if self.active_mask == mask_name {
82 self.active_mask.clear();
83 }
84 return Ok(CosemDataType::Null);
85 }
86 Err("Mask not found".to_string())
87 }
88}
89
90impl InterfaceClass for RegisterActivation {
91 fn class_id(&self) -> u16 {
92 6
93 }
94
95 fn version(&self) -> u8 {
96 0
97 }
98
99 fn logical_name(&self) -> &ObisCode {
100 &self.logical_name
101 }
102
103 fn attributes(&self) -> Vec<(u8, CosemDataType)> {
104 vec![
105 (1, CosemDataType::OctetString(self.logical_name.to_bytes())),
106 (
107 2,
108 CosemDataType::Array(
109 self.register_assignment.iter().map(|od| CosemDataType::from(od.clone())).collect(),
110 ),
111 ),
112 (3, CosemDataType::Array(self.mask_list.iter().map(|m| CosemDataType::from(m.clone())).collect())),
113 (4, CosemDataType::OctetString(self.active_mask.clone())),
114 ]
115 }
116
117 fn methods(&self) -> Vec<(u8, String)> {
118 vec![(1, "add_mask".to_string()), (2, "delete_mask".to_string())]
119 }
120
121 fn serialize_ber(&self, buf: &mut Vec<u8>) -> Result<(), BerError> {
122 let mut seq_buf = Vec::new();
123 CosemDataType::LongUnsigned(self.class_id()).serialize_ber(&mut seq_buf)?;
124 for (_, attr) in self.attributes() {
125 attr.serialize_ber(&mut seq_buf)?;
126 }
127 buf.push(0x02); write_length(1 + self.attributes().len(), buf); buf.extend_from_slice(&seq_buf);
130 Ok(())
131 }
132
133 fn deserialize_ber(&mut self, data: &[u8]) -> Result<(), BerError> {
134 let (tlv, rest) = CosemDataType::deserialize_ber(data)?;
135 if !rest.is_empty() {
136 return Err(BerError::InvalidTag);
137 }
138 if let CosemDataType::Structure(seq) = tlv {
139 if seq.len() == 5 {
140 if let CosemDataType::LongUnsigned(class_id) = seq[0] {
141 if class_id != self.class_id() {
142 return Err(BerError::InvalidValue);
143 }
144 } else {
145 return Err(BerError::InvalidTag);
146 }
147 if let CosemDataType::OctetString(obis) = &seq[1] {
148 if obis.len() == 6 {
149 self.logical_name = ObisCode::new(obis[0], obis[1], obis[2], obis[3], obis[4], obis[5]);
150 } else {
151 return Err(BerError::InvalidLength);
152 }
153 } else {
154 return Err(BerError::InvalidTag);
155 }
156 if let CosemDataType::Array(items) = &seq[2] {
157 self.register_assignment = items
158 .iter()
159 .map(ObjectDefinition::try_from)
160 .collect::<Result<Vec<_>, _>>()
161 .map_err(|_| BerError::InvalidValue)?;
162 } else {
163 return Err(BerError::InvalidTag);
164 }
165 if let CosemDataType::Array(items) = &seq[3] {
166 self.mask_list = items
167 .iter()
168 .map(RegisterActMask::try_from)
169 .collect::<Result<Vec<_>, _>>()
170 .map_err(|_| BerError::InvalidValue)?;
171 } else {
172 return Err(BerError::InvalidTag);
173 }
174 if let CosemDataType::OctetString(bytes) = &seq[4] {
175 self.active_mask.clone_from(bytes);
176 } else {
177 return Err(BerError::InvalidTag);
178 }
179 return Ok(());
180 }
181 return Err(BerError::InvalidLength);
182 }
183 Err(BerError::InvalidTag)
184 }
185
186 fn invoke_method(&mut self, method_id: u8, params: Option<CosemDataType>) -> Result<CosemDataType, String> {
187 match method_id {
188 1 => self.add_mask(params),
189 2 => self.delete_mask(params),
190 _ => Err(format!("Method {method_id} not supported for RegisterActivation class")),
191 }
192 }
193
194 fn as_any(&self) -> &dyn Any {
195 self
196 }
197}
198
199#[allow(clippy::cast_possible_truncation)] fn write_length(length: usize, buf: &mut Vec<u8>) {
202 if length < 128 {
203 buf.push(length as u8);
204 } else {
205 let bytes = (length as u64).to_be_bytes();
206 let first_non_zero = bytes.iter().position(|&b| b != 0).unwrap_or(7);
207 let num_octets = 8 - first_non_zero;
208 buf.push(0x80 | num_octets as u8);
209 buf.extend_from_slice(&bytes[first_non_zero..]);
210 }
211}