#![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 = 0x0062;
pub const REVISION: u16 = 1;
pub const PICS: &str = "S";
pub mod feature {
pub const SCENE_NAMES: u32 = 1 << 0;
}
pub const FEATURES: &[Feature] = &[Feature {
bit: 0,
code: "SN",
name: "SceneNames",
conform: Conform::OPTIONAL,
}];
pub mod attribute {
use crate::im::AttributeId;
pub const DO_NOT_USE: AttributeId = 0x00;
pub const SCENE_TABLE_SIZE: AttributeId = 0x01;
pub const FABRIC_SCENE_INFO: AttributeId = 0x02;
}
pub mod command {
use crate::im::CommandId;
pub const ADD_SCENE: CommandId = 0x00;
pub const ADD_SCENE_RESPONSE: CommandId = 0x00;
pub const VIEW_SCENE: CommandId = 0x01;
pub const VIEW_SCENE_RESPONSE: CommandId = 0x01;
pub const REMOVE_SCENE: CommandId = 0x02;
pub const REMOVE_SCENE_RESPONSE: CommandId = 0x02;
pub const REMOVE_ALL_SCENES: CommandId = 0x03;
pub const REMOVE_ALL_SCENES_RESPONSE: CommandId = 0x03;
pub const STORE_SCENE: CommandId = 0x04;
pub const STORE_SCENE_RESPONSE: CommandId = 0x04;
pub const RECALL_SCENE: CommandId = 0x05;
pub const GET_SCENE_MEMBERSHIP: CommandId = 0x06;
pub const GET_SCENE_MEMBERSHIP_RESPONSE: CommandId = 0x06;
pub const COPY_SCENE: CommandId = 0x40;
pub const COPY_SCENE_RESPONSE: CommandId = 0x40;
}
bitflags::bitflags! {
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash, Default)]
pub struct CopyModeBitmap: u8 {
const COPY_ALL_SCENES = 1 << 0;
}
}
impl ToTlv for CopyModeBitmap {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
self.bits().to_tlv(w, tag)
}
}
impl<'a> FromTlv<'a> for CopyModeBitmap {
fn from_tlv(reader: &mut TlvReader<'a>, element: &Element<'a>) -> Result<Self> {
let bits = <u8 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 AttributeValuePairStruct {
pub attribute_id: u32,
pub value_unsigned8: Option<u8>,
pub value_signed8: Option<i8>,
pub value_unsigned16: Option<u16>,
pub value_signed16: Option<i16>,
pub value_unsigned32: Option<u32>,
pub value_signed32: Option<i32>,
pub value_unsigned64: Option<u64>,
pub value_signed64: Option<i64>,
}
impl ToTlv for AttributeValuePairStruct {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.attribute_id.to_tlv(w, Tag::Context(0))?;
if let Some(value) = &self.value_unsigned8 {
value.to_tlv(w, Tag::Context(1))?;
}
if let Some(value) = &self.value_signed8 {
value.to_tlv(w, Tag::Context(2))?;
}
if let Some(value) = &self.value_unsigned16 {
value.to_tlv(w, Tag::Context(3))?;
}
if let Some(value) = &self.value_signed16 {
value.to_tlv(w, Tag::Context(4))?;
}
if let Some(value) = &self.value_unsigned32 {
value.to_tlv(w, Tag::Context(5))?;
}
if let Some(value) = &self.value_signed32 {
value.to_tlv(w, Tag::Context(6))?;
}
if let Some(value) = &self.value_unsigned64 {
value.to_tlv(w, Tag::Context(7))?;
}
if let Some(value) = &self.value_signed64 {
value.to_tlv(w, Tag::Context(8))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for AttributeValuePairStruct {
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 value_unsigned8 = None;
let mut value_signed8 = None;
let mut value_unsigned16 = None;
let mut value_signed16 = None;
let mut value_unsigned32 = None;
let mut value_signed32 = None;
let mut value_unsigned64 = None;
let mut value_signed64 = 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) => value_unsigned8 = Some(<u8>::from_tlv(reader, &field)?),
Some(2) => value_signed8 = Some(<i8>::from_tlv(reader, &field)?),
Some(3) => value_unsigned16 = Some(<u16>::from_tlv(reader, &field)?),
Some(4) => value_signed16 = Some(<i16>::from_tlv(reader, &field)?),
Some(5) => value_unsigned32 = Some(<u32>::from_tlv(reader, &field)?),
Some(6) => value_signed32 = Some(<i32>::from_tlv(reader, &field)?),
Some(7) => value_unsigned64 = Some(<u64>::from_tlv(reader, &field)?),
Some(8) => value_signed64 = Some(<i64>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
attribute_id: attribute_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
value_unsigned8,
value_signed8,
value_unsigned16,
value_signed16,
value_unsigned32,
value_signed32,
value_unsigned64,
value_signed64,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ExtensionFieldSetStruct<'a> {
pub cluster_id: u32,
pub attribute_value_list: TlvList<'a, AttributeValuePairStruct>,
}
impl<'a> ToTlv for ExtensionFieldSetStruct<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.cluster_id.to_tlv(w, Tag::Context(0))?;
self.attribute_value_list.to_tlv(w, Tag::Context(1))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for ExtensionFieldSetStruct<'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 cluster_id = None;
let mut attribute_value_list = 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) => cluster_id = Some(<u32>::from_tlv(reader, &field)?),
Some(1) => {
attribute_value_list = Some(<TlvList<'a, AttributeValuePairStruct>>::from_tlv(
reader, &field,
)?)
}
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
cluster_id: cluster_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
attribute_value_list: attribute_value_list
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct SceneInfoStruct {
pub scene_count: u8,
pub current_scene: u8,
pub current_group: crate::msg::GroupId,
pub scene_valid: bool,
pub remaining_capacity: u8,
pub fabric_index: crate::msg::FabricIndex,
}
impl ToTlv for SceneInfoStruct {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.scene_count.to_tlv(w, Tag::Context(0))?;
self.current_scene.to_tlv(w, Tag::Context(1))?;
self.current_group.to_tlv(w, Tag::Context(2))?;
self.scene_valid.to_tlv(w, Tag::Context(3))?;
self.remaining_capacity.to_tlv(w, Tag::Context(4))?;
self.fabric_index.to_tlv(w, Tag::Context(254))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for SceneInfoStruct {
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 scene_count = None;
let mut current_scene = None;
let mut current_group = None;
let mut scene_valid = None;
let mut remaining_capacity = 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) => scene_count = Some(<u8>::from_tlv(reader, &field)?),
Some(1) => current_scene = Some(<u8>::from_tlv(reader, &field)?),
Some(2) => current_group = Some(<crate::msg::GroupId>::from_tlv(reader, &field)?),
Some(3) => scene_valid = Some(<bool>::from_tlv(reader, &field)?),
Some(4) => remaining_capacity = Some(<u8>::from_tlv(reader, &field)?),
Some(254) => {
fabric_index = Some(<crate::msg::FabricIndex>::from_tlv(reader, &field)?)
}
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
scene_count: scene_count.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
current_scene: current_scene.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
current_group: current_group.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
scene_valid: scene_valid.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
remaining_capacity: remaining_capacity
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
fabric_index: fabric_index.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct AddSceneFields<'a> {
pub group_id: crate::msg::GroupId,
pub scene_id: u8,
pub transition_time: u32,
pub scene_name: &'a str,
pub extension_field_set_structs: TlvList<'a, ExtensionFieldSetStruct<'a>>,
}
impl<'a> ToTlv for AddSceneFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.group_id.to_tlv(w, Tag::Context(0))?;
self.scene_id.to_tlv(w, Tag::Context(1))?;
self.transition_time.to_tlv(w, Tag::Context(2))?;
self.scene_name.to_tlv(w, Tag::Context(3))?;
self.extension_field_set_structs
.to_tlv(w, Tag::Context(4))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for AddSceneFields<'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 group_id = None;
let mut scene_id = None;
let mut transition_time = None;
let mut scene_name = None;
let mut extension_field_set_structs = 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) => group_id = Some(<crate::msg::GroupId>::from_tlv(reader, &field)?),
Some(1) => scene_id = Some(<u8>::from_tlv(reader, &field)?),
Some(2) => transition_time = Some(<u32>::from_tlv(reader, &field)?),
Some(3) => scene_name = Some(<&'a str>::from_tlv(reader, &field)?),
Some(4) => {
extension_field_set_structs = Some(
<TlvList<'a, ExtensionFieldSetStruct<'a>>>::from_tlv(reader, &field)?,
)
}
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
group_id: group_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
scene_id: scene_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
transition_time: transition_time
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
scene_name: scene_name.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
extension_field_set_structs: extension_field_set_structs
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct AddSceneResponseFields {
pub status: u8,
pub group_id: crate::msg::GroupId,
pub scene_id: u8,
}
impl ToTlv for AddSceneResponseFields {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.status.to_tlv(w, Tag::Context(0))?;
self.group_id.to_tlv(w, Tag::Context(1))?;
self.scene_id.to_tlv(w, Tag::Context(2))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for AddSceneResponseFields {
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 status = None;
let mut group_id = None;
let mut scene_id = 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) => status = Some(<u8>::from_tlv(reader, &field)?),
Some(1) => group_id = Some(<crate::msg::GroupId>::from_tlv(reader, &field)?),
Some(2) => scene_id = Some(<u8>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
status: status.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
group_id: group_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
scene_id: scene_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ViewSceneFields {
pub group_id: crate::msg::GroupId,
pub scene_id: u8,
}
impl ToTlv for ViewSceneFields {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.group_id.to_tlv(w, Tag::Context(0))?;
self.scene_id.to_tlv(w, Tag::Context(1))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for ViewSceneFields {
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 group_id = None;
let mut scene_id = 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) => group_id = Some(<crate::msg::GroupId>::from_tlv(reader, &field)?),
Some(1) => scene_id = Some(<u8>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
group_id: group_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
scene_id: scene_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct ViewSceneResponseFields<'a> {
pub status: u8,
pub group_id: crate::msg::GroupId,
pub scene_id: u8,
pub transition_time: Option<u32>,
pub scene_name: Option<&'a str>,
pub extension_field_set_structs: Option<TlvList<'a, ExtensionFieldSetStruct<'a>>>,
}
impl<'a> ToTlv for ViewSceneResponseFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.status.to_tlv(w, Tag::Context(0))?;
self.group_id.to_tlv(w, Tag::Context(1))?;
self.scene_id.to_tlv(w, Tag::Context(2))?;
if let Some(value) = &self.transition_time {
value.to_tlv(w, Tag::Context(3))?;
}
if let Some(value) = &self.scene_name {
value.to_tlv(w, Tag::Context(4))?;
}
if let Some(value) = &self.extension_field_set_structs {
value.to_tlv(w, Tag::Context(5))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for ViewSceneResponseFields<'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 status = None;
let mut group_id = None;
let mut scene_id = None;
let mut transition_time = None;
let mut scene_name = None;
let mut extension_field_set_structs = 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) => status = Some(<u8>::from_tlv(reader, &field)?),
Some(1) => group_id = Some(<crate::msg::GroupId>::from_tlv(reader, &field)?),
Some(2) => scene_id = Some(<u8>::from_tlv(reader, &field)?),
Some(3) => transition_time = Some(<u32>::from_tlv(reader, &field)?),
Some(4) => scene_name = Some(<&'a str>::from_tlv(reader, &field)?),
Some(5) => {
extension_field_set_structs = Some(
<TlvList<'a, ExtensionFieldSetStruct<'a>>>::from_tlv(reader, &field)?,
)
}
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
status: status.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
group_id: group_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
scene_id: scene_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
transition_time,
scene_name,
extension_field_set_structs,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct RemoveSceneFields {
pub group_id: crate::msg::GroupId,
pub scene_id: u8,
}
impl ToTlv for RemoveSceneFields {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.group_id.to_tlv(w, Tag::Context(0))?;
self.scene_id.to_tlv(w, Tag::Context(1))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for RemoveSceneFields {
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 group_id = None;
let mut scene_id = 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) => group_id = Some(<crate::msg::GroupId>::from_tlv(reader, &field)?),
Some(1) => scene_id = Some(<u8>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
group_id: group_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
scene_id: scene_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct RemoveSceneResponseFields {
pub status: u8,
pub group_id: crate::msg::GroupId,
pub scene_id: u8,
}
impl ToTlv for RemoveSceneResponseFields {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.status.to_tlv(w, Tag::Context(0))?;
self.group_id.to_tlv(w, Tag::Context(1))?;
self.scene_id.to_tlv(w, Tag::Context(2))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for RemoveSceneResponseFields {
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 status = None;
let mut group_id = None;
let mut scene_id = 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) => status = Some(<u8>::from_tlv(reader, &field)?),
Some(1) => group_id = Some(<crate::msg::GroupId>::from_tlv(reader, &field)?),
Some(2) => scene_id = Some(<u8>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
status: status.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
group_id: group_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
scene_id: scene_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct RemoveAllScenesFields {
pub group_id: crate::msg::GroupId,
}
impl ToTlv for RemoveAllScenesFields {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.group_id.to_tlv(w, Tag::Context(0))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for RemoveAllScenesFields {
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 group_id = 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) => group_id = Some(<crate::msg::GroupId>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
group_id: group_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct RemoveAllScenesResponseFields {
pub status: u8,
pub group_id: crate::msg::GroupId,
}
impl ToTlv for RemoveAllScenesResponseFields {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.status.to_tlv(w, Tag::Context(0))?;
self.group_id.to_tlv(w, Tag::Context(1))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for RemoveAllScenesResponseFields {
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 status = None;
let mut group_id = 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) => status = Some(<u8>::from_tlv(reader, &field)?),
Some(1) => group_id = Some(<crate::msg::GroupId>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
status: status.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
group_id: group_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct StoreSceneFields {
pub group_id: crate::msg::GroupId,
pub scene_id: u8,
}
impl ToTlv for StoreSceneFields {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.group_id.to_tlv(w, Tag::Context(0))?;
self.scene_id.to_tlv(w, Tag::Context(1))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for StoreSceneFields {
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 group_id = None;
let mut scene_id = 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) => group_id = Some(<crate::msg::GroupId>::from_tlv(reader, &field)?),
Some(1) => scene_id = Some(<u8>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
group_id: group_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
scene_id: scene_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct StoreSceneResponseFields {
pub status: u8,
pub group_id: crate::msg::GroupId,
pub scene_id: u8,
}
impl ToTlv for StoreSceneResponseFields {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.status.to_tlv(w, Tag::Context(0))?;
self.group_id.to_tlv(w, Tag::Context(1))?;
self.scene_id.to_tlv(w, Tag::Context(2))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for StoreSceneResponseFields {
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 status = None;
let mut group_id = None;
let mut scene_id = 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) => status = Some(<u8>::from_tlv(reader, &field)?),
Some(1) => group_id = Some(<crate::msg::GroupId>::from_tlv(reader, &field)?),
Some(2) => scene_id = Some(<u8>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
status: status.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
group_id: group_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
scene_id: scene_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct RecallSceneFields {
pub group_id: crate::msg::GroupId,
pub scene_id: u8,
pub transition_time: Option<Nullable<u32>>,
}
impl ToTlv for RecallSceneFields {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.group_id.to_tlv(w, Tag::Context(0))?;
self.scene_id.to_tlv(w, Tag::Context(1))?;
if let Some(value) = &self.transition_time {
value.to_tlv(w, Tag::Context(2))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for RecallSceneFields {
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 group_id = None;
let mut scene_id = None;
let mut transition_time = 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) => group_id = Some(<crate::msg::GroupId>::from_tlv(reader, &field)?),
Some(1) => scene_id = Some(<u8>::from_tlv(reader, &field)?),
Some(2) => transition_time = Some(<Nullable<u32>>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
group_id: group_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
scene_id: scene_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
transition_time,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct GetSceneMembershipFields {
pub group_id: crate::msg::GroupId,
}
impl ToTlv for GetSceneMembershipFields {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.group_id.to_tlv(w, Tag::Context(0))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for GetSceneMembershipFields {
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 group_id = 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) => group_id = Some(<crate::msg::GroupId>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
group_id: group_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct GetSceneMembershipResponseFields<'a> {
pub status: u8,
pub capacity: Nullable<u8>,
pub group_id: crate::msg::GroupId,
pub scene_list: Option<TlvList<'a, u8>>,
}
impl<'a> ToTlv for GetSceneMembershipResponseFields<'a> {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.status.to_tlv(w, Tag::Context(0))?;
self.capacity.to_tlv(w, Tag::Context(1))?;
self.group_id.to_tlv(w, Tag::Context(2))?;
if let Some(value) = &self.scene_list {
value.to_tlv(w, Tag::Context(3))?;
}
w.end_container()
}
}
impl<'a> FromTlv<'a> for GetSceneMembershipResponseFields<'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 status = None;
let mut capacity = None;
let mut group_id = None;
let mut scene_list = 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) => status = Some(<u8>::from_tlv(reader, &field)?),
Some(1) => capacity = Some(<Nullable<u8>>::from_tlv(reader, &field)?),
Some(2) => group_id = Some(<crate::msg::GroupId>::from_tlv(reader, &field)?),
Some(3) => scene_list = Some(<TlvList<'a, u8>>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
status: status.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
capacity: capacity.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
group_id: group_id.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
scene_list,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CopySceneFields {
pub mode: CopyModeBitmap,
pub group_identifier_from: crate::msg::GroupId,
pub scene_identifier_from: u8,
pub group_identifier_to: crate::msg::GroupId,
pub scene_identifier_to: u8,
}
impl ToTlv for CopySceneFields {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.mode.to_tlv(w, Tag::Context(0))?;
self.group_identifier_from.to_tlv(w, Tag::Context(1))?;
self.scene_identifier_from.to_tlv(w, Tag::Context(2))?;
self.group_identifier_to.to_tlv(w, Tag::Context(3))?;
self.scene_identifier_to.to_tlv(w, Tag::Context(4))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for CopySceneFields {
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 mode = None;
let mut group_identifier_from = None;
let mut scene_identifier_from = None;
let mut group_identifier_to = None;
let mut scene_identifier_to = 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) => mode = Some(<CopyModeBitmap>::from_tlv(reader, &field)?),
Some(1) => {
group_identifier_from = Some(<crate::msg::GroupId>::from_tlv(reader, &field)?)
}
Some(2) => scene_identifier_from = Some(<u8>::from_tlv(reader, &field)?),
Some(3) => {
group_identifier_to = Some(<crate::msg::GroupId>::from_tlv(reader, &field)?)
}
Some(4) => scene_identifier_to = Some(<u8>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
mode: mode.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
group_identifier_from: group_identifier_from
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
scene_identifier_from: scene_identifier_from
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
group_identifier_to: group_identifier_to
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
scene_identifier_to: scene_identifier_to
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq)]
pub struct CopySceneResponseFields {
pub status: u8,
pub group_identifier_from: crate::msg::GroupId,
pub scene_identifier_from: u8,
}
impl ToTlv for CopySceneResponseFields {
fn to_tlv(&self, w: &mut TlvWriter<'_>, tag: Tag) -> Result<()> {
w.start_structure(tag)?;
self.status.to_tlv(w, Tag::Context(0))?;
self.group_identifier_from.to_tlv(w, Tag::Context(1))?;
self.scene_identifier_from.to_tlv(w, Tag::Context(2))?;
w.end_container()
}
}
impl<'a> FromTlv<'a> for CopySceneResponseFields {
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 status = None;
let mut group_identifier_from = None;
let mut scene_identifier_from = 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) => status = Some(<u8>::from_tlv(reader, &field)?),
Some(1) => {
group_identifier_from = Some(<crate::msg::GroupId>::from_tlv(reader, &field)?)
}
Some(2) => scene_identifier_from = Some(<u8>::from_tlv(reader, &field)?),
_ => reader.skip_value(&field)?,
}
}
Ok(Self {
status: status.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
group_identifier_from: group_identifier_from
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
scene_identifier_from: scene_identifier_from
.ok_or(crate::Error::new(crate::ErrorCode::TlvNotFound))?,
})
}
}
pub const ATTRIBUTES: &[Attribute] = &[
Attribute {
id: 0x0000,
name: "DoNotUse",
kind: "",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::empty(),
reporting: Reporting::OnChange,
conform: Conform::DISALLOWED,
},
Attribute {
id: 0x0001,
name: "SceneTableSize",
kind: "uint16",
access: Access::read_only(Privilege::View),
qualities: AttributeQualities::FIXED,
reporting: Reporting::OnChange,
conform: Conform::MANDATORY,
},
Attribute {
id: 0x0002,
name: "FabricSceneInfo",
kind: "list[SceneInfoStruct]",
access: Access::read_only(Privilege::View).with_qualities(AccessQualities::FABRIC_SCOPED),
qualities: AttributeQualities::empty(),
reporting: Reporting::OnChange,
conform: Conform::MANDATORY,
},
];
pub const COMMANDS: &[Command] = &[
Command {
id: 0x00,
name: "AddScene",
to_server: true,
response: Some(0x00),
access: Access::invoke(Privilege::Manage).with_qualities(AccessQualities::FABRIC_SCOPED),
conform: Conform::MANDATORY,
},
Command {
id: 0x00,
name: "AddSceneResponse",
to_server: false,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform::MANDATORY,
},
Command {
id: 0x01,
name: "ViewScene",
to_server: true,
response: Some(0x01),
access: Access::invoke(Privilege::Operate).with_qualities(AccessQualities::FABRIC_SCOPED),
conform: Conform::MANDATORY,
},
Command {
id: 0x01,
name: "ViewSceneResponse",
to_server: false,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform::MANDATORY,
},
Command {
id: 0x02,
name: "RemoveScene",
to_server: true,
response: Some(0x02),
access: Access::invoke(Privilege::Manage).with_qualities(AccessQualities::FABRIC_SCOPED),
conform: Conform::MANDATORY,
},
Command {
id: 0x02,
name: "RemoveSceneResponse",
to_server: false,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform::MANDATORY,
},
Command {
id: 0x03,
name: "RemoveAllScenes",
to_server: true,
response: Some(0x03),
access: Access::invoke(Privilege::Manage).with_qualities(AccessQualities::FABRIC_SCOPED),
conform: Conform::MANDATORY,
},
Command {
id: 0x03,
name: "RemoveAllScenesResponse",
to_server: false,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform::MANDATORY,
},
Command {
id: 0x04,
name: "StoreScene",
to_server: true,
response: Some(0x04),
access: Access::invoke(Privilege::Manage).with_qualities(AccessQualities::FABRIC_SCOPED),
conform: Conform::MANDATORY,
},
Command {
id: 0x04,
name: "StoreSceneResponse",
to_server: false,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform::MANDATORY,
},
Command {
id: 0x05,
name: "RecallScene",
to_server: true,
response: None,
access: Access::invoke(Privilege::Operate).with_qualities(AccessQualities::FABRIC_SCOPED),
conform: Conform::MANDATORY,
},
Command {
id: 0x06,
name: "GetSceneMembership",
to_server: true,
response: Some(0x06),
access: Access::invoke(Privilege::Operate).with_qualities(AccessQualities::FABRIC_SCOPED),
conform: Conform::MANDATORY,
},
Command {
id: 0x06,
name: "GetSceneMembershipResponse",
to_server: false,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform::MANDATORY,
},
Command {
id: 0x40,
name: "CopyScene",
to_server: true,
response: Some(0x40),
access: Access::invoke(Privilege::Manage).with_qualities(AccessQualities::FABRIC_SCOPED),
conform: Conform::OPTIONAL,
},
Command {
id: 0x40,
name: "CopySceneResponse",
to_server: false,
response: None,
access: Access::invoke(Privilege::Operate),
conform: Conform {
clauses: &[Clause {
verdict: Conformance::Mandatory,
when: Condition::Command(0x40),
}],
},
},
];
pub const EVENTS: &[Event] = &[];
pub const CLUSTER: Cluster = Cluster {
id: ID,
name: "Scenes Management",
revision: REVISION,
pics: "S",
derived_from: None,
features: FEATURES,
attributes: ATTRIBUTES,
commands: COMMANDS,
events: EVENTS,
};