use std::any::Any;
use crate::interface::InterfaceClass;
use crate::obis::ObisCode;
use crate::types::{BerError, CosemDataType};
fn key_of(row: &CosemDataType, key_index: usize) -> Option<CosemDataType> {
match row {
CosemDataType::Structure(fields) => fields.get(key_index).cloned(),
_ => None,
}
}
#[derive(Clone, Debug)]
pub struct TableManager {
logical_name: ObisCode,
key_index: usize,
rows: Vec<CosemDataType>,
}
impl TableManager {
pub fn new(logical_name: ObisCode, key_index: usize) -> Self {
TableManager { logical_name, key_index, rows: Vec::new() }
}
pub fn rows(&self) -> &[CosemDataType] {
&self.rows
}
pub fn set_rows(&mut self, rows: Vec<CosemDataType>) {
self.rows = rows;
}
fn add_update_entries(&mut self, entries: Vec<CosemDataType>) -> Result<CosemDataType, String> {
let key_index = self.key_index;
for entry in entries {
let key = key_of(&entry, key_index).ok_or("entry is not a keyed structure")?;
match self.rows.iter_mut().find(|r| key_of(r, key_index).as_ref() == Some(&key)) {
Some(existing) => *existing = entry,
None => self.rows.push(entry),
}
}
Ok(CosemDataType::Null)
}
fn remove_entries(&mut self, keys: &[CosemDataType]) -> CosemDataType {
let key_index = self.key_index;
if keys.is_empty() {
self.rows.clear();
} else {
self.rows.retain(|row| !keys.iter().any(|k| key_of(row, key_index).as_ref() == Some(k)));
}
CosemDataType::Null
}
fn retrieve_entries(&self, keys: &[CosemDataType]) -> CosemDataType {
let key_index = self.key_index;
let selected = if keys.is_empty() {
self.rows.clone()
} else {
self.rows
.iter()
.filter(|row| keys.iter().any(|k| key_of(row, key_index).as_ref() == Some(k)))
.cloned()
.collect()
};
CosemDataType::Array(selected)
}
fn entries_list(params: Option<CosemDataType>) -> Result<Vec<CosemDataType>, String> {
match params {
Some(CosemDataType::Structure(fields)) => match fields.into_iter().nth(1) {
Some(CosemDataType::Array(entries)) => Ok(entries),
_ => Err("entries_list must be an array".to_string()),
},
_ => Err("expected a {object_obis, entries_list} structure".to_string()),
}
}
}
impl InterfaceClass for TableManager {
fn class_id(&self) -> u16 {
8200
}
fn version(&self) -> u8 {
0
}
fn logical_name(&self) -> &ObisCode {
&self.logical_name
}
fn attributes(&self) -> Vec<(u8, CosemDataType)> {
vec![(1, CosemDataType::OctetString(self.logical_name.to_bytes()))]
}
fn methods(&self) -> Vec<(u8, String)> {
vec![
(1, "add_update_entries".to_string()),
(2, "remove_entries".to_string()),
(3, "retrieve_number_of_entries".to_string()),
(4, "retrieve_entries".to_string()),
]
}
fn serialize_ber(&self, buf: &mut Vec<u8>) -> Result<(), BerError> {
buf.push(0x02); buf.push(0x02); CosemDataType::LongUnsigned(self.class_id()).serialize_ber(buf)?;
CosemDataType::OctetString(self.logical_name.to_bytes()).serialize_ber(buf)
}
fn deserialize_ber(&mut self, _data: &[u8]) -> Result<(), BerError> {
Ok(())
}
fn invoke_method(&mut self, method_id: u8, params: Option<CosemDataType>) -> Result<CosemDataType, String> {
match method_id {
1 => {
let entries = Self::entries_list(params)?;
self.add_update_entries(entries)
}
2 => {
let keys = Self::entries_list(params)?;
Ok(self.remove_entries(&keys))
}
3 => {
#[allow(clippy::cast_possible_truncation)]
let count = self.rows.len().min(u8::MAX as usize) as u8;
Ok(CosemDataType::Unsigned(count))
}
4 => {
let keys = Self::entries_list(params)?;
Ok(self.retrieve_entries(&keys))
}
other => Err(format!("method {other} not supported for the Table manager class")),
}
}
fn as_any(&self) -> &dyn Any {
self
}
}
#[cfg(test)]
mod tests {
use super::*;
fn key(id: &[u8]) -> CosemDataType {
CosemDataType::OctetString(id.to_vec())
}
fn row(id: &[u8], value: u16) -> CosemDataType {
CosemDataType::Structure(vec![key(id), CosemDataType::LongUnsigned(value)])
}
fn wrap(entries: Vec<CosemDataType>) -> CosemDataType {
CosemDataType::Structure(vec![CosemDataType::OctetString(vec![]), CosemDataType::Array(entries)])
}
#[test]
fn table_manager_group_operations() {
let mut mgr = TableManager::new(ObisCode::new(0, 0, 94, 7, 200, 255), 0);
assert_eq!(mgr.class_id(), 8200);
mgr.invoke_method(1, Some(wrap(vec![row(b"A", 1), row(b"B", 2)]))).unwrap();
assert_eq!(mgr.invoke_method(3, None).unwrap(), CosemDataType::Unsigned(2));
mgr.invoke_method(1, Some(wrap(vec![row(b"A", 100)]))).unwrap();
assert_eq!(mgr.invoke_method(3, None).unwrap(), CosemDataType::Unsigned(2));
let CosemDataType::Array(got) = mgr.invoke_method(4, Some(wrap(vec![key(b"A")]))).unwrap() else {
panic!("array");
};
assert_eq!(got, vec![row(b"A", 100)]);
mgr.invoke_method(2, Some(wrap(vec![key(b"B")]))).unwrap();
assert_eq!(mgr.invoke_method(3, None).unwrap(), CosemDataType::Unsigned(1));
mgr.invoke_method(2, Some(wrap(vec![]))).unwrap();
assert_eq!(mgr.invoke_method(3, None).unwrap(), CosemDataType::Unsigned(0));
}
}