Address space

The node/reference graph model, instantiation engine, conditions, and NodeSet helpers.

ua::ConditionBranch

A prior condition state that was retained because it still needs operator attention.

A branch is created when the trunk transitions while an unacknowledged or unconfirmed state is outstanding, so the earlier state is not lost. The snapshot is a polymorphic BaseEvent captured via build_event() at branch-creation time; acknowledgement and confirmation are tracked by mutating the snapshot's fields in place.

Public attributes

NodeId branchId

Non-null Guid NodeId identifying this branch.

ByteString eventId

EventId of the branch's last emitted event; assigned by the shell after emission.

std::unique_ptr< BaseEvent > snapshot

Owned snapshot of the full event state at branch-creation time.

ua::AcknowledgeableConditionLogic

Pure state machine for the OPC UA AcknowledgeableConditionType (Part 9).

Extends ConditionLogic with AckedState and an optional ConfirmedState, and tracks any outstanding branches. The retain computation accounts for acknowledgement and confirmation in addition to enable state. Like its base, this holds state only: no I/O, no address space, no strands. A strand-serialized shell drives async work and feeds results back via the setters.

Functions

~AcknowledgeableConditionLogic() override=default

AcknowledgeableConditionLogic()=default

Default constructor: the deleted copy/move members above suppress the implicit default ctor; this concrete logic type is default-constructed directly and by subclasses.

ConditionStateTransition acknowledge(const ByteString &eventId, const LocalizedText &comment)

Acknowledges the condition (or branch) identified by an EventId.

• eventId (const ByteString &) - EventId of the trunk or branch event being acknowledged.
• comment (const LocalizedText &) - Operator comment to attach to the acknowledgement.

Returns: The resulting transition. Its status is BadEventIdUnknown if eventId matches no outstanding event, or BadConditionBranchAlreadyAcked if it is already acknowledged.

ConditionStateTransition add_comment(const ByteString &eventId, const LocalizedText &comment) override

Adds a comment to the condition or one of its branches.

• eventId (const ByteString &) - EventId of the trunk or branch event to comment on.
• comment (const LocalizedText &) - Comment to attach.

Returns: The resulting transition; its status is BadEventIdUnknown if eventId matches no outstanding event.

ConditionStateTransition confirm(const ByteString &eventId, const LocalizedText &comment)

Confirms the condition (or branch) identified by an EventId.

• eventId (const ByteString &) - EventId of the trunk or branch event being confirmed.
• comment (const LocalizedText &) - Operator comment to attach to the confirmation.

Returns: The resulting transition. Its status is BadEventIdUnknown if eventId matches no outstanding event, or BadConditionBranchAlreadyConfirmed if it is already confirmed or if confirmation is not supported.

bool supports_confirm() const

Returns whether ConfirmedState is supported.

Returns: true if ConfirmedState is supported.

void set_supports_confirm(bool value)

Enables or disables ConfirmedState support.

• value (bool) - true to enable ConfirmedState support; false to disable it.

void set_supports_branches(bool value)

Enables or disables branch support (optional per Part 9 4.2).

• value (bool) - true to enable branch support; false to disable it.

void set_max_branches(size_t maxBranches)

Sets the maximum number of live ConditionBranches retained at once (memory bound).

• maxBranches (size_t) - Maximum number of live ConditionBranches to retain at once; clamped to a minimum of 1.

const std::vector< ConditionBranch > & branches() const

Returns read-only access to the live branches.

Returns: The live branches; the reference stays valid only until the next mutation of this logic object.

void set_branch_event_id(const NodeId &branchId, ByteString eventId)

Records the EventId assigned by the EventBus after emitting a branch event.

• branchId (const NodeId &) - Identifier of the branch to update.
• eventId (ByteString) - EventId assigned to the branch's most recent event.

void remove_branch(const NodeId &branchId)

Removes a resolved branch.

• branchId (const NodeId &) - Identifier of the branch to remove.

std::unique_ptr< BaseEvent > build_branch_event(const NodeId &branchId, bool retain) const

Builds a clone of a branch's snapshot event with its branch_id and Retain flag set.

• branchId (const NodeId &) - Identifier of the branch to clone.
• retain (bool) - Value to set on the cloned event's Retain field.

Returns: An owned clone of the branch's snapshot, or nullptr if no branch matches branchId.

void set_last_event_id(ByteString eventId) override

Records the EventId assigned after emitting the trunk event.

• eventId (ByteString) - EventId assigned to the most recently emitted trunk event.

void set_initial_acked(bool acked)

Sets the initial acknowledged state without triggering transitions or events.

• acked (bool) - Initial AckedState.Id value.

void set_initial_confirmed(bool confirmed)

Sets the initial confirmed state without triggering transitions or events.

• confirmed (bool) - Initial ConfirmedState.Id value.

std::unique_ptr< BaseEvent > build_event() const override

Builds an AcknowledgeableConditionType event struct from the current state.

Returns: An owned event carrying the current condition state.

ua::AlarmConditionLogic

Pure state machine for the OPC UA AlarmConditionType (Part 9).

Extends AcknowledgeableConditionLogic with ActiveState plus the optional alarm sub-states: shelving, suppression, out-of-service, silence, latching, and on/off delay behaviour. Like its base classes this is a pure logic object: it performs no I/O, owns no address space, and is not strand-serialized. Each mutator returns a ConditionStateTransition that a strand-serialized shell inspects to drive event emission and timer commands; none of these methods throw.

Functions

~AlarmConditionLogic() override=default

AlarmConditionLogic()=default

Default constructor: the deleted copy/move members above suppress the implicit default ctor; this concrete logic type is default-constructed directly and by subclasses.

ConditionStateTransition activate(uint16_t severity)

Activates the alarm.

• severity (uint16_t) - New alarm severity, 1..1000 per Part 8.

Returns: The resulting state transition for the shell to apply.

ConditionStateTransition deactivate()

Deactivates the alarm.

Returns: The resulting state transition for the shell to apply.

ConditionStateTransition suppress()

Sets SuppressedState to suppressed.

Returns: The resulting state transition. No-op unless suppression is supported.

ConditionStateTransition suppress(const LocalizedText &comment)

Suppresses the alarm and records a comment against it (Suppress2, OPC 10000-9 5.8.9).

• comment (const LocalizedText &) - Comment to apply; a NULL comment leaves any existing one unchanged.

Returns: The resulting state transition, identical to suppress().

ConditionStateTransition unsuppress()

Clears SuppressedState back to unsuppressed.

Returns: The resulting state transition. No-op unless suppression is supported.

ConditionStateTransition unsuppress(const LocalizedText &comment)

Unsuppresses the alarm and records a comment against it (Unsuppress2, OPC 10000-9 5.8.11).

• comment (const LocalizedText &) - Comment to apply; a NULL comment leaves any existing one unchanged.

Returns: The resulting state transition, identical to unsuppress().

ConditionStateTransition remove_from_service()

Sets OutOfServiceState to out-of-service.

Returns: The resulting state transition. No-op unless out-of-service is supported.

ConditionStateTransition remove_from_service(const LocalizedText &comment)

Takes the alarm out of service and records a comment against it (RemoveFromService2, OPC 10000-9 5.8.13).

• comment (const LocalizedText &) - Comment to apply; a NULL comment leaves any existing one unchanged.

Returns: The resulting state transition, identical to remove_from_service().

ConditionStateTransition place_in_service()

Clears OutOfServiceState back to in-service.

Returns: The resulting state transition. No-op unless out-of-service is supported.

ConditionStateTransition place_in_service(const LocalizedText &comment)

Returns the alarm to service and records a comment against it (PlaceInService2, OPC 10000-9 5.8.15).

• comment (const LocalizedText &) - Comment to apply; a NULL comment leaves any existing one unchanged.

Returns: The resulting state transition, identical to place_in_service().

ConditionStateTransition silence()

Sets SilenceState to silenced.

Returns: The resulting state transition. No-op unless silence is supported.

ConditionStateTransition timed_shelve(double durationMs)

Shelves the alarm for a fixed duration (TimedShelved).

• durationMs (double) - Shelve duration in milliseconds; clamped to the configured MaxTimeShelved when set.

