Server

Server entry point, endpoint configuration, services, and authentication/authorization hooks.

ua::ConditionAlarmMetrics

Aggregate alarm metrics summarising a collection of condition instances.

Each metric (active count, unacknowledged count, highest severity, ...) is computed once at construction by snapshotting every supplied ConditionInstance, and is thereafter returned from the cached value by the corresponding accessor. The object is an immutable value snapshot: it does not track later changes to the source conditions, and a fresh instance must be constructed to observe updated metrics.

Construction reads each condition's state snapshot, which is itself mutex-protected; the resulting accessors are plain reads of cached values and are safe to call from any thread. ConditionInstance

Functions

ConditionAlarmMetrics(const std::vector< std::shared_ptr< ConditionInstance > > &conditions)

Computes the alarm metrics from the given condition instances.

• conditions (const std::vector< std::shared_ptr< ConditionInstance > > &) - Condition instances to aggregate. Borrowed for the duration of the call only; no ownership is retained and the metrics do not reference the conditions afterwards.

uint32_t active_count() const

Returns the number of enabled conditions that were in the active state.

Returns: The count of enabled, active conditions in the snapshot.

uint32_t unacknowledged_count() const

Returns the number of enabled conditions that were unacknowledged.

Returns: The count of enabled, unacknowledged conditions in the snapshot.

uint32_t unconfirmed_count() const

Returns the number of enabled conditions that were unconfirmed.

Returns: The count of enabled, unconfirmed conditions in the snapshot.

uint16_t highest_active_severity() const

Returns the highest severity among the active conditions.

Returns: The highest severity among active conditions, or 0 if none were active.

uint16_t highest_unack_severity() const

Returns the highest severity among the unacknowledged conditions.

Returns: The highest severity among unacknowledged conditions, or 0 if none were unacknowledged.

ua::ConditionInstance

A strand-serialized OPC UA condition/alarm instance wrapping a ConditionLogic machine.

Owns a ConditionLogic and serializes every state transition, event emission, and address-space interaction through a private strand. The public API is callback-canonical: each operation exposes an *_async core plus sync and try_sync convenience wrappers. The instance is reference-counted via enable_shared_from_this; construct it only through create and hold it by std::shared_ptr.

Initialization is two-phase: call create, then initialize_async to integrate with the address space (instantiate nodes, wire variables, register method handlers). When no AddressSpace is supplied to create, the instance runs in logic-only mode: it drives the state machine and emits events but creates no address-space nodes, method handlers, or variable wiring.

Member types

std::function< void(VoidResult)> CompleteCallback

Callback signalling completion of an *_async operation; the VoidResult carries an ErrorDetail on failure.

std::function< void(NodeId conditionId, NodeId inputNode, StatusCode status)> InputCommunicationObserver

Observer invoked when a bound input enters or leaves a communication-failure state.

std::function< void(std::vector< std::unique_ptr< BaseEvent > >)> BuildEventsCallback

Callback receiving the events built by build_refresh_events_async; ownership of the returned BaseEvent objects transfers to the callee.

Static functions

std::shared_ptr< ConditionInstance > create(boost::asio::any_io_executor executor, std::unique_ptr< ConditionLogic > logic, NodeId conditionId, NodeId sourceNode, String sourceName, std::weak_ptr< EventSink > eventSink, std::optional< AddressSpace > addressSpace=std::nullopt, NodeId typeDefinition=NodeId{}, InputCommunicationObserver inputCommunicationObserver={})

Creates a condition instance and returns a shared owner; the canonical construction path.

• executor (boost::asio::any_io_executor) - Executor whose strand serializes all state access and async work.
• logic (std::unique_ptr< ConditionLogic >) - The condition/alarm state machine this instance drives. Ownership is transferred; must not be null.
• conditionId (NodeId) - NodeId of the condition node this instance represents.
• sourceNode (NodeId) - NodeId of the source that owns the condition (the event SourceNode).
• sourceName (String) - Human-readable source name reported on emitted events.
• eventSink (std::weak_ptr< EventSink >) - Sink that receives emitted condition/branch/audit events; held weakly, so the sink may outlive or predecease this instance safely.
• addressSpace (std::optional< AddressSpace >) - Address space to integrate with, or std::nullopt for logic-only mode.
• typeDefinition (NodeId) - NodeId of the condition type to instantiate; defaults to an empty NodeId.
• inputCommunicationObserver (InputCommunicationObserver) - Invoked when the bound input enters or leaves a communication-failure state, with this condition's id, the input node, and the status: a bad status reports the failure and retains its ErrorDetail, Good reports recovery. Reached only once an input node has been bound - a condition with no input never notifies - and defaults to empty, in which case the state is tracked but not reported.

Returns: A shared owner of the new instance.

Functions

~ConditionInstance()=default

void initialize_async(CompleteCallback callback)

Integrates the condition into the address space, completing asynchronously.

• callback (CompleteCallback) - Receives a VoidResult - good, or an ErrorDetail on failure. Never throws.

void initialize_sync()

Integrates the condition into the address space, blocking until complete.

VoidResult try_initialize_sync() noexcept

Integrates the condition into the address space, blocking until complete.

Returns: A VoidResult holding an ErrorDetail on failure. Never throws.

void attach_async(CompleteCallback callback)

Attaches to a pre-existing condition node in the address space, completing asynchronously.

• callback (CompleteCallback) - Receives a VoidResult - good, or an ErrorDetail on failure. Never throws.

void attach_sync()

Attaches to a pre-existing condition node, blocking until complete.

VoidResult try_attach_sync() noexcept

Attaches to a pre-existing condition node, blocking until complete.

Returns: A VoidResult holding an ErrorDetail on failure. Never throws.

void enable_async(CompleteCallback callback)

Enables the condition, completing asynchronously.

• callback (CompleteCallback) - Receives a VoidResult - good, or an ErrorDetail on failure. Never throws.

void enable_sync()

Enables the condition, blocking until complete.

VoidResult try_enable_sync() noexcept

Enables the condition, blocking until complete.

Returns: A VoidResult holding an ErrorDetail on failure. Never throws.

void disable_async(CompleteCallback callback)

Disables the condition, completing asynchronously.

• callback (CompleteCallback) - Receives a VoidResult - good, or an ErrorDetail on failure. Never throws.

void disable_sync()

Disables the condition, blocking until complete.

VoidResult try_disable_sync() noexcept

Disables the condition, blocking until complete.

Returns: A VoidResult holding an ErrorDetail on failure. Never throws.

void activate_async(uint16_t severity, CompleteCallback callback)

Activates the alarm at the given severity, completing asynchronously.

• severity (uint16_t) - Alarm severity to report (OPC UA severity scale, 1-1000).
• callback (CompleteCallback) - Receives a VoidResult - good, or an ErrorDetail on failure. Never throws.

void activate_sync(uint16_t severity)

Activates the alarm at the given severity, blocking until complete.

• severity (uint16_t) - Alarm severity to report (OPC UA severity scale, 1-1000).

VoidResult try_activate_sync(uint16_t severity) noexcept

Activates the alarm at the given severity, blocking until complete.

• severity (uint16_t) - Alarm severity to report (OPC UA severity scale, 1-1000).

Returns: A VoidResult holding an ErrorDetail on failure. Never throws.

void deactivate_async(CompleteCallback callback)

Deactivates the alarm, completing asynchronously.

• callback (CompleteCallback) - Receives a VoidResult - good, or an ErrorDetail on failure. Never throws.

void deactivate_sync()

Deactivates the alarm, blocking until complete.

VoidResult try_deactivate_sync() noexcept

Deactivates the alarm, blocking until complete.

Returns: A VoidResult holding an ErrorDetail on failure. Never throws.

void acknowledge_async(ByteString eventId, LocalizedText comment, CompleteCallback callback)

Acknowledges the condition (or branch) identified by eventId, completing asynchronously.

• eventId (ByteString) - EventId identifying the trunk or branch state to acknowledge.
• comment (LocalizedText) - Operator comment recorded with the acknowledgement.
• callback (CompleteCallback) - Receives a VoidResult - good, or an ErrorDetail on failure. Never throws.

void acknowledge_sync(ByteString eventId, LocalizedText comment)

Acknowledges the condition (or branch) identified by eventId, blocking until complete.

• eventId (ByteString) - EventId identifying the trunk or branch state to acknowledge.
• comment (LocalizedText) - Operator comment recorded with the acknowledgement.

VoidResult try_acknowledge_sync(ByteString eventId, LocalizedText comment) noexcept

Acknowledges the condition (or branch) identified by eventId, blocking until complete.

