use crate::error::{Error, ErrorCode, Result, bail};
use crate::im::ib::{
AttributeData, AttributeReport, CommandData, DataVersionFilter, EventFilter, InvokeResponse,
};
use crate::im::path::{AttributePath, EventPath};
use crate::im::status::Status;
use crate::tlv::{ContainerKind, Element, Tag, TlvReader, TlvWriter, Value, set_once};
pub const REVISION_TAG: u8 = 0xFF;
pub const INTERACTION_MODEL_REVISION: u16 = 13;
pub mod opcode {
pub const STATUS_RESPONSE: u8 = 0x01;
pub const READ_REQUEST: u8 = 0x02;
pub const SUBSCRIBE_REQUEST: u8 = 0x03;
pub const SUBSCRIBE_RESPONSE: u8 = 0x04;
pub const REPORT_DATA: u8 = 0x05;
pub const WRITE_REQUEST: u8 = 0x06;
pub const WRITE_RESPONSE: u8 = 0x07;
pub const INVOKE_REQUEST: u8 = 0x08;
pub const INVOKE_RESPONSE: u8 = 0x09;
pub const TIMED_REQUEST: u8 = 0x0A;
}
fn open(buf: &[u8]) -> Result<TlvReader<'_>> {
let mut reader = TlvReader::new(buf);
let Some(head) = reader.next_element()? else {
bail!(TlvTruncated)
};
if head.value.container() != Some(ContainerKind::Structure) || !head.tag.is_anonymous() {
bail!(TlvWrongType)
}
Ok(reader)
}
fn take_array<'a>(
reader: &mut TlvReader<'a>,
element: &Element<'a>,
start: usize,
) -> Result<&'a [u8]> {
if element.value.container() != Some(ContainerKind::Array) {
bail!(TlvWrongType)
}
reader.skip_value(element)?;
reader.slice_from(start)
}
#[derive(Debug, Clone)]
pub struct ArrayIter<'a, T> {
reader: TlvReader<'a>,
done: bool,
member: ContainerKind,
decode: fn(&mut TlvReader<'a>) -> Result<T>,
}
impl<'a, T> ArrayIter<'a, T> {
pub(crate) fn new(
bytes: &'a [u8],
member: ContainerKind,
decode: fn(&mut TlvReader<'a>) -> Result<T>,
) -> Result<Self> {
let mut reader = TlvReader::new_in(bytes, ContainerKind::Structure);
let Some(head) = reader.next_element()? else {
bail!(TlvTruncated)
};
if head.value.container() != Some(ContainerKind::Array) {
bail!(TlvWrongType)
}
Ok(Self {
reader,
done: false,
member,
decode,
})
}
}
impl<'a, T> Iterator for ArrayIter<'a, T> {
type Item = Result<T>;
fn next(&mut self) -> Option<Self::Item> {
if self.done {
return None;
}
let element = match self.reader.next_element() {
Ok(Some(element)) => element,
Ok(None) => {
self.done = true;
return None;
}
Err(e) => {
self.done = true;
return Some(Err(e));
}
};
if element.value == Value::EndOfContainer {
self.done = true;
return None;
}
if element.value.container() != Some(self.member) || !element.tag.is_anonymous() {
self.done = true;
return Some(Err(Error::new(ErrorCode::TlvWrongType)));
}
let out = (self.decode)(&mut self.reader);
if out.is_err() {
self.done = true;
}
Some(out)
}
}
fn write_revision(w: &mut TlvWriter<'_>) -> Result<()> {
w.unsigned(
Tag::Context(REVISION_TAG),
u64::from(INTERACTION_MODEL_REVISION),
)
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct StatusResponse {
pub status: Status,
pub revision: Option<u16>,
}
impl StatusResponse {
#[must_use]
pub const fn new(status: Status) -> Self {
Self {
status,
revision: Some(INTERACTION_MODEL_REVISION),
}
}
pub fn encode<'b>(&self, buf: &'b mut [u8]) -> Result<&'b [u8]> {
let mut w = TlvWriter::new(buf);
w.start_structure(Tag::Anonymous)?;
w.unsigned(Tag::Context(0), u64::from(self.status.value()))?;
write_revision(&mut w)?;
w.end_container()?;
w.finish()
}
pub fn decode(buf: &[u8]) -> Result<Self> {
let mut reader = open(buf)?;
let mut status = None;
let mut revision = None;
loop {
let Some(element) = reader.next_element()? else {
bail!(TlvTruncated)
};
if element.value == Value::EndOfContainer {
break;
}
match element.tag.context() {
Some(0) => set_once(
&mut status,
Status::from_value(
u8::try_from(element.unsigned()?)
.map_err(|_| Error::new(ErrorCode::TlvOutOfRange))?,
),
)?,
Some(REVISION_TAG) => set_once(&mut revision, narrow16(element.unsigned()?)?)?,
_ => reader.skip_value(&element)?,
}
}
reader.finish()?;
Ok(Self {
status: status.ok_or(Error::new(ErrorCode::TlvNotFound))?,
revision,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ReadRequest<'a> {
attribute_requests: Option<&'a [u8]>,
event_requests: Option<&'a [u8]>,
event_filters: Option<&'a [u8]>,
data_version_filters: Option<&'a [u8]>,
pub fabric_filtered: bool,
pub revision: Option<u16>,
}
impl<'a> ReadRequest<'a> {
pub fn attribute_paths(&self) -> Result<Option<ArrayIter<'a, AttributePath>>> {
self.attribute_requests
.map(|bytes| ArrayIter::new(bytes, ContainerKind::List, path_from_list))
.transpose()
}
pub fn event_paths(&self) -> Result<Option<ArrayIter<'a, EventPath>>> {
self.event_requests
.map(|bytes| ArrayIter::new(bytes, ContainerKind::List, event_path_from_list))
.transpose()
}
#[must_use]
pub const fn event_filters_raw(&self) -> Option<&'a [u8]> {
self.event_filters
}
pub fn event_filters(&self) -> Result<Option<ArrayIter<'a, EventFilter>>> {
self.event_filters
.map(|bytes| ArrayIter::new(bytes, ContainerKind::Structure, EventFilter::decode))
.transpose()
}
#[must_use]
pub const fn data_version_filters_raw(&self) -> Option<&'a [u8]> {
self.data_version_filters
}
pub fn data_version_filters(&self) -> Result<Option<ArrayIter<'a, DataVersionFilter>>> {
self.data_version_filters
.map(|bytes| ArrayIter::new(bytes, ContainerKind::Structure, DataVersionFilter::decode))
.transpose()
}
pub fn decode(buf: &'a [u8]) -> Result<Self> {
let mut reader = open(buf)?;
let mut attribute_requests = None;
let mut event_requests = None;
let mut event_filters = None;
let mut data_version_filters = None;
let mut fabric_filtered = None;
let mut revision = None;
loop {
let start = reader.position();
let Some(element) = reader.next_element()? else {
bail!(TlvTruncated)
};
if element.value == Value::EndOfContainer {
break;
}
match element.tag.context() {
Some(0) => set_once(
&mut attribute_requests,
take_array(&mut reader, &element, start)?,
)?,
Some(1) => set_once(
&mut event_requests,
take_array(&mut reader, &element, start)?,
)?,
Some(2) => {
set_once(
&mut event_filters,
take_array(&mut reader, &element, start)?,
)?;
}
Some(3) => set_once(&mut fabric_filtered, element.bool()?)?,
Some(4) => set_once(
&mut data_version_filters,
take_array(&mut reader, &element, start)?,
)?,
Some(REVISION_TAG) => set_once(&mut revision, narrow16(element.unsigned()?)?)?,
_ => reader.skip_value(&element)?,
}
}
reader.finish()?;
Ok(Self {
attribute_requests,
event_requests,
event_filters,
data_version_filters,
fabric_filtered: fabric_filtered.ok_or(Error::new(ErrorCode::TlvNotFound))?,
revision,
})
}
}
pub fn encode_read_request<A, E>(
buf: &mut [u8],
attribute_paths: A,
event_paths: E,
fabric_filtered: bool,
) -> Result<&[u8]>
where
A: IntoIterator<Item = AttributePath>,
E: IntoIterator<Item = EventPath>,
{
let mut w = TlvWriter::new(buf);
w.start_structure(Tag::Anonymous)?;
let mut attributes = attribute_paths.into_iter().peekable();
if attributes.peek().is_some() {
w.start_array(Tag::Context(0))?;
for path in attributes {
path.encode(&mut w, Tag::Anonymous)?;
}
w.end_container()?;
}
let mut events = event_paths.into_iter().peekable();
if events.peek().is_some() {
w.start_array(Tag::Context(1))?;
for path in events {
path.encode(&mut w, Tag::Anonymous)?;
}
w.end_container()?;
}
w.bool(Tag::Context(3), fabric_filtered)?;
write_revision(&mut w)?;
w.end_container()?;
w.finish()
}
pub fn encode_subscribe_request<A, E>(
buf: &mut [u8],
attribute_paths: A,
event_paths: E,
min_interval_floor_s: u16,
max_interval_ceiling_s: u16,
keep_subscriptions: bool,
fabric_filtered: bool,
) -> Result<&[u8]>
where
A: IntoIterator<Item = AttributePath>,
E: IntoIterator<Item = EventPath>,
{
let mut w = TlvWriter::new(buf);
w.start_structure(Tag::Anonymous)?;
w.bool(Tag::Context(0), keep_subscriptions)?;
w.unsigned(Tag::Context(1), u64::from(min_interval_floor_s))?;
w.unsigned(Tag::Context(2), u64::from(max_interval_ceiling_s))?;
let mut attributes = attribute_paths.into_iter().peekable();
if attributes.peek().is_some() {
w.start_array(Tag::Context(3))?;
for path in attributes {
path.encode(&mut w, Tag::Anonymous)?;
}
w.end_container()?;
}
let mut events = event_paths.into_iter().peekable();
if events.peek().is_some() {
w.start_array(Tag::Context(4))?;
for path in events {
path.encode(&mut w, Tag::Anonymous)?;
}
w.end_container()?;
}
w.bool(Tag::Context(7), fabric_filtered)?;
write_revision(&mut w)?;
w.end_container()?;
w.finish()
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ReportData<'a> {
pub subscription_id: Option<u32>,
attribute_reports: Option<&'a [u8]>,
event_reports: Option<&'a [u8]>,
pub more_chunked_messages: bool,
pub suppress_response: bool,
pub revision: Option<u16>,
}
impl<'a> ReportData<'a> {
pub fn attribute_reports(&self) -> Result<Option<ArrayIter<'a, AttributeReport<'a>>>> {
self.attribute_reports
.map(|bytes| ArrayIter::new(bytes, ContainerKind::Structure, AttributeReport::decode))
.transpose()
}
pub fn event_reports(&self) -> Result<Option<ArrayIter<'a, crate::im::EventReport<'a>>>> {
self.event_reports
.map(|bytes| {
ArrayIter::new(
bytes,
ContainerKind::Structure,
crate::im::EventReport::decode,
)
})
.transpose()
}
#[must_use]
pub const fn attribute_reports_bytes(&self) -> Option<&'a [u8]> {
self.attribute_reports
}
#[must_use]
pub const fn event_reports_bytes(&self) -> Option<&'a [u8]> {
self.event_reports
}
pub fn decode(buf: &'a [u8]) -> Result<Self> {
let mut reader = open(buf)?;
let mut subscription_id = None;
let mut attribute_reports = None;
let mut event_reports = None;
let mut more_chunked_messages = None;
let mut suppress_response = None;
let mut revision = None;
loop {
let start = reader.position();
let Some(element) = reader.next_element()? else {
bail!(TlvTruncated)
};
if element.value == Value::EndOfContainer {
break;
}
match element.tag.context() {
Some(0) => set_once(&mut subscription_id, narrow32(element.unsigned()?)?)?,
Some(1) => set_once(
&mut attribute_reports,
take_array(&mut reader, &element, start)?,
)?,
Some(2) => {
set_once(
&mut event_reports,
take_array(&mut reader, &element, start)?,
)?;
}
Some(3) => set_once(&mut more_chunked_messages, element.bool()?)?,
Some(4) => set_once(&mut suppress_response, element.bool()?)?,
Some(REVISION_TAG) => set_once(&mut revision, narrow16(element.unsigned()?)?)?,
_ => reader.skip_value(&element)?,
}
}
reader.finish()?;
Ok(Self {
subscription_id,
attribute_reports,
event_reports,
more_chunked_messages: more_chunked_messages.unwrap_or(false),
suppress_response: suppress_response.unwrap_or(false),
revision,
})
}
}
pub fn encode_report_data<'b, R>(
buf: &'b mut [u8],
subscription_id: Option<u32>,
reports: R,
more_chunked_messages: bool,
suppress_response: bool,
) -> Result<&'b [u8]>
where
R: IntoIterator<Item = AttributeReport<'b>>,
{
let mut w = TlvWriter::new(buf);
w.start_structure(Tag::Anonymous)?;
if let Some(id) = subscription_id {
w.unsigned(Tag::Context(0), u64::from(id))?;
}
let mut reports = reports.into_iter().peekable();
if reports.peek().is_some() {
w.start_array(Tag::Context(1))?;
for report in reports {
report.encode(&mut w)?;
}
w.end_container()?;
}
if more_chunked_messages {
w.bool(Tag::Context(3), true)?;
}
if suppress_response {
w.bool(Tag::Context(4), true)?;
}
write_revision(&mut w)?;
w.end_container()?;
w.finish()
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct WriteRequest<'a> {
pub suppress_response: bool,
pub timed_request: bool,
write_requests: &'a [u8],
pub more_chunked_messages: bool,
pub revision: Option<u16>,
}
impl<'a> WriteRequest<'a> {
pub fn writes(&self) -> Result<ArrayIter<'a, AttributeData<'a>>> {
ArrayIter::new(
self.write_requests,
ContainerKind::Structure,
AttributeData::decode,
)
}
pub fn decode(buf: &'a [u8]) -> Result<Self> {
let mut reader = open(buf)?;
let mut suppress_response = None;
let mut timed_request = None;
let mut write_requests = None;
let mut more_chunked_messages = None;
let mut revision = None;
loop {
let start = reader.position();
let Some(element) = reader.next_element()? else {
bail!(TlvTruncated)
};
if element.value == Value::EndOfContainer {
break;
}
match element.tag.context() {
Some(0) => set_once(&mut suppress_response, element.bool()?)?,
Some(1) => set_once(&mut timed_request, element.bool()?)?,
Some(2) => set_once(
&mut write_requests,
take_array(&mut reader, &element, start)?,
)?,
Some(3) => set_once(&mut more_chunked_messages, element.bool()?)?,
Some(REVISION_TAG) => set_once(&mut revision, narrow16(element.unsigned()?)?)?,
_ => reader.skip_value(&element)?,
}
}
reader.finish()?;
Ok(Self {
suppress_response: suppress_response.unwrap_or(false),
timed_request: timed_request.unwrap_or(false),
write_requests: write_requests.ok_or(Error::new(ErrorCode::TlvNotFound))?,
more_chunked_messages: more_chunked_messages.unwrap_or(false),
revision,
})
}
}
pub fn encode_write_request<'b, W>(
buf: &'b mut [u8],
writes: W,
timed_request: bool,
suppress_response: bool,
) -> Result<&'b [u8]>
where
W: IntoIterator<Item = AttributeData<'b>>,
{
let mut w = TlvWriter::new(buf);
w.start_structure(Tag::Anonymous)?;
if suppress_response {
w.bool(Tag::Context(0), true)?;
}
w.bool(Tag::Context(1), timed_request)?;
w.start_array(Tag::Context(2))?;
for data in writes {
data.encode(&mut w, Tag::Anonymous)?;
}
w.end_container()?;
write_revision(&mut w)?;
w.end_container()?;
w.finish()
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct WriteResponse<'a> {
write_responses: &'a [u8],
pub revision: Option<u16>,
}
impl<'a> WriteResponse<'a> {
pub fn statuses(&self) -> Result<ArrayIter<'a, crate::im::ib::AttributeStatus>> {
ArrayIter::new(
self.write_responses,
ContainerKind::Structure,
crate::im::ib::AttributeStatus::decode,
)
}
pub fn decode(buf: &'a [u8]) -> Result<Self> {
let mut reader = open(buf)?;
let mut write_responses = None;
let mut revision = None;
loop {
let start = reader.position();
let Some(element) = reader.next_element()? else {
bail!(TlvTruncated)
};
if element.value == Value::EndOfContainer {
break;
}
match element.tag.context() {
Some(0) => set_once(
&mut write_responses,
take_array(&mut reader, &element, start)?,
)?,
Some(REVISION_TAG) => set_once(&mut revision, narrow16(element.unsigned()?)?)?,
_ => reader.skip_value(&element)?,
}
}
reader.finish()?;
Ok(Self {
write_responses: write_responses.ok_or(Error::new(ErrorCode::TlvNotFound))?,
revision,
})
}
}
pub fn encode_write_response<S>(buf: &mut [u8], statuses: S) -> Result<&[u8]>
where
S: IntoIterator<Item = crate::im::ib::AttributeStatus>,
{
let mut w = TlvWriter::new(buf);
w.start_structure(Tag::Anonymous)?;
w.start_array(Tag::Context(0))?;
for status in statuses {
status.encode(&mut w, Tag::Anonymous)?;
}
w.end_container()?;
write_revision(&mut w)?;
w.end_container()?;
w.finish()
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct InvokeRequest<'a> {
pub suppress_response: bool,
pub timed_request: bool,
invoke_requests: &'a [u8],
pub revision: Option<u16>,
}
impl<'a> InvokeRequest<'a> {
pub fn commands(&self) -> Result<ArrayIter<'a, CommandData<'a>>> {
ArrayIter::new(
self.invoke_requests,
ContainerKind::Structure,
CommandData::decode,
)
}
pub fn decode(buf: &'a [u8]) -> Result<Self> {
let mut reader = open(buf)?;
let mut suppress_response = None;
let mut timed_request = None;
let mut invoke_requests = None;
let mut revision = None;
loop {
let start = reader.position();
let Some(element) = reader.next_element()? else {
bail!(TlvTruncated)
};
if element.value == Value::EndOfContainer {
break;
}
match element.tag.context() {
Some(0) => set_once(&mut suppress_response, element.bool()?)?,
Some(1) => set_once(&mut timed_request, element.bool()?)?,
Some(2) => set_once(
&mut invoke_requests,
take_array(&mut reader, &element, start)?,
)?,
Some(REVISION_TAG) => set_once(&mut revision, narrow16(element.unsigned()?)?)?,
_ => reader.skip_value(&element)?,
}
}
reader.finish()?;
Ok(Self {
suppress_response: suppress_response.unwrap_or(false),
timed_request: timed_request.unwrap_or(false),
invoke_requests: invoke_requests.ok_or(Error::new(ErrorCode::TlvNotFound))?,
revision,
})
}
}
pub fn encode_invoke_request<'b, C>(
buf: &'b mut [u8],
commands: C,
timed_request: bool,
suppress_response: bool,
) -> Result<&'b [u8]>
where
C: IntoIterator<Item = CommandData<'b>>,
{
let mut w = TlvWriter::new(buf);
w.start_structure(Tag::Anonymous)?;
w.bool(Tag::Context(0), suppress_response)?;
w.bool(Tag::Context(1), timed_request)?;
w.start_array(Tag::Context(2))?;
for command in commands {
command.encode(&mut w)?;
}
w.end_container()?;
write_revision(&mut w)?;
w.end_container()?;
w.finish()
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct InvokeResponseMessage<'a> {
pub suppress_response: bool,
invoke_responses: &'a [u8],
pub more_chunked_messages: bool,
pub revision: Option<u16>,
}
impl<'a> InvokeResponseMessage<'a> {
pub fn responses(&self) -> Result<ArrayIter<'a, InvokeResponse<'a>>> {
ArrayIter::new(
self.invoke_responses,
ContainerKind::Structure,
InvokeResponse::decode,
)
}
pub fn decode(buf: &'a [u8]) -> Result<Self> {
let mut reader = open(buf)?;
let mut suppress_response = None;
let mut invoke_responses = None;
let mut more_chunked_messages = None;
let mut revision = None;
loop {
let start = reader.position();
let Some(element) = reader.next_element()? else {
bail!(TlvTruncated)
};
if element.value == Value::EndOfContainer {
break;
}
match element.tag.context() {
Some(0) => set_once(&mut suppress_response, element.bool()?)?,
Some(1) => set_once(
&mut invoke_responses,
take_array(&mut reader, &element, start)?,
)?,
Some(2) => set_once(&mut more_chunked_messages, element.bool()?)?,
Some(REVISION_TAG) => set_once(&mut revision, narrow16(element.unsigned()?)?)?,
_ => reader.skip_value(&element)?,
}
}
reader.finish()?;
Ok(Self {
suppress_response: suppress_response.unwrap_or(false),
invoke_responses: invoke_responses.ok_or(Error::new(ErrorCode::TlvNotFound))?,
more_chunked_messages: more_chunked_messages.unwrap_or(false),
revision,
})
}
}
pub fn encode_invoke_response<'b, R>(
buf: &'b mut [u8],
responses: R,
suppress_response: bool,
) -> Result<&'b [u8]>
where
R: IntoIterator<Item = InvokeResponse<'b>>,
{
let mut w = TlvWriter::new(buf);
w.start_structure(Tag::Anonymous)?;
w.bool(Tag::Context(0), suppress_response)?;
w.start_array(Tag::Context(1))?;
for response in responses {
response.encode(&mut w)?;
}
w.end_container()?;
write_revision(&mut w)?;
w.end_container()?;
w.finish()
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct TimedRequest {
pub timeout_ms: u16,
pub revision: Option<u16>,
}
impl TimedRequest {
#[must_use]
pub const fn new(timeout_ms: u16) -> Self {
Self {
timeout_ms,
revision: Some(INTERACTION_MODEL_REVISION),
}
}
pub fn encode<'b>(&self, buf: &'b mut [u8]) -> Result<&'b [u8]> {
let mut w = TlvWriter::new(buf);
w.start_structure(Tag::Anonymous)?;
w.unsigned(Tag::Context(0), u64::from(self.timeout_ms))?;
write_revision(&mut w)?;
w.end_container()?;
w.finish()
}
pub fn decode(buf: &[u8]) -> Result<Self> {
let mut reader = open(buf)?;
let mut timeout_ms = None;
let mut revision = None;
loop {
let Some(element) = reader.next_element()? else {
bail!(TlvTruncated)
};
if element.value == Value::EndOfContainer {
break;
}
match element.tag.context() {
Some(0) => set_once(&mut timeout_ms, narrow16(element.unsigned()?)?)?,
Some(REVISION_TAG) => set_once(&mut revision, narrow16(element.unsigned()?)?)?,
_ => reader.skip_value(&element)?,
}
}
reader.finish()?;
Ok(Self {
timeout_ms: timeout_ms.ok_or(Error::new(ErrorCode::TlvNotFound))?,
revision,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SubscribeRequest<'a> {
pub keep_subscriptions: bool,
pub min_interval_floor_s: u16,
pub max_interval_ceiling_s: u16,
attribute_requests: Option<&'a [u8]>,
event_requests: Option<&'a [u8]>,
event_filters: Option<&'a [u8]>,
data_version_filters: Option<&'a [u8]>,
pub fabric_filtered: bool,
pub revision: Option<u16>,
}
impl<'a> SubscribeRequest<'a> {
pub fn attribute_paths(&self) -> Result<Option<ArrayIter<'a, AttributePath>>> {
self.attribute_requests
.map(|bytes| ArrayIter::new(bytes, ContainerKind::List, path_from_list))
.transpose()
}
pub fn event_paths(&self) -> Result<Option<ArrayIter<'a, EventPath>>> {
self.event_requests
.map(|bytes| ArrayIter::new(bytes, ContainerKind::List, event_path_from_list))
.transpose()
}
#[must_use]
pub const fn data_version_filters_raw(&self) -> Option<&'a [u8]> {
self.data_version_filters
}
pub fn data_version_filters(&self) -> Result<Option<ArrayIter<'a, DataVersionFilter>>> {
self.data_version_filters
.map(|bytes| ArrayIter::new(bytes, ContainerKind::Structure, DataVersionFilter::decode))
.transpose()
}
#[must_use]
pub const fn event_filters_raw(&self) -> Option<&'a [u8]> {
self.event_filters
}
pub fn event_filters(&self) -> Result<Option<ArrayIter<'a, EventFilter>>> {
self.event_filters
.map(|bytes| ArrayIter::new(bytes, ContainerKind::Structure, EventFilter::decode))
.transpose()
}
pub fn decode(buf: &'a [u8]) -> Result<Self> {
let mut reader = open(buf)?;
let mut keep_subscriptions = None;
let mut min_interval_floor_s = None;
let mut max_interval_ceiling_s = None;
let mut attribute_requests = None;
let mut event_requests = None;
let mut event_filters = None;
let mut data_version_filters = None;
let mut fabric_filtered = None;
let mut revision = None;
loop {
let start = reader.position();
let Some(element) = reader.next_element()? else {
bail!(TlvTruncated)
};
if element.value == Value::EndOfContainer {
break;
}
match element.tag.context() {
Some(0) => set_once(&mut keep_subscriptions, element.bool()?)?,
Some(1) => set_once(&mut min_interval_floor_s, narrow16(element.unsigned()?)?)?,
Some(2) => set_once(&mut max_interval_ceiling_s, narrow16(element.unsigned()?)?)?,
Some(3) => set_once(
&mut attribute_requests,
take_array(&mut reader, &element, start)?,
)?,
Some(4) => set_once(
&mut event_requests,
take_array(&mut reader, &element, start)?,
)?,
Some(5) => {
set_once(
&mut event_filters,
take_array(&mut reader, &element, start)?,
)?;
}
Some(7) => set_once(&mut fabric_filtered, element.bool()?)?,
Some(8) => set_once(
&mut data_version_filters,
take_array(&mut reader, &element, start)?,
)?,
Some(REVISION_TAG) => set_once(&mut revision, narrow16(element.unsigned()?)?)?,
_ => reader.skip_value(&element)?,
}
}
reader.finish()?;
Ok(Self {
keep_subscriptions: keep_subscriptions.unwrap_or(false),
min_interval_floor_s: min_interval_floor_s.ok_or(Error::new(ErrorCode::TlvNotFound))?,
max_interval_ceiling_s: max_interval_ceiling_s
.ok_or(Error::new(ErrorCode::TlvNotFound))?,
attribute_requests,
event_requests,
event_filters,
data_version_filters,
fabric_filtered: fabric_filtered.ok_or(Error::new(ErrorCode::TlvNotFound))?,
revision,
})
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct SubscribeResponse {
pub subscription_id: u32,
pub max_interval_s: u16,
pub revision: Option<u16>,
}
impl SubscribeResponse {
#[must_use]
pub const fn new(subscription_id: u32, max_interval_s: u16) -> Self {
Self {
subscription_id,
max_interval_s,
revision: Some(INTERACTION_MODEL_REVISION),
}
}
pub fn encode<'b>(&self, buf: &'b mut [u8]) -> Result<&'b [u8]> {
let mut w = TlvWriter::new(buf);
w.start_structure(Tag::Anonymous)?;
w.unsigned(Tag::Context(0), u64::from(self.subscription_id))?;
w.unsigned(Tag::Context(2), u64::from(self.max_interval_s))?;
write_revision(&mut w)?;
w.end_container()?;
w.finish()
}
pub fn decode(buf: &[u8]) -> Result<Self> {
let mut reader = open(buf)?;
let mut subscription_id = None;
let mut max_interval_s = None;
let mut revision = None;
loop {
let Some(element) = reader.next_element()? else {
bail!(TlvTruncated)
};
if element.value == Value::EndOfContainer {
break;
}
match element.tag.context() {
Some(0) => set_once(&mut subscription_id, narrow32(element.unsigned()?)?)?,
Some(2) => set_once(&mut max_interval_s, narrow16(element.unsigned()?)?)?,
Some(REVISION_TAG) => set_once(&mut revision, narrow16(element.unsigned()?)?)?,
_ => reader.skip_value(&element)?,
}
}
reader.finish()?;
Ok(Self {
subscription_id: subscription_id.ok_or(Error::new(ErrorCode::TlvNotFound))?,
max_interval_s: max_interval_s.ok_or(Error::new(ErrorCode::TlvNotFound))?,
revision,
})
}
}
fn path_from_list(reader: &mut TlvReader<'_>) -> Result<AttributePath> {
AttributePath::decode(reader)
}
fn event_path_from_list(reader: &mut TlvReader<'_>) -> Result<EventPath> {
EventPath::decode(reader)
}
fn narrow16(value: u64) -> Result<u16> {
u16::try_from(value).map_err(|_| Error::new(ErrorCode::TlvOutOfRange))
}
fn narrow32(value: u64) -> Result<u32> {
u32::try_from(value).map_err(|_| Error::new(ErrorCode::TlvOutOfRange))
}