matter-clusters 0.3.0

//! OnOff cluster (0x0006).
//! @generated by `cargo xtask codegen` — do not edit.

#![allow(
    clippy::all,
    clippy::pedantic,
    dead_code,
    unreachable_pub,
    unused_imports
)]

use crate::datatypes::SemanticTagStruct;
use crate::error::ClusterError;
use crate::types::Nullable;
use matter_codec::{ContainerKind, Element, Tag, TlvReader, TlvWriter, Value};

/// Cluster ID.
pub const CLUSTER_ID: u32 = 0x0006;
/// Cluster revision.
pub const CLUSTER_REVISION: u16 = 6;

/// Command IDs (requests and responses).
pub mod command_id {
    /// `Off` (request).
    pub const OFF: u32 = 0x00;
    /// `On` (request).
    pub const ON: u32 = 0x01;
    /// `Toggle` (request).
    pub const TOGGLE: u32 = 0x02;
    /// `OffWithEffect` (request).
    pub const OFF_WITH_EFFECT: u32 = 0x40;
    /// `OnWithRecallGlobalScene` (request).
    pub const ON_WITH_RECALL_GLOBAL_SCENE: u32 = 0x41;
    /// `OnWithTimedOff` (request).
    pub const ON_WITH_TIMED_OFF: u32 = 0x42;
}

/// Attribute IDs (cluster-specific).
pub mod attribute_id {
    /// `OnOff`.
    pub const ON_OFF: u32 = 0x0000;
    /// `GlobalSceneControl`.
    pub const GLOBAL_SCENE_CONTROL: u32 = 0x4000;
    /// `OnTime`.
    pub const ON_TIME: u32 = 0x4001;
    /// `OffWaitTime`.
    pub const OFF_WAIT_TIME: u32 = 0x4002;
    /// `StartUpOnOff`.
    pub const START_UP_ON_OFF: u32 = 0x4003;
}

bitflags::bitflags! {
    /// `OnOff` feature bits (FeatureMap).
    #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
    pub struct Feature: u32 {
        /// Lighting (LT).
        const LT = 1 << 0;
        /// DeadFrontBehavior (DF).
        const DF = 1 << 1;
        /// OffOnly (OFFONLY).
        const OFFONLY = 1 << 2;
    }
}

/// `DelayedAllOffEffectVariantEnum` (enum8).
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum DelayedAllOffEffectVariantEnum {
    /// DelayedOffFastFade = 0.
    DelayedOffFastFade,
    /// NoFade = 1.
    NoFade,
    /// DelayedOffSlowFade = 2.
    DelayedOffSlowFade,
    /// A value not known to this codegen revision.
    Unknown(u8),
}

impl DelayedAllOffEffectVariantEnum {
    /// Decode from its raw discriminant (unknown → `Unknown`).
    #[must_use]
    pub fn from_raw(v: u8) -> Self {
        match v {
            0 => Self::DelayedOffFastFade,
            1 => Self::NoFade,
            2 => Self::DelayedOffSlowFade,
            other => Self::Unknown(other),
        }
    }
    /// The raw discriminant.
    #[must_use]
    pub fn to_raw(self) -> u8 {
        match self {
            Self::DelayedOffFastFade => 0,
            Self::NoFade => 1,
            Self::DelayedOffSlowFade => 2,
            Self::Unknown(v) => v,
        }
    }
}

/// `DyingLightEffectVariantEnum` (enum8).
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum DyingLightEffectVariantEnum {
    /// DyingLightFadeOff = 0.
    DyingLightFadeOff,
    /// A value not known to this codegen revision.
    Unknown(u8),
}

impl DyingLightEffectVariantEnum {
    /// Decode from its raw discriminant (unknown → `Unknown`).
    #[must_use]
    pub fn from_raw(v: u8) -> Self {
        match v {
            0 => Self::DyingLightFadeOff,
            other => Self::Unknown(other),
        }
    }
    /// The raw discriminant.
    #[must_use]
    pub fn to_raw(self) -> u8 {
        match self {
            Self::DyingLightFadeOff => 0,
            Self::Unknown(v) => v,
        }
    }
}

/// `EffectIdentifierEnum` (enum8).
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum EffectIdentifierEnum {
    /// DelayedAllOff = 0.
    DelayedAllOff,
    /// DyingLight = 1.
    DyingLight,
    /// A value not known to this codegen revision.
    Unknown(u8),
}

impl EffectIdentifierEnum {
    /// Decode from its raw discriminant (unknown → `Unknown`).
    #[must_use]
    pub fn from_raw(v: u8) -> Self {
        match v {
            0 => Self::DelayedAllOff,
            1 => Self::DyingLight,
            other => Self::Unknown(other),
        }
    }
    /// The raw discriminant.
    #[must_use]
    pub fn to_raw(self) -> u8 {
        match self {
            Self::DelayedAllOff => 0,
            Self::DyingLight => 1,
            Self::Unknown(v) => v,
        }
    }
}

bitflags::bitflags! {
    /// `OnOffControlBitmap` (map8).
    #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
    pub struct OnOffControlBitmap: u8 {
        /// AcceptOnlyWhenOn.
        const ACCEPT_ONLY_WHEN_ON = 1 << 0;
    }
}

/// `StartUpOnOffEnum` (enum8).
#[derive(Copy, Clone, Debug, PartialEq, Eq)]
pub enum StartUpOnOffEnum {
    /// Off = 0.
    Off,
    /// On = 1.
    On,
    /// Toggle = 2.
    Toggle,
    /// A value not known to this codegen revision.
    Unknown(u8),
}

