#![allow(unused_imports)]
use crate::dm::conformance::{Clause, Condition, Conform, Conformance};
use crate::dm::meta::{EventPriority, Reporting};
use crate::dm::spec::{Attribute, Cluster, Command, Event, Feature};
use crate::dm::{Access, AccessQualities, AttributeQualities, Privilege};
use crate::error::Result;
use crate::im::{AttributeId, ClusterId, CommandId, EventId};
use crate::tlv::{
ContainerKind, Element, FromTlv, Nullable, Tag, TlvList, TlvReader, TlvWriter, ToTlv, Value,
};
pub const ID: ClusterId = 0xFFFF0000;
pub const REVISION: u16 = 1;
pub const FEATURES: &[Feature] = &[];
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum AtomicRequestTypeEnum {
BeginWrite = 0,
CommitWrite = 1,
RollbackWrite = 2,
}
impl AtomicRequestTypeEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::BeginWrite),
1 => Some(Self::CommitWrite),
2 => Some(Self::RollbackWrite),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for AtomicRequestTypeEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for AtomicRequestTypeEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum CertificationTypeEnum {
DeviceAttestationPKI = 0,
OperationalPKI = 1,
VIDSignerPKI = 2,
}
impl CertificationTypeEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::DeviceAttestationPKI),
1 => Some(Self::OperationalPKI),
2 => Some(Self::VIDSignerPKI),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for CertificationTypeEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for CertificationTypeEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum MeasurementTypeEnum {
Unspecified = 0,
Voltage = 1,
ActiveCurrent = 2,
ReactiveCurrent = 3,
ApparentCurrent = 4,
ActivePower = 5,
ReactivePower = 6,
ApparentPower = 7,
RMSVoltage = 8,
RMSCurrent = 9,
RMSPower = 10,
Frequency = 11,
PowerFactor = 12,
NeutralCurrent = 13,
ElectricalEnergy = 14,
ReactiveEnergy = 15,
ApparentEnergy = 16,
SoilMoisture = 17,
}
impl MeasurementTypeEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::Unspecified),
1 => Some(Self::Voltage),
2 => Some(Self::ActiveCurrent),
3 => Some(Self::ReactiveCurrent),
4 => Some(Self::ApparentCurrent),
5 => Some(Self::ActivePower),
6 => Some(Self::ReactivePower),
7 => Some(Self::ApparentPower),
8 => Some(Self::RMSVoltage),
9 => Some(Self::RMSCurrent),
10 => Some(Self::RMSPower),
11 => Some(Self::Frequency),
12 => Some(Self::PowerFactor),
13 => Some(Self::NeutralCurrent),
14 => Some(Self::ElectricalEnergy),
15 => Some(Self::ReactiveEnergy),
16 => Some(Self::ApparentEnergy),
17 => Some(Self::SoilMoisture),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for MeasurementTypeEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for MeasurementTypeEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum PowerThresholdSourceEnum {
Contract = 0,
Regulator = 1,
Equipment = 2,
}
impl PowerThresholdSourceEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::Contract),
1 => Some(Self::Regulator),
2 => Some(Self::Equipment),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for PowerThresholdSourceEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for PowerThresholdSourceEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum SoftwareVersionCertificationStatusEnum {
DevTest = 0,
Provisional = 1,
Certified = 2,
Revoked = 3,
}
impl SoftwareVersionCertificationStatusEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::DevTest),
1 => Some(Self::Provisional),
2 => Some(Self::Certified),
3 => Some(Self::Revoked),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for SoftwareVersionCertificationStatusEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for SoftwareVersionCertificationStatusEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum StreamUsageEnum {
Internal = 0,
Recording = 1,
Analysis = 2,
LiveView = 3,
}
impl StreamUsageEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::Internal),
1 => Some(Self::Recording),
2 => Some(Self::Analysis),
3 => Some(Self::LiveView),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for StreamUsageEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for StreamUsageEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum TariffPriceTypeEnum {
Standard = 0,
Critical = 1,
Virtual = 2,
Incentive = 3,
IncentiveSignal = 4,
}
impl TariffPriceTypeEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::Standard),
1 => Some(Self::Critical),
2 => Some(Self::Virtual),
3 => Some(Self::Incentive),
4 => Some(Self::IncentiveSignal),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for TariffPriceTypeEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for TariffPriceTypeEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum TariffUnitEnum {
KWh = 0,
KVAh = 1,
}
impl TariffUnitEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::KWh),
1 => Some(Self::KVAh),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for TariffUnitEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for TariffUnitEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum ThreeLevelAutoEnum {
Auto = 0,
Low = 1,
Medium = 2,
High = 3,
}
impl ThreeLevelAutoEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::Auto),
1 => Some(Self::Low),
2 => Some(Self::Medium),
3 => Some(Self::High),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for ThreeLevelAutoEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for ThreeLevelAutoEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
#[repr(u8)]
pub enum WebRTCEndReasonEnum {
ICEFailed = 0,
ICETimeout = 1,
UserHangup = 2,
UserBusy = 3,
Replaced = 4,
NoUserMedia = 5,
InviteTimeout = 6,
AnsweredElsewhere = 7,
OutOfResources = 8,
MediaTimeout = 9,
LowPower = 10,
PrivacyMode = 11,
UnknownReason = 12,
}
impl WebRTCEndReasonEnum {
#[must_use]
pub const fn from_value(value: u8) -> Option<Self> {
match value {
0 => Some(Self::ICEFailed),
1 => Some(Self::ICETimeout),
2 => Some(Self::UserHangup),
3 => Some(Self::UserBusy),
4 => Some(Self::Replaced),
5 => Some(Self::NoUserMedia),
6 => Some(Self::InviteTimeout),
7 => Some(Self::AnsweredElsewhere),
8 => Some(Self::OutOfResources),
9 => Some(Self::MediaTimeout),
10 => Some(Self::LowPower),
11 => Some(Self::PrivacyMode),
12 => Some(Self::UnknownReason),
_ => None,
}
}
#[must_use]
pub const fn value(self) -> u8 {
self as u8
}
}
impl ToTlv for WebRTCEndReasonEnum {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.value().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for WebRTCEndReasonEnum {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let value = <u8 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_value(value).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
bitflags::bitflags! {
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct WildcardPathFlagsBitmap: u16 {
const WILDCARD_SKIP_ROOT_NODE = 1 << 0;
const WILDCARD_SKIP_GLOBAL_ATTRIBUTES = 1 << 1;
const WILDCARD_SKIP_ATTRIBUTE_LIST = 1 << 2;
const DO_NOT_USE = 1 << 3;
const WILDCARD_SKIP_COMMAND_LISTS = 1 << 4;
const WILDCARD_SKIP_CUSTOM_ELEMENTS = 1 << 5;
const WILDCARD_SKIP_FIXED_ATTRIBUTES = 1 << 6;
const WILDCARD_SKIP_CHANGES_OMITTED_ATTRIBUTES = 1 << 7;
const WILDCARD_SKIP_DIAGNOSTICS_CLUSTERS = 1 << 8;
}
}
impl ToTlv for WildcardPathFlagsBitmap {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.bits().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for WildcardPathFlagsBitmap {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let bits = <u16 as FromTlv<'a>>::from_tlv(reader, element)?;
Self::from_bits(bits).ok_or(crate::Error::new(crate::ErrorCode::TlvOutOfRange))
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct AtomicAttributeStatusStruct {
pub attribute_id: u32,
pub status_code: u8,
}
impl ToTlv for AtomicAttributeStatusStruct {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.attribute_id.to_tlv(w, Tag::Context(0))?;
self.status_code.to_tlv(w, Tag::Context(1))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for AtomicAttributeStatusStruct {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut attribute_id = None;
let mut status_code = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => attribute_id = Some(<u32>::from_tlv(reader, &field)?),
Some(1) => status_code = Some(<u8>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
attribute_id: attribute_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
status_code: status_code.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CurrencyStruct {
pub currency: u16,
pub decimal_points: u8,
}
impl ToTlv for CurrencyStruct {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.currency.to_tlv(w, Tag::Context(0))?;
self.decimal_points.to_tlv(w, Tag::Context(1))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for CurrencyStruct {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut currency = None;
let mut decimal_points = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => currency = Some(<u16>::from_tlv(reader, &field)?),
Some(1) => decimal_points = Some(<u8>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
currency: currency.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
decimal_points: decimal_points
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ICECandidateStruct<'a> {
pub candidate: &'a str,
pub sdp_mid: Nullable<&'a str>,
pub sdpm_line_index: Nullable<u16>,
}
impl<'a> ToTlv for ICECandidateStruct<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.candidate.to_tlv(w, Tag::Context(0))?;
self.sdp_mid.to_tlv(w, Tag::Context(1))?;
self.sdpm_line_index.to_tlv(w, Tag::Context(2))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for ICECandidateStruct<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut candidate = None;
let mut sdp_mid = None;
let mut sdpm_line_index = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => candidate = Some(<&'a str>::from_tlv(reader, &field)?),
Some(1) => sdp_mid = Some(<Nullable<&'a str>>::from_tlv(reader, &field)?),
Some(2) => sdpm_line_index = Some(<Nullable<u16>>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
candidate: candidate.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
sdp_mid: sdp_mid.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
sdpm_line_index: sdpm_line_index
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ICEServerStruct<'a> {
pub ur_ls: TlvList<'a, &'a str>,
pub username: Option<&'a str>,
pub credential: Option<&'a str>,
pub caid: Option<u16>,
}
impl<'a> ToTlv for ICEServerStruct<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.ur_ls.to_tlv(w, Tag::Context(0))?;
if let Some(value) = &self.username {
value.to_tlv(w, Tag::Context(1))?;
}
if let Some(value) = &self.credential {
value.to_tlv(w, Tag::Context(2))?;
}
if let Some(value) = &self.caid {
value.to_tlv(w, Tag::Context(3))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for ICEServerStruct<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut ur_ls = None;
let mut username = None;
let mut credential = None;
let mut caid = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => ur_ls = Some(<TlvList<'a, &'a str>>::from_tlv(reader, &field)?),
Some(1) => username = Some(<&'a str>::from_tlv(reader, &field)?),
Some(2) => credential = Some(<&'a str>::from_tlv(reader, &field)?),
Some(3) => caid = Some(<u16>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
ur_ls: ur_ls.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
username,
credential,
caid,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct LocationDescriptorStruct<'a> {
pub location_name: &'a str,
pub floor_number: Nullable<i16>,
pub area_type: Nullable<u8>,
}
impl<'a> ToTlv for LocationDescriptorStruct<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.location_name.to_tlv(w, Tag::Context(0))?;
self.floor_number.to_tlv(w, Tag::Context(1))?;
self.area_type.to_tlv(w, Tag::Context(2))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for LocationDescriptorStruct<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut location_name = None;
let mut floor_number = None;
let mut area_type = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => location_name = Some(<&'a str>::from_tlv(reader, &field)?),
Some(1) => floor_number = Some(<Nullable<i16>>::from_tlv(reader, &field)?),
Some(2) => area_type = Some(<Nullable<u8>>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
location_name: location_name.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
floor_number: floor_number.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
area_type: area_type.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct MeasurementAccuracyRangeStruct {
pub range_min: i64,
pub range_max: i64,
pub percent_max: Option<u16>,
pub percent_min: Option<u16>,
pub percent_typical: Option<u16>,
pub fixed_max: Option<u64>,
pub fixed_min: Option<u64>,
pub fixed_typical: Option<u64>,
}
impl ToTlv for MeasurementAccuracyRangeStruct {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.range_min.to_tlv(w, Tag::Context(0))?;
self.range_max.to_tlv(w, Tag::Context(1))?;
if let Some(value) = &self.percent_max {
value.to_tlv(w, Tag::Context(2))?;
}
if let Some(value) = &self.percent_min {
value.to_tlv(w, Tag::Context(3))?;
}
if let Some(value) = &self.percent_typical {
value.to_tlv(w, Tag::Context(4))?;
}
if let Some(value) = &self.fixed_max {
value.to_tlv(w, Tag::Context(5))?;
}
if let Some(value) = &self.fixed_min {
value.to_tlv(w, Tag::Context(6))?;
}
if let Some(value) = &self.fixed_typical {
value.to_tlv(w, Tag::Context(7))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for MeasurementAccuracyRangeStruct {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut range_min = None;
let mut range_max = None;
let mut percent_max = None;
let mut percent_min = None;
let mut percent_typical = None;
let mut fixed_max = None;
let mut fixed_min = None;
let mut fixed_typical = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => range_min = Some(<i64>::from_tlv(reader, &field)?),
Some(1) => range_max = Some(<i64>::from_tlv(reader, &field)?),
Some(2) => percent_max = Some(<u16>::from_tlv(reader, &field)?),
Some(3) => percent_min = Some(<u16>::from_tlv(reader, &field)?),
Some(4) => percent_typical = Some(<u16>::from_tlv(reader, &field)?),
Some(5) => fixed_max = Some(<u64>::from_tlv(reader, &field)?),
Some(6) => fixed_min = Some(<u64>::from_tlv(reader, &field)?),
Some(7) => fixed_typical = Some(<u64>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
range_min: range_min.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
range_max: range_max.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
percent_max,
percent_min,
percent_typical,
fixed_max,
fixed_min,
fixed_typical,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct MeasurementAccuracyStruct<'a> {
pub measurement_type: MeasurementTypeEnum,
pub measured: bool,
pub min_measured_value: i64,
pub max_measured_value: i64,
pub accuracy_ranges: TlvList<'a, MeasurementAccuracyRangeStruct>,
}
impl<'a> ToTlv for MeasurementAccuracyStruct<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.measurement_type.to_tlv(w, Tag::Context(0))?;
self.measured.to_tlv(w, Tag::Context(1))?;
self.min_measured_value.to_tlv(w, Tag::Context(2))?;
self.max_measured_value.to_tlv(w, Tag::Context(3))?;
self.accuracy_ranges.to_tlv(w, Tag::Context(4))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for MeasurementAccuracyStruct<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut measurement_type = None;
let mut measured = None;
let mut min_measured_value = None;
let mut max_measured_value = None;
let mut accuracy_ranges = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => {
measurement_type = Some(<MeasurementTypeEnum>::from_tlv(reader, &field)?)
}
Some(1) => measured = Some(<bool>::from_tlv(reader, &field)?),
Some(2) => min_measured_value = Some(<i64>::from_tlv(reader, &field)?),
Some(3) => max_measured_value = Some(<i64>::from_tlv(reader, &field)?),
Some(4) => {
accuracy_ranges = Some(<TlvList<'a, MeasurementAccuracyRangeStruct>>::from_tlv(
reader, &field,
)?)
}
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
measurement_type: measurement_type
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
measured: measured.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
min_measured_value: min_measured_value
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
max_measured_value: max_measured_value
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
accuracy_ranges: accuracy_ranges
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct PowerThresholdStruct {
pub power_threshold: Option<i32>,
pub apparent_power_threshold: Option<i32>,
pub power_threshold_source: Nullable<PowerThresholdSourceEnum>,
}
impl ToTlv for PowerThresholdStruct {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
if let Some(value) = &self.power_threshold {
value.to_tlv(w, Tag::Context(0))?;
}
if let Some(value) = &self.apparent_power_threshold {
value.to_tlv(w, Tag::Context(1))?;
}
self.power_threshold_source.to_tlv(w, Tag::Context(2))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for PowerThresholdStruct {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut power_threshold = None;
let mut apparent_power_threshold = None;
let mut power_threshold_source = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => power_threshold = Some(<i32>::from_tlv(reader, &field)?),
Some(1) => apparent_power_threshold = Some(<i32>::from_tlv(reader, &field)?),
Some(2) => {
power_threshold_source = Some(<Nullable<PowerThresholdSourceEnum>>::from_tlv(
reader, &field,
)?)
}
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
power_threshold,
apparent_power_threshold,
power_threshold_source: power_threshold_source
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct PriceStruct {
pub amount: i64,
pub currency: CurrencyStruct,
}
impl ToTlv for PriceStruct {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.amount.to_tlv(w, Tag::Context(0))?;
self.currency.to_tlv(w, Tag::Context(1))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for PriceStruct {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut amount = None;
let mut currency = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => amount = Some(<i64>::from_tlv(reader, &field)?),
Some(1) => currency = Some(<CurrencyStruct>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
amount: amount.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
currency: currency.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct SemanticTagStruct<'a> {
pub mfg_code: Nullable<crate::msg::VendorId>,
pub namespace_id: u8,
pub tag: u8,
pub label: Option<Nullable<&'a str>>,
}
impl<'a> ToTlv for SemanticTagStruct<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.mfg_code.to_tlv(w, Tag::Context(0))?;
self.namespace_id.to_tlv(w, Tag::Context(1))?;
self.tag.to_tlv(w, Tag::Context(2))?;
if let Some(value) = &self.label {
value.to_tlv(w, Tag::Context(3))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for SemanticTagStruct<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut mfg_code = None;
let mut namespace_id = None;
let mut tag = None;
let mut label = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => {
mfg_code = Some(<Nullable<crate::msg::VendorId>>::from_tlv(reader, &field)?)
}
Some(1) => namespace_id = Some(<u8>::from_tlv(reader, &field)?),
Some(2) => tag = Some(<u8>::from_tlv(reader, &field)?),
Some(3) => label = Some(<Nullable<&'a str>>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
mfg_code: mfg_code.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
namespace_id: namespace_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
tag: tag.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
label,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ViewportStruct {
pub x1: u16,
pub y1: u16,
pub x2: u16,
pub y2: u16,
}
impl ToTlv for ViewportStruct {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.x1.to_tlv(w, Tag::Context(0))?;
self.y1.to_tlv(w, Tag::Context(1))?;
self.x2.to_tlv(w, Tag::Context(2))?;
self.y2.to_tlv(w, Tag::Context(3))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for ViewportStruct {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut x1 = None;
let mut y1 = None;
let mut x2 = None;
let mut y2 = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => x1 = Some(<u16>::from_tlv(reader, &field)?),
Some(1) => y1 = Some(<u16>::from_tlv(reader, &field)?),
Some(2) => x2 = Some(<u16>::from_tlv(reader, &field)?),
Some(3) => y2 = Some(<u16>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
x1: x1.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
y1: y1.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
x2: x2.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
y2: y2.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct WebRTCSessionStruct<'a> {
pub id: u16,
pub peer_node_id: crate::msg::NodeId,
pub peer_endpoint_id: u16,
pub stream_usage: StreamUsageEnum,
pub video_stream_id: Option<Nullable<u16>>,
pub audio_stream_id: Option<Nullable<u16>>,
pub metadata_enabled: bool,
pub video_streams: Option<TlvList<'a, u16>>,
pub audio_streams: Option<TlvList<'a, u16>>,
pub fabric_index: crate::msg::FabricIndex,
}
impl<'a> ToTlv for WebRTCSessionStruct<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.id.to_tlv(w, Tag::Context(0))?;
self.peer_node_id.to_tlv(w, Tag::Context(1))?;
self.peer_endpoint_id.to_tlv(w, Tag::Context(2))?;
self.stream_usage.to_tlv(w, Tag::Context(3))?;
if let Some(value) = &self.video_stream_id {
value.to_tlv(w, Tag::Context(4))?;
}
if let Some(value) = &self.audio_stream_id {
value.to_tlv(w, Tag::Context(5))?;
}
self.metadata_enabled.to_tlv(w, Tag::Context(6))?;
if let Some(value) = &self.video_streams {
value.to_tlv(w, Tag::Context(7))?;
}
if let Some(value) = &self.audio_streams {
value.to_tlv(w, Tag::Context(8))?;
}
self.fabric_index.to_tlv(w, Tag::Context(254))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for WebRTCSessionStruct<'a> {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
if element.value.container() != Some(ContainerKind::Structure) {
return Err(crate::Error::new(crate::ErrorCode::TlvWrongType));
}
let mut id = None;
let mut peer_node_id = None;
let mut peer_endpoint_id = None;
let mut stream_usage = None;
let mut video_stream_id = None;
let mut audio_stream_id = None;
let mut metadata_enabled = None;
let mut video_streams = None;
let mut audio_streams = None;
let mut fabric_index = None;
loop {
let Some(field) = reader.next_element()? else {
return Err(crate::Error::new(crate::ErrorCode::TlvTruncated));
};
if field.value == Value::EndOfContainer {
break;
}
match field.tag.context() {
Some(0) => id = Some(<u16>::from_tlv(reader, &field)?),
Some(1) => peer_node_id = Some(<crate::msg::NodeId>::from_tlv(reader, &field)?),
Some(2) => peer_endpoint_id = Some(<u16>::from_tlv(reader, &field)?),
Some(3) => stream_usage = Some(<StreamUsageEnum>::from_tlv(reader, &field)?),
Some(4) => video_stream_id = Some(<Nullable<u16>>::from_tlv(reader, &field)?),
Some(5) => audio_stream_id = Some(<Nullable<u16>>::from_tlv(reader, &field)?),
Some(6) => metadata_enabled = Some(<bool>::from_tlv(reader, &field)?),
Some(7) => video_streams = Some(<TlvList<'a, u16>>::from_tlv(reader, &field)?),
Some(8) => audio_streams = Some(<TlvList<'a, u16>>::from_tlv(reader, &field)?),
Some(254) => {
fabric_index = Some(<crate::msg::FabricIndex>::from_tlv(reader, &field)?)
}
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
id: id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
peer_node_id: peer_node_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
peer_endpoint_id: peer_endpoint_id
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
stream_usage: stream_usage.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
video_stream_id,
audio_stream_id,
metadata_enabled: metadata_enabled
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
video_streams,
audio_streams,
fabric_index: fabric_index.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}