Returns: The resulting state transition, including a start-shelve-timer command for the shell.

ConditionStateTransition timed_shelve(double durationMs, const LocalizedText &comment)

Shelves the alarm for a fixed duration and records a comment against it (TimedShelve2, OPC 10000-9 5.8.17.5).

• durationMs (double) - Shelve duration in milliseconds.
• comment (const LocalizedText &) - Comment to apply; a NULL comment leaves any existing one unchanged.

Returns: The resulting state transition, identical to timed_shelve(double).

ConditionStateTransition one_shot_shelve()

Shelves the alarm until it next deactivates and reactivates (OneShotShelved).

Returns: The resulting state transition.

ConditionStateTransition one_shot_shelve(const LocalizedText &comment)

One-shot shelves the alarm and records a comment against it (OneShotShelve2, OPC 10000-9 5.8.17.7).

• comment (const LocalizedText &) - Comment to apply; a NULL comment leaves any existing one unchanged.

Returns: The resulting state transition, identical to one_shot_shelve().

ConditionStateTransition unshelve()

Returns the alarm to the Unshelved state.

Returns: The resulting state transition, including a cancel-shelve-timer command for the shell.

ConditionStateTransition unshelve(const LocalizedText &comment)

Unshelves the alarm and records a comment against it (Unshelve2, OPC 10000-9 5.8.17.3).

• comment (const LocalizedText &) - Comment to apply; a NULL comment leaves any existing one unchanged.

Returns: The resulting state transition, identical to unshelve().

ConditionStateTransition on_shelve_timer_expired()

Handles expiry of the shelve timer started by timed_shelve.

Returns: The resulting state transition.

ConditionStateTransition on_delay_expired()

Handles expiry of the on-delay timer, committing a delayed activation.

Returns: The resulting state transition.

ConditionStateTransition off_delay_expired()

Handles expiry of the off-delay timer, committing a delayed deactivation.

Returns: The resulting state transition.

ConditionStateTransition on_re_alarm_timer_expired()

Handles expiry of the configured ReAlarmTime while the Alarm remains active.

Returns: The resulting state transition, or a no-op when disabled, inactive, or unconfigured.

ConditionStateTransition evaluate_input(const Variant &value, DateTime timestamp)

Evaluates a new input sample and updates alarm state accordingly.

• value (const Variant &) - The newly sampled input value.
• timestamp (DateTime) - Source timestamp of the sample.

Returns: The resulting state transition for the shell to apply.

ConditionStateTransition reset()

Resets a latched alarm whose input has already cleared.

Returns: The resulting state transition. No-op unless latching is supported.

ConditionStateTransition reset(const LocalizedText &comment)

Resets a latched alarm and records a comment against it (Reset2, OPC 10000-9 5.8.6).

• comment (const LocalizedText &) - Comment to apply; a NULL comment leaves any existing one unchanged.

Returns: The resulting state transition, identical to reset().

void set_initial_active(bool active, uint16_t severity)

Sets the initial active state without triggering transitions or events.

• active (bool) - Initial ActiveState value.
• severity (uint16_t) - Initial severity, 1..1000.

void set_initial_acked(bool acked)

Seeds AckedState and, when SilenceState was not independently recovered, uses it as the required recovery fallback for SilenceState.

• acked (bool) - Initial AckedState value: true for a condition recovered as acknowledged. When the alarm carries the optional SilenceState and no initial silence was set, this value also seeds SilenceState (silenced when acknowledged), which is the recovery fallback rather than an equivalence between the two states.

void set_initial_suppressed(bool suppressed)

Sets the initial suppressed state without triggering transitions or events.

• suppressed (bool) - Initial SuppressedState value.

void set_initial_out_of_service(bool outOfService)

Sets the initial out-of-service state without triggering transitions or events.

• outOfService (bool) - Initial OutOfServiceState value.

void set_initial_silenced(bool silenced)

Sets the initial silence state without triggering transitions or events.

• silenced (bool) - Initial SilenceState value.

void set_initial_latched(bool latched)

Sets the initial latched state without triggering transitions or events.

• latched (bool) - Initial LatchedState value.

void set_initial_shelved(ShelveState state)

Sets the initial shelve state without triggering transitions or events.

• state (ShelveState) - Initial ShelveState.

void set_input_node(NodeId nodeId)

Sets the NodeId of the input source whose samples drive this alarm.

• nodeId (NodeId) - NodeId of the input source whose samples drive this alarm.

void set_max_time_shelved(double ms)

Sets the maximum permitted shelve duration in milliseconds (MaxTimeShelved).

• ms (double) - Upper bound applied to timed_shelve durations; 0 disables the cap.

void set_on_delay(double ms)

Sets the on-delay in milliseconds applied before a pending activation takes effect.

• ms (double) - Delay duration in milliseconds; 0 disables the delay.

void set_off_delay(double ms)

Sets the off-delay in milliseconds applied before a pending deactivation takes effect.

• ms (double) - Delay duration in milliseconds; 0 disables the delay.

void set_re_alarm_time(double ms)

Sets the re-alarm interval in milliseconds (ReAlarmTime).

• ms (double) - Repeat interval in milliseconds; a non-positive value disables re-alarming.

void set_supports_suppressed(bool value)

Enables or disables the optional SuppressedState sub-state.

• value (bool) - true to enable the SuppressedState sub-state; false to disable it.

void set_supports_out_of_service(bool value)

Enables or disables the optional OutOfServiceState sub-state.

• value (bool) - true to enable the OutOfServiceState sub-state; false to disable it.

void set_supports_silence(bool value)

Enables or disables the optional SilenceState sub-state.

• value (bool) - true to enable the SilenceState sub-state; false to disable it.

void set_supports_latched(bool value)

Enables or disables the optional LatchedState sub-state.

• value (bool) - true to enable the LatchedState sub-state; false to disable it.

bool supports_suppressed() const

Returns whether the SuppressedState sub-state is supported.

Returns: true if the SuppressedState sub-state is supported.

bool supports_out_of_service() const

Returns whether the OutOfServiceState sub-state is supported.

Returns: true if the OutOfServiceState sub-state is supported.

bool supports_silence() const

Returns whether the SilenceState sub-state is supported.

Returns: true if the SilenceState sub-state is supported.

bool supports_latched() const

Returns whether the LatchedState sub-state is supported.

Returns: true if the LatchedState sub-state is supported.

std::unique_ptr< BaseEvent > build_event() const override

Builds an alarm event snapshot from the current state.

Returns: A newly allocated event whose ownership transfers to the caller.

ShelveState shelve_state() const

Returns the current ShelveState.

Returns: The current ShelveState.

ua::CertificateExpirationAlarmLogic

State machine for the OPC UA CertificateExpirationAlarmType (Part 9, 5.8.24.7).

Monitors a certificate's expiration. The alarm activates once the current time plus the configured expiration limit reaches or passes the certificate's expiration date, signalling that the certificate is due for renewal before it expires. Extends OffNormalAlarmLogic.

This is a synchronous in-memory state machine: callers drive it from the owning condition's serialization context and inspect the returned ConditionStateTransition to decide what events and timer commands to run. It performs no I/O and never blocks.

Functions

~CertificateExpirationAlarmLogic() override=default

CertificateExpirationAlarmLogic()=default

Default constructor: the deleted copy/move members above suppress the implicit default ctor; this concrete logic type is default-constructed directly and by subclasses.

void set_expiration_date(DateTime expirationDate)

Sets the certificate's expiration date used by evaluate_expiration.

• expirationDate (DateTime) - Absolute time at which the monitored certificate expires.

void set_expiration_limit(double ms)

Sets how far before expiry the alarm activates.

• ms (double) - Lead time before the expiration date, in milliseconds. Defaults to two weeks (1209600000 ms) until overridden.

void set_certificate_type(NodeId certType)

Sets the NodeId of the certificate type this alarm reports.

• certType (NodeId) - NodeId identifying the certificate's type (e.g. application instance certificate). Surfaced on the emitted event.

void set_certificate(ByteString cert)

Sets the DER-encoded certificate this alarm reports.

