bacnet_encoding/constructed/event_notification/

parameters_decode.rs

use super::decode_helpers::{
    closing_tag_start, decode_context_status_flags, decode_context_u16, decode_context_value,
    finish_variant as check_variant_end,
};
use super::decode_timer::{decode_change_of_discrete_value, decode_change_of_timer};
use super::structured::{decode_access_event, decode_complex_event_type};
use super::*;
use crate::constructed::tagged::decode_ctx_character_string;

/// Decode one notification-parameter choice, with an optional enclosing `[12]` close.
pub fn decode_notification_parameters(
    data: &[u8],
    offset: usize,
) -> Result<NotificationParameters, Error> {
    let end = closing_tag_start(data, data.len(), 12, "NotificationParameters event-values")
        .unwrap_or(data.len());
    decode_bounded(data, offset, end)
}

/// Decode one notification-parameter choice that ends exactly at `end`.
pub(super) fn decode_bounded(
    data: &[u8],
    offset: usize,
    end: usize,
) -> Result<NotificationParameters, Error> {
    let data = data
        .get(..end)
        .ok_or_else(|| Error::decoding(end, "NotificationParameters boundary exceeds input"))?;
    let framed = data
        .get(offset..)
        .ok_or_else(|| Error::decoding(offset, "NotificationParameters offset exceeds input"))?;
    // Peek the inner opening tag to determine the variant
    if offset >= data.len() {
        return Err(Error::missing(
            offset,
            "NotificationParameters: empty payload",
        ));
    }
    let (inner_tag, inner_start) = tags::decode_tag(data, offset)?;
    if !inner_tag.is_opening {
        return Err(misplaced_tag(
            data,
            &inner_tag,
            None,
            offset,
            "NotificationParameters: expected opening tag for variant",
        ));
    }
    let variant_tag = inner_tag.number;
    if variant_tag == 6 {
        let (_, next) = tags::extract_context_value(data, inner_start, 6)?;
        if next != data.len() {
            return Err(Error::trailing(
                next,
                "ComplexEventType has trailing encoded fields",
            ));
        }
    } else {
        validate_tlv_sequence(framed, "NotificationParameters")?;
    }
    let variant_body_end = closing_tag_start(
        data,
        data.len(),
        variant_tag,
        "NotificationParameters variant",
    )?;
    let finish_variant =
        |value, consumed| check_variant_end(value, consumed, variant_body_end, variant_tag);

    match variant_tag {
        // [1] Change of state
        1 => {
            let mut pos = inner_start;
            // [0] new-state: BACnetPropertyStates — wrapped in opening/closing [0]
            let (t, p) = tags::decode_tag(data, pos)?;
            if !t.is_opening || t.number != 0 {
                return Err(misplaced_tag(
                    data,
                    &t,
                    Some(0),
                    pos,
                    "ChangeOfState: expected opening tag [0] for new-state",
                ));
            }
            pos = p;
            let new_state = decode_property_states(data, &mut pos)?;
            // Skip closing tag [0]
            let (ct, cp) = tags::decode_tag(data, pos)?;
            if !ct.is_closing || ct.number != 0 {
                return Err(Error::decoding_kind(
                    unclosed_kind(&ct),
                    pos,
                    "ChangeOfState: expected closing [0]",
                ));
            }
            pos = cp;
            // [1] status-flags
            let (status_flags, pos) =
                decode_context_status_flags(data, pos, 1, "ChangeOfState status-flags")?;
            finish_variant(
                NotificationParameters::ChangeOfState {
                    new_state,
                    status_flags,
                },
                pos,
            )
        }
        // [2] Change of value
        2 => {
            let mut pos = inner_start;
            // [0] new-value CHOICE — wrapped in opening/closing [0]
            let (t, p) = tags::decode_tag(data, pos)?;
            if !t.is_opening || t.number != 0 {
                return Err(misplaced_tag(
                    data,
                    &t,
                    Some(0),
                    pos,
                    "ChangeOfValue: expected opening [0] for new-value",
                ));
            }
            pos = p;
            // Peek CHOICE tag
            let (choice_tag, _) = tags::decode_tag(data, pos)?;
            let new_value = match choice_tag.number {
                0 if choice_tag.is_context(0) => {
                    let ((unused_bits, data), end) = decode_context_value(
                        data,
                        pos,
                        0,
                        "ChangeOfValue changed-bits",
                        primitives::decode_bit_string,
                    )?;
                    pos = end;
                    ChangeOfValueChoice::ChangedBits { unused_bits, data }
                }
                1 if choice_tag.is_context(1) => {
                    let (value, end) = decode_context_value(
                        data,
                        pos,
                        1,
                        "ChangeOfValue changed-value",
                        primitives::decode_real,
                    )?;
                    pos = end;
                    ChangeOfValueChoice::ChangedValue(value)
                }
                _ => {
                    return Err(misplaced_tag(
                        data,
                        &choice_tag,
                        None,
                        pos,
                        "ChangeOfValue: expected context choice [0] or [1]",
                    ));
                }
            };
            // Closing tag [0]
            let (ct, cp) = tags::decode_tag(data, pos)?;
            if !ct.is_closing || ct.number != 0 {
                return Err(Error::decoding_kind(
                    unclosed_kind(&ct),
                    pos,
                    "ChangeOfValue: expected closing [0]",
                ));
            }
            pos = cp;
            // [1] status-flags
            let (status_flags, pos) =
                decode_context_status_flags(data, pos, 1, "ChangeOfValue status-flags")?;
            finish_variant(
                NotificationParameters::ChangeOfValue {
                    new_value,
                    status_flags,
                },
                pos,
            )
        }
        // [5] Out of range
        5 => {
            // [0] exceeding-value
            let (exceeding_value, pos) = decode_context_value(
                data,
                inner_start,
                0,
                "OutOfRange exceeding-value",
                primitives::decode_real,
            )?;
            // [1] status-flags
            let (status_flags, pos) =
                decode_context_status_flags(data, pos, 1, "OutOfRange status-flags")?;
            // [2] deadband
            let (deadband, pos) =
                decode_context_value(data, pos, 2, "OutOfRange deadband", primitives::decode_real)?;
            // [3] exceeded-limit
            let (exceeded_limit, pos) = decode_context_value(
                data,
                pos,
                3,
                "OutOfRange exceeded-limit",
                primitives::decode_real,
            )?;
            finish_variant(
                NotificationParameters::OutOfRange {
                    exceeding_value,
                    status_flags,
                    deadband,
                    exceeded_limit,
                },
                pos,
            )
        }
        // [6] Complex event type
        6 => decode_complex_event_type(data, inner_start, variant_body_end),
        // [10] Buffer ready
        10 => {
            let mut pos = inner_start;
            // [0] buffer-property: BACnetDeviceObjectPropertyReference
            let (t, p) = tags::decode_tag(data, pos)?;
            if !t.is_opening || t.number != 0 {
                return Err(misplaced_tag(
                    data,
                    &t,
                    Some(0),
                    pos,
                    "BufferReady: expected opening [0] for buffer-property",
                ));
            }
            pos = p;
            let buffer_property = decode_device_obj_prop_ref(data, &mut pos)?;
            // Closing tag [0]
            let (ct, cp) = tags::decode_tag(data, pos)?;
            if !ct.is_closing || ct.number != 0 {
                return Err(Error::decoding_kind(
                    unclosed_kind(&ct),
                    pos,
                    "BufferReady: expected closing [0]",
                ));
            }
            pos = cp;
            // [1] previous-notification
            let (previous_notification, pos) =
                decode_context_u32(data, pos, 1, "BufferReady previous-notification")?;
            // [2] current-notification
            let (current_notification, end) =
                decode_context_u32(data, pos, 2, "BufferReady current-notification")?;
            finish_variant(
                NotificationParameters::BufferReady {
                    buffer_property,
                    previous_notification,
                    current_notification,
                },
                end,
            )
        }
        // [11] Unsigned range
        11 => {
            // [0] exceeding-value
            let (exceeding_value, pos) = decode_context_value(
                data,
                inner_start,
                0,
                "UnsignedRange exceeding-value",
                primitives::decode_unsigned,
            )?;
            // [1] status-flags
            let (status_flags, pos) =
                decode_context_status_flags(data, pos, 1, "UnsignedRange status-flags")?;
            // [2] exceeded-limit
            let (exceeded_limit, pos) = decode_context_value(
                data,
                pos,
                2,
                "UnsignedRange exceeded-limit",
                primitives::decode_unsigned,
            )?;
            finish_variant(
                NotificationParameters::UnsignedRange {
                    exceeding_value,
                    status_flags,
                    exceeded_limit,
                },
                pos,
            )
        }
        // [0] Change of bitstring
        0 => {
            // [0] referenced-bitstring
            let ((unused, bits), pos) = decode_context_value(
                data,
                inner_start,
                0,
                "ChangeOfBitstring referenced-bitstring",
                primitives::decode_bit_string,
            )?;
            // [1] status-flags
            let (status_flags, pos) =
                decode_context_status_flags(data, pos, 1, "ChangeOfBitstring status-flags")?;
            finish_variant(
                NotificationParameters::ChangeOfBitstring {
                    referenced_bitstring: (unused, bits),
                    status_flags,
                },
                pos,
            )
        }
        // [3] Command failure
        3 => {
            let mut pos = inner_start;
            // [0] command-value — opening/closing, raw
            let (t, p) = tags::decode_tag(data, pos)?;
            if !t.is_opening || t.number != 0 {
                return Err(misplaced_tag(
                    data,
                    &t,
                    Some(0),
                    pos,
                    "CommandFailure: expected opening [0]",
                ));
            }
            let (command_value, after) = extract_raw_context(data, p, 0)?;
            pos = after;
            // [1] status-flags
            let (status_flags, pos) =
                decode_context_status_flags(data, pos, 1, "CommandFailure status-flags")?;
            // [2] feedback-value — opening/closing, raw
            let (t, p) = tags::decode_tag(data, pos)?;
            if !t.is_opening || t.number != 2 {
                return Err(misplaced_tag(
                    data,
                    &t,
                    Some(2),
                    pos,
                    "CommandFailure: expected opening [2]",
                ));
            }
            let (feedback_value, after) = extract_raw_context(data, p, 2)?;
            finish_variant(
                NotificationParameters::CommandFailure {
                    command_value,
                    status_flags,
                    feedback_value,
                },
                after,
            )
        }
        // [4] Floating limit
        4 => {
            // [0] reference-value
            let (reference_value, pos) = decode_context_value(
                data,
                inner_start,
                0,
                "FloatingLimit reference-value",
                primitives::decode_real,
            )?;
            // [1] status-flags
            let (status_flags, pos) =
                decode_context_status_flags(data, pos, 1, "FloatingLimit status-flags")?;
            // [2] setpoint-value
            let (setpoint_value, pos) = decode_context_value(
                data,
                pos,
                2,
                "FloatingLimit setpoint-value",
                primitives::decode_real,
            )?;
            // [3] error-limit
            let (error_limit, pos) = decode_context_value(
                data,
                pos,
                3,
                "FloatingLimit error-limit",
                primitives::decode_real,
            )?;
            finish_variant(
                NotificationParameters::FloatingLimit {
                    reference_value,
                    status_flags,
                    setpoint_value,
                    error_limit,
                },
                pos,
            )
        }
        // [8] Change of life safety
        8 => {
            let (new_state, pos) = decode_context_enum(
                data,
                inner_start,
                0,
                "ChangeOfLifeSafety new-state",
                LifeSafetyState::from_raw,
            )?;
            let (new_mode, pos) = decode_context_enum(
                data,
                pos,
                1,
                "ChangeOfLifeSafety new-mode",
                LifeSafetyMode::from_raw,
            )?;
            let (status_flags, pos) =
                decode_context_status_flags(data, pos, 2, "ChangeOfLifeSafety status-flags")?;
            let (operation_expected, pos) = decode_context_enum(
                data,
                pos,
                3,
                "ChangeOfLifeSafety operation-expected",
                LifeSafetyOperation::from_raw,
            )?;
            finish_variant(
                NotificationParameters::ChangeOfLifeSafety {
                    new_state,
                    new_mode,
                    status_flags,
                    operation_expected,
                },
                pos,
            )
        }
        // [9] Extended
        9 => {
            // [0] vendor-id
            let (vendor_id, pos) = decode_context_u16(data, inner_start, 0, "Extended vendor-id")?;
            // [1] extended-event-type
            let (extended_event_type, pos) =
                decode_context_u32(data, pos, 1, "Extended extended-event-type")?;
            // [2] parameters — opening/closing, raw
            let (t, p) = tags::decode_tag(data, pos)?;
            if !t.is_opening_tag(2) {
                return Err(misplaced_tag(
                    data,
                    &t,
                    Some(2),
                    pos,
                    "Extended: expected opening [2]",
                ));
            }
            let (parameters, after) = extract_raw_context(data, p, 2)?;
            finish_variant(
                NotificationParameters::Extended {
                    vendor_id,
                    extended_event_type,
                    parameters,
                },
                after,
            )
        }
        // [13] Access event
        13 => decode_access_event(data, inner_start, variant_body_end),
        // [14] Double out of range
        14 => {
            // [0] exceeding-value
            let (exceeding_value, pos) = decode_context_value(
                data,
                inner_start,
                0,
                "DoubleOutOfRange exceeding-value",
                primitives::decode_double,
            )?;
            // [1] status-flags
            let (status_flags, pos) =
                decode_context_status_flags(data, pos, 1, "DoubleOutOfRange status-flags")?;
            // [2] deadband
            let (deadband, pos) = decode_context_value(
                data,
                pos,
                2,
                "DoubleOutOfRange deadband",
                primitives::decode_double,
            )?;
            // [3] exceeded-limit
            let (exceeded_limit, pos) = decode_context_value(
                data,
                pos,
                3,
                "DoubleOutOfRange exceeded-limit",
                primitives::decode_double,
            )?;
            finish_variant(
                NotificationParameters::DoubleOutOfRange {
                    exceeding_value,
                    status_flags,
                    deadband,
                    exceeded_limit,
                },
                pos,
            )
        }
        // [15] Signed out of range
        15 => {
            // [0] exceeding-value
            let (exceeding_value, pos) = decode_context_value(
                data,
                inner_start,
                0,
                "SignedOutOfRange exceeding-value",
                primitives::decode_signed,
            )?;
            // [1] status-flags
            let (status_flags, pos) =
                decode_context_status_flags(data, pos, 1, "SignedOutOfRange status-flags")?;
            // [2] deadband
            let (deadband, pos) = decode_context_value(
                data,
                pos,
                2,
                "SignedOutOfRange deadband",
                primitives::decode_unsigned,
            )?;
            // [3] exceeded-limit
            let (exceeded_limit, pos) = decode_context_value(
                data,
                pos,
                3,
                "SignedOutOfRange exceeded-limit",
                primitives::decode_signed,
            )?;
            finish_variant(
                NotificationParameters::SignedOutOfRange {
                    exceeding_value,
                    status_flags,
                    deadband,
                    exceeded_limit,
                },
                pos,
            )
        }
        // [16] Unsigned out of range
        16 => {
            // [0] exceeding-value
            let (exceeding_value, pos) = decode_context_value(
                data,
                inner_start,
                0,
                "UnsignedOutOfRange exceeding-value",
                primitives::decode_unsigned,
            )?;
            // [1] status-flags
            let (status_flags, pos) =
                decode_context_status_flags(data, pos, 1, "UnsignedOutOfRange status-flags")?;
            // [2] deadband
            let (deadband, pos) = decode_context_value(
                data,
                pos,
                2,
                "UnsignedOutOfRange deadband",
                primitives::decode_unsigned,
            )?;
            // [3] exceeded-limit
            let (exceeded_limit, pos) = decode_context_value(
                data,
                pos,
                3,
                "UnsignedOutOfRange exceeded-limit",
                primitives::decode_unsigned,
            )?;
            finish_variant(
                NotificationParameters::UnsignedOutOfRange {
                    exceeding_value,
                    status_flags,
                    deadband,
                    exceeded_limit,
                },
                pos,
            )
        }
        // [17] Change of characterstring
        17 => {
            // [0] changed-value
            let (changed_value, pos) = decode_ctx_character_string(
                data,
                inner_start,
                0,
                "ChangeOfCharacterstring changed-value",
            )?;
            // [1] status-flags
            let (status_flags, pos) =
                decode_context_status_flags(data, pos, 1, "ChangeOfCharacterstring status-flags")?;
            // [2] alarm-value
            let (alarm_value, new_pos) =
                decode_ctx_character_string(data, pos, 2, "ChangeOfCharacterstring alarm-value")?;
            finish_variant(
                NotificationParameters::ChangeOfCharacterstring {
                    changed_value,
                    status_flags,
                    alarm_value,
                },
                new_pos,
            )
        }
        // [18] Change of status flags
        18 => {
            let mut pos = inner_start;
            // [0] present-value — opening/closing, raw, optional
            let (t, p) = tags::decode_tag(data, pos)?;
            let present_value = if t.is_opening_tag(0) {
                let (value, after) = extract_raw_context(data, p, 0)?;
                pos = after;
                Some(value)
            } else {
                None
            };
            // [1] referenced-flags
            let (referenced_flags, pos) =
                decode_context_status_flags(data, pos, 1, "ChangeOfStatusFlags referenced-flags")?;
            finish_variant(
                NotificationParameters::ChangeOfStatusFlags {
                    present_value,
                    referenced_flags,
                },
                pos,
            )
        }
        // [19] Change of reliability
        19 => {
            // [0] reliability
            let (reliability, pos) = decode_context_enum(
                data,
                inner_start,
                0,
                "ChangeOfReliability reliability",
                Reliability::from_raw,
            )?;
            // [1] status-flags
            let (status_flags, pos) =
                decode_context_status_flags(data, pos, 1, "ChangeOfReliability status-flags")?;
            // [2] property-values — opening/closing, raw
            let (t, p) = tags::decode_tag(data, pos)?;
            if !t.is_opening_tag(2) {
                return Err(misplaced_tag(
                    data,
                    &t,
                    Some(2),
                    pos,
                    "ChangeOfReliability: expected opening [2]",
                ));
            }
            let (property_values, after) = extract_raw_context(data, p, 2)?;
            finish_variant(
                NotificationParameters::ChangeOfReliability {
                    reliability,
                    status_flags,
                    property_values,
                },
                after,
            )
        }
        // [21] Change of discrete value
        21 => decode_change_of_discrete_value(data, inner_start, variant_body_end),
        // [22] Change of timer
        22 => decode_change_of_timer(data, inner_start, variant_body_end),
        other => Err(Error::invalid_tag(
            offset,
            format!("NotificationParameters variant [{other}] unknown"),
        )),
    }
}