• eventId (ByteString) - EventId identifying the trunk or branch state to acknowledge.
• comment (LocalizedText) - Operator comment recorded with the acknowledgement.

Returns: A VoidResult holding an ErrorDetail on failure. Never throws.

void confirm_async(ByteString eventId, LocalizedText comment, CompleteCallback callback)

Confirms the condition (or branch) identified by eventId, completing asynchronously.

• eventId (ByteString) - EventId identifying the trunk or branch state to confirm.
• comment (LocalizedText) - Operator comment recorded with the confirmation.
• callback (CompleteCallback) - Receives a VoidResult - good, or an ErrorDetail on failure. Never throws.

void confirm_sync(ByteString eventId, LocalizedText comment)

Confirms the condition (or branch) identified by eventId, blocking until complete.

• eventId (ByteString) - EventId identifying the trunk or branch state to confirm.
• comment (LocalizedText) - Operator comment recorded with the confirmation.

VoidResult try_confirm_sync(ByteString eventId, LocalizedText comment) noexcept

Confirms the condition (or branch) identified by eventId, blocking until complete.

• eventId (ByteString) - EventId identifying the trunk or branch state to confirm.
• comment (LocalizedText) - Operator comment recorded with the confirmation.

Returns: A VoidResult holding an ErrorDetail on failure. Never throws.

void add_comment_async(ByteString eventId, LocalizedText comment, CompleteCallback callback)

Adds an operator comment to the condition or branch by eventId, completing asynchronously.

• eventId (ByteString) - EventId identifying the trunk or branch state to annotate.
• comment (LocalizedText) - Operator comment to record.
• callback (CompleteCallback) - Receives a VoidResult - good, or an ErrorDetail on failure. Never throws.

void add_comment_sync(ByteString eventId, LocalizedText comment)

Adds an operator comment to the condition (or branch) identified by eventId, blocking.

• eventId (ByteString) - EventId identifying the trunk or branch state to annotate.
• comment (LocalizedText) - Operator comment to record.

VoidResult try_add_comment_sync(ByteString eventId, LocalizedText comment) noexcept

Adds an operator comment to the condition (or branch) identified by eventId, blocking.

• eventId (ByteString) - EventId identifying the trunk or branch state to annotate.
• comment (LocalizedText) - Operator comment to record.

Returns: A VoidResult holding an ErrorDetail on failure. Never throws.

void call_enable_async(String userId, Node::CallMethodCompleteCallback complete)

Enables the condition (client Enable method) and emits an audit event.

• userId (String) - ClientUserId attributed to the call (may be empty).
• complete (Node::CallMethodCompleteCallback) - Receives the CallResult exactly once. Never throws.

void call_disable_async(String userId, Node::CallMethodCompleteCallback complete)

Disables the condition (client Disable method) and emits an audit event.

• userId (String) - ClientUserId attributed to the call (may be empty).
• complete (Node::CallMethodCompleteCallback) - Receives the CallResult exactly once. Never throws.

void call_add_comment_async(ByteString eventId, LocalizedText comment, String userId, Node::CallMethodCompleteCallback complete)

Adds an operator comment (client AddComment method) and emits an audit event.

• eventId (ByteString) - EventId identifying the trunk or branch state to annotate.
• comment (LocalizedText) - Operator comment to record.
• userId (String) - ClientUserId attributed to the call (may be empty).
• complete (Node::CallMethodCompleteCallback) - Receives the CallResult exactly once. Never throws.

void call_acknowledge_async(ByteString eventId, LocalizedText comment, String userId, Node::CallMethodCompleteCallback complete)

Acknowledges the condition (client Acknowledge method) and emits an audit event.

• eventId (ByteString) - EventId identifying the trunk or branch state to acknowledge.
• comment (LocalizedText) - Operator comment recorded with the acknowledgement.
• userId (String) - ClientUserId attributed to the call (may be empty).
• complete (Node::CallMethodCompleteCallback) - Receives the CallResult exactly once. Never throws.

void call_confirm_async(ByteString eventId, LocalizedText comment, String userId, Node::CallMethodCompleteCallback complete)

Confirms the condition (client Confirm method) and emits an audit event.

• eventId (ByteString) - EventId identifying the trunk or branch state to confirm.
• comment (LocalizedText) - Operator comment recorded with the confirmation.
• userId (String) - ClientUserId attributed to the call (may be empty).
• complete (Node::CallMethodCompleteCallback) - Receives the CallResult exactly once. Never throws.

void call_one_shot_shelve_async(String userId, Node::CallMethodCompleteCallback complete)

Shelves the alarm until it is explicitly unshelved (client OneShotShelve method) and emits an audit event.

• userId (String) - ClientUserId attributed to the call (may be empty).
• complete (Node::CallMethodCompleteCallback) - Receives the CallResult exactly once. Never throws.

void call_timed_shelve_async(double durationMs, String userId, Node::CallMethodCompleteCallback complete)

Shelves the alarm for durationMs (client TimedShelve method) and emits an audit event.

• durationMs (double) - Shelving duration in milliseconds.
• userId (String) - ClientUserId attributed to the call (may be empty).
• complete (Node::CallMethodCompleteCallback) - Receives the CallResult exactly once. Never throws.

void call_unshelve_async(String userId, Node::CallMethodCompleteCallback complete)

Returns the alarm to the Unshelved state (client Unshelve method) and emits an audit event.

• userId (String) - ClientUserId attributed to the call (may be empty).
• complete (Node::CallMethodCompleteCallback) - Receives the CallResult exactly once. Never throws.

void call_suppress_async(String userId, Node::CallMethodCompleteCallback complete)

Suppresses the alarm (client Suppress method) and emits an audit event.

• userId (String) - ClientUserId attributed to the call (may be empty).
• complete (Node::CallMethodCompleteCallback) - Receives the CallResult exactly once. Never throws.

void call_unsuppress_async(String userId, Node::CallMethodCompleteCallback complete)

Clears suppression (client Unsuppress method) and emits an audit event.

• userId (String) - ClientUserId attributed to the call (may be empty).
• complete (Node::CallMethodCompleteCallback) - Receives the CallResult exactly once. Never throws.

void call_silence_async(String userId, Node::CallMethodCompleteCallback complete)

Silences the alarm (client Silence method) and emits an audit event.

• userId (String) - ClientUserId attributed to the call (may be empty).
• complete (Node::CallMethodCompleteCallback) - Receives the CallResult exactly once. Never throws.

void call_remove_from_service_async(String userId, Node::CallMethodCompleteCallback complete)

Takes the alarm out of service (client RemoveFromService method) and emits an audit event.

• userId (String) - ClientUserId attributed to the call (may be empty).
• complete (Node::CallMethodCompleteCallback) - Receives the CallResult exactly once. Never throws.

void call_place_in_service_async(String userId, Node::CallMethodCompleteCallback complete)

Returns the alarm to service (client PlaceInService method) and emits an audit event.

• userId (String) - ClientUserId attributed to the call (may be empty).
• complete (Node::CallMethodCompleteCallback) - Receives the CallResult exactly once. Never throws.

void call_reset_async(String userId, Node::CallMethodCompleteCallback complete)

Resets a latched alarm (client Reset method) and emits an audit event.

• userId (String) - ClientUserId attributed to the call (may be empty).
• complete (Node::CallMethodCompleteCallback) - Receives the CallResult exactly once. Never throws.

void timed_shelve_async(double durationMs, CompleteCallback callback)

Shelves the alarm for a fixed duration, completing asynchronously.

• durationMs (double) - Shelving duration in milliseconds.
• callback (CompleteCallback) - Receives a VoidResult that is good or carries an ErrorDetail on failure. Never throws.

void timed_shelve_sync(double durationMs)

Shelves the alarm for a fixed duration, blocking until complete.

• durationMs (double) - Shelving duration in milliseconds.

VoidResult try_timed_shelve_sync(double durationMs) noexcept

Shelves the alarm for a fixed duration, blocking until complete.

• durationMs (double) - Shelving duration in milliseconds.

Returns: A VoidResult holding an ErrorDetail on failure. Never throws.

void one_shot_shelve_async(CompleteCallback callback)

One-shot-shelves the alarm until its next state change, completing asynchronously.

• callback (CompleteCallback) - Receives a VoidResult - good, or an ErrorDetail on failure. Never throws.

void one_shot_shelve_sync()

One-shot-shelves the alarm until its next state change, blocking until complete.

VoidResult try_one_shot_shelve_sync() noexcept

One-shot-shelves the alarm until its next state change, blocking until complete.

Returns: A VoidResult holding an ErrorDetail on failure. Never throws.

void unshelve_async(CompleteCallback callback)