• cert (ByteString) - The monitored certificate as a DER byte string. Surfaced on the emitted event.

ConditionStateTransition evaluate_expiration(DateTime now)

Evaluates whether the certificate is within its expiration limit.

• now (DateTime) - The current time to evaluate against.

Returns: The resulting ConditionStateTransition. The shell inspects it to decide whether to emit an event and which timer commands to run.

std::unique_ptr< BaseEvent > build_event() const override

Builds the event for the current alarm state.

Returns: A newly constructed event describing the current state. Ownership transfers to the caller.

ua::TimerCommand

A timer operation that the Condition shell must execute after a state transition.

Produced by the pure ConditionStateTransition logic and replayed by the owning Condition instance, which schedules or cancels the corresponding alarm timer (on/off delay, shelving, or re-alarm) on its strand.

Member types

Kind (enum)

The timer and operation a command refers to.

• None - No-op; the command carries no timer action.
• StartOnDelay - (Re)start the active-state on-delay timer.
• CancelOnDelay - Cancel any pending on-delay timer.
• StartOffDelay - (Re)start the inactive-state off-delay timer.
• CancelOffDelay - Cancel any pending off-delay timer.
• StartShelveTimer - (Re)start the one-shot/timed-shelving unshelve timer.
• CancelShelveTimer - Cancel any pending shelving timer.
• StartReAlarmTimer - (Re)start the re-alarm repeat timer.
• CancelReAlarmTimer - Cancel any pending re-alarm timer.

Public attributes

Kind kind

Which timer to act on, and whether to start or cancel it.

double durationMs

Delay before the timer fires, in milliseconds; ignored for cancel kinds.

ua::BranchEventData

A branch event that the Condition shell must emit after a state transition.

Each entry corresponds to one ConditionBranch whose state changed and must be reported to subscribers via an event.

Public attributes

NodeId branchId

Identifier of the ConditionBranch the event reports on.

bool retain

true to emit a normal branch event; false to emit the final event (Retain=False) that deletes the branch.

ua::ConditionStateTransition

The outcome of a ConditionLogic state mutation.

Returned by the pure Condition logic and inspected by the owning Condition instance (the "shell"), which decides whether to emit the condition event, replay the timer commands, emit any branch events, and what status to report back to the caller. This is a plain value with no ownership or threading semantics of its own.

Public attributes

bool changed

true if the mutation altered any condition state.

bool emitEvent

true if the shell must emit the main condition event.

StatusCode status

Status to report back to the caller of the mutation.

std::vector< TimerCommand > timerCommands

Timer operations to execute, in order.

std::vector< BranchEventData > branchEvents

Branch events to emit, in order.

ua::ConditionLogic

Pure state machine for the OPC UA ConditionType (Part 9).

Holds all condition state and exposes deterministic, side-effect-free transitions. Performs no I/O, holds no address-space references, and is not strand-serialized - every method runs synchronously on the caller's thread and never blocks. Intended for the Logic/Shell split pattern: a strand-serialized shell component owns this object, drives the async operations it describes (event emission, timer commands), and feeds the results back in.

State mutations return a ConditionStateTransition that tells the shell whether an event must be emitted, which timer commands to run, and the status to report to the caller; the logic object itself never emits events.

Subclasses (AcknowledgeableConditionLogic, AlarmConditionLogic, etc.) override the protected extension points - compute_retain(), on_enabled(), on_disabled() - to add their type-specific behavior.

Not thread-safe. The owning shell must serialize all access (its strand provides this).

Functions

~ConditionLogic()=default

ConditionLogic()=default

Default constructor: the deleted copy/move members above suppress the implicit default ctor; this concrete logic type is default-constructed directly and by subclasses.

ConditionStateTransition enable()

Enables the condition.

Returns: The resulting transition. Carries status BadConditionAlreadyEnabled (and no change) when the condition was already enabled.

ConditionStateTransition disable()

Disables the condition.

Returns: The resulting transition. Carries status BadConditionAlreadyDisabled (and no change) when the condition was already disabled.

ConditionStateTransition add_comment(const ByteString &eventId, const LocalizedText &comment)

Adds a comment to the condition or one of its branches.

• eventId (const ByteString &) - EventId of the event the comment refers to, used to select the target branch.
• comment (const LocalizedText &) - Comment text to record.

Returns: The resulting transition.

ConditionStateTransition set_quality(StatusCode quality)

Updates the condition quality.

• quality (StatusCode) - New quality status code.

Returns: The resulting transition; requests an event emission when the condition is retained.

ConditionStateTransition set_severity(uint16_t severity)

Updates the condition severity.

• severity (uint16_t) - New severity, in OPC UA severity units (1-1000).

Returns: The resulting transition; requests an event emission when the condition is retained.

void set_initial_enabled(bool enabled)

Sets the initial enabled state without triggering any transition or event.

• enabled (bool) - Initial enabled flag.

void set_source(NodeId sourceNode, String sourceName)

Sets the source node and source name reported in emitted events.

• sourceNode (NodeId) - NodeId of the source the condition relates to.
• sourceName (String) - Human-readable source name.

void set_condition_name(String name)

Sets the condition name reported in emitted events.

• name (String) - Condition name reported in emitted events.

void set_condition_class(NodeId classId, LocalizedText className)

Sets the condition class identifier and its display name.

• classId (NodeId) - NodeId of the condition class (e.g. a well-known ConditionClassType).
• className (LocalizedText) - Localized display name of the condition class.

void set_client_user_id(String userId)

Sets the ClientUserId recorded on the next comment/acknowledge interaction.

• userId (String) - ClientUserId to record on the next comment/acknowledge interaction.

void set_supports_filtered_retain(bool value)

Sets whether the condition supports the FilteredRetain behavior.

• value (bool) - true to enable FilteredRetain behavior support; false to disable it.

void set_last_event_id(ByteString eventId)

Sets the last event ID.

• eventId (ByteString) - EventId of the most recently emitted event.

const ByteString & last_event_id() const

Returns the last emitted event ID, used to correlate ConditionRefresh.

Returns: Reference to the stored EventId; valid until the next set_last_event_id() call.

std::unique_ptr< BaseEvent > build_event() const

Builds an event struct populated from the current condition state.

Returns: An owning pointer to a freshly built event; never null.

ua::DialogConditionLogic

Pure state machine for the OPC UA DialogConditionType (Part 9).

Extends ConditionLogic with dialog-specific state: the prompt, the response-option set, and the DialogState two-state variable. Dialogs are not alarms - they derive directly from ConditionLogic. A dialog is activated with a prompt and is then awaiting a response; responses are validated against the configured number of options.

Like its base, this is a synchronous, side-effect-free logic object: it holds no I/O, address space, or strands. Each mutation returns a ConditionStateTransition that the owning strand-serialized shell inspects to decide whether to emit an event and what status to report to the caller.

Functions

~DialogConditionLogic() override=default

DialogConditionLogic()=default

Default constructor: the deleted copy/move members above suppress the implicit default ctor; this concrete logic type is default-constructed directly and by subclasses.

ConditionStateTransition activate_dialog(LocalizedText prompt)

Activates the dialog with the given prompt, entering the active DialogState.

• prompt (LocalizedText) - Text shown to the client for this dialog. Taken by value.

Returns: The resulting state transition for the shell to apply.

ConditionStateTransition respond(int32_t selectedResponse)

Responds to the active dialog with the selected option.

• selectedResponse (int32_t) - Zero-based option index in the range 0 .. numOptions - 1 (see set_response_options()).

Returns: The resulting state transition. Its status is BadDialogNotActive when the dialog is not currently active, or BadDialogResponseInvalid when selectedResponse is out of range.

ConditionStateTransition respond(int32_t selectedResponse, LocalizedText comment)

Responds to the active dialog and updates the condition comment.

• selectedResponse (int32_t) - Zero-based option index, validated as in respond(int32_t).
• comment (LocalizedText) - Comment to record alongside the response. Taken by value.

Returns: The resulting state transition, with the same status semantics as respond(int32_t).

void set_response_options(int32_t numOptions)

Sets the number of valid response options accepted by respond().

