Struct AccessPointObject 

pub struct AccessPointObject { /* private fields */ }

BACnet Access Point object (type 33).

Represents an access point (reader/controller at a door) in an access control system. The most recent access event is Access_Event; Table 12-36 has no Present_Value row, so the object serves none (#1064).

Each change of Out_Of_Service is an access event of the point’s own (Clause 12.31.8; #1248): entering out of service records OUT_OF_SERVICE and the return to service OUT_OF_SERVICE_RELINQUISHED. Recording one follows Clause 12.31.27.1, which moves Access_Event_Tag on when an event starts a new access transaction and stamps Access_Event_Time with the current date and time. The introduction to Clause 12.31 counts an operator action as an access transaction, so each change of Out_Of_Service starts a new one: the tag moves on by one (wrapping at the top of the Unsigned range), and the time comes from the Device clock. A write that leaves Out_Of_Service as it was, NULL included, records nothing. No credential or factor belongs to an edge, so each one stores the no-credential reference in Access_Event_Credential (Clause 12.31.30) and the UNDEFINED factor in Access_Event_Authentication_Factor (Clause 12.31.31).

The application’s own access events reach a point the server holds through BACnetServer::report_access_event_local (#1132), which refuses them while Out_Of_Service is TRUE: the point then performs no authentication or authorization (Clause 12.31.8), so it has no events of its own to report.

Authentication_Status is the status the application reports for its authentication process (Clause 12.31.9; #1284), READY until it reports another. While Out_Of_Service is TRUE no authentication runs, so the property reads DISABLED; the reported status is kept and served again on the return to service.

Each event the point stamps itself, an edge or a reported event with no time, gets an Access_Event_Time strictly after the one served before it, so every event moves the time (Clause 12.31.29), several events of one transaction included: the clock’s time, or one hundredth past the time served when the clock isn’t later, and with no usable clock the next sequence number (Clause 21.6). The module point_event_time has the rule.

Access_Event_Time is the Table 13-1 trigger, and each edge moves it, so each edge sends the SubscribeCOV report, which also carries the changed OUT_OF_SERVICE flag. That holds for a round trip in one WritePropertyMultiple too, where Status_Flags ends where it started. The point runs no intrinsic reporting (no ACCESS_EVENT algorithm; Event_State stays NORMAL), so an edge raises no event notification.

Active_Authentication_Policy, Number_Of_Authentication_Policies, Authentication_Policy_List, Authentication_Policy_Names, Authorization_Mode and Priority_For_Writing hold the settings the application’s authentication and authorization work from (#1307, #1325). A client picks the policy in effect and the authorization mode; the application sets the policies, the modes it carries out and the door command priority. The module point_authorization has the rules.

Reliability is CONFIGURATION_ERROR while Active_Authentication_Policy is zero, which happens when the policies leave none usable in effect (Clause 12.31.10), or while Authentication_Policy_List holds any invalid policy (Clause 12.31.12), and NO_FAULT_DETECTED otherwise. While it isn’t NO_FAULT_DETECTED the point performs no authentication and generates no access events (Clause 12.31.7), so report_access_event_local refuses them. Since it can leave NO_FAULT_DETECTED, a client may write it while Out_Of_Service is TRUE to simulate a fault, and only then (Clause 12.31.8): an Enumerated inside the BACnetReliability production, else INVALID_DATA_TYPE or VALUE_OUT_OF_RANGE, and WRITE_ACCESS_DENIED in service. Out of service the value served stays decoupled from the policies: it starts as the value served at the edge, follows only those writes, and the return to service serves the derived value again. Status_Flags carries FAULT from the value served.

Implementations

impl AccessPointObject

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

Create a new Access Point object.

pub fn set_access_event( &mut self, report: AccessEventReport, ) -> Result<(), Error>

Record the most recent access event: Access_Event, Access_Event_Tag, Access_Event_Time, Access_Event_Credential and Access_Event_Authentication_Factor, which the application’s access logic produces. They change together, as Clause 12.31.27.1 has them stored for each event; AccessEventReport documents each field.

Access_Event_Time is a BACnetTimeStamp (Clause 12.31.29) and goes out in its Clause 21 CHOICE form. A report without one is stamped strictly after the time served, from the Device clock or a sequence number, as an Out_Of_Service edge is (point_event_time). A change of the time triggers a SubscribeCOV notification; the other four only ride along (Table 13-1). Over the network all five stay read-only.

The credential, when given, names the Access Credential object behind the event; without one the point stores the no-credential reference, instance 4194303, for an event no credential belongs to or one whose credential is unknown or kept back (Clause 12.31.30). Given explicitly, that reference carries 4194303 as the object instance and, when it names a device, as the device instance too. The factor is stored as given, or the UNDEFINED factor without one (Clause 12.31.31). Refused with VALUE_OUT_OF_RANGE, with none of the five changing: a reference to another object type, one whose device identifier isn’t a Device (#1285), one with 4194303 in only one of the two instances, which is neither a credential nor the no-credential reference, a factor whose format type isn’t a named BACnetAuthenticationFactorType, and an event that is neither a named BACnetAccessEvent nor a proprietary one from 512 to 65535 (Clause 21). These rows have no network write route, so this setter is the only check.

This setter takes an event in or out of service, to set a point up before the server holds it. A running server’s route, BACnetServer::report_access_event_local, refuses one while Out_Of_Service is TRUE (#1132).

pub fn set_authentication_status( &mut self, status: AuthenticationStatus, ) -> Result<(), Error>

Report the status of the point’s authentication process (Clause 12.31.9), read-only over the network. A value outside the closed BACnetAuthenticationStatus production is refused with VALUE_OUT_OF_RANGE. While Out_Of_Service is TRUE the status is kept but DISABLED is served until the return to service.

pub fn authentication_status(&self) -> AuthenticationStatus

Authentication_Status as served: DISABLED while Out_Of_Service is TRUE, else the status last reported.

pub fn set_access_doors( &mut self, doors: impl IntoIterator<Item = impl Into<BACnetDeviceObjectReference>>, ) -> Result<(), Error>

Set Access_Doors, the Access Door objects whose Present_Value this point commands once access is granted (Clause 12.31.32). A point that commands no door keeps the array empty. A reference with no Device identifier names an object in this device.

Every reference must name an Access Door object, and a device identifier, when given, a Device object (#1285); a list breaking either rule is refused with VALUE_OUT_OF_RANGE and the doors set before are kept. The array is read-only over the network.

pub fn set_number_of_authentication_policies( &mut self, count: u32, ) -> Result<(), Error>

Set Number_Of_Authentication_Policies, how many authentication policies the application defines (Clause 12.31.11), 1 until set. It is read-only over the network. Zero is refused with VALUE_OUT_OF_RANGE.

Once Self::set_authentication_policies has set the policy arrays, they follow the count, which can then be at most MAX_AUTHENTICATION_POLICIES (VALUE_OUT_OF_RANGE above it): a smaller count drops the last policies, and a larger one adds empty policies, not enforcing order and with no timeout (Clause 12.31.12.2), each with an empty name. An empty policy is invalid, so a grown point reads Reliability CONFIGURATION_ERROR until the application fills the new policies in. A count below Active_Authentication_Policy, or one that leaves it naming an invalid policy, drops it to zero (Clause 12.31.10) until a client writes a usable policy.

pub fn set_authentication_policies( &mut self, policies: impl IntoIterator<Item = (impl Into<String>, BACnetAuthenticationPolicy)>, ) -> Result<(), Error>

Set Authentication_Policy_List and Authentication_Policy_Names, the policies the point defines, as (name, policy) pairs in policy order (Clauses 12.31.12 and 12.31.13). The point serves both arrays from then on, and Number_Of_Authentication_Policies takes the number of pairs, since both arrays are that long (Table 12-36 footnote 1). All three are read-only over the network. No pairs at all, or more than MAX_AUTHENTICATION_POLICIES, is refused with VALUE_OUT_OF_RANGE, and nothing changes.

A policy is stored as given, but only a well-formed one is usable: at least one entry, each naming a Credential Data Input object (in a Device, when it names a device), with indexes that start at 1 and, in list order, either repeat (a second factor that completes the same step) or go up by one. A client can’t make an invalid policy the active one (VALUE_OUT_OF_RANGE), and while the list holds any invalid policy Reliability reads CONFIGURATION_ERROR (Clause 12.31.12). When the new list leaves Active_Authentication_Policy beyond the count or on an invalid policy, it drops to zero (Clause 12.31.10) until a client writes a usable policy; the point doesn’t pick one itself.

pub fn set_supported_authorization_modes( &mut self, modes: impl IntoIterator<Item = AuthorizationMode>, ) -> Result<(), Error>

Set the authorization modes the application carries out, the values a write of Authorization_Mode can take (Clause 12.31.14). A new point takes AUTHORIZE alone, since the point enforces no mode itself: an application that acts on Authorization_Mode declares the other modes it carries out here. The set must hold AUTHORIZE and the mode in effect, and each mode must be a standard one or a proprietary one from 64 to 65535; otherwise it is refused with VALUE_OUT_OF_RANGE and the set before is kept. A repeated mode counts once.

pub fn set_priority_for_writing(&mut self, priority: u8) -> Result<(), Error>

Set Priority_For_Writing, the priority at which the application commands the Access_Doors after a grant (Clauses 12.31.32.1 and 12.31.33), 16 until set. It is read-only over the network. A priority outside 1..=16 is refused with VALUE_OUT_OF_RANGE.

Trait Implementations

impl BACnetObject for AccessPointObject

fn supports_cov(&self) -> bool

Table 13-1 lists Access Point, so it takes SubscribeCOV; its report leads with Access_Event, as the point has no Present_Value.

fn report_access_input_internal( &mut self, input: AccessControlInput, ) -> Result<(), Error>

Take an access event the application reports (#1132), through Self::set_access_event. Refused with WRITE_ACCESS_DENIED while Out_Of_Service is TRUE (Clause 12.31.8) or Reliability isn’t NO_FAULT_DETECTED (Clause 12.31.7), since the point performs no authentication then, and any other record with OPTIONAL_FUNCTIONALITY_NOT_SUPPORTED.

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 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 write_property_from( &mut self, property: PropertyIdentifier, array_index: Option<u32>, value: PropertyValue, priority: Option<u8>, _origin: &CommandOrigin, ) -> Result<(), Error>

Write with explicit actual command provenance. Standalone callers assert the origin; server boundaries additionally validate ingress or membership. Decorators must forward this hook without discarding the origin. The default preserves custom/unaffected object behavior. First-party source-tracked commands require this hook and deny context-free writing.

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

Whether a property write route can accept property for this object.

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

Whether property accepts an array index on this object.

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

Whether property is a BACnetLIST on this object.

fn is_createable(&self) -> bool

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

fn creation_only_properties(&self) -> &'static [PropertyIdentifier]

The properties whose whole value a CreateObject initial value may set on this object although WriteProperty can’t change it afterwards.

fn initialize_property( &mut self, _property: PropertyIdentifier, _value: PropertyValue, ) -> Result<(), Error>

Apply a CreateObject initial value to one of Self::creation_only_properties, written whole.

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_subscribe_cov_property(&self) -> bool

Whether SubscribeCOVProperty and SubscribeCOVPropertyMultiple may monitor this object’s properties.

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

Whether a readable property supports property-specific COV.

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

COV increment for this object (objects with a COV_Increment property).

fn cov_reported_properties(&self) -> &'static [CovReportedProperty]

Properties a whole-object (SubscribeCOV) notification reports after its leading value and Status_Flags, in report order.

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, _today: SpecificDate, _time: Time, _calendar_active: &dyn Fn(ObjectIdentifier) -> bool, ) -> Option<ScheduleWrite>

Evaluate this object’s schedule at time on today (Clause 12.24.4).

fn take_owed_schedule_writes(&mut self) -> Vec<ScheduleWrite>

Take the writes this schedule owes its targets apart from its calculation, each once, in order: a NULL to every priority slot a change of List_Of_Object_Property_References or Priority_For_Writing left behind (#1088), then the Present_Value owed out of service, for a client’s write (Clause 12.24.14) or a change of those two properties.

fn complete_schedule_write( &mut self, _write: &ScheduleWrite, _outcomes: &[ScheduleTargetOutcome], ) -> bool

Report how each target took write, one of this schedule’s writes: outcomes holds one entry per member of write.references, in order.

fn retry_refusals_naming( &self, _target: ObjectIdentifier, ) -> Option<ScheduleWrite>

The retry of the current value to the references whose last write was refused and that name target, an object just added to the database (#1440), so the refusal can clear without waiting for the next pass. None when no such refusal stands, or when the pass itself would retry nothing: out of service, outside Effective_Period, or with a NULL Present_Value. Only meaningful for Schedule objects; default returns None.

fn acknowledge_alarm( &mut self, _transition_bit: EventTransitionBits, ) -> Result<(), Error>

Acknowledge an alarm transition. Sets the transition_bit flags in acked_transitions. Returns Ok(()) if the object supports event detection, Err otherwise.

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

Apply a LifeSafetyOperation atomically to this object.

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

Set the next LifeSafetyOperation expected by trusted local logic.

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

Apply an internally-detected Event_State transition.

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

Snapshot this object’s Event Enrollment evaluation state, if it models one.

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

Store this object’s Event Enrollment evaluation state.

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 set_acked_transitions_internal( &mut self, _transition_bit: EventTransitionBits, _acknowledged: bool, ) -> Result<(), Error>

Set or clear one Acked_Transitions bit on a received event-state transition.

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: Reliability, ) -> 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 the local application.

fn set_present_value_from_internal( &mut self, value: PropertyValue, _origin: &CommandOrigin, ) -> Result<(), Error>

set_present_value_internal on behalf of origin, the local Device the application runs in.

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

Apply the Tracking_Value the local application derived.

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

Apply the Controlled_Variable_Value measured by the local application.

fn add_averaging_sample_internal( &mut self, _sample: Option<PropertyValue>, ) -> Result<(), Error>

Record one sample for an Averaging object.

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 log_buffer_internal(&self) -> Option<&dyn LogBufferRecords>

Borrow this object’s Log_Buffer records as ReadRange pages them.

fn add_trend_record(&mut self, _record: BACnetLogRecord) -> Result<(), Error>

Submit a trend record to an object’s log lifecycle.

fn add_trend_multiple_record( &mut self, _record: BACnetLogMultipleRecord, ) -> Result<(), Error>

Submit a Trend Log Multiple record, one value per monitored member, to an object’s log lifecycle.

fn add_event_log_record( &mut self, _record: BACnetEventLogRecord, ) -> Result<(), Error>

Submit an Event Log record to an object’s log lifecycle.