Unshelves the alarm, completing asynchronously.

• callback (CompleteCallback) - Receives a VoidResult - good, or an ErrorDetail on failure. Never throws.

void unshelve_sync()

Unshelves the alarm, blocking until complete.

VoidResult try_unshelve_sync() noexcept

Unshelves the alarm, blocking until complete.

Returns: A VoidResult holding an ErrorDetail on failure. Never throws.

void suppress_async(CompleteCallback callback)

Suppresses the alarm, completing asynchronously.

• callback (CompleteCallback) - Receives a VoidResult - good, or an ErrorDetail on failure. Never throws.

void suppress_sync()

Suppresses the alarm, blocking until complete.

VoidResult try_suppress_sync() noexcept

Suppresses the alarm, blocking until complete.

Returns: A VoidResult holding an ErrorDetail on failure. Never throws.

void unsuppress_async(CompleteCallback callback)

Removes suppression from the alarm, completing asynchronously.

• callback (CompleteCallback) - Receives a VoidResult - good, or an ErrorDetail on failure. Never throws.

void unsuppress_sync()

Removes suppression from the alarm, blocking until complete.

VoidResult try_unsuppress_sync() noexcept

Removes suppression from the alarm, blocking until complete.

Returns: A VoidResult holding an ErrorDetail on failure. Never throws.

void remove_from_service_async(CompleteCallback callback)

Marks the alarm out of service, completing asynchronously.

• callback (CompleteCallback) - Receives a VoidResult - good, or an ErrorDetail on failure. Never throws.

void remove_from_service_sync()

Marks the alarm out of service, blocking until complete.

VoidResult try_remove_from_service_sync() noexcept

Marks the alarm out of service, blocking until complete.

Returns: A VoidResult holding an ErrorDetail on failure. Never throws.

void place_in_service_async(CompleteCallback callback)

Returns the alarm to service, completing asynchronously.

• callback (CompleteCallback) - Receives a VoidResult - good, or an ErrorDetail on failure. Never throws.

void place_in_service_sync()

Returns the alarm to service, blocking until complete.

VoidResult try_place_in_service_sync() noexcept

Returns the alarm to service, blocking until complete.

Returns: A VoidResult holding an ErrorDetail on failure. Never throws.

void silence_async(CompleteCallback callback)

Silences the alarm's audible/visible annunciation, completing asynchronously.

• callback (CompleteCallback) - Receives a VoidResult - good, or an ErrorDetail on failure. Never throws.

void silence_sync()

Silences the alarm's annunciation, blocking until complete.

VoidResult try_silence_sync() noexcept

Silences the alarm's annunciation, blocking until complete.

Returns: A VoidResult holding an ErrorDetail on failure. Never throws.

void reset_async(CompleteCallback callback)

Resets a latched alarm, completing asynchronously.

• callback (CompleteCallback) - Receives a VoidResult - good, or an ErrorDetail on failure. Never throws.

void reset_sync()

Resets a latched alarm, blocking until complete.

VoidResult try_reset_sync() noexcept

Resets a latched alarm, blocking until complete.

Returns: A VoidResult holding an ErrorDetail on failure. Never throws.

void respond_async(int32_t selectedResponse, CompleteCallback callback)

Responds to a dialog condition with the selected option, completing asynchronously.

• selectedResponse (int32_t) - Zero-based index of the chosen response option.
• callback (CompleteCallback) - Receives a VoidResult that is good or carries an ErrorDetail on failure. Never throws.

void respond_sync(int32_t selectedResponse)

Responds to a dialog condition with the selected option, blocking until complete.

• selectedResponse (int32_t) - Zero-based index of the chosen response option.

VoidResult try_respond_sync(int32_t selectedResponse) noexcept

Responds to a dialog condition with the selected option, blocking until complete.

• selectedResponse (int32_t) - Zero-based index of the chosen response option.

Returns: A VoidResult holding an ErrorDetail on failure. Never throws.

void bind_input_async(NodeId inputNode, double samplingIntervalMs, CompleteCallback callback)

Binds the alarm to an input variable for automatic evaluation, completing asynchronously.

• inputNode (NodeId) - NodeId of the variable to sample.
• samplingIntervalMs (double) - Sampling period in milliseconds.
• callback (CompleteCallback) - Receives a VoidResult that is good or carries an ErrorDetail on failure. Never throws.

void bind_input_sync(NodeId inputNode, double samplingIntervalMs)

Binds the alarm to an input variable for automatic evaluation, blocking until complete.

• inputNode (NodeId) - NodeId of the variable to sample.
• samplingIntervalMs (double) - Sampling period in milliseconds.

VoidResult try_bind_input_sync(NodeId inputNode, double samplingIntervalMs) noexcept

Binds the alarm to an input variable for automatic evaluation, blocking until complete.

• inputNode (NodeId) - NodeId of the variable to sample.
• samplingIntervalMs (double) - Sampling period in milliseconds.

Returns: A VoidResult holding an ErrorDetail on failure. Never throws.

void unbind_input_async(CompleteCallback callback)

Unbinds the input variable and cancels its sampling timer, completing asynchronously.

• callback (CompleteCallback) - Receives a VoidResult - good, or an ErrorDetail on failure. Never throws.

void build_refresh_events_async(BuildEventsCallback callback)

Builds refresh events for the current condition state, completing asynchronously.

• callback (BuildEventsCallback) - Receives the built events; ownership transfers to the callee.

void close_async(CompleteCallback callback)

Closes the condition, completing asynchronously.

• callback (CompleteCallback) - Receives a VoidResult - good, or an ErrorDetail on failure. Never throws.

void close_sync()

Closes the condition, blocking until complete.

VoidResult try_close_sync() noexcept

Closes the condition, blocking until complete.

Returns: A VoidResult holding an ErrorDetail on failure. Never throws.

std::shared_ptr< const ConditionStateSnapshot > snapshot() const

Returns a thread-safe immutable snapshot of the current condition state.

Returns: Shared owner of the immutable state snapshot.

const NodeId & condition_id() const

Returns the NodeId of the condition node.

Returns: The NodeId of the condition node.

const NodeId & source_node() const

Returns the NodeId of the condition's source node.

Returns: The NodeId of the condition's source node.

ua::ConditionStateSnapshot

Thread-safe snapshot of a condition's current state, readable from any thread.

A condition's authoritative state lives on its ConditionInstance strand. This snapshot mirrors the subset of that state that must be read outside the strand - for example by an ExternalValueSource handler servicing an attribute read on an unrelated thread. The ConditionInstance writes the snapshot from its strand via the update_from overloads; readers call the getters from any thread. Every read and write is serialized by an internal mutex, so no external synchronization is required.

Getters return values by copy. For the optional alarm sub-states (suppression, out-of-service, silencing, latching) the std::optional<bool> accessor is empty when the condition does not model that capability, while the paired current-state/transition-time accessors return default-constructed values in that case.

Functions

ByteString event_id() const

Returns the EventId of the most recently emitted event for this condition.

Returns: EventId of the most recently emitted event for this condition.

NodeId event_type() const

Returns the concrete EventType of the condition (its type-definition NodeId).

Returns: The condition's concrete EventType (its type-definition NodeId).

NodeId source_node() const

Returns the NodeId of the condition's source node.

Returns: NodeId of the condition's source node.

String source_name() const

Returns the human-readable name of the condition's source.

Returns: Human-readable name of the condition's source.

DateTime time() const

Returns the time the condition's most recent event was generated.

Returns: Time the condition's most recent event was generated.

DateTime receive_time() const

Returns the time the condition's most recent event was received for processing.

Returns: Time the condition's most recent event was received for processing.

LocalizedText message() const

Returns the condition's current message.

Returns: The condition's current message.

NodeId condition_class_id() const

Returns the ConditionClassId (the well-known condition-class type, Part 9).

Returns: ConditionClassId (the well-known condition-class type, Part 9).

LocalizedText condition_class_name() const

Returns the ConditionClassName (display name of the condition class).

Returns: ConditionClassName (display name of the condition class).

String condition_name() const

Returns the ConditionName (the application-assigned name of this condition).

Returns: ConditionName (the application-assigned name of this condition).

NodeId branch_id() const

Returns the BranchId of the condition (null NodeId for the main/current branch).

Returns: BranchId of the condition (null NodeId for the main/current branch).

String client_user_id() const

Returns the ClientUserId - the identity of the client that last drove a state change.

Returns: ClientUserId - the identity of the client that last drove a state change.

std::optional< TwoStateVariableState > high_high_state() const

Returns the NonExclusiveLimitAlarm HighHighState, or empty if not a non-exclusive limit alarm.