• numOptions (int32_t) - Count of selectable options; valid response indices are 0 .. numOptions - 1.

void set_default_response(int32_t index)

Sets the default response option index.

• index (int32_t) - Zero-based option index, or -1 for none.

void set_ok_response(int32_t index)

Sets the option index that represents the OK response.

• index (int32_t) - Zero-based option index, or -1 for none.

void set_cancel_response(int32_t index)

Sets the option index that represents the Cancel response.

• index (int32_t) - Zero-based option index, or -1 for none.

std::unique_ptr< BaseEvent > build_event() const override

Builds a dialog-condition event populated from the current state.

Returns: A newly allocated event carrying the dialog fields plus the inherited condition fields. Ownership transfers to the caller.

ua::DiscrepancyAlarmLogic

State machine for the OPC UA DiscrepancyAlarmType (Part 9, 5.8.25).

Monitors whether an input value reaches a configured target value within an expected time. When the input differs from the target (outside tolerance) for longer than the expected time, the alarm activates; when the input reaches the target, the alarm deactivates. Like every ConditionLogic this is a pure state machine: it performs no I/O, owns no strand, and is driven by a shell component that feeds it inputs and acts on the returned transitions.

Functions

~DiscrepancyAlarmLogic() override=default

DiscrepancyAlarmLogic()=default

Default constructor: the deleted copy/move members above suppress the implicit default ctor; this concrete logic type is default-constructed directly and by subclasses.

void set_target_value_node(NodeId nodeId)

Sets the NodeId of the variable that holds the target value.

• nodeId (NodeId) - NodeId of the target-value variable.

void set_expected_time(double ms)

Sets the time the input may discrepate from the target before the alarm activates.

• ms (double) - Expected time to reach the target, in milliseconds.

void set_tolerance(double tolerance)

Sets the tolerance band used for target comparison.

• tolerance (double) - Maximum absolute difference, in input units, still treated as at-target.

void set_target_value(Variant value)

Sets the current target value the input is compared against.

• value (Variant) - Target value; its type should match the input supplied to evaluate_input.

ConditionStateTransition evaluate_input(const Variant &value, DateTime timestamp) override

Evaluates a new input sample against the target and updates alarm state.

• value (const Variant &) - The input sample to evaluate.
• timestamp (DateTime) - Source timestamp of the sample, used to measure how long the input has been discrepant.

Returns: The state transition produced by the evaluation.

std::unique_ptr< BaseEvent > build_event() const override

Builds a DiscrepancyAlarmType event populated from the current state.

Returns: An owning event struct carrying this alarm's fields; never null.

ua::DiscreteAlarmLogic

Pure state machine for the OPC UA DiscreteAlarmType (Part 9).

A discrete alarm is driven by changes to a discrete input rather than by limit comparison against an analog process value. It inherits the full AlarmConditionLogic behavior (activation, shelving, suppression, out-of-service, silence, latching, on/off delays) unchanged and only specializes the emitted event type. Like its bases it performs no I/O and touches no address space or strand; a strand-serialized shell drives it.

Functions

~DiscreteAlarmLogic() override=default

DiscreteAlarmLogic()=default

Default constructor: the deleted copy/move members above suppress the implicit default ctor; this concrete logic type is default-constructed directly and by subclasses.

std::unique_ptr< BaseEvent > build_event() const override

Builds a DiscreteAlarm event struct from the current alarm state.

Returns: An owning handle to the freshly built event; never null.

ua::ConfiguredLimit

One limit exposed by a LimitAlarmType.

A configured limit may carry its numeric threshold or may be unavailable because the underlying system cannot supply the actual value. The latter remains an exposed Property but is excluded from alarm evaluation and has no Event-field value.

Static functions

ConfiguredLimit unavailable() noexcept

Constructs a configured limit whose actual value is unavailable.

Returns: A present but unavailable limit.

Functions

ConfiguredLimit(double value) noexcept

Constructs an available configured limit.

• value (double) - Numeric threshold in the input's engineering units.

ConfiguredLimit & operator=(double value) noexcept

Replaces this limit with an available numeric threshold.

• value (double) - Numeric threshold in the input's engineering units.

Returns: This configured limit.

bool is_available() const noexcept

Returns whether the underlying system supplied the numeric threshold.

Returns: true when a threshold was supplied; false when the limit is configured - the model declares it - but its actual value is not known to this server.

const std::optional< double > & value() const noexcept

Returns the supplied threshold, or empty when its actual value is unavailable.

Returns: The threshold in the input's engineering units, or an empty optional when the limit is configured but unavailable - the same distinction is_available reports.

ua::LimitConfig

Configuration for limit thresholds, per-limit deadbands, and per-limit severities.

Each limit has three states: an absent outer optional is not exposed, an available ConfiguredLimit is exposed and evaluated, and an unavailable ConfiguredLimit is exposed with CurrentRead cleared but is not evaluated. Available values use the same engineering units as the alarm's input. Severities are OPC UA severity values in the range 1..1000.

Public attributes

std::optional< ConfiguredLimit > highHighLimit

HighHigh limit; unset omits the Property.

std::optional< ConfiguredLimit > highLimit

High limit; unset omits the Property.

std::optional< ConfiguredLimit > lowLimit

Low limit; unset omits the Property.

std::optional< ConfiguredLimit > lowLowLimit

LowLow limit; unset omits the Property.

double highHighDeadband

Per-limit deadbands.

double highDeadband

Deadband for the High limit, in input units.

double lowDeadband

Deadband for the Low limit, in input units.

double lowLowDeadband

Deadband for the LowLow limit, in input units.

uint16_t severityHighHigh

Per-limit severity values.

uint16_t severityHigh

Severity reported while the High limit is active.

uint16_t severityLow

Severity reported while the Low limit is active.

uint16_t severityLowLow

Severity reported while the LowLow limit is active.

ua::LimitAlarmLogic

State machine for the OPC UA LimitAlarmType (Part 9).

Extends AlarmConditionLogic with limit evaluation, deadband support, and exclusive/non-exclusive limit modes.

In exclusive mode, only the most severe violated limit is active at a time. In non-exclusive mode, each limit is evaluated independently and multiple can be active simultaneously.

Functions

~LimitAlarmLogic() override=default

LimitAlarmLogic()=default

Default constructor: the deleted copy/move members above suppress the implicit default ctor; this concrete logic type is default-constructed directly and by subclasses.

void set_limits(LimitConfig config)

Sets the limit thresholds, deadbands, and severities.

• config (LimitConfig) - New limit configuration; ownership is taken by value.

void set_exclusive(bool exclusive)

Selects exclusive (true) or non-exclusive (false) limit mode.

• exclusive (bool) - true for exclusive mode, false for non-exclusive mode.

void enable_rate_of_change_per_second()

Enables evaluation of limits against the input's rate of change per second.

ActiveLimit active_limit() const

Returns the currently active limit.

Returns: The active limit, or ActiveLimit::None when no limit is violated.

bool high_high_active() const

Returns whether the HighHigh limit is currently active (non-exclusive mode).

Returns: true when the HighHigh limit is currently violated.

bool high_active() const

Returns whether the High limit is currently active (non-exclusive mode).

Returns: true when the High limit is currently violated.

bool low_active() const

Returns whether the Low limit is currently active (non-exclusive mode).

Returns: true when the Low limit is currently violated.

bool low_low_active() const

Returns whether the LowLow limit is currently active (non-exclusive mode).

Returns: true when the LowLow limit is currently violated.

const LimitConfig & limits() const

Returns the current limit configuration.

Returns: A reference valid until the next set_limits call.

bool exclusive() const

Returns whether exclusive mode is enabled.

Returns: true when exclusive limit mode is enabled, false for non-exclusive mode.

ConditionStateTransition evaluate_input(const Variant &value, DateTime timestamp) override

Evaluates a new input value against the configured limits and updates state.

• value (const Variant &) - New process value to evaluate; must be numeric to take effect.
• timestamp (DateTime) - Source timestamp associated with the value.

Returns: The resulting state transition (which states changed, and whether an event should be emitted).

std::unique_ptr< BaseEvent > build_event() const override

Builds the event instance reflecting the current limit-alarm state.

