Struct EventEnrollmentObject 

pub struct EventEnrollmentObject { /* private fields */ }

BACnet EventEnrollment object.

Provides algorithmic event detection for a referenced object property. The event_parameters are stored as a structured BACnetEventParameter, preserving algorithm alternatives and unknown (vendor/reserved) values across a complete property round trip.

Implementations

impl EventEnrollmentObject

pub fn new( instance: u32, name: impl Into<String>, event_type: u32, ) -> Result<Self, Error>

Create a new EventEnrollment object.

event_type is the BACnet EventType enumeration value.

pub fn set_description(&mut self, desc: impl Into<String>)

Set the description string.

pub fn set_object_property_reference( &mut self, reference: Option<BACnetDeviceObjectPropertyReference>, )

Set the object property reference.

pub fn set_event_parameters(&mut self, params: BACnetEventParameter)

Set the structured event parameters.

pub fn set_fault_parameters(&mut self, fp: Option<FaultParameters>)

Set the fault parameters for this event enrollment.

pub fn set_event_state(&mut self, state: u32)

Set the event state (raw u32).

A configuration/seeding helper, not a lifecycle path — the evaluator uses BACnetObject::set_event_state_internal. It honors the same Clause 13.2.2.1 rule: while Event_Detection_Enable is FALSE the object must read NORMAL, so a non-NORMAL seed is ignored rather than silently breaking the invariant. Without this the public API would offer a way around a guard the rest of the object enforces.

pub fn set_notification_class(&mut self, nc: u32)

Set the notification class.

pub fn set_event_enable(&mut self, enable: u8)

Set the event enable bitmask (3 bits: TO_OFFNORMAL, TO_FAULT, TO_NORMAL).

pub fn set_time_delay_normal(&mut self, delay: Option<u32>)

Set Time_Delay_Normal (the pTimeDelayNormal parameter). None restores the not-configured case, which takes on the Event_Parameters Time_Delay value (Clause 13.3 fallback).

Trait Implementations

impl BACnetObject for EventEnrollmentObject

fn set_event_state_internal(&mut self, state: EventState) -> Result<(), Error>

Internal lifecycle path for the algorithmically-derived Event_State.

