Skip to main content

spodes_rs/classes/
schedule.rs

1use crate::interface::InterfaceClass;
2use crate::obis::ObisCode;
3use crate::types::attrs::ScheduleTableEntry;
4use crate::types::{BerError, CosemDataType};
5use serde::{Deserialize, Serialize};
6use std::any::Any;
7
8/// Configuration used to build a `Schedule` object.
9#[derive(Clone, Serialize, Deserialize, Debug)]
10pub struct ScheduleConfig {
11    /// Attribute 1: the object's logical name (OBIS code).
12    pub logical_name: ObisCode,
13    /// Attribute 2: array of `schedule_table_entry` structures.
14    pub entries: Vec<ScheduleTableEntry>,
15    /// Whether the schedule is currently enabled.
16    pub enabled: bool,
17}
18
19/// The `Schedule` interface class (class_id = 10) managing schedules that
20/// define the times at which actions run, per IEC 62056-6-2.
21#[derive(Clone, Serialize, Deserialize, Debug)]
22pub struct Schedule {
23    logical_name: ObisCode,
24    entries: Vec<ScheduleTableEntry>,
25    enabled: bool, // schedule state (enabled/disabled)
26}
27
28impl Schedule {
29    /// Creates a new `Schedule` object from its configuration.
30    ///
31    /// # Arguments
32    /// * `config` - The configuration used to build the object.
33    ///
34    /// # Returns
35    /// A new `Schedule`.
36    pub fn new(config: ScheduleConfig) -> Self {
37        Schedule { logical_name: config.logical_name, entries: config.entries, enabled: config.enabled }
38    }
39
40    /// Method 1: `enable_disable` — toggles the `enable` flag of the entry at
41    /// the given 0-based index (IEC 62056-6-2 §4.5.3).
42    fn enable_disable(&mut self, params: Option<&CosemDataType>) -> Result<CosemDataType, String> {
43        let idx = index_param(params).ok_or("enable_disable requires an entry index")?;
44        let entry = self.entries.get_mut(idx).ok_or_else(|| format!("No schedule entry at index {idx}"))?;
45        entry.enable = !entry.enable;
46        Ok(CosemDataType::Null)
47    }
48
49    /// Method 2: `insert` — appends a new `schedule_table_entry`
50    /// (IEC 62056-6-2 §4.5.3).
51    fn insert(&mut self, params: Option<CosemDataType>) -> Result<CosemDataType, String> {
52        let value = params.ok_or("insert requires a schedule_table_entry structure")?;
53        let entry = ScheduleTableEntry::try_from(&value).map_err(|e| format!("Invalid schedule_table_entry: {e}"))?;
54        self.entries.push(entry);
55        Ok(CosemDataType::Null)
56    }
57
58    /// Method 3: `delete` — removes the entry at the given 0-based index
59    /// (IEC 62056-6-2 §4.5.3).
60    fn delete(&mut self, params: Option<&CosemDataType>) -> Result<CosemDataType, String> {
61        let idx = index_param(params).ok_or("delete requires an entry index")?;
62        if idx >= self.entries.len() {
63            return Err(format!("No schedule entry at index {idx}"));
64        }
65        self.entries.remove(idx);
66        Ok(CosemDataType::Null)
67    }
68
69    /// Returns the schedule state (enabled/disabled).
70    pub fn is_enabled(&self) -> bool {
71        self.enabled
72    }
73
74    /// Returns the schedule entries.
75    pub fn entries(&self) -> &[ScheduleTableEntry] {
76        &self.entries
77    }
78}
79
80/// Extracts an entry index from an unsigned method parameter.
81fn index_param(value: Option<&CosemDataType>) -> Option<usize> {
82    match value? {
83        CosemDataType::Unsigned(v) => Some(*v as usize),
84        CosemDataType::LongUnsigned(v) => Some(*v as usize),
85        CosemDataType::DoubleLongUnsigned(v) => Some(*v as usize),
86        _ => None,
87    }
88}
89
90impl InterfaceClass for Schedule {
91    fn class_id(&self) -> u16 {
92        10
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            (2, CosemDataType::Array(self.entries.iter().cloned().map(CosemDataType::from).collect())),
107        ]
108    }
109
110    fn methods(&self) -> Vec<(u8, String)> {
111        vec![(1, "enable_disable".to_string()), (2, "insert".to_string()), (3, "delete".to_string())]
112    }
113
114    fn serialize_ber(&self, buf: &mut Vec<u8>) -> Result<(), BerError> {
115        let mut seq_buf = Vec::new();
116        CosemDataType::LongUnsigned(self.class_id()).serialize_ber(&mut seq_buf)?;
117        for (_, attr) in self.attributes() {
118            attr.serialize_ber(&mut seq_buf)?;
119        }
120        seq_buf.push(0x03); // boolean [3]
121        seq_buf.push(if self.enabled { 0xFF } else { 0x00 }); // enabled value
122        buf.push(0x02); // structure [2]
123        write_length(2 + self.attributes().len(), buf); // element count: class_id + attributes + enabled
124        buf.extend_from_slice(&seq_buf);
125        Ok(())
126    }
127
128    fn deserialize_ber(&mut self, data: &[u8]) -> Result<(), BerError> {
129        let (tlv, rest) = CosemDataType::deserialize_ber(data)?;
130        if !rest.is_empty() {
131            return Err(BerError::InvalidTag);
132        }
133        let CosemDataType::Structure(seq) = tlv else {
134            return Err(BerError::InvalidTag);
135        };
136        if seq.len() == 4 {
137            if let CosemDataType::LongUnsigned(class_id) = seq[0] {
138                if class_id != self.class_id() {
139                    return Err(BerError::InvalidValue);
140                }
141            } else {
142                return Err(BerError::InvalidTag);
143            }
144            if let CosemDataType::OctetString(obis) = &seq[1] {
145                if obis.len() == 6 {
146                    self.logical_name = ObisCode::new(obis[0], obis[1], obis[2], obis[3], obis[4], obis[5]);
147                } else {
148                    return Err(BerError::InvalidLength);
149                }
150            } else {
151                return Err(BerError::InvalidTag);
152            }
153            if let CosemDataType::Array(entries) = &seq[2] {
154                self.entries = entries
155                    .iter()
156                    .map(ScheduleTableEntry::try_from)
157                    .collect::<Result<Vec<_>, _>>()
158                    .map_err(|_| BerError::InvalidValue)?;
159            } else {
160                return Err(BerError::InvalidTag);
161            }
162            if let CosemDataType::Boolean(enabled) = seq[3] {
163                self.enabled = enabled;
164            } else {
165                return Err(BerError::InvalidTag);
166            }
167            Ok(())
168        } else {
169            Err(BerError::InvalidLength)
170        }
171    }
172
173    fn invoke_method(&mut self, method_id: u8, params: Option<CosemDataType>) -> Result<CosemDataType, String> {
174        match method_id {
175            1 => self.enable_disable(params.as_ref()),
176            2 => self.insert(params),
177            3 => self.delete(params.as_ref()),
178            _ => Err(format!("Method {method_id} not supported for Schedule class")),
179        }
180    }
181
182    fn as_any(&self) -> &dyn Any {
183        self
184    }
185}
186
187/// Writes a length in BER (short or long form).
188#[allow(clippy::cast_possible_truncation)] // length < 128 and num_octets in 1..=8 always fit u8
189fn write_length(length: usize, buf: &mut Vec<u8>) {
190    if length < 128 {
191        buf.push(length as u8);
192    } else {
193        let bytes = (length as u64).to_be_bytes();
194        let first_non_zero = bytes.iter().position(|&b| b != 0).unwrap_or(7);
195        let num_octets = 8 - first_non_zero;
196        buf.push(0x80 | num_octets as u8);
197        buf.extend_from_slice(&bytes[first_non_zero..]);
198    }
199}