spodes_rs/classes/
sap_assignment.rs1use crate::interface::InterfaceClass;
2use crate::obis::ObisCode;
3use crate::types::attrs::SapAssignmentEntry;
4use crate::types::{BerError, CosemDataType};
5use serde::{Deserialize, Serialize};
6use std::any::Any;
7
8#[derive(Clone, Serialize, Deserialize, Debug)]
10pub struct SapAssignmentConfig {
11 pub logical_name: ObisCode,
13 pub sap_assignment_list: Vec<SapAssignmentEntry>,
16}
17
18#[derive(Clone, Serialize, Deserialize, Debug)]
21pub struct SapAssignment {
22 logical_name: ObisCode,
23 sap_assignment_list: Vec<SapAssignmentEntry>,
24}
25
26impl SapAssignment {
27 pub fn new(config: SapAssignmentConfig) -> Self {
29 SapAssignment { logical_name: config.logical_name, sap_assignment_list: config.sap_assignment_list }
30 }
31
32 fn connect_logical_device(&mut self, data: &CosemDataType) -> Result<CosemDataType, String> {
36 let (sap, ldn) = match data {
37 CosemDataType::Structure(fields) if fields.len() == 2 => match (&fields[0], &fields[1]) {
38 (CosemDataType::LongUnsigned(sap), CosemDataType::OctetString(ldn)) => (*sap, ldn.clone()),
39 _ => return Err("Expected structure { SAP: long-unsigned, ldn: octet-string }".to_string()),
40 },
41 _ => return Err("Expected structure { SAP, logical_device_name }".to_string()),
42 };
43 self.sap_assignment_list.retain(|e| e.sap != sap);
44 if !ldn.is_empty() {
45 let entry = SapAssignmentEntry::try_from(data)?;
46 self.sap_assignment_list.push(entry);
47 }
48 Ok(CosemDataType::Null)
49 }
50}
51
52impl InterfaceClass for SapAssignment {
53 fn class_id(&self) -> u16 {
54 17
55 }
56
57 fn version(&self) -> u8 {
58 0
59 }
60
61 fn logical_name(&self) -> &ObisCode {
62 &self.logical_name
63 }
64
65 fn attributes(&self) -> Vec<(u8, CosemDataType)> {
66 vec![
67 (1, CosemDataType::OctetString(self.logical_name.to_bytes())),
68 (2, CosemDataType::Array(self.sap_assignment_list.iter().cloned().map(CosemDataType::from).collect())),
69 ]
70 }
71
72 fn methods(&self) -> Vec<(u8, String)> {
73 vec![(1, "connect_logical_device".to_string())]
74 }
75
76 fn serialize_ber(&self, buf: &mut Vec<u8>) -> Result<(), BerError> {
77 let mut seq_buf = Vec::new();
78 CosemDataType::LongUnsigned(self.class_id()).serialize_ber(&mut seq_buf)?;
79 for (_, attr) in self.attributes() {
80 attr.serialize_ber(&mut seq_buf)?;
81 }
82 buf.push(0x02); write_length(1 + self.attributes().len(), buf); buf.extend_from_slice(&seq_buf);
85 Ok(())
86 }
87
88 fn deserialize_ber(&mut self, data: &[u8]) -> Result<(), BerError> {
89 let (tlv, rest) = CosemDataType::deserialize_ber(data)?;
90 if !rest.is_empty() {
91 return Err(BerError::InvalidTag);
92 }
93 let CosemDataType::Structure(seq) = tlv else {
94 return Err(BerError::InvalidTag);
95 };
96 if seq.len() != 3 {
98 return Err(BerError::InvalidLength);
99 }
100 if let CosemDataType::LongUnsigned(class_id) = seq[0] {
101 if class_id != self.class_id() {
102 return Err(BerError::InvalidValue);
103 }
104 } else {
105 return Err(BerError::InvalidTag);
106 }
107 if let CosemDataType::OctetString(obis) = &seq[1] {
108 if obis.len() == 6 {
109 self.logical_name = ObisCode::new(obis[0], obis[1], obis[2], obis[3], obis[4], obis[5]);
110 } else {
111 return Err(BerError::InvalidLength);
112 }
113 } else {
114 return Err(BerError::InvalidTag);
115 }
116 self.sap_assignment_list = match &seq[2] {
117 CosemDataType::Array(list) => list
118 .iter()
119 .map(SapAssignmentEntry::try_from)
120 .collect::<Result<Vec<_>, _>>()
121 .map_err(|_| BerError::InvalidValue)?,
122 _ => return Err(BerError::InvalidTag),
123 };
124 Ok(())
125 }
126
127 fn invoke_method(&mut self, method_id: u8, params: Option<CosemDataType>) -> Result<CosemDataType, String> {
128 match method_id {
129 1 => self.connect_logical_device(¶ms.ok_or("Missing method parameter")?),
130 _ => Err(format!("Method {method_id} not supported for SAP assignment")),
131 }
132 }
133
134 fn as_any(&self) -> &dyn Any {
135 self
136 }
137}
138
139#[allow(clippy::cast_possible_truncation)] fn write_length(length: usize, buf: &mut Vec<u8>) {
142 if length < 128 {
143 buf.push(length as u8);
144 } else {
145 let bytes = (length as u64).to_be_bytes();
146 let first_non_zero = bytes.iter().position(|&b| b != 0).unwrap_or(7);
147 let num_octets = 8 - first_non_zero;
148 buf.push(0x80 | num_octets as u8);
149 buf.extend_from_slice(&bytes[first_non_zero..]);
150 }
151}
152
153#[cfg(test)]
154mod tests {
155 use super::*;
156
157 fn sample() -> SapAssignment {
158 SapAssignment::new(SapAssignmentConfig {
159 logical_name: ObisCode::new(0, 0, 41, 0, 0, 255),
160 sap_assignment_list: vec![SapAssignmentEntry { sap: 1, logical_device_name: b"MANLD".to_vec() }],
161 })
162 }
163
164 #[test]
165 fn class_id_and_attributes() {
166 let obj = sample();
167 assert_eq!(obj.class_id(), 17);
168 assert_eq!(obj.version(), 0);
169 assert_eq!(obj.attributes().len(), 2);
170 assert_eq!(obj.methods().len(), 1);
171 }
172
173 #[test]
174 fn round_trip() {
175 let obj = sample();
176 let mut buf = Vec::new();
177 obj.serialize_ber(&mut buf).unwrap();
178 let mut decoded = sample();
179 decoded.sap_assignment_list = vec![];
180 decoded.deserialize_ber(&buf).unwrap();
181 assert_eq!(decoded.attributes(), obj.attributes());
182 }
183
184 #[test]
185 fn connect_adds_updates_and_removes() {
186 let mut obj = sample();
187 obj.invoke_method(
189 1,
190 Some(CosemDataType::Structure(vec![
191 CosemDataType::LongUnsigned(1),
192 CosemDataType::OctetString(b"NEWLD".to_vec()),
193 ])),
194 )
195 .unwrap();
196 assert_eq!(obj.sap_assignment_list.len(), 1);
197 obj.invoke_method(
199 1,
200 Some(CosemDataType::Structure(vec![
201 CosemDataType::LongUnsigned(2),
202 CosemDataType::OctetString(b"OTHER".to_vec()),
203 ])),
204 )
205 .unwrap();
206 assert_eq!(obj.sap_assignment_list.len(), 2);
207 obj.invoke_method(
209 1,
210 Some(CosemDataType::Structure(vec![CosemDataType::LongUnsigned(1), CosemDataType::OctetString(vec![])])),
211 )
212 .unwrap();
213 assert_eq!(obj.sap_assignment_list.len(), 1);
214 }
215}