Struct AccessRightsObject 

pub struct AccessRightsObject { /* private fields */ }

BACnet Access Rights object (type 34).

Holds the positive and negative access rules that credentials and users are assigned. Both rule arrays are BACnetARRAYs of BACnetAccessRule. The application provisions them with set_positive_access_rules and set_negative_access_rules, and peers write them whole, one element at a time, or resize them at index 0, with the setters’ checks. Enable (property 133, LOG_ENABLE in PropertyIdentifier) switches the whole object: while it is FALSE every rule in both arrays counts as disabled (Clause 12.34.8). The optional Accompaniment row (#1393) is served once the application sets it with set_accompaniment. The object stores the rules, the flag and the accompaniment without evaluating them; the application checks a credential against the rules with evaluate_access_rights (#1331).

Restarts

An object built with new keeps everything in memory, so a restart brings back what the application configures. One built with with_persistence saves each write of the two arrays, Enable and Accompaniment in an AccessRightsPersistence before serving it, and serves the saved values when built again (#1392). A saved value wins over the configured one: the setter for a property a write set (property_saved) checks its argument but leaves the property alone. To change a saved value, write the property.

Implementations

impl AccessRightsObject

pub fn with_persistence( instance: u32, name: impl Into<String>, persistence: Arc<dyn AccessRightsPersistence>, ) -> Result<Self, Error>

An Access Rights object that keeps written rule arrays, Enable and Accompaniment in persistence, starting from what is saved there for this object, if anything. A saved Accompaniment serves the optional row whether or not the application sets one.

Each saved array and Accompaniment goes through the setters’ checks, so this fails when a saved array holds more than MAX_ACCESS_RULES rules or a rule the setters refuse, or the saved Accompaniment is one set_accompaniment refuses, as well as when storage cannot be read.

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

Whether storage holds a value a write set for property (Positive_Access_Rules, Negative_Access_Rules, Enable, property 133, or Accompaniment), now or before a restart. That property’s setter then leaves it alone. Always false without persistence, and for any other property.

pub fn wait_for_saves(&self)

Block until the saves queued so far have run. Dropping the object waits for them too.

impl AccessRightsObject

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

Create a new Access Rights object with no access rules, enabled. It keeps what peers write in memory only; see with_persistence.

pub fn set_enable(&mut self, enable: bool)

Set Enable. FALSE disables every rule in both arrays (Clause 12.34.8) and leaves each rule’s own enable flag alone, so TRUE again brings the rules back as they were. The default, TRUE, is a local choice; the standard names none.

This configures the object and is not saved. With persistence, once a write has set Enable and it was saved, the saved value wins and this does nothing.

pub fn enable(&self) -> bool

The stored Enable flag.

pub fn set_positive_access_rules( &mut self, rules: impl IntoIterator<Item = BACnetAccessRule>, ) -> Result<(), Error>

Replace Positive_Access_Rules, the rules that grant access.

The whole list is refused, keeping the rules set before, when it holds more than MAX_ACCESS_RULES rules (NO_SPACE_TO_WRITE_PROPERTY), or with VALUE_OUT_OF_RANGE when any rule (Clause 12.34.9.1):

• names a device that isn’t a Device in either reference (#1285);
• holds a specifier outside its two named values;
• is SPECIFIED for a member whose reference is left out;
• is ALWAYS or ALL for a member whose reference is present and not unspecified;
• is SPECIFIED for a location that names neither an Access Point nor an Access Zone and isn’t unspecified.

A reference is unspecified when its object identifier, and its device identifier if it has one, carry instance 4194303. A SPECIFIED member may hold one, standing for nothing to match yet. The time range may name a property of any object; a Schedule’s Present_Value is typical.

This configures the object and is not saved. With persistence, once a write has set the array and it was saved, the saved rules win: the rules given here are still checked, but not stored.

pub fn set_negative_access_rules( &mut self, rules: impl IntoIterator<Item = BACnetAccessRule>, ) -> Result<(), Error>

Replace Negative_Access_Rules, the rules that deny access, with the same checks, and the same rule for saved rules, as set_positive_access_rules.

pub fn positive_access_rules(&self) -> &[BACnetAccessRule]

The stored Positive_Access_Rules.

pub fn negative_access_rules(&self) -> &[BACnetAccessRule]

The stored Negative_Access_Rules.

pub fn set_accompaniment( &mut self, accompaniment: Option<BACnetDeviceObjectReference>, ) -> Result<(), Error>

Set Accompaniment (Clause 12.34.11), the object a second credential presented with the first has to match for these rights to grant access: an Access Rights object the second credential holds, the Access Credential itself, or the Access User who owns it, here or in another device. A reference whose object, and device if it names one, carry instance 4194303 asks for no accompaniment. None leaves the optional property out, as a new object does; once set, the property is in Property_List and peers can write it.

Refused with VALUE_OUT_OF_RANGE, keeping the value set before: a device member that isn’t a Device (#1285), or an object of any other type unless the reference asks for no accompaniment.

This configures the object and is not saved. With persistence, once a write has set Accompaniment and it was saved, the saved reference wins: the one given here is still checked, but not stored, and None leaves the property in place. To lift a saved requirement, write the no-accompaniment reference (instance 4194303), which keeps the row; to drop the row itself, remove the storage file, which also drops the saved rules and Enable.

pub fn accompaniment(&self) -> Option<&BACnetDeviceObjectReference>

The stored Accompaniment, None while the property is left out.

Trait Implementations

impl BACnetObject for AccessRightsObject

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

Whether this object type supports COV notifications.

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 report_access_input_internal( &mut self, _input: AccessControlInput, ) -> Result<(), Error>

Apply an input the application reports for an access-control object the server holds (#1132): an Access Point’s access event, a Credential Data Input’s read or an Access Door’s hardware state, each a record whose values change together. See AccessControlInput.

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.