Returns: NonExclusiveLimitAlarm HighHighState, or an empty optional if not a non-exclusive limit alarm.

std::optional< TwoStateVariableState > high_state() const

Returns the NonExclusiveLimitAlarm HighState, or empty if not a non-exclusive limit alarm.

Returns: NonExclusiveLimitAlarm HighState, or an empty optional if not a non-exclusive limit alarm.

std::optional< TwoStateVariableState > low_state() const

Returns the NonExclusiveLimitAlarm LowState, or empty if not a non-exclusive limit alarm.

Returns: NonExclusiveLimitAlarm LowState, or an empty optional if not a non-exclusive limit alarm.

std::optional< TwoStateVariableState > low_low_state() const

Returns the NonExclusiveLimitAlarm LowLowState, or empty if not a non-exclusive limit alarm.

Returns: NonExclusiveLimitAlarm LowLowState, or an empty optional if not a non-exclusive limit alarm.

LocalizedText limit_state_name() const

Returns the ExclusiveLimitAlarm LimitState.CurrentState display name (empty when no limit active).

Returns: ExclusiveLimitAlarm LimitState.CurrentState display name (empty when no limit is active).

NodeId limit_state_id() const

Returns the ExclusiveLimitAlarm LimitState.CurrentState.Id (the state NodeId; null when inactive).

Returns: ExclusiveLimitAlarm LimitState.CurrentState.Id (the state NodeId; null when inactive).

LocalizedText shelve_state_name() const