Returns: A newly allocated event populated with the current condition state; ownership transfers to the caller.

ua::OffNormalAlarmLogic

State machine for the OPC UA OffNormalAlarmType (Part 9).

Extends DiscreteAlarmLogic with a comparison against a configured "normal" state. On each input evaluation the alarm activates when the input value differs from the normal state and deactivates when it equals the normal state. The comparison is by value equality of the Variant.

Functions

~OffNormalAlarmLogic() override=default

OffNormalAlarmLogic()=default

Default constructor: the deleted copy/move members above suppress the implicit default ctor; this concrete logic type is default-constructed directly and by subclasses.

void set_normal_state(Variant normalValue)

Sets the value that represents the "normal" (non-alarming) state.

• normalValue (Variant) - Value taken to represent the normal state.

void set_normal_state_node(NodeId nodeId)

Sets the NodeId of the NormalState property exposed by the alarm node.

• nodeId (NodeId) - NodeId of the NormalState property in the address space.

ConditionStateTransition evaluate_input(const Variant &value, DateTime timestamp) override

Evaluates a new input value against the normal state and returns the resulting condition state transition.

• value (const Variant &) - New input value to evaluate.
• timestamp (DateTime) - Source timestamp associated with the input change.

Returns: The transition describing any resulting condition state change.

std::unique_ptr< BaseEvent > build_event() const override

Builds an OffNormalAlarm event reflecting the current alarm state.

Returns: A newly allocated event whose ownership is transferred to the caller; never null.

ua::FileHelper

Convenience class that backs a FileType address-space node with real filesystem I/O.

All six FileType methods (Open, Close, Read, Write, GetPosition, SetPosition) are wired automatically to operate on the given filesystem path. Concurrent clients receive independent file handles with independent stream positions. The four mandatory properties (Size, Writable, UserWritable, OpenCount) are populated automatically; Size and OpenCount are dynamic, queried from live state by their read handlers.

A helper created via create_async/create_sync owns the FileType subtree it instantiates and removes it on destruction (RAII); call release to detach that ownership. A helper produced by attach_async/attach_sync wraps a pre-existing node and never owns it.

Member types

std::function< void(FileHelperResult)> CreateCompleteCallback

Callback type reporting the outcome of create_async.

std::function< void(FileHelperResult)> AttachCompleteCallback

Callback type reporting the outcome of attach_async.

Static functions

void create_async(AddressSpace addressSpace, const NodeId &parent, const QualifiedName &browseName, std::filesystem::path filePath, const InstantiationOptions &options, bool writable, CreateCompleteCallback complete) noexcept

Creates a new FileType instance under parent and wires all method/property handlers.

• addressSpace (AddressSpace) - Address space in which the node is created.
• parent (const NodeId &) - Node under which the new FileType instance is created.
• browseName (const QualifiedName &) - Browse name of the new node.
• filePath (std::filesystem::path) - Filesystem path the FileType methods operate on.
• options (const InstantiationOptions &) - Instantiation options for the new subtree.
• writable (bool) - Whether the file may be opened for writing (drives the Writable / UserWritable properties and rejects write opens when false).
• complete (CreateCompleteCallback) - Receives the outcome: on success the Result holds the owning FileHelper; on failure it carries an ErrorDetail. This overload never throws.

FileHelperResult try_create_sync(AddressSpace addressSpace, const NodeId &parent, const QualifiedName &browseName, std::filesystem::path filePath, const InstantiationOptions &options, bool writable=true) noexcept

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

• addressSpace (AddressSpace) - Address space in which the node is created.
• parent (const NodeId &) - Node under which the new FileType instance is created.
• browseName (const QualifiedName &) - Browse name of the new node.
• filePath (std::filesystem::path) - Filesystem path the FileType methods operate on.
• options (const InstantiationOptions &) - Instantiation options for the new subtree.
• writable (bool) - Whether the file may be opened for writing (drives the Writable / UserWritable properties and rejects write opens when false).

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

FileHelper create_sync(AddressSpace addressSpace, const NodeId &parent, const QualifiedName &browseName, std::filesystem::path filePath, const InstantiationOptions &options, bool writable=true)

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

• addressSpace (AddressSpace) - Address space in which the node is created.
• parent (const NodeId &) - Node under which the new FileType instance is created.
• browseName (const QualifiedName &) - Browse name of the new node.
• filePath (std::filesystem::path) - Filesystem path the FileType methods operate on.
• options (const InstantiationOptions &) - Instantiation options for the new subtree.
• writable (bool) - Whether the file may be opened for writing (drives the Writable / UserWritable properties and rejects write opens when false).

Returns: The owning FileHelper.

void attach_async(AddressSpace addressSpace, const NodeId &existingInstance, std::filesystem::path filePath, bool writable, AttachCompleteCallback complete) noexcept

Wraps an existing FileType node and wires all method/property handlers.

• addressSpace (AddressSpace) - Address space containing the node.
• existingInstance (const NodeId &) - Node id of the existing FileType instance to back.
• filePath (std::filesystem::path) - Filesystem path the FileType methods operate on.
• writable (bool) - Whether the file may be opened for writing (drives the Writable / UserWritable properties and rejects write opens when false).
• complete (AttachCompleteCallback) - Receives the outcome: on success the Result holds the non-owning FileHelper; on failure it carries an ErrorDetail. This overload never throws.

FileHelperResult try_attach_sync(AddressSpace addressSpace, const NodeId &existingInstance, std::filesystem::path filePath, bool writable=true) noexcept

Wraps an existing FileType node, blocking until complete.

• addressSpace (AddressSpace) - Address space containing the node.
• existingInstance (const NodeId &) - Node id of the existing FileType instance to back.
• filePath (std::filesystem::path) - Filesystem path the FileType methods operate on.
• writable (bool) - Whether the file may be opened for writing (drives the Writable / UserWritable properties and rejects write opens when false).

Returns: The non-owning FileHelper, or an ErrorDetail on failure. Never throws.

FileHelper attach_sync(AddressSpace addressSpace, const NodeId &existingInstance, std::filesystem::path filePath, bool writable=true)

Wraps an existing FileType node, blocking until complete.

• addressSpace (AddressSpace) - Address space containing the node.
• existingInstance (const NodeId &) - Node id of the existing FileType instance to back.
• filePath (std::filesystem::path) - Filesystem path the FileType methods operate on.
• writable (bool) - Whether the file may be opened for writing (drives the Writable / UserWritable properties and rejects write opens when false).

Returns: The non-owning FileHelper.

Functions

FileHelper()=default

Constructs an empty helper that backs no node.

const NodeId & node_id() const

Returns the node id of the backed FileType instance.

Returns: The node id of the backed FileType instance.

const File & file() const

Returns the File handle wrapping the backed FileType instance.

Returns: The File handle wrapping the backed FileType instance.

Result< uint32_t > try_open_handle(uint8_t mode, const NodeId &sessionId={})

Open the backing file and return the FileType handle a Client would get from Open.

• mode (uint8_t) - OPC 10000-20 section 4.2.1 open-mode byte, as the Open Method takes it.
• sessionId (const NodeId &) - Session the handle is issued to, checked on every later call against it. Null for an internal caller, which forms its own handle space no Client can reach.

Returns: The new file handle, or an error if the backing file could not be opened.

void release()

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

std::shared_ptr< State > shared_state() const

The shared state backing this file's installed handlers.

Returns: The shared state; outlives this accessor, because the installed handlers hold it.

FileHelper(File file, std::shared_ptr< State > state)

Implementation-only constructor used by the install flow once handlers are wired and the File handle is ready.

• file (File) - The File handle wrapping the wired FileType node.
• state (std::shared_ptr< State >) - Shared state backing the installed method and property handlers.

ua::FileDirectoryHelper

Convenience class that backs a FileDirectoryType address-space node with a real filesystem directory.

The four FileDirectoryType methods are wired automatically against the backing directory path:

CreateFile creates a file on disk and a child FileType node backed by FileHelper. CreateDirectory creates a directory on disk and a child FileDirectoryType node backed recursively by FileDirectoryHelper. DeleteFileSystemObject deletes the file/directory on disk and removes the child node(s). MoveOrCopy currently returns BadNotSupported (cross-directory coordination is a planned follow-up).

