Struct ReportContext 

pub struct ReportContext<'a, 's, B, const N: usize>
where
    B: Buffers<Vec<u8, rs_matter::::transport::exchange::Buffer::{constant#0}>> + 'a,
{ /* private fields */ }

Per-subscription context for an in-progress report.

Implementations

impl<'a, 's, B, const N: usize> ReportContext<'a, 's, B, N>

where B: Buffers<Vec<u8, rs_matter::::transport::exchange::Buffer::{constant#0}>> + 'a,

pub fn subscription(&self) -> &Subscription

Return a reference to the subscription being reported on.

pub fn rx(&self) -> &[u8]

Return a reference to the RX buffer associated with the subscription being reported on.

pub fn should_send_if_empty(&self) -> bool

Return true if the report should be sent even if it turns out to be empty (i.e. no attributes or events to report), or false if it can be skipped in that case.

pub fn should_report_attr( &self, endpoint_id: u16, cluster_id: u32, attr_id: u32, ) -> bool

Return true if the subscription should report the attribute identified by the given triple, or false if it can skip it.

pub fn max_seen_event_number(&self) -> u64

Return the maximum event number the subscription has seen so far.

pub fn next_max_seen_event_number(&self) -> u64

Return the next maximum event number to be updated into the subscription upon returning it to the table.

pub fn set_keep(&mut self)

Mark the subscription to be kept in the table after the report completes, meaning the other peer acknowledged our report.

pub fn set_keep_retry(&mut self)

Keep the subscription in the table after a failed send to the peer, so it retries — with a back-off, and without advancing its watermarks or its last-success timestamp.

Three things happen, each of which matters:

• Watermarks are preserved. Self::set_keep is only correct after a delivered report: report() captured the current change/event watermarks as “what this report covers”, and committing them would mark the still-unsent changes/events as seen — they would then never be reported. We restore the last actually-reported values so the pending data is re-attempted.
• reported_at is preserved (not advanced to now). is_expired measures max_int from reported_at, so keeping it pinned to the last successful report means a run of failures eventually expires the subscription instead of retrying it forever.
• A back-off is scheduled. retry_at is pushed to a growing (capped) delay from now, so an unreachable peer is retried with exponential back-off rather than in a tight loop that would flood the network.

Trait Implementations

impl<'a, 's, B, const N: usize> Drop for ReportContext<'a, 's, B, N>

where B: Buffers<Vec<u8, rs_matter::::transport::exchange::Buffer::{constant#0}>> + 'a,

fn drop(&mut self)

Executes the destructor for this type.

fn pin_drop(self: Pin<&mut Self>)

🔬This is a nightly-only experimental API. (pin_ergonomics)

Execute the destructor for this type, but different to Drop::drop, it requires self to be pinned.