bacnet-server 0.11.0

BACnet server: APDU dispatch and service handlers
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136

//! Transition profiles consumed by the shared EventNotification sender.

use bacnet_objects::event::{EventStateChange, TransitionOutcome};
use bacnet_types::enums::EventType;
use bacnet_types::primitives::BACnetTimeStamp;

use super::super::event_notification_payload::CommittedNotificationPayload;
use super::super::event_timestamp::SampledEventClock;

/// One exact transition-coordinate projection from object-owned event history.
#[derive(Debug, Clone, PartialEq)]
pub(in crate::server) struct CommittedHistorySnapshot {
    pub(in crate::server) timestamp: BACnetTimeStamp,
    pub(in crate::server) message_text: Option<String>,
}

pub(in crate::server) enum CommittedMessageProjection {
    RequiredProperty,
    IntentionallyAbsent,
}

/// The source boundary for the notification's timestamp and message.
pub(in crate::server) enum NotificationHistorySource {
    /// Legacy/default objects sample their timestamp when distribution begins.
    SendTime,
    /// Atomic transitions use the exact history coordinate read after commit.
    Committed {
        snapshot: CommittedHistorySnapshot,
        recipient_clock: SampledEventClock,
    },
}

/// Whether the sender builds an ordinary event or an acknowledgment notice.
pub(in crate::server) enum NotificationConstruction {
    Event,
    Acknowledgment,
}

pub(in crate::server) struct NotificationTransition {
    pub(in crate::server) change: EventStateChange,
    pub(in crate::server) event_type: EventType,
    pub(in crate::server) history_source: NotificationHistorySource,
    pub(in crate::server) ack_required: Option<bool>,
    pub(in crate::server) event_values: Option<CommittedNotificationPayload>,
    pub(in crate::server) construction: NotificationConstruction,
}

impl NotificationTransition {
    pub(in crate::server) fn acknowledgment(
        change: EventStateChange,
        event_type: EventType,
    ) -> Self {
        Self {
            change,
            event_type,
            history_source: NotificationHistorySource::SendTime,
            ack_required: Some(false),
            event_values: None,
            construction: NotificationConstruction::Acknowledgment,
        }
    }
}

impl From<(EventStateChange, EventType)> for NotificationTransition {
    fn from((change, event_type): (EventStateChange, EventType)) -> Self {
        Self {
            change,
            event_type,
            history_source: NotificationHistorySource::SendTime,
            ack_required: None,
            event_values: None,
            construction: NotificationConstruction::Event,
        }
    }
}

/// One built-in intrinsic transition committed under the database write guard.
pub(in crate::server) struct CommittedIntrinsicTransition {
    pub(in crate::server) change: EventStateChange,
    pub(in crate::server) event_type: EventType,
    pub(in crate::server) distribute: bool,
    pub(in crate::server) history_snapshot: CommittedHistorySnapshot,
    pub(in crate::server) recipient_clock: SampledEventClock,
    pub(in crate::server) ack_required: bool,
    pub(in crate::server) event_values: Option<CommittedNotificationPayload>,
}

impl From<CommittedIntrinsicTransition> for NotificationTransition {
    fn from(committed: CommittedIntrinsicTransition) -> Self {
        Self {
            change: committed.change,
            event_type: committed.event_type,
            history_source: NotificationHistorySource::Committed {
                snapshot: committed.history_snapshot,
                recipient_clock: committed.recipient_clock,
            },
            ack_required: Some(committed.ack_required),
            event_values: committed.event_values,
            construction: NotificationConstruction::Event,
        }
    }
}

/// A server-ready intrinsic outcome under its declared object contract.
///
/// Built-ins carry their atomic commit snapshot. Legacy implementations have
/// already mutated state during evaluation and retain send-time policy and
/// timestamp sampling.
pub(in crate::server) enum ResolvedIntrinsicTransition {
    Committed(CommittedIntrinsicTransition),
    Legacy(TransitionOutcome),
}

impl ResolvedIntrinsicTransition {
    pub(in crate::server) fn distribute(&self) -> bool {
        match self {
            Self::Committed(committed) => committed.distribute,
            Self::Legacy(outcome) => outcome.distribute,
        }
    }

    pub(in crate::server) fn can_emit(&self) -> bool {
        !matches!(self, Self::Committed(committed) if committed.event_values.is_none())
    }
}

impl From<ResolvedIntrinsicTransition> for NotificationTransition {
    fn from(transition: ResolvedIntrinsicTransition) -> Self {
        match transition {
            ResolvedIntrinsicTransition::Committed(committed) => committed.into(),
            ResolvedIntrinsicTransition::Legacy(outcome) => {
                (outcome.change, outcome.event_type).into()
            }
        }
    }
}