Create-only: only objects created through the methods appear in the address space; pre-existing on-disk content is not reflected (a continuously-accurate view of an external directory belongs in a custom Namespace, not this helper). CreateFile with RequestFileOpen=true returns the new node with FileHandle 0 - clients open it via the File's Open method (auto-open-on-create is a follow-up).

The created subtree is owned by this handle through RAII: on destruction the instantiated node(s) are removed from the address space unless release has been called.

Static functions

FileDirectoryHelperResult try_create_sync(AddressSpace addressSpace, const NodeId &parent, const QualifiedName &browseName, std::filesystem::path dirPath, const InstantiationOptions &options, bool writable=true) noexcept

Creates a new FileDirectoryType instance under parent, backed by dirPath, and wires all method handlers.

• addressSpace (AddressSpace) - Address space the new node is instantiated into.
• parent (const NodeId &) - Node the new FileDirectoryType instance is organized under.
• browseName (const QualifiedName &) - BrowseName of the new instance.
• dirPath (std::filesystem::path) - Filesystem directory backing the node; created if absent.
• options (const InstantiationOptions &) - Instantiation options for the new subtree.
• writable (bool) - Whether the directory and its created files accept writes.

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

FileDirectoryHelper create_sync(AddressSpace addressSpace, const NodeId &parent, const QualifiedName &browseName, std::filesystem::path dirPath, const InstantiationOptions &options, bool writable=true)

Creates a new FileDirectoryType instance under parent, backed by dirPath, and wires all method handlers.

• addressSpace (AddressSpace) - Address space the new node is instantiated into.
• parent (const NodeId &) - Node the new FileDirectoryType instance is organized under.
• browseName (const QualifiedName &) - BrowseName of the new instance.
• dirPath (std::filesystem::path) - Filesystem directory backing the node; created if absent.
• options (const InstantiationOptions &) - Instantiation options for the new subtree.
• writable (bool) - Whether the directory and its created files accept writes.

Returns: The owning helper.

FileDirectoryHelperResult try_attach_sync(AddressSpace addressSpace, const NodeId &existingInstance, std::filesystem::path dirPath, const InstantiationOptions &options, bool writable=true) noexcept

Wraps an existing FileDirectoryType node and wires all method handlers against dirPath.

• addressSpace (AddressSpace) - Address space containing the node.
• existingInstance (const NodeId &) - FileDirectoryType node to wire method handlers onto.
• dirPath (std::filesystem::path) - Filesystem directory the wrapped node operates on.
• options (const InstantiationOptions &) - Instantiation options applied to children created via the methods.
• writable (bool) - Whether the directory and its created files accept writes.

Returns: The helper on success, or an ErrorDetail on failure. Never throws.

Functions

FileDirectoryHelper()=default

Constructs an empty handle that owns no node and wires no method handlers.

const NodeId & node_id() const

Returns the NodeId of the backed FileDirectoryType node.

Returns: The NodeId of the backed FileDirectoryType node.

const FileDirectory & directory() const

Returns the typed accessor for the backed FileDirectoryType node.

Returns: The typed FileDirectory accessor for the backed node.

void release()

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

std::shared_ptr< State > shared_state() const

The shared state backing this directory's installed handlers.

Returns: The shared state; outlives this accessor, because the installed handlers hold it.

FileDirectoryHelper(FileDirectory directory, std::shared_ptr< State > state)

Constructs a helper bound to an already-instantiated directory and its shared state.

• directory (FileDirectory) - Typed accessor for the backed FileDirectoryType node.
• state (std::shared_ptr< State >) - Shared state driving the installed method handlers.

ua::TemporaryFileTransferConfig

Configuration and host hooks for a TemporaryFileTransferHelper.

Carries the on-disk location and instantiation limits for transient transfer files, plus two optional host callbacks (onCommit, onGenerateForRead) that decide what an uploaded file becomes and what bytes a read transfer serves. Both callbacks default to unset, which yields a scratch transfer (uploads discarded, reads served an empty file).

Public attributes

std::filesystem::path tempDir

Filesystem directory holding the transient transfer files.

NodeId transientFileParent

Node under which transient FileType nodes are created (browsable).

EncodingLimits limits

Encoding limits applied when instantiating transient File nodes.

std::function< VoidResult(const std::filesystem::path &uploadedFile, shared_ptr< const MethodCallContext >)> onCommit

Invoked on CloseAndCommit of a write transfer with the path of the uploaded temp file.

std::function< Result< std::filesystem::path >(const Variant &generateOptions, shared_ptr< const MethodCallContext >)> onGenerateForRead

Invoked on GenerateFileForRead to obtain the file the client will read.

ua::TemporaryFileTransferHelper

Convenience class backing a TemporaryFileTransferType node in the address space.

Implements the GenerateFileForWrite, GenerateFileForRead, and CloseAndCommit methods. Each transfer gets a transient FileType node backed by a FileHelper over a temp file in TemporaryFileTransferConfig::tempDir; CloseAndCommit invokes the host commit hook (for write transfers), then removes the transient node and temp file. Transfers complete synchronously, so the CompletionStateMachine output is left null (valid for synchronous completion).

This is a value handle that holds shared ownership of the created subtree. Copying shares the same backing state; destroying the last handle tears the subtree down unless release was called first.

Static functions

TemporaryFileTransferHelperResult try_create_sync(AddressSpace addressSpace, const NodeId &parent, const QualifiedName &browseName, const InstantiationOptions &options, TemporaryFileTransferConfig config) noexcept

Instantiates a TemporaryFileTransferType node under parent and backs it with this helper.

• addressSpace (AddressSpace) - Address space the node is created in.
• parent (const NodeId &) - Node under which the transfer object is instantiated.
• browseName (const QualifiedName &) - Browse name of the new transfer object.
• options (const InstantiationOptions &) - Instantiation options for the created subtree.
• config (TemporaryFileTransferConfig) - Configuration and host hooks (see TemporaryFileTransferConfig).

Returns: The helper handle on success, or an ErrorDetail on failure. Never throws.

TemporaryFileTransferHelper create_sync(AddressSpace addressSpace, const NodeId &parent, const QualifiedName &browseName, const InstantiationOptions &options, TemporaryFileTransferConfig config)

Instantiates a TemporaryFileTransferType node under parent and backs it with this helper.

• addressSpace (AddressSpace) - Address space the node is created in.
• parent (const NodeId &) - Node under which the transfer object is instantiated.
• browseName (const QualifiedName &) - Browse name of the new transfer object.
• options (const InstantiationOptions &) - Instantiation options for the created subtree.
• config (TemporaryFileTransferConfig) - Configuration and host hooks (see TemporaryFileTransferConfig).

Returns: The helper handle.

Functions

TemporaryFileTransferHelper()=default

Constructs an empty handle that backs no node.

const NodeId & node_id() const

Returns the node id of the instantiated transfer object.

Returns: The node id of the instantiated transfer object.

const TemporaryFileTransfer & transfer() const

Returns the underlying TemporaryFileTransfer wrapper for the instantiated node.

Returns: The TemporaryFileTransfer wrapper for the instantiated node.

void release()

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

TemporaryFileTransferHelper(TemporaryFileTransfer transfer, std::shared_ptr< State > state)

Constructs a helper that wraps an already-instantiated transfer object and its backing state.

• transfer (TemporaryFileTransfer) - Wrapper for the instantiated TemporaryFileTransferType node.
• state (std::shared_ptr< State >) - Shared backing state owning the transient transfer machinery.

ua::BaseObject

Handle to an Object node whose type definition is the base BaseObjectType (i=58).

Wraps an existing or freshly instantiated Object node together with the AddressSpace it lives in. When the handle owns the node subtree it created, destroying the handle without first calling release removes that subtree from the address space; an attached handle (see attach_async) owns nothing and only references the node.

Move-only: copying would duplicate ownership of the underlying subtree. This type serves both as a usable handle and as the base class for generated, strongly typed Object handles, which call create_object_impl_async to instantiate.

Member types

Result< CreateResultData > CreateResult

Result carrying the outcome of an Object instantiation.

std::function< void(CreateResult)> CreateImplCompleteCallback

Callback receiving the CreateResult of create_object_impl_async.

std::function< void(BaseObjectResult)> AttachCompleteCallback

Callback receiving the BaseObjectResult of attach_async.

Static functions

void attach_async(AddressSpace addressSpace, const NodeId &existingInstance, AttachCompleteCallback complete) noexcept

Attaches an existing Object node as a BaseObject handle.

• addressSpace (AddressSpace) - Address space containing the node.
• existingInstance (const NodeId &) - NodeId of the Object node to attach.
• complete (AttachCompleteCallback) - Receives the outcome: on success the Result holds the BaseObject handle; on failure it carries an ErrorDetail. This overload never throws.

Functions

BaseObject()=default

Constructs an empty handle that references no node.

~BaseObject()=default

BaseObject(BaseObject &&) noexcept=default

Transfers ownership of the referenced node and any owned subtree from the moved-from handle, leaving it empty.

BaseObject & operator=(BaseObject &&) noexcept=default

Transfers ownership of the referenced node and any owned subtree from the moved-from handle, leaving it empty.

Returns: Reference to this handle after the move.

const NodeId & node_id() const

Returns the NodeId of the referenced Object node.

Returns: The NodeId of the referenced node; a null NodeId when the handle is empty.

void release()

Releases ownership of the node subtree this handle created.

ua::BaseVariable

Handle to a Variable node whose type definition is the base BaseVariableType (i=62).

Wraps an existing or freshly instantiated Variable node together with the AddressSpace it lives in, and exposes the variable's live value: reading and writing the value, and installing the read/write handlers that produce and consume it. A Variable's value is dynamic and possibly externally sourced - it is never a stored attribute, so it is always accessed through this handle's value API rather than via attribute read/write.

When the handle owns the node subtree it created, destroying the handle without first calling release removes that subtree from the address space; a handle that references a pre-existing node owns nothing and only references it.

Move-only: copying would duplicate ownership of the underlying subtree. This type serves both as a usable handle and as the base class for generated, strongly typed Variable handles, which call create_variable_impl_async to instantiate.

Member types

std::function< void(DataValueResult)> ReadValueCompleteCallback

Callback receiving the DataValueResult of read_value_async.

std::function< void(VoidResult)> WriteValueCompleteCallback

Callback receiving the VoidResult of write_value_async.

Result< CreateResultData > CreateResult

Result carrying the outcome of a Variable instantiation.

std::function< void(CreateResult)> CreateImplCompleteCallback

Callback receiving the CreateResult of create_variable_impl_async.

Functions

BaseVariable()=default

Constructs an empty handle that references no node.

~BaseVariable()=default

BaseVariable(BaseVariable &&) noexcept=default

Transfers ownership of the referenced node and any owned subtree from the moved-from handle, leaving it empty.

BaseVariable & operator=(BaseVariable &&) noexcept=default

Transfers ownership of the referenced node and any owned subtree from the moved-from handle, leaving it empty.

Returns: Reference to this handle after the move.

const NodeId & node_id() const

Returns the NodeId of the referenced Variable node.

Returns: The NodeId of the referenced node; a null NodeId when the handle is empty.

void release()

Releases ownership of the node subtree this handle created.

void read_value_async(ReadValueCompleteCallback complete) const noexcept

Reads the variable's live value asynchronously.

• complete (ReadValueCompleteCallback) - Receives the outcome: on success the Result holds the DataValue; on failure it carries an ErrorDetail. A null callback is ignored and the read is not performed. This overload never throws.

DataValueResult try_read_value_sync() const noexcept

Reads the variable's live value, blocking until complete.

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

DataValue read_value_sync() const

Reads the variable's live value, blocking until complete.

Returns: The DataValue.

void write_value_async(DataValue value, WriteValueCompleteCallback complete) const noexcept

Writes the variable's live value asynchronously.

• value (DataValue) - The DataValue to write (value, status, timestamps).
• complete (WriteValueCompleteCallback) - Receives the outcome: on success an empty Result; on failure it carries an ErrorDetail. A null callback is ignored and the write is not performed. This overload never throws.

VoidResult try_write_value_sync(DataValue value) const noexcept

Writes the variable's live value, blocking until complete.

• value (DataValue) - The DataValue to write.

Returns: An empty Result on success, or an ErrorDetail on failure. Never throws.

void write_value_sync(DataValue value) const

Writes the variable's live value, blocking until complete.

• value (DataValue) - The DataValue to write.

void set_read_handler_async(ExternalValueSource::ReadValueHandler handler, std::function< void(VoidResult)> done) const noexcept

Installs the read handler that produces the variable's value asynchronously.

• handler (ExternalValueSource::ReadValueHandler) - The read handler to install (see ExternalValueSource).
• done (std::function< void(VoidResult)>) - Receives the outcome: on success an empty Result; on failure it carries an ErrorDetail (e.g. the node does not support handler registration). A null callback is ignored and the handler is not installed. This overload never throws.

VoidResult try_set_read_handler_sync(ExternalValueSource::ReadValueHandler handler) const noexcept

Installs the read handler that produces the variable's value, blocking until complete.

• handler (ExternalValueSource::ReadValueHandler) - The read handler to install (see ExternalValueSource).

Returns: An empty Result on success, or an ErrorDetail on failure. Never throws.

void set_read_handler_sync(ExternalValueSource::ReadValueHandler handler) const

Installs the read handler that produces the variable's value, blocking until complete.

• handler (ExternalValueSource::ReadValueHandler) - The read handler to install (see ExternalValueSource).

void set_write_handler_async(ExternalValueSource::WriteValueHandler handler, std::function< void(VoidResult)> done) const noexcept

Installs the write handler that consumes the variable's value asynchronously.

• handler (ExternalValueSource::WriteValueHandler) - The write handler to install (see ExternalValueSource).
• done (std::function< void(VoidResult)>) - Receives the outcome: on success an empty Result; on failure it carries an ErrorDetail (e.g. the node does not support handler registration). A null callback is ignored and the handler is not installed. This overload never throws.

VoidResult try_set_write_handler_sync(ExternalValueSource::WriteValueHandler handler) const noexcept

Installs the write handler that consumes the variable's value, blocking until complete.

• handler (ExternalValueSource::WriteValueHandler) - The write handler to install (see ExternalValueSource).

Returns: An empty Result on success, or an ErrorDetail on failure. Never throws.

void set_write_handler_sync(ExternalValueSource::WriteValueHandler handler) const

Installs the write handler that consumes the variable's value, blocking until complete.

• handler (ExternalValueSource::WriteValueHandler) - The write handler to install (see ExternalValueSource).

ua::ChildFilterInfo

Describes a non-mandatory child declaration offered to the optional-child filter.

One instance is passed to an OptionalChildFilter for each candidate child so the filter can decide whether to instantiate it.

Public attributes

QualifiedName mBrowseName

Browse name of the candidate child.

NodeClass mNodeClass

Node class of the candidate child.

NodeId mTypeDefinition

Type definition of the child; empty if it has no HasTypeDefinition reference.

ua::InstantiationOptions

Tunable options controlling a single type-instantiation operation.

All fields are optional; a default-constructed instance instantiates only mandatory children using the SDK's default string-based NodeId allocation.

Public attributes

ua::EncodingLimits mLimits

Recursion/size limits bounding the instantiation work.

std::optional< NodeId > mParentReferenceType

Reference type linking the parent to the new instance; unset uses the SDK default.

NodeIdAllocator mNodeIdAllocator

Custom allocator for node IDs.

OptionalChildFilter mOptionalChildFilter

Filter deciding which non-mandatory children to instantiate.

std::optional< uint16_t > mTargetNamespaceIndex

Namespace index override for the entire instantiated subtree.

bool mInstantiateNestedTypeOptionals

Also instantiate OPTIONAL children declared on a child's TYPE DEFINITION but not redeclared on its instance declaration (e.g.

ua::VariableInstantiationAttributes

Attribute overrides applied to a Variable node as it is instantiated.