Returns the AlarmCondition ShelvingState.CurrentState display name (e.g.

Returns: AlarmCondition ShelvingState.CurrentState display name (e.g. "Unshelved").

NodeId shelve_state_id() const

Returns the AlarmCondition ShelvingState.CurrentState.Id (the ShelvedStateMachineType state NodeId).

Returns: AlarmCondition ShelvingState.CurrentState.Id (the ShelvedStateMachineType state NodeId).

bool enabled() const

Returns whether the condition is enabled.

Returns: True if the condition is enabled.

bool retained() const

Returns whether the condition is retained (currently of interest to a client).

Returns: True if the condition is retained (currently of interest to a client).

uint16_t severity() const

Returns the current severity, on the OPC UA 1..1000 scale.

Returns: Current severity, on the OPC UA 1..1000 scale.

StatusCode quality() const

Returns the quality of the condition's underlying value.

Returns: Quality of the condition's underlying value.

DateTime quality_source_timestamp() const

Returns the source timestamp of the current quality.

Returns: Source timestamp of the current quality.

LocalizedText comment() const

Returns the most recent comment associated with the condition.

Returns: Most recent comment associated with the condition.

DateTime comment_source_timestamp() const

Returns the source timestamp of the current comment.

Returns: Source timestamp of the current comment.

uint16_t last_severity() const

Returns the previous severity, recorded when severity last changed.

Returns: Previous severity, recorded when severity last changed.

DateTime last_severity_source_timestamp() const

Returns the source timestamp at which last_severity was recorded.

Returns: Source timestamp at which last_severity was recorded.

bool acked() const

Returns whether the condition has been acknowledged.

Returns: True if the condition has been acknowledged.

DateTime acked_transition_time() const

Returns the time of the last transition of the AckedState two-state variable.

Returns: Time of the last transition of the AckedState two-state variable.

LocalizedText acked_current_state() const

Returns the localized name of the current AckedState.

Returns: Localized name of the current AckedState.

bool confirmed() const

Returns whether the condition has been confirmed.

Returns: True if the condition has been confirmed.

DateTime confirmed_transition_time() const

Returns the time of the last transition of the ConfirmedState two-state variable.

Returns: Time of the last transition of the ConfirmedState two-state variable.

LocalizedText confirmed_current_state() const

Returns the localized name of the current ConfirmedState.

Returns: Localized name of the current ConfirmedState.

bool active() const

Returns whether the alarm is active.

Returns: True if the alarm is active.

DateTime active_transition_time() const

Returns the time of the last transition of the ActiveState two-state variable.

Returns: Time of the last transition of the ActiveState two-state variable.

LocalizedText active_current_state() const

Returns the localized name of the current ActiveState.

Returns: Localized name of the current ActiveState.

LocalizedText enabled_current_state() const

Returns the localized name of the current EnabledState.

Returns: Localized name of the current EnabledState.

DateTime enabled_transition_time() const

Returns the time of the last transition of the EnabledState two-state variable.

Returns: Time of the last transition of the EnabledState two-state variable.

bool suppressed_or_shelved() const

Returns whether the alarm is currently suppressed or shelved.

Returns: True if the alarm is currently suppressed or shelved.

NodeId input_node() const

Returns the node whose value drives this alarm's input.

Returns: NodeId of the node whose value drives this alarm's input.

std::optional< bool > suppressed() const

Returns the suppression state, or an empty optional if the condition does not model suppression.

Returns: Suppression state, or an empty optional if the condition does not model suppression.

LocalizedText suppressed_current_state() const

Returns the localized name of the current SuppressedState, or an empty value if not modelled.

Returns: Localized name of the current SuppressedState, or an empty value if not modelled.

DateTime suppressed_transition_time() const

Returns the time of the last SuppressedState transition, or a default value if not modelled.

Returns: Time of the last SuppressedState transition, or a default value if not modelled.

std::optional< bool > out_of_service() const

Returns the out-of-service state, or an empty optional if the condition does not model it.

Returns: Out-of-service state, or an empty optional if the condition does not model it.

LocalizedText out_of_service_current_state() const

Returns the localized name of the current OutOfServiceState, or an empty value if not modelled.

Returns: Localized name of the current OutOfServiceState, or an empty value if not modelled.

DateTime out_of_service_transition_time() const

Returns the time of the last OutOfServiceState transition, or a default value if not modelled.

Returns: Time of the last OutOfServiceState transition, or a default value if not modelled.

std::optional< bool > silenced() const

Returns the silencing state, or an empty optional if the condition does not model silencing.

Returns: Silencing state, or an empty optional if the condition does not model silencing.

LocalizedText silenced_current_state() const

Returns the localized name of the current SilenceState, or an empty value if not modelled.

Returns: Localized name of the current SilenceState, or an empty value if not modelled.

DateTime silenced_transition_time() const

Returns the time of the last SilenceState transition, or a default value if not modelled.

Returns: Time of the last SilenceState transition, or a default value if not modelled.

std::optional< bool > latched() const

Returns the latching state, or an empty optional if the condition does not model latching.

Returns: Latching state, or an empty optional if the condition does not model latching.

LocalizedText latched_current_state() const

Returns the localized name of the current LatchedState, or an empty value if not modelled.

Returns: Localized name of the current LatchedState, or an empty value if not modelled.

DateTime latched_transition_time() const

Returns the time of the last LatchedState transition, or a default value if not modelled.

Returns: Time of the last LatchedState transition, or a default value if not modelled.

void update_from(const ConditionPayload &event)

Updates the snapshot's base condition fields from a condition event payload.

• event (const ConditionPayload &) - Source payload supplying the base condition fields.

void update_from(const AcknowledgeableConditionPayload &event)

Updates the snapshot's acknowledgement-related fields from an acknowledgeable condition payload.

• event (const AcknowledgeableConditionPayload &) - Source payload supplying the acknowledge/confirm fields.

void update_from(const AlarmConditionPayload &event)

Updates the snapshot's alarm-related fields from an alarm condition payload.

• event (const AlarmConditionPayload &) - Source payload supplying the alarm fields.

void set_non_exclusive_limit_states(std::optional< TwoStateVariableState > highHigh, std::optional< TwoStateVariableState > high, std::optional< TwoStateVariableState > low, std::optional< TwoStateVariableState > lowLow)

Sets the NonExclusiveLimitAlarm per-limit sub-states (empty for non-limit / exclusive alarms).

• highHigh (std::optional< TwoStateVariableState >) - HighHighState sub-state, or an empty optional when the limit is not modelled.
• high (std::optional< TwoStateVariableState >) - HighState sub-state, or an empty optional when the limit is not modelled.
• low (std::optional< TwoStateVariableState >) - LowState sub-state, or an empty optional when the limit is not modelled.
• lowLow (std::optional< TwoStateVariableState >) - LowLowState sub-state, or an empty optional when the limit is not modelled.

void set_exclusive_limit_state(LocalizedText currentStateName, NodeId currentStateId)

Sets the ExclusiveLimitAlarm LimitState.CurrentState name + state NodeId.

• currentStateName (LocalizedText) - Display name of the LimitState.CurrentState.
• currentStateId (NodeId) - NodeId of the LimitState.CurrentState.

void set_shelve_state(LocalizedText currentStateName, NodeId currentStateId)

Sets the AlarmCondition ShelvingState.CurrentState name + ShelvedStateMachineType state NodeId.

• currentStateName (LocalizedText) - Display name of the ShelvingState.CurrentState.
• currentStateId (NodeId) - NodeId of the ShelvingState.CurrentState (a ShelvedStateMachineType state).

ua::Conditions

Server-level registry of all live condition instances and their factories.

Owns the set of ConditionInstance objects the server exposes, the per-type ConditionFactory map, and the ConditionRefresh / HasEffect machinery that drives alarm-and-condition behaviour (OPC UA Part 9).

This is a strand-serialized component: all mutable state (the condition registry, the factory map, the in-progress refresh and discover guards, and the shutting-down flag) is owned by an internal strand. Every public *_async method posts entry onto that strand internally, so callers may invoke from any thread. The component holds the registry by shared_ptr (enable_shared_from_this) and captures itself weakly across async hops, so it is safe to destroy concurrently with in-flight work.

The public surface follows the canonical async trio: *_async - callback-canonical; the callback receives a Result (or VoidResult) carrying any ErrorDetail on failure. Never throws. sync - blocks and returns the bare value (or void); throws UaException on a bad status. External convenience only. try_sync - blocks and returns a Result (or VoidResult); never throws. External convenience only.

Lookup methods (find_condition_, find_factory_) treat a missing key as success: the Result is Good with a null payload. Only a real failure (the component is shutting down) yields a Bad status.

sync and try_sync block the calling thread; never call them from inside the SDK. Internal callers use the *_async variants. ConditionInstance, ConditionFactory, server::EventBus

Member types

std::function< void(ConditionInstanceResult)> CreateConditionCallback

Receives the outcome of a condition-creation request.

std::function< void(BaseEvent &)> EmitFunction

Sink invoked once per event to deliver it during a refresh.

std::function< void(VoidResult)> DiscoverExistingConditionsCallback

Receives the outcome of a discover-existing-conditions scan.

std::function< bool(uint32_t subscriptionId, const NodeId &callerSessionId)> SubscriptionValidator

Predicate that tests whether a subscription belongs to a given session.

std::function< void(uint32_t subscriptionId, uint32_t monitoredItemId, std::function< void(std::optional< NodeId >)> callback)> MonitoredItemNodeResolver

Resolves the monitored NodeId of an event MonitoredItem.

std::function< void(VoidResult)> ProcessHasEffectReferencesCallback

Receives the outcome of HasEffect reference processing.

Functions

Conditions(ConstructionKey, boost::asio::any_io_executor executor, std::weak_ptr< EventSink > eventSink)

Constructs a registry without address space integration.

• executor (boost::asio::any_io_executor) - Executor whose strand serializes all registry state. The component does not take ownership of the underlying io_context; it must outlive the registry.
• eventSink (std::weak_ptr< EventSink >) - Sink that retained condition events are emitted through. Held weakly; may expire without invalidating the registry.

Conditions(ConstructionKey, boost::asio::any_io_executor executor, std::weak_ptr< EventSink > eventSink, AddressSpace addressSpace)

Constructs an address-space-integrated registry and installs the default factories.

• executor (boost::asio::any_io_executor) - Executor whose strand serializes all registry state; it must outlive the registry.
• eventSink (std::weak_ptr< EventSink >) - Sink that retained condition events are emitted through. Held weakly.
• addressSpace (AddressSpace) - Address space the condition objects are instantiated in.

void create_condition_async(NodeId conditionId, NodeId sourceNode, String sourceName, std::unique_ptr< ConditionLogic > logic, NodeId typeDefinition, CreateConditionCallback callback)

Creates a condition instance and integrates it into the address space.

• conditionId (NodeId) - NodeId the condition object is created under.
• sourceNode (NodeId) - Node the condition reports about (its source).
• sourceName (String) - Human-readable name of the source node.
• logic (std::unique_ptr< ConditionLogic >) - Behaviour for the condition; ownership transfers in.
• typeDefinition (NodeId) - ObjectType the condition is instantiated from.
• callback (CreateConditionCallback) - Receives the created ConditionInstance on success, or an ErrorDetail on failure. This overload never throws.

std::shared_ptr< ConditionInstance > create_condition_sync(NodeId conditionId, NodeId sourceNode, String sourceName, std::unique_ptr< ConditionLogic > logic, NodeId typeDefinition)

Creates an address-space-integrated condition, blocking until complete.

• conditionId (NodeId) - NodeId the condition object is created under.
• sourceNode (NodeId) - Node the condition reports about (its source).
• sourceName (String) - Human-readable name of the source node.
• logic (std::unique_ptr< ConditionLogic >) - Behaviour for the condition; ownership transfers in.
• typeDefinition (NodeId) - ObjectType the condition is instantiated from.

Returns: The created condition instance.

ConditionInstanceResult try_create_condition_sync(NodeId conditionId, NodeId sourceNode, String sourceName, std::unique_ptr< ConditionLogic > logic, NodeId typeDefinition) noexcept

Creates an address-space-integrated condition, blocking until complete.

• conditionId (NodeId) - NodeId the condition object is created under.
• sourceNode (NodeId) - Node the condition reports about (its source).
• sourceName (String) - Human-readable name of the source node.
• logic (std::unique_ptr< ConditionLogic >) - Behaviour for the condition; ownership transfers in.
• typeDefinition (NodeId) - ObjectType the condition is instantiated from.

Returns: The created condition instance, or an ErrorDetail on failure. Never throws.

void create_condition_async(NodeId conditionId, NodeId sourceNode, String sourceName, std::unique_ptr< ConditionLogic > logic, CreateConditionCallback callback)

Creates a condition instance without address space integration.

• conditionId (NodeId) - NodeId the condition is registered under.
• sourceNode (NodeId) - Node the condition reports about.
• sourceName (String) - Human-readable name of the source node.
• logic (std::unique_ptr< ConditionLogic >) - Behaviour for the condition; ownership transfers in.
• callback (CreateConditionCallback) - Receives the created ConditionInstance on success, or an ErrorDetail on failure. This overload never throws.

std::shared_ptr< ConditionInstance > create_condition_sync(NodeId conditionId, NodeId sourceNode, String sourceName, std::unique_ptr< ConditionLogic > logic)

Creates a logic-only condition, blocking until complete.

• conditionId (NodeId) - NodeId the condition is registered under.
• sourceNode (NodeId) - Node the condition reports about.
• sourceName (String) - Human-readable name of the source node.
• logic (std::unique_ptr< ConditionLogic >) - Behaviour for the condition; ownership transfers in.

Returns: The created condition instance.

ConditionInstanceResult try_create_condition_sync(NodeId conditionId, NodeId sourceNode, String sourceName, std::unique_ptr< ConditionLogic > logic) noexcept

Creates a logic-only condition, blocking until complete.

• conditionId (NodeId) - NodeId the condition is registered under.
• sourceNode (NodeId) - Node the condition reports about.
• sourceName (String) - Human-readable name of the source node.
• logic (std::unique_ptr< ConditionLogic >) - Behaviour for the condition; ownership transfers in.

Returns: The created condition instance, or an ErrorDetail on failure. Never throws.

void register_condition_async(std::shared_ptr< ConditionInstance > instance, std::function< void(VoidResult)> callback)

Registers a pre-created condition instance.

• instance (std::shared_ptr< ConditionInstance >) - Condition to register, keyed by its conditionId.
• callback (std::function< void(VoidResult)>) - Receives success, or an ErrorDetail on failure (BadAlreadyExists if a different instance is already registered under the same conditionId). Never throws.

void register_condition_sync(std::shared_ptr< ConditionInstance > instance)

Registers a pre-created condition instance, blocking until complete.

• instance (std::shared_ptr< ConditionInstance >) - Condition to register, keyed by its conditionId.

VoidResult try_register_condition_sync(std::shared_ptr< ConditionInstance > instance) noexcept

Registers a pre-created condition instance, blocking until complete.

• instance (std::shared_ptr< ConditionInstance >) - Condition to register, keyed by its conditionId.

Returns: Success, or an ErrorDetail on failure. Never throws.

void deregister_condition_async(NodeId conditionId, std::function< void(VoidResult)> callback)

Removes a condition from the registry by its conditionId.

• conditionId (NodeId) - Key of the condition to remove.
• callback (std::function< void(VoidResult)>) - Receives success, or an ErrorDetail on failure. Never throws.

void deregister_condition_sync(NodeId conditionId)

Removes a condition by its conditionId, blocking until complete.

• conditionId (NodeId) - Key of the condition to remove.

VoidResult try_deregister_condition_sync(NodeId conditionId) noexcept

Removes a condition by its conditionId, blocking until complete.

• conditionId (NodeId) - Key of the condition to remove.

Returns: Success, or an ErrorDetail on failure. Never throws.

void find_condition_async(NodeId conditionId, std::function< void(Result< std::shared_ptr< ConditionInstance > >)> callback)

Looks up a registered condition by its conditionId.

• conditionId (NodeId) - Key to look up.
• callback (std::function< void(Result< std::shared_ptr< ConditionInstance > >)>) - Receives the ConditionInstance, a Good result with a null payload if conditionId is not registered, or a Bad status (Shutdown) if the component is shutting down. Carries an ErrorDetail on failure. Never throws.

std::shared_ptr< ConditionInstance > find_condition_sync(NodeId conditionId)

Looks up a registered condition by its conditionId, blocking until complete.

• conditionId (NodeId) - Key to look up.

Returns: The condition instance, or null if not registered.

Result< std::shared_ptr< ConditionInstance > > try_find_condition_sync(NodeId conditionId) noexcept

Looks up a registered condition by its conditionId, blocking until complete.

• conditionId (NodeId) - Key to look up.

Returns: The condition instance (null if not registered), or an ErrorDetail on failure. Never throws.

void condition_refresh_async(EmitFunction emitter, std::function< void(VoidResult)> callback)

Performs a ConditionRefresh: replays all retained condition events.

• emitter (EmitFunction) - Invoked once per event in refresh order.
• callback (std::function< void(VoidResult)>) - Receives success, or an ErrorDetail on failure. Never throws.

void condition_refresh_async(EventSink &sink, std::function< void(VoidResult)> callback)

Performs a ConditionRefresh, delivering events to an EventSink.

• sink (EventSink &) - Sink the refresh events are emitted through.
• callback (std::function< void(VoidResult)>) - Receives success, or an ErrorDetail on failure. Never throws.

void condition_refresh_sync(EmitFunction emitter)

Performs a ConditionRefresh via an emit function, blocking until complete.

• emitter (EmitFunction) - Invoked once per event in refresh order.

void condition_refresh_sync(EventSink &sink)

Performs a ConditionRefresh via an EventSink, blocking until complete.

• sink (EventSink &) - Sink the refresh events are emitted through.

VoidResult try_condition_refresh_sync(EmitFunction emitter) noexcept

Performs a ConditionRefresh via an emit function, blocking until complete.

• emitter (EmitFunction) - Invoked once per event in refresh order.

Returns: Success, or an ErrorDetail on failure. Never throws.

VoidResult try_condition_refresh_sync(EventSink &sink) noexcept

Performs a ConditionRefresh via an EventSink, blocking until complete.

• sink (EventSink &) - Sink the refresh events are emitted through.

Returns: Success, or an ErrorDetail on failure. Never throws.

void condition_refresh2_async(EmitFunction emitter, NodeId monitoredNode, std::function< void(VoidResult)> callback)

Performs a ConditionRefresh2: refresh scoped to a single monitored node.

• emitter (EmitFunction) - Invoked once per event in refresh order.
• monitoredNode (NodeId) - Source node the refresh is scoped to.
• callback (std::function< void(VoidResult)>) - Receives success, or an ErrorDetail on failure. Never throws.

void condition_refresh2_async(EventSink &sink, NodeId monitoredNode, std::function< void(VoidResult)> callback)

Performs a ConditionRefresh2, delivering events to an EventSink.

• sink (EventSink &) - Sink the refresh events are emitted through.
• monitoredNode (NodeId) - Source node the refresh is scoped to.
• callback (std::function< void(VoidResult)>) - Receives success, or an ErrorDetail on failure. Never throws.

void condition_refresh2_sync(EmitFunction emitter, NodeId monitoredNode)

Performs a ConditionRefresh2 via an emit function, blocking until complete.

• emitter (EmitFunction) - Invoked once per event in refresh order.
• monitoredNode (NodeId) - Source node the refresh is scoped to.

void condition_refresh2_sync(EventSink &sink, NodeId monitoredNode)

Performs a ConditionRefresh2 via an EventSink, blocking until complete.

• sink (EventSink &) - Sink the refresh events are emitted through.
• monitoredNode (NodeId) - Source node the refresh is scoped to.

VoidResult try_condition_refresh2_sync(EmitFunction emitter, NodeId monitoredNode) noexcept

Performs a ConditionRefresh2 via an emit function, blocking until complete.

• emitter (EmitFunction) - Invoked once per event in refresh order.
• monitoredNode (NodeId) - Source node the refresh is scoped to.

Returns: Success, or an ErrorDetail on failure. Never throws.

VoidResult try_condition_refresh2_sync(EventSink &sink, NodeId monitoredNode) noexcept

Performs a ConditionRefresh2 via an EventSink, blocking until complete.

• sink (EventSink &) - Sink the refresh events are emitted through.
• monitoredNode (NodeId) - Source node the refresh is scoped to.

Returns: Success, or an ErrorDetail on failure. Never throws.

void register_factory_async(NodeId objectTypeId, ConditionFactory factory, std::function< void(VoidResult)> callback)

Registers a ConditionFactory for an ObjectType.

• objectTypeId (NodeId) - ObjectType NodeId the factory is keyed by.
• factory (ConditionFactory) - Factory invoked to build logic for that type.
• callback (std::function< void(VoidResult)>) - Receives success, or an ErrorDetail on failure. Never throws.

void register_factory_sync(NodeId objectTypeId, ConditionFactory factory)

Registers a factory for an ObjectType, blocking until complete.

• objectTypeId (NodeId) - ObjectType NodeId the factory is keyed by.
• factory (ConditionFactory) - Factory invoked to build logic for that type.

void set_max_branches_per_condition(size_t maxBranches)

Sets the per-condition ConditionBranch retention cap applied to factory-created acknowledgeable condition logic (memory fail-safe).

• maxBranches (size_t) - Maximum number of ConditionBranches retained per condition; clamped to >= 1.

VoidResult try_register_factory_sync(NodeId objectTypeId, ConditionFactory factory) noexcept

Registers a factory for an ObjectType, blocking until complete.

• objectTypeId (NodeId) - ObjectType NodeId the factory is keyed by.
• factory (ConditionFactory) - Factory invoked to build logic for that type.

Returns: Success, or an ErrorDetail on failure. Never throws.

void find_factory_async(NodeId objectTypeId, std::function< void(Result< ConditionFactory >)> callback)

Looks up a registered factory by ObjectType NodeId.

• objectTypeId (NodeId) - ObjectType NodeId to look up.
• callback (std::function< void(Result< ConditionFactory >)>) - Receives the ConditionFactory, a Good result with an empty factory if objectTypeId is not registered, or a Bad status (Shutdown) if the component is shutting down. Never throws.

ConditionFactory find_factory_sync(NodeId objectTypeId)

Looks up a registered factory, blocking until complete.

• objectTypeId (NodeId) - ObjectType NodeId to look up.

Returns: The factory, or an empty factory if not registered.

Result< ConditionFactory > try_find_factory_sync(NodeId objectTypeId) noexcept

Looks up a registered factory, blocking until complete.

• objectTypeId (NodeId) - ObjectType NodeId to look up.

Returns: The factory (empty if not registered), or an ErrorDetail on failure. Never throws.

void retained_conditions_async(std::function< void(Result< std::vector< std::shared_ptr< ConditionInstance > > >)> callback)

Snapshots all currently retained conditions.

• callback (std::function< void(Result< std::vector< std::shared_ptr< ConditionInstance > > >)>) - Receives the snapshot vector, or a Bad status (Shutdown) carrying an ErrorDetail if the component is shutting down. Never throws.

std::vector< std::shared_ptr< ConditionInstance > > retained_conditions_sync()

Snapshots all currently retained conditions, blocking until complete.

Returns: The retained conditions.

Result< std::vector< std::shared_ptr< ConditionInstance > > > try_retained_conditions_sync() noexcept

Snapshots all currently retained conditions, blocking until complete.

Returns: The retained conditions, or an ErrorDetail on failure. Never throws.

void compute_alarm_metrics_async(std::function< void(Result< ConditionAlarmMetrics >)> callback)

Computes aggregate alarm metrics across all registered conditions.

• callback (std::function< void(Result< ConditionAlarmMetrics >)>) - Receives the ConditionAlarmMetrics, or a Bad status (Shutdown) carrying an ErrorDetail if the component is shutting down. Never throws.

ConditionAlarmMetrics compute_alarm_metrics_sync()

Computes aggregate alarm metrics, blocking until complete.

Returns: The computed metrics.

Result< ConditionAlarmMetrics > try_compute_alarm_metrics_sync() noexcept

Computes aggregate alarm metrics, blocking until complete.

Returns: The computed metrics, or an ErrorDetail on failure. Never throws.

void discover_existing_conditions_async(DiscoverExistingConditionsCallback callback)

Scans the address space for condition-typed objects and attaches them.

• callback (DiscoverExistingConditionsCallback) - Receives success, or an ErrorDetail on failure. Never throws.

void discover_existing_conditions_sync()

Scans for and attaches existing conditions, blocking until complete.

VoidResult try_discover_existing_conditions_sync() noexcept

Scans for and attaches existing conditions, blocking until complete.

Returns: Success, or an ErrorDetail on failure. Never throws.

void register_refresh_methods(std::weak_ptr< server::EventBus > eventBus, SubscriptionValidator validator, MonitoredItemNodeResolver itemNodeResolver)

Installs the ConditionRefresh and ConditionRefresh2 method handlers.

• eventBus (std::weak_ptr< server::EventBus >) - Weak handle to the server EventBus the refresh handlers emit refreshed Condition events through. Weak (not a raw reference) because the emit runs across async hops on a pool thread and the bus can be torn down (~ServerImpl) while a refresh is in flight; each emit locks it and is skipped if the bus is gone.
• validator (SubscriptionValidator) - Confirms the caller owns the target subscription.
• itemNodeResolver (MonitoredItemNodeResolver) - Resolves a ConditionRefresh2 MonitoredItemId to its monitored NodeId so the refresh is scoped to that one MonitoredItem (Part 9 5.5.8). When null, ConditionRefresh2 cannot resolve any MonitoredItem and reports BadMonitoredItemIdInvalid.

void register_condition_methods()

Installs the standard Condition method handlers on the NS0 type method nodes.

void process_has_effect_references_async(NodeId transitionNodeId, ProcessHasEffectReferencesCallback callback)

Applies HasEffect references emanating from a transition node.

• transitionNodeId (NodeId) - Transition node whose HasEffect references are processed.
• callback (ProcessHasEffectReferencesCallback) - Receives success, or an ErrorDetail on failure. Never throws.

void process_has_effect_references_sync(NodeId transitionNodeId)

Applies a transition node's HasEffect references, blocking until complete.

• transitionNodeId (NodeId) - Transition node whose HasEffect references are processed.

VoidResult try_process_has_effect_references_sync(NodeId transitionNodeId) noexcept

Applies a transition node's HasEffect references, blocking until complete.

• transitionNodeId (NodeId) - Transition node whose HasEffect references are processed.

Returns: Success, or an ErrorDetail on failure. Never throws.

ua::server::SessionDiagnosticsHelper

Convenience class that backs a session's SessionDiagnosticsObjectType node with live counters.

Instantiates a SessionDiagnosticsObjectType instance under a parent node and wires read handlers for all diagnostic child Variables so that each read reports the current value from the shared SessionCounters / SessionSecurityState the helper was given. The counters and security state are held by shared_ptr and updated by the owning session; the read handlers observe them live.

A helper created via create_async/create_sync owns the instantiated subtree and removes it on destruction (RAII); call release to detach that ownership.

Member types

std::function< void(SessionDiagnosticsHelperResult)> CreateCompleteCallback

Callback type reporting the outcome of create_async.

Static functions

void create_async(AddressSpace addressSpace, const NodeId &parent, const QualifiedName &browseName, std::shared_ptr< SessionCounters > counters, std::shared_ptr< SessionSecurityState > securityState, std::shared_ptr< SessionDescriptiveState > descriptiveState, const InstantiationOptions &options, CreateCompleteCallback complete) noexcept

Creates a new SessionDiagnosticsObjectType instance under parent and wires its read handlers.

• addressSpace (AddressSpace) - Address space in which the node is created.
• parent (const NodeId &) - Node under which the new instance is created.
• browseName (const QualifiedName &) - Browse name of the new node.
• counters (std::shared_ptr< SessionCounters >) - Shared per-session counters the read handlers observe live; must outlive the helper.
• securityState (std::shared_ptr< SessionSecurityState >) - Shared per-session security state the read handlers observe live; must outlive the helper.
• descriptiveState (std::shared_ptr< SessionDescriptiveState >) - Shared per-session descriptive state (session name, client description, connection timestamps) the read handlers observe live; must outlive the helper.
• options (const InstantiationOptions &) - Instantiation options for the new subtree.
• complete (CreateCompleteCallback) - Receives the outcome: on success the Result holds the owning SessionDiagnosticsHelper; on failure it carries an ErrorDetail. This overload never throws.

SessionDiagnosticsHelperResult try_create_sync(AddressSpace addressSpace, const NodeId &parent, const QualifiedName &browseName, std::shared_ptr< SessionCounters > counters, std::shared_ptr< SessionSecurityState > securityState, std::shared_ptr< SessionDescriptiveState > descriptiveState, const InstantiationOptions &options) noexcept

Creates a new SessionDiagnosticsObjectType instance under parent, blocking until complete.

• addressSpace (AddressSpace) - Address space in which the node is created.
• parent (const NodeId &) - Node under which the new instance is created.
• browseName (const QualifiedName &) - Browse name of the new node.
• counters (std::shared_ptr< SessionCounters >) - Shared per-session counters the read handlers observe live; must outlive the helper.
• securityState (std::shared_ptr< SessionSecurityState >) - Shared per-session security state the read handlers observe live; must outlive the helper.
• descriptiveState (std::shared_ptr< SessionDescriptiveState >) - Shared per-session descriptive state (session name, client description, connection timestamps) the read handlers observe live; must outlive the helper.
• options (const InstantiationOptions &) - Instantiation options for the new subtree.

Returns: The owning SessionDiagnosticsHelper, or an ErrorDetail on failure. Never throws.

SessionDiagnosticsHelper create_sync(AddressSpace addressSpace, const NodeId &parent, const QualifiedName &browseName, std::shared_ptr< SessionCounters > counters, std::shared_ptr< SessionSecurityState > securityState, std::shared_ptr< SessionDescriptiveState > descriptiveState, const InstantiationOptions &options)

Creates a new SessionDiagnosticsObjectType instance under parent, blocking until complete.

• addressSpace (AddressSpace) - Address space in which the node is created.
• parent (const NodeId &) - Node under which the new instance is created.
• browseName (const QualifiedName &) - Browse name of the new node.
• counters (std::shared_ptr< SessionCounters >) - Shared per-session counters the read handlers observe live; must outlive the helper.
• securityState (std::shared_ptr< SessionSecurityState >) - Shared per-session security state the read handlers observe live; must outlive the helper.
• descriptiveState (std::shared_ptr< SessionDescriptiveState >) - Shared per-session descriptive state (session name, client description, connection timestamps) the read handlers observe live; must outlive the helper.
• options (const InstantiationOptions &) - Instantiation options for the new subtree.

Returns: The owning SessionDiagnosticsHelper.

Functions

SessionDiagnosticsHelper()=default

Constructs an empty helper that backs no node.

const std::vector< NodeId > & security_diagnostic_node_ids() const

Returns the node ids of the security-diagnostic child Variables.

Returns: The node ids of the security-diagnostic child Variables, valid for the helper's lifetime.

const NodeId & node_id() const

Returns the node id of the backed SessionDiagnosticsObjectType instance.

Returns: The NodeId of the backed SessionDiagnosticsObjectType instance.

void release()

Detaches RAII ownership of the created subtree so it persists beyond this handle's lifetime.

ua::server::BrowseContinuationPoint

Captured state that lets a truncated Browse be continued by BrowseNext.

When a Browse produces more references than the client requested (or more than max_refs_per_node permits), the server returns a slice plus an opaque continuation point. This object holds everything needed to resume: the originating ViewDescription and BrowseDescription, the per-node reference cap, and the resume token for the producing namespace. It is identified by a server-generated Guid that is handed to the client and matched on the subsequent BrowseNext request.

When the references come from a NamespaceBrowseDelegate, the stored namespace_continuation_token is the delegate's own opaque token. The continuation point owns that token's lifetime: on destruction (and on the destination side of a move-assignment) a non-empty token is handed back to the delegate via release_resume_token, so the delegate can free any state it pinned for the paged browse.

Move-only: copying would duplicate ownership of the resume token. The moved-from instance has its delegate cleared so the token is released exactly once. Instances are not internally synchronized; serialize access externally (the server confines each continuation point to its session).

Functions

BrowseContinuationPoint(ViewDescription viewDescription, Counter maxRefsPerNode, const BrowseDescription &browseDescription, ByteString namespaceContinuationToken)

Constructs a continuation point for a built-in (non-delegated) Browse.

• viewDescription (ViewDescription) - View the Browse was issued against.
• maxRefsPerNode (Counter) - Maximum references returned per node, as negotiated for the originating request.
• browseDescription (const BrowseDescription &) - The node and reference filter being browsed.
• namespaceContinuationToken (ByteString) - Opaque token marking the resume position; ownership is taken by this object.

BrowseContinuationPoint(ViewDescription viewDescription, Counter maxRefsPerNode, const BrowseDescription &browseDescription, ByteString resumeToken, shared_ptr< NamespaceBrowseDelegate > delegate)

Constructs a continuation point backed by a NamespaceBrowseDelegate.

• viewDescription (ViewDescription) - View the Browse was issued against.
• maxRefsPerNode (Counter) - Maximum references returned per node.
• browseDescription (const BrowseDescription &) - The node and reference filter being browsed.
• resumeToken (ByteString) - Delegate-owned opaque resume token; ownership is taken by this object and released to delegate.
• delegate (shared_ptr< NamespaceBrowseDelegate >) - Delegate that produced the references and that owns the resume token's backing state.

~BrowseContinuationPoint()

Releases the resume token back to the delegate, if one is held.

BrowseContinuationPoint(BrowseContinuationPoint &&other) noexcept

Move-constructs, transferring resume-token ownership.

• other (BrowseContinuationPoint &&) - Source; left without a delegate and must not be reused except to assign or destroy.

BrowseContinuationPoint & operator=(BrowseContinuationPoint &&other) noexcept

Move-assigns, releasing this object's token before taking other 's.

• other (BrowseContinuationPoint &&) - Source; left without a delegate and must not be reused except to assign or destroy.

Returns: Reference to this object.

const Guid & identifier() const

Server-generated identifier matched against incoming BrowseNext requests.

Returns: The server-generated Guid identifying this continuation point.

const ViewDescription & view_description() const

View the originating Browse was issued against.

Returns: The ViewDescription the originating Browse targeted.

Counter max_refs_per_node() const

Maximum number of references to return per node, as negotiated for the originating Browse request.

Returns: The per-node reference cap negotiated for the originating Browse.

const BrowseDescription & browse_description() const

Node and reference filter being browsed.

Returns: The BrowseDescription (node plus reference filter) being browsed.

const ByteString & namespace_continuation_token() const

Opaque token marking the resume position within the producing namespace.

Returns: The opaque resume token; empty once the browse is fully consumed.

ByteString & namespace_continuation_token()

Mutable access to the resume token so it can be advanced on BrowseNext.

Returns: Mutable reference to the resume token, for advancing it on BrowseNext.

const shared_ptr< NamespaceBrowseDelegate > & delegate() const

Delegate that produced the references, or null for a built-in Browse.

Returns: The producing NamespaceBrowseDelegate, or null for a built-in Browse.

const References & buffered_references() const

Unprocessed references from the namespace page that was open when this continuation point was emitted.

Returns: The buffered mid-page references to replay before the namespace token resumes.

void set_buffered_references(References references)

Stores the mid-page references to replay before the namespace token resumes.

• references (References) - The unprocessed references from the open page; moved in, replacing any buffer already held.

ua::server::HistoryContinuationPoint

Server-side state that lets a HistoryRead be resumed across service calls.

When a HistoryRead cannot return all values in one response, the SDK creates one HistoryContinuationPoint per unfinished operation and hands the client an opaque identifier. On the follow-up request the client returns that identifier and the SDK replays the stored NamespaceHistoryDelegate::Cursor back to the delegate to fetch the next page.

The handle owns the delegate cursor: its destructor (and move-assignment overwrite) calls NamespaceHistoryDelegate::release_cursor exactly once on the last owning instance, so the delegate can reclaim any per-cursor resources. It is move-only to keep that ownership single, and is not thread-safe - it is created, accessed, and destroyed on the session's serialized service path.

Functions

HistoryContinuationPoint(uint16_t namespaceIndex, NamespaceHistoryDelegate::Cursor cursor, shared_ptr< NamespaceHistoryDelegate > delegate, TimestampsToReturn timestampsToReturn, NamespaceHistoryDelegate::DetailKind detailKind)

Constructs a continuation point and assigns it a fresh random identifier.

• namespaceIndex (uint16_t) - Namespace whose history delegate owns the cursor.
• cursor (NamespaceHistoryDelegate::Cursor) - Opaque pagination state produced by the delegate; moved in.
• delegate (shared_ptr< NamespaceHistoryDelegate >) - History delegate that produced and will reclaim the cursor. Must outlive this handle.
• timestampsToReturn (TimestampsToReturn) - Timestamps the original request asked for, replayed on resume.
• detailKind (NamespaceHistoryDelegate::DetailKind) - Which HistoryRead operation this point continues.

~HistoryContinuationPoint()

Releases the owned cursor back to the delegate, if one is still held.

HistoryContinuationPoint(HistoryContinuationPoint &&other) noexcept

Move-constructs from other, transferring cursor ownership and leaving other inert.

• other (HistoryContinuationPoint &&) - Source handle; left holding no delegate so it releases no cursor.

HistoryContinuationPoint & operator=(HistoryContinuationPoint &&other) noexcept

Move-assigns from other, releasing any cursor this handle currently owns first.

• other (HistoryContinuationPoint &&) - Source handle; left holding no delegate so it releases no cursor.

Returns: Reference to this handle.

const Guid & identifier() const

Returns the random identifier the client uses to resume this read.

Returns: The Guid the client presents to resume this HistoryRead.

uint16_t namespace_index() const

Returns the namespace index whose history delegate owns the cursor.

Returns: The namespace index whose history delegate owns the cursor.

NamespaceHistoryDelegate::Cursor & cursor()

Returns a mutable reference to the owned delegate cursor.

Returns: Mutable reference to the owned delegate cursor.

const NamespaceHistoryDelegate::Cursor & cursor() const

Returns a read-only reference to the owned delegate cursor.

Returns: Read-only reference to the owned delegate cursor.

const shared_ptr< NamespaceHistoryDelegate > & delegate() const

Returns the history delegate that produced and will reclaim the cursor.

Returns: The NamespaceHistoryDelegate that produced and will reclaim the cursor.

TimestampsToReturn timestamps_to_return() const

Returns the timestamps the originating request asked for, replayed on resume.

Returns: The TimestampsToReturn the originating HistoryRead requested.

NamespaceHistoryDelegate::DetailKind detail_kind() const

Returns which HistoryRead operation this continuation point continues.

Returns: The NamespaceHistoryDelegate::DetailKind this continuation point continues.

ua::server::NodeManagementDelegate

Extension seam through which a server applies the OPC UA NodeManagement service.

A delegate implements the AddNodes, AddReferences, DeleteNodes, and DeleteReferences operations on behalf of a namespace. The SDK validates and authorizes the request, then dispatches each batch to the delegate; the delegate effects the mutation against the supplied AddressSpace and reports a per-item outcome.

All operations are callback-canonical (*_async). A delegate may complete its callback inline or after deferred work; per the SDK post discipline the caller is responsible for unwinding the stack, so the delegate need not post.

Member types

Result< AddNodeDestination > PrepareAddNodesItemResult

Per-item outcome of side-effect-free AddNodes destination preparation.

std::function< void(BatchResult< PrepareAddNodesItemResult >)> PrepareAddNodesCallback

Completion callback for prepare_add_nodes_async.

Result< AddNodesResult > AddNodesItemResult

Per-item outcome of an AddNodes operation.

std::function< void(BatchResult< AddNodesItemResult >)> AddNodesCompleteCallback

Completion callback for add_nodes_async.

std::function< void(BatchResult< VoidResult >)> NodeMgmtCompleteCallback

Completion callback shared by AddReferences, DeleteNodes, and DeleteReferences.

Functions

~NodeManagementDelegate()=default

void prepare_add_nodes_async(std::shared_ptr< const Context > context, AddressSpace addressSpace, std::vector< AddNodesItem > items, PrepareAddNodesCallback callback) noexcept

Selects the destination namespace for each AddNodes item without mutation.

• context (std::shared_ptr< const Context >) - Request context; the delegate may extend its lifetime.
• addressSpace (AddressSpace) - Read-only routing context. Preparation must not mutate it.
• items (std::vector< AddNodesItem >) - Owned items to route, in request order.
• callback (PrepareAddNodesCallback) - One destination result per item.