Skip to main content

spodes_rs/classes/
sap_assignment.rs

1use 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/// Configuration structure used to build a [`SapAssignment`] object.
9#[derive(Clone, Serialize, Deserialize, Debug)]
10pub struct SapAssignmentConfig {
11    /// Attribute 1: the object's logical name (OBIS code).
12    pub logical_name: ObisCode,
13    /// Attribute 2: array of `sap_assignment` structures
14    /// { SAP: long-unsigned, logical_device_name: octet-string }.
15    pub sap_assignment_list: Vec<SapAssignmentEntry>,
16}
17
18/// `SAP assignment` interface class (class_id = 17, version = 0) per
19/// IEC 62056-6-2 §4.4.5. Maps SAPs to logical devices.
20#[derive(Clone, Serialize, Deserialize, Debug)]
21pub struct SapAssignment {
22    logical_name: ObisCode,
23    sap_assignment_list: Vec<SapAssignmentEntry>,
24}
25
26impl SapAssignment {
27    /// Builds a new [`SapAssignment`] from its configuration.
28    pub fn new(config: SapAssignmentConfig) -> Self {
29        SapAssignment { logical_name: config.logical_name, sap_assignment_list: config.sap_assignment_list }
30    }
31
32    /// Method 1: `connect_logical_device` — adds or updates a SAP-to-logical-device
33    /// assignment (IEC 62056-6-2 §4.4.5.3). An empty logical device name removes
34    /// the assignment for that SAP.
35    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); // structure [2]
83        write_length(1 + self.attributes().len(), buf); // length = element count
84        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        // class_id + 2 attributes.
97        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(&params.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/// Writes a BER length octet (short or long form).
140#[allow(clippy::cast_possible_truncation)] // length < 128 and num_octets in 1..=8 always fit u8
141fn 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        // Update SAP 1.
188        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        // Add SAP 2.
198        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        // Remove SAP 1 with an empty name.
208        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}