The evaluator calls this — not write_property(EVENT_STATE, …) — so the network route (which rejects EVENT_STATE) and the internal lifecycle path are distinct (issue #130). Stores the modeled state verbatim; the only caller is the trusted server evaluator.

Refuses any non-NORMAL state while Event_Detection_Enable is FALSE. Clause 13.2.2.1 requires that “no transitions shall occur” in that case, and the server evaluator already skips such objects — this guard makes the invariant hold by construction rather than by the caller remembering, so a future caller cannot reintroduce the violation.

fn enrollment_eval_state_internal(&self) -> Option<EventEnrollmentEvalState>

Snapshot the pending countdown and algorithm baselines for the server evaluator.

fn set_enrollment_eval_state_internal( &mut self, state: EventEnrollmentEvalState, ) -> Result<(), Error>

Store the enrollment evaluation state. Refused while Event_Detection_Enable is FALSE: Clause 13.2.2.1 freezes the state machine (“this state machine is not evaluated”), and the reset in the write arm has already returned these fields to their initial condition, so a write arriving while disabled can only be stale.

fn acknowledge_alarm(&mut self, transition_bit: u8) -> Result<(), Error>

Acknowledge an alarm transition (the AcknowledgeAlarm service route, Clause 13.9): Clause 13.2.3 sets the bit on the acknowledgment indication — unconditional and idempotent, so a repeated ack succeeds again. A detection-DISABLED enrollment instead refuses with OBJECT/NO_ALARM_CONFIGURED, Table 13-10’s “The object exists but does not support or is not configured for event generation”: it can generate nothing, and Clause 12.12 keeps its Acked_Transitions at the initial condition, which an accepted ack would break. Out_Of_Service does not gate the ack: no clause bars acknowledging a notification already issued while the object is out of service.

fn set_acked_transitions_internal( &mut self, transition_bit: u8, acknowledged: bool, ) -> Result<(), Error>

Clause 13.2.3’s transition-received maintenance of Acked_Transitions: the evaluator resolves Ack_Required from the referenced Notification Class object and this call applies the outcome — clear the bit when ack is required, set it otherwise. Refused while detection is disabled, the same invariant as above: “Acked_Transitions shall be equal to [its] initial condition” while FALSE.

fn is_writable_property(&self, property: PropertyIdentifier) -> bool

Mirrors the write_property arms above, so PICS reports what dispatch actually accepts.

Enumerated rather than reusing common::is_event_property_writable: that helper covers the intrinsic-reporting objects and includes HIGH_LIMIT, LOW_LIMIT, DEADBAND, LIMIT_ENABLE and TIME_DELAY, none of which an Event Enrollment accepts — it carries those inside Event_Parameters instead. Reusing it would over-report writability. TIME_DELAY_NORMAL overlaps the helper: an enrollment carries THAT one as a real (O-coded) property, per Table 12-14.

Event_Detection_Enable is writable even though Table 12-14 codes it R rather than W: Clause 12.1.2 allows an R property to be writable “at the implementor’s option unless specifically prohibited in the text describing that particular standard object’s property”, and Clause 12.12 prohibits nothing — it only says the value “is expected” to be set during configuration, which is guidance, not a “shall”. Annex K’s AE-AVM-A BIBB (Table K-17) positively requires a conforming workstation to be able to write this property, so refusing the write would be interoperably hostile.

fn object_identifier(&self) -> ObjectIdentifier

The object’s identifier (type + instance).

fn object_name(&self) -> &str

The object’s name.

fn read_property( &self, property: PropertyIdentifier, array_index: Option<u32>, ) -> Result<PropertyValue, Error>

Read a property value.

fn write_property( &mut self, property: PropertyIdentifier, _array_index: Option<u32>, value: PropertyValue, _priority: Option<u8>, ) -> Result<(), Error>

Write a property value.

fn enrollment_eval_source_internal( &self, ) -> Option<Option<EventEnrollmentMonitoredSource>>

Snapshot the monitored source that owns Event Enrollment private state.

fn set_enrollment_eval_source_internal( &mut self, source: Option<EventEnrollmentMonitoredSource>, ) -> Result<(), Error>

Store or clear the monitored source that owns Event Enrollment state.

fn property_metadata(&self) -> Cow<'_, [PropertyMetadata]>

Return canonical metadata for this object’s effective property rows.

fn property_list(&self) -> Cow<'static, [PropertyIdentifier]>

List all properties this object supports in the legacy projection.

fn is_array_property(&self, property: PropertyIdentifier) -> bool

Whether property accepts an array index on this object.

fn is_createable(&self) -> bool

Whether this object type can be created at runtime via CreateObject.

fn is_deleteable(&self) -> bool

Whether this object type can be deleted at runtime via DeleteObject.

fn required_properties(&self) -> Cow<'static, [PropertyIdentifier]>

List the REQUIRED properties for this object type.

fn supports_cov(&self) -> bool

Whether this object type supports COV notifications.

fn supports_cov_property(&self, property: PropertyIdentifier) -> bool

Whether a readable property supports property-specific COV.

fn cov_increment(&self) -> Option<f32>

COV increment for this object (analog objects only).

fn set_overridden(&mut self, _overridden: bool)

Set the OVERRIDDEN bit in StatusFlags.

fn evaluate_intrinsic_reporting(&mut self) -> Option<TransitionOutcome>

Evaluate intrinsic reporting after a present_value change.

fn tick_intrinsic_reporting(&mut self) -> Option<TransitionOutcome>

Advance the Time_Delay countdown for a pending transition.

fn tick_schedule( &mut self, _day_of_week: u8, _hour: u8, _minute: u8, ) -> Option<(PropertyValue, Vec<(ObjectIdentifier, u32)>)>

Evaluate this object’s schedule for the given time.

fn apply_life_safety_operation( &mut self, _operation: LifeSafetyOperation, ) -> Result<LifeSafetyOperationEffect, Error>

Apply a LifeSafetyOperation atomically to this object.

fn apply_life_safety_operation_detailed( &mut self, operation: LifeSafetyOperation, ) -> Result<LifeSafetyOperationOutcome, Error>

Apply a LifeSafetyOperation and report exact known property deltas.

fn set_life_safety_operation_expected_internal( &mut self, _operation: LifeSafetyOperation, ) -> Result<(), Error>

Set the next LifeSafetyOperation expected by trusted local logic.

fn evaluate_reliability_internal( &mut self, ) -> Result<ReliabilityEvaluation, Error>

Evaluate and, when necessary, mutate this object’s Reliability.

fn set_reliability_internal(&mut self, _reliability: u32) -> Result<(), Error>

Apply an internally-derived Reliability value.

fn set_present_value_internal( &mut self, _value: PropertyValue, ) -> Result<(), Error>

Apply the logical Present_Value supplied by an Input’s application.

fn audit_log_storage_internal(&self) -> Option<&dyn AuditLogStorage>

Borrow this object’s Audit Log query storage, if it has any.

fn audit_log_notification_sink_internal( &mut self, ) -> Option<&mut dyn AuditLogNotificationSink>

Mutably borrow this object’s Audit notification receiver capability.

fn file_storage_internal(&self) -> Option<&dyn FileStorage>

Borrow this object’s File storage, if it has any.

fn file_storage_internal_mut(&mut self) -> Option<&mut dyn FileStorage>

Mutably borrow this object’s File storage, if it has any.

fn log_record_identities_internal(&self) -> Option<Vec<LogRecordIdentity>>

Return stable identities aligned with this object’s resident log records.

fn add_trend_record(&mut self, _record: BACnetLogRecord)

Add a trend log record (only meaningful for TrendLog / TrendLogMultiple).