use crate::interface::InterfaceClass;
use crate::obis::ObisCode;
use crate::types::attrs::{CaptureObjectDefinition, Choice, SortMethod};
use crate::types::{BerError, CosemDataType};
use serde::{Deserialize, Serialize};
use std::any::Any;
use std::fmt;
use std::sync::Arc;
#[derive(Clone, Serialize, Deserialize)]
pub struct ProfileGenericConfig {
pub logical_name: ObisCode,
pub version: u8,
pub buffer: Vec<Choice>,
#[serde(skip)]
pub capture_objects: Vec<(Arc<dyn InterfaceClass + Send + Sync>, u8)>,
pub capture_period: u32,
pub sort_method: SortMethod,
pub sort_object: Option<CaptureObjectDefinition>,
pub entries_in_use: u32,
pub profile_entries: u32,
}
impl fmt::Debug for ProfileGenericConfig {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ProfileGenericConfig")
.field("logical_name", &self.logical_name)
.field("buffer", &self.buffer)
.field("capture_objects", &format_args!("Vec<...> (len={})", self.capture_objects.len()))
.field("capture_period", &self.capture_period)
.field("sort_method", &self.sort_method)
.field("sort_object", &self.sort_object)
.field("entries_in_use", &self.entries_in_use)
.field("profile_entries", &self.profile_entries)
.finish()
}
}
#[derive(Clone, Serialize, Deserialize)]
pub struct ProfileGeneric {
version: u8,
logical_name: ObisCode,
buffer: Vec<Choice>,
#[serde(skip)]
capture_objects: Vec<(Arc<dyn InterfaceClass + Send + Sync>, u8)>,
#[serde(skip)]
capture_objects_value: Option<CosemDataType>,
capture_period: u32,
sort_method: SortMethod,
sort_object: Option<CaptureObjectDefinition>,
entries_in_use: u32,
profile_entries: u32,
}
impl fmt::Debug for ProfileGeneric {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
f.debug_struct("ProfileGeneric")
.field("logical_name", &self.logical_name)
.field("buffer", &self.buffer)
.field("capture_objects", &format_args!("Vec<...> (len={})", self.capture_objects.len()))
.field("capture_period", &self.capture_period)
.field("sort_method", &self.sort_method)
.field("sort_object", &self.sort_object)
.field("entries_in_use", &self.entries_in_use)
.field("profile_entries", &self.profile_entries)
.finish()
}
}
impl ProfileGeneric {
pub fn new(config: ProfileGenericConfig) -> Self {
ProfileGeneric {
version: config.version,
logical_name: config.logical_name,
buffer: config.buffer,
capture_objects: config.capture_objects,
capture_objects_value: None,
capture_period: config.capture_period,
sort_method: config.sort_method,
sort_object: config.sort_object,
entries_in_use: config.entries_in_use,
profile_entries: config.profile_entries,
}
}
fn reset(&mut self) -> CosemDataType {
self.buffer.clear();
self.entries_in_use = 0;
CosemDataType::Null
}
fn capture(&mut self) -> Result<CosemDataType, String> {
let mut captured_values = Vec::new();
for (obj, attr_id) in &self.capture_objects {
let attributes = obj.attributes();
if let Some((_, value)) = attributes.iter().find(|(id, _)| *id == *attr_id) {
captured_values.push(value.clone());
} else {
return Err(format!("Attribute {attr_id} not found in object"));
}
}
let new_entry = CosemDataType::Structure(captured_values);
if self.profile_entries > 0 && self.entries_in_use >= self.profile_entries && !self.buffer.is_empty() {
self.buffer.remove(0);
self.entries_in_use -= 1;
}
self.buffer.push(new_entry);
self.entries_in_use += 1;
Ok(CosemDataType::Null)
}
fn get_buffer_by_range(&self, _params: Option<CosemDataType>) -> CosemDataType {
CosemDataType::Array(self.buffer.clone())
}
fn get_buffer_by_index(&self, params: Option<CosemDataType>) -> Result<CosemDataType, String> {
let (from_entry, to_entry) = match params {
Some(CosemDataType::Structure(fields)) if fields.len() >= 2 => {
let from = as_u32(&fields[0]).ok_or("from_entry must be an unsigned integer")?;
let to = as_u32(&fields[1]).ok_or("to_entry must be an unsigned integer")?;
(from, to)
}
None => return Ok(CosemDataType::Array(self.buffer.clone())),
_ => return Err("Expected structure { from_entry, to_entry, .. }".to_string()),
};
if from_entry == 0 || to_entry < from_entry {
return Err("Invalid entry range (1-based, from ≤ to)".to_string());
}
let start = (from_entry - 1) as usize;
let end = (to_entry as usize).min(self.buffer.len());
let slice = if start < end { self.buffer[start..end].to_vec() } else { Vec::new() };
Ok(CosemDataType::Array(slice))
}
}
fn as_u32(value: &CosemDataType) -> Option<u32> {
match value {
CosemDataType::DoubleLongUnsigned(v) => Some(*v),
CosemDataType::LongUnsigned(v) => Some(u32::from(*v)),
CosemDataType::Unsigned(v) => Some(u32::from(*v)),
_ => None,
}
}
impl InterfaceClass for ProfileGeneric {
fn class_id(&self) -> u16 {
7
}
fn version(&self) -> u8 {
self.version
}
fn logical_name(&self) -> &ObisCode {
&self.logical_name
}
fn attributes(&self) -> Vec<(u8, CosemDataType)> {
let capture_objects = self.capture_objects_value.clone().unwrap_or_else(|| {
CosemDataType::Array(
self.capture_objects
.iter()
.map(|(obj, attr_id)| {
#[allow(clippy::cast_possible_wrap)]
let attr_id = *attr_id as i8;
CosemDataType::Structure(vec![
CosemDataType::LongUnsigned(obj.class_id()),
CosemDataType::OctetString(obj.logical_name().to_bytes()),
CosemDataType::Integer(attr_id), CosemDataType::LongUnsigned(0), ])
})
.collect(),
)
});
vec![
(1, CosemDataType::OctetString(self.logical_name.to_bytes())),
(2, CosemDataType::Array(self.buffer.clone())),
(3, capture_objects),
(4, CosemDataType::DoubleLongUnsigned(self.capture_period)),
(5, CosemDataType::Unsigned(self.sort_method as u8)),
(6, self.sort_object.as_ref().map(|c| c.clone().into()).unwrap_or(CosemDataType::Null)),
(7, CosemDataType::DoubleLongUnsigned(self.entries_in_use)),
(8, CosemDataType::DoubleLongUnsigned(self.profile_entries)),
]
}
fn methods(&self) -> Vec<(u8, String)> {
if self.version == 0 {
vec![
(1, "reset".to_string()),
(2, "capture".to_string()),
(3, "get_buffer_by_range".to_string()),
(4, "get_buffer_by_index".to_string()),
]
} else {
vec![(1, "reset".to_string()), (2, "capture".to_string())]
}
}
fn serialize_ber(&self, buf: &mut Vec<u8>) -> Result<(), BerError> {
let mut seq_buf = Vec::new();
CosemDataType::LongUnsigned(self.class_id()).serialize_ber(&mut seq_buf)?;
for (_, attr) in self.attributes() {
attr.serialize_ber(&mut seq_buf)?;
}
buf.push(0x02); write_length(1 + self.attributes().len(), buf); buf.extend_from_slice(&seq_buf);
Ok(())
}
fn deserialize_ber(&mut self, data: &[u8]) -> Result<(), BerError> {
let (tlv, rest) = CosemDataType::deserialize_ber(data)?;
if !rest.is_empty() {
return Err(BerError::InvalidTag);
}
if let CosemDataType::Structure(seq) = tlv {
if seq.len() == 9 {
if let CosemDataType::LongUnsigned(class_id) = seq[0] {
if class_id != self.class_id() {
return Err(BerError::InvalidValue);
}
} else {
return Err(BerError::InvalidTag);
}
if let CosemDataType::OctetString(obis) = &seq[1] {
if obis.len() == 6 {
self.logical_name = ObisCode::new(obis[0], obis[1], obis[2], obis[3], obis[4], obis[5]);
} else {
return Err(BerError::InvalidLength);
}
} else {
return Err(BerError::InvalidTag);
}
if let CosemDataType::Array(buffer) = &seq[2] {
self.buffer.clone_from(buffer);
} else {
return Err(BerError::InvalidTag);
}
if let CosemDataType::Array(_) = &seq[3] {
} else {
return Err(BerError::InvalidTag);
}
if let CosemDataType::DoubleLongUnsigned(capture_period) = seq[4] {
self.capture_period = capture_period;
} else {
return Err(BerError::InvalidTag);
}
if let CosemDataType::Unsigned(sort_method) = seq[5] {
self.sort_method = SortMethod::from_u8(sort_method).unwrap_or(SortMethod::Fifo);
} else {
return Err(BerError::InvalidTag);
}
self.sort_object = CaptureObjectDefinition::try_from(&seq[6]).ok();
if let CosemDataType::DoubleLongUnsigned(entries_in_use) = seq[7] {
self.entries_in_use = entries_in_use;
} else {
return Err(BerError::InvalidTag);
}
if let CosemDataType::DoubleLongUnsigned(profile_entries) = seq[8] {
self.profile_entries = profile_entries;
} else {
return Err(BerError::InvalidTag);
}
return Ok(());
}
return Err(BerError::InvalidLength);
}
Err(BerError::InvalidTag)
}
fn set_attribute(&mut self, attribute_id: u8, value: CosemDataType) -> Result<(), String> {
match attribute_id {
3 => {
let CosemDataType::Array(ref list) = value else {
return Err("capture_objects must be array".into());
};
for item in list {
let _ = CaptureObjectDefinition::try_from(item)?;
}
self.capture_objects_value = Some(value);
Ok(())
}
4 => match value {
CosemDataType::DoubleLongUnsigned(v) => {
self.capture_period = v;
Ok(())
}
_ => Err("capture_period must be double-long-unsigned".into()),
},
5 => match value {
CosemDataType::Unsigned(v) => {
self.sort_method = SortMethod::from_u8(v).unwrap_or(SortMethod::Fifo);
Ok(())
}
_ => Err("sort_method must be unsigned".into()),
},
8 => match value {
CosemDataType::DoubleLongUnsigned(v) => {
self.profile_entries = v;
Ok(())
}
_ => Err("profile_entries must be double-long-unsigned".into()),
},
_ => Err(format!("ProfileGeneric attribute {attribute_id} is not writable")),
}
}
fn invoke_method(&mut self, method_id: u8, params: Option<CosemDataType>) -> Result<CosemDataType, String> {
match method_id {
1 => Ok(self.reset()),
2 => self.capture(),
3 if self.version == 0 => Ok(self.get_buffer_by_range(params)),
4 if self.version == 0 => self.get_buffer_by_index(params),
_ => Err(format!("Method {} not supported for ProfileGeneric version {}", method_id, self.version)),
}
}
fn as_any(&self) -> &dyn Any {
self
}
}
#[allow(clippy::cast_possible_truncation)] fn write_length(length: usize, buf: &mut Vec<u8>) {
if length < 128 {
buf.push(length as u8);
} else {
let bytes = (length as u64).to_be_bytes();
let first_non_zero = bytes.iter().position(|&b| b != 0).unwrap_or(7);
let num_octets = 8 - first_non_zero;
buf.push(0x80 | num_octets as u8);
buf.extend_from_slice(&bytes[first_non_zero..]);
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::interface::InterfaceClass;
fn versioned_profile(version: u8, profile_entries: u32) -> ProfileGeneric {
ProfileGeneric::new(ProfileGenericConfig {
logical_name: ObisCode::new(1, 0, 99, 1, 0, 255),
version,
buffer: vec![],
capture_objects: vec![],
capture_period: 0,
sort_method: SortMethod::Fifo,
sort_object: None,
entries_in_use: 0,
profile_entries,
})
}
fn empty_profile(profile_entries: u32) -> ProfileGeneric {
versioned_profile(1, profile_entries)
}
#[test]
fn capture_evicts_oldest_when_full() {
let mut p = empty_profile(2);
for _ in 0..3 {
p.invoke_method(2, None).expect("capture failed");
}
assert_eq!(p.attributes()[6].1, CosemDataType::DoubleLongUnsigned(2)); if let CosemDataType::Array(buf) = &p.attributes()[1].1 {
assert_eq!(buf.len(), 2);
} else {
panic!("buffer must be an array");
}
}
#[test]
fn reset_clears_buffer() {
let mut p = empty_profile(4);
p.invoke_method(2, None).unwrap();
p.invoke_method(1, None).unwrap(); assert_eq!(p.attributes()[6].1, CosemDataType::DoubleLongUnsigned(0));
}
#[test]
fn method_set_depends_on_version() {
assert_eq!(versioned_profile(0, 4).methods().len(), 4);
assert_eq!(versioned_profile(1, 4).methods().len(), 2);
assert!(versioned_profile(1, 4).invoke_method(4, None).is_err());
}
#[test]
fn get_buffer_by_index_slices_entries() {
let mut p = versioned_profile(0, 10);
for _ in 0..5 {
p.invoke_method(2, None).unwrap();
}
let params =
CosemDataType::Structure(vec![CosemDataType::DoubleLongUnsigned(2), CosemDataType::DoubleLongUnsigned(4)]);
let result = p.invoke_method(4, Some(params)).unwrap();
if let CosemDataType::Array(entries) = result {
assert_eq!(entries.len(), 3);
} else {
panic!("get_buffer_by_index must return an array");
}
}
}