spodes_rs/classes/
schedule.rs1use 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#[derive(Clone, Serialize, Deserialize, Debug)]
10pub struct ScheduleConfig {
11 pub logical_name: ObisCode,
13 pub entries: Vec<ScheduleTableEntry>,
15 pub enabled: bool,
17}
18
19#[derive(Clone, Serialize, Deserialize, Debug)]
22pub struct Schedule {
23 logical_name: ObisCode,
24 entries: Vec<ScheduleTableEntry>,
25 enabled: bool, }
27
28impl Schedule {
29 pub fn new(config: ScheduleConfig) -> Self {
37 Schedule { logical_name: config.logical_name, entries: config.entries, enabled: config.enabled }
38 }
39
40 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 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 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 pub fn is_enabled(&self) -> bool {
71 self.enabled
72 }
73
74 pub fn entries(&self) -> &[ScheduleTableEntry] {
76 &self.entries
77 }
78}
79
80fn 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); seq_buf.push(if self.enabled { 0xFF } else { 0x00 }); buf.push(0x02); write_length(2 + self.attributes().len(), buf); 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#[allow(clippy::cast_possible_truncation)] fn 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}