impl StartUpOnOffEnum {
    /// Decode from its raw discriminant (unknown → `Unknown`).
    #[must_use]
    pub fn from_raw(v: u8) -> Self {
        match v {
            0 => Self::Off,
            1 => Self::On,
            2 => Self::Toggle,
            other => Self::Unknown(other),
        }
    }
    /// The raw discriminant.
    #[must_use]
    pub fn to_raw(self) -> u8 {
        match self {
            Self::Off => 0,
            Self::On => 1,
            Self::Toggle => 2,
            Self::Unknown(v) => v,
        }
    }
}

/// Decode the `OnOff` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_on_off(tlv: &[u8]) -> Result<bool, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Bool(v),
            ..
        }) => Ok(v),
        _ => Err(ClusterError::UnexpectedType { context: "OnOff" }),
    }
}

/// Decode the `GlobalSceneControl` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_global_scene_control(tlv: &[u8]) -> Result<bool, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Bool(v),
            ..
        }) => Ok(v),
        _ => Err(ClusterError::UnexpectedType {
            context: "GlobalSceneControl",
        }),
    }
}

/// Decode the `OnTime` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_on_time(tlv: &[u8]) -> Result<u16, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Uint(v),
            ..
        }) => Ok(u16::try_from(v).map_err(|_| ClusterError::InvalidLength("OnTime"))?),
        _ => Err(ClusterError::UnexpectedType { context: "OnTime" }),
    }
}

/// Encode the `OnTime` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_on_time(value: u16) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.put_uint(Tag::Anonymous, u64::from(value))
        .expect("infallible: vec writer");
    buf
}

/// Decode the `OffWaitTime` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_off_wait_time(tlv: &[u8]) -> Result<u16, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Uint(v),
            ..
        }) => Ok(u16::try_from(v).map_err(|_| ClusterError::InvalidLength("OffWaitTime"))?),
        _ => Err(ClusterError::UnexpectedType {
            context: "OffWaitTime",
        }),
    }
}

/// Encode the `OffWaitTime` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_off_wait_time(value: u16) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.put_uint(Tag::Anonymous, u64::from(value))
        .expect("infallible: vec writer");
    buf
}

/// Decode the `StartUpOnOff` attribute value.
///
/// # Errors
/// Returns [`ClusterError`] on a type mismatch or out-of-range value.
pub fn decode_start_up_on_off(tlv: &[u8]) -> Result<Nullable<StartUpOnOffEnum>, ClusterError> {
    let mut r = TlvReader::new(tlv);
    match r.next()? {
        Some(Element::Scalar {
            value: Value::Null, ..
        }) => Ok(Nullable::Null),
        Some(Element::Scalar {
            value: Value::Uint(v),
            ..
        }) => Ok(Nullable::Value(StartUpOnOffEnum::from_raw(
            u8::try_from(v).map_err(|_| ClusterError::InvalidLength("StartUpOnOff"))?,
        ))),
        _ => Err(ClusterError::UnexpectedType {
            context: "StartUpOnOff",
        }),
    }
}

/// Encode the `StartUpOnOff` attribute value as a standalone TLV element.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_start_up_on_off(value: Nullable<StartUpOnOffEnum>) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    match value {
        Nullable::Null => w.put_null(Tag::Anonymous).expect("infallible: vec writer"),
        Nullable::Value(value) => {
            w.put_uint(Tag::Anonymous, u64::from(value.to_raw()))
                .expect("infallible: vec writer");
        }
    }
    buf
}

/// Encode the `Off` command request payload.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_off() -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.start_structure(Tag::Anonymous)
        .expect("infallible: vec writer");
    w.end_container().expect("infallible: vec writer");
    buf
}

/// Encode the `On` command request payload.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_on() -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.start_structure(Tag::Anonymous)
        .expect("infallible: vec writer");
    w.end_container().expect("infallible: vec writer");
    buf
}

/// Encode the `Toggle` command request payload.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_toggle() -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.start_structure(Tag::Anonymous)
        .expect("infallible: vec writer");
    w.end_container().expect("infallible: vec writer");
    buf
}

/// Encode the `OffWithEffect` command request payload.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_off_with_effect(
    effect_identifier: EffectIdentifierEnum,
    effect_variant: u8,
) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.start_structure(Tag::Anonymous)
        .expect("infallible: vec writer");
    w.put_uint(Tag::Context(0), u64::from(effect_identifier.to_raw()))
        .expect("infallible: vec writer");
    w.put_uint(Tag::Context(1), u64::from(effect_variant))
        .expect("infallible: vec writer");
    w.end_container().expect("infallible: vec writer");
    buf
}

/// Encode the `OnWithRecallGlobalScene` command request payload.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_on_with_recall_global_scene() -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.start_structure(Tag::Anonymous)
        .expect("infallible: vec writer");
    w.end_container().expect("infallible: vec writer");
    buf
}

/// Encode the `OnWithTimedOff` command request payload.
#[must_use]
#[allow(clippy::expect_used, clippy::missing_panics_doc)] // Vec-backed TlvWriter is infallible.
pub fn encode_on_with_timed_off(
    on_off_control: OnOffControlBitmap,
    on_time: u16,
    off_wait_time: u16,
) -> Vec<u8> {
    let mut buf = Vec::new();
    let mut w = TlvWriter::new(&mut buf);
    w.start_structure(Tag::Anonymous)
        .expect("infallible: vec writer");
    w.put_uint(Tag::Context(0), u64::from(on_off_control.bits()))
        .expect("infallible: vec writer");
    w.put_uint(Tag::Context(1), u64::from(on_time))
        .expect("infallible: vec writer");
    w.put_uint(Tag::Context(2), u64::from(off_wait_time))
        .expect("infallible: vec writer");
    w.end_container().expect("infallible: vec writer");
    buf
}