Passed to InstantiationService::instantiate_variable_async to set instance-specific Variable attributes that differ from the VariableType definition. Each field is optional: an absent (std::nullopt) field leaves the attribute at the value inherited from the type definition, while a present field overrides it on the new instance.

Public attributes

std::optional< NodeId > mDataType

DataType of the instance's Value, or std::nullopt to inherit from the type.

std::optional< int32_t > mValueRank

ValueRank of the instance, or std::nullopt to inherit from the type.

std::optional< AccessLevelType > mAccessLevel

AccessLevel bitmask of the instance, or std::nullopt to leave the node's default.

ua::InstantiationService

Instantiates type-defined nodes (objects, variables, and optional members) into an address space.

Walks an ObjectType or VariableType definition and materialises its mandatory children (and any selected optional members) under a parent node, allocating NodeIds, attaching HasTypeDefinition and parent edges, and copying attributes recursively. Every operation posts to the owning AddressSpace strand and completes asynchronously on an unspecified worker thread.

The service holds the AddressSpace by value; the caller need not keep its own copy alive for the duration of a call.

Member types

std::function< void(NodeSubtreeResult)> InstantiateCompleteCallback

Completion callback for an instantiation that creates a node subtree.

Functions

InstantiationService(AddressSpace addressSpace)

Constructs a service that instantiates into the given address space.

• addressSpace (AddressSpace) - Address space the service materialises nodes into; held by value for the lifetime of the service.

void instantiate_object_async(const NodeId &parent, const QualifiedName &browseName, const NodeId &typeDefinition, const InstantiationOptions &options, InstantiateCompleteCallback complete) const noexcept

Instantiates an object of typeDefinition as a child of parent.

• parent (const NodeId &) - Node the new object is attached to as a child.
• browseName (const QualifiedName &) - Browse name of the new object node.
• typeDefinition (const NodeId &) - ObjectType whose definition is instantiated.
• options (const InstantiationOptions &) - Allocation and filtering policy; see InstantiationOptions.
• complete (InstantiateCompleteCallback) - Receives the outcome: on success a NodeSubtree rooted at the new object, on failure an ErrorDetail. This overload never throws.

void instantiate_variable_async(const NodeId &parent, const QualifiedName &browseName, const NodeId &typeDefinition, const InstantiationOptions &options, const VariableInstantiationAttributes &attributes, InstantiateCompleteCallback complete) const noexcept

Instantiates a variable of typeDefinition as a child of parent.

• parent (const NodeId &) - Node the new variable is attached to as a child.
• browseName (const QualifiedName &) - Browse name of the new variable node.
• typeDefinition (const NodeId &) - VariableType whose definition is instantiated.
• options (const InstantiationOptions &) - Allocation and filtering policy; see InstantiationOptions.
• attributes (const VariableInstantiationAttributes &) - Variable-specific attributes applied to the created node.
• complete (InstantiateCompleteCallback) - Receives the outcome: on success a NodeSubtree rooted at the new variable, on failure an ErrorDetail. This overload never throws.

void instantiate_optional_members_async(const NodeId &instance, const NodeId &typeDefinition, const InstantiationOptions &options, OptionalChildFilter optionalFilter, std::function< void(VoidResult)> complete) const noexcept

Materialises the optional members of typeDefinition onto an existing instance.

• instance (const NodeId &) - Existing node the selected members are added to.
• typeDefinition (const NodeId &) - Type whose optional members are considered.
• options (const InstantiationOptions &) - Allocation policy; see InstantiationOptions.
• optionalFilter (OptionalChildFilter) - Predicate selecting which non-mandatory members to materialise; see OptionalChildFilter.
• complete (std::function< void(VoidResult)>) - Receives the outcome: a success VoidResult, or an ErrorDetail on failure. This overload never throws.

ua::NodeSubtree

An owning, move-only handle to the nodes produced by a single instantiation.

Returned by the instantiation engine, it records the subtree's root. On destruction the handle fires a fire-and-forget async delete of exactly the nodes it created (reverse creation order, one single-node AddressSpace::delete_node_async each - not a reference-walked cascade) - never a blocking/synchronous call - giving instantiated subtrees RAII lifetime tied to this object. Call release() to keep the nodes alive past the handle's lifetime, or remove_async() to delete them eagerly.

The handle is move-only: moving transfers ownership and leaves the source released, so only one handle ever owns a given subtree.

Functions

NodeSubtree()=default

Constructs an empty handle that owns no nodes.

NodeSubtree(AddressSpace addressSpace, NodeId rootId, std::vector< NodeId > createdNodes)

Constructs a handle owning a freshly instantiated subtree.

• addressSpace (AddressSpace) - Address space the nodes live in and are deleted from on cleanup; copied and retained by the handle.
• rootId (NodeId) - Node id of the subtree's root.
• createdNodes (std::vector< NodeId >) - Ids of every node created for the subtree, in creation order; cleanup deletes them in reverse.

NodeSubtree(NodeSubtree &&other) noexcept

Move-constructs, transferring ownership and leaving other released.

• other (NodeSubtree &&) - Handle whose owned subtree is transferred; left released.

NodeSubtree & operator=(NodeSubtree &&other) noexcept

Move-assigns, removing this handle's current subtree before taking other's.

• other (NodeSubtree &&) - Handle whose owned subtree is adopted; left released.

Returns: Reference to this handle.

~NodeSubtree()

Deletes the owned nodes unless the handle was released or already removed.

const NodeId & root() const

Returns the node id of the subtree's root.

Returns: The NodeId identifying the subtree's root node.

void release()

Abandons ownership so the nodes are not deleted on destruction.

void remove_async()

Asynchronously deletes the owned subtree and releases the handle.

void add_created_node(NodeId id)

Records a node as part of the owned subtree so cleanup will delete it.

• id (NodeId) - Node id to track for cleanup.

ua::ReferenceView

Immutable, XML-free view of a single reference, passed to reference_filter.

Functions

ReferenceView(NodeId referenceTypeId, NodeId targetId, bool isForward)

Constructs a view over one reference.

• referenceTypeId (NodeId) - File-local NodeId of the reference type.
• targetId (NodeId) - File-local NodeId of the referenced (target) node.
• isForward (bool) - True for a forward reference, false for an inverse one.

const NodeId & reference_type_id() const

File-local NodeId of the reference type.

Returns: The file-local NodeId of the reference type.

const NodeId & target_id() const

File-local NodeId of the referenced (target) node.

Returns: The file-local NodeId of the referenced (target) node.

bool is_forward() const

True if the reference points forward, false if it is inverse.

Returns: True if the reference points forward, false if it is inverse.

ua::NodeView

Immutable, XML-free view of a single node.

Backed by the (private) parse-tree node via a non-owning typed pointer; the accessors below are the only surface customers see. Ids and names are in the file's own (document-local) namespace, matching what a node_filter decides about before any server-side translation. The richer accessors (references, as_data_type, as_variable) require a parsed NodeSetDocument context; in a bare node_filter they return empty.

Functions

NodeView(const ua::xml::nodeset::Node *node, const NodeSetDocumentImpl *document=nullptr)

Constructs a view over a parse-tree node, with an optional document context.

• node (const ua::xml::nodeset::Node *) - Non-owning pointer to the private parse-tree node.
• document (const NodeSetDocumentImpl *) - Non-owning pointer to the owning document context, or nullptr when the view is supplied to a bare node_filter (richer accessors then return empty).

NodeId node_id() const

File-local NodeId of this node.

Returns: This node's file-local NodeId.

QualifiedName browse_name() const

File-local browse name of this node.

Returns: This node's file-local browse name.

NodeClass node_class() const

NodeClass of this node.

Returns: This node's NodeClass.

optional< String > category() const

The node's Category annotation, or empty if absent.

Returns: The node's Category annotation, or empty if the node has none.

optional< NodeReleaseStatus > release_status() const

The node's <ReleaseStatus> annotation, or empty if unspecified.

Returns: The node's release status, or empty if the annotation is unspecified.

optional< XmlElement > extensions() const

The node's raw <Extensions> block, or empty if absent.

Returns: The node's raw <Extensions> block, or empty if absent.

std::vector< ReferenceView > references() const