Skip to main content

bacnet_objects/event_enrollment/
transition.rs

1use crate::event::history::{EventHistory, EventTransitionState};
2use crate::event::{EventTransitionCommit, EventTransitionCommitError};
3use bacnet_types::enums::{EventState, Reliability};
4
5/// All object-owned values needed to commit Event Enrollment Reliability.
6///
7/// A transition is present whenever a Reliability observation indicates a
8/// FAULT entry, re-entry, or recovery. Keeping it optional also permits an
9/// idempotent Reliability-only commit without fabricating event history.
10#[derive(Debug, Clone, PartialEq)]
11pub struct EventEnrollmentReliabilityCommit {
12    /// Desired value of the Event Enrollment object's Reliability property.
13    pub reliability: Reliability,
14    /// Event transition to commit atomically with Reliability, when indicated.
15    pub transition: Option<EventTransitionCommit>,
16}
17
18pub(super) fn commit_event_transition(
19    event_state: &mut u32,
20    acked_transitions: &mut u8,
21    event_history: &mut EventHistory,
22    commit: EventTransitionCommit,
23) -> Result<(), EventTransitionCommitError> {
24    // Event Enrollment stores Event_State as its wire enumeration. Stage
25    // typed and cloned locals so validation and kernel mutation complete
26    // before any object-owned field changes.
27    let mut typed_event_state = EventState::from_raw(*event_state);
28    let mut staged_acknowledgments = *acked_transitions;
29    let mut staged_history = event_history.clone();
30    EventTransitionState::new(
31        &mut typed_event_state,
32        &mut staged_acknowledgments,
33        &mut staged_history,
34    )
35    .commit(commit)?;
36
37    *event_state = typed_event_state.to_raw();
38    *acked_transitions = staged_acknowledgments;
39    *event_history = staged_history;
40    Ok(())
41}
42
43pub(super) fn commit_reliability(
44    reliability: &mut u32,
45    event_state: &mut u32,
46    acked_transitions: &mut u8,
47    event_history: &mut EventHistory,
48    commit: EventEnrollmentReliabilityCommit,
49) -> Result<(), EventTransitionCommitError> {
50    // Reliability is staged alongside the three event-transition stores. A
51    // rejected transition therefore leaves all four properties unchanged.
52    let staged_reliability = commit.reliability.to_raw();
53    let mut typed_event_state = EventState::from_raw(*event_state);
54    let mut staged_acknowledgments = *acked_transitions;
55    let mut staged_history = event_history.clone();
56
57    if let Some(transition) = commit.transition {
58        EventTransitionState::new(
59            &mut typed_event_state,
60            &mut staged_acknowledgments,
61            &mut staged_history,
62        )
63        .commit(transition)?;
64    }
65
66    *reliability = staged_reliability;
67    *event_state = typed_event_state.to_raw();
68    *acked_transitions = staged_acknowledgments;
69    *event_history = staged_history;
70    Ok(())
71}
72
73macro_rules! impl_event_enrollment_transition_commit {
74    () => {
75        fn commit_event_transition_internal(
76            &mut self,
77            commit: EventTransitionCommit,
78        ) -> Result<(), EventTransitionCommitError> {
79            transition::commit_event_transition(
80                &mut self.event_state,
81                &mut self.acked_transitions,
82                &mut self.event_history,
83                commit,
84            )
85        }
86
87        fn commit_event_enrollment_reliability_internal(
88            &mut self,
89            commit: $crate::event_enrollment::EventEnrollmentReliabilityCommit,
90        ) -> Result<(), EventTransitionCommitError> {
91            transition::commit_reliability(
92                &mut self.reliability,
93                &mut self.event_state,
94                &mut self.acked_transitions,
95                &mut self.event_history,
96                commit,
97            )
98        }
99    };
100}
101
102pub(super) use impl_event_enrollment_transition_commit;