Node Store Plugin API¶
Warning!! The structures defined in this section are only relevant for the developers of custom Nodestores. The interaction with the information model is possible only via the OPC UA Services. So the following sections are purely informational so that users may have a clear mental model of the underlying representation.
Node Lifecycle: Constructors, Destructors and Node Contexts¶
To finalize the instantiation of a node, a (user-defined) constructor callback is executed. There can be both a global constructor for all nodes and node-type constructor specific to the TypeDefinition of the new node (attached to an ObjectTypeNode or VariableTypeNode).
In the hierarchy of ObjectTypes and VariableTypes, only the constructor of
the (lowest) type defined for the new node is executed. Note that every
Object and Variable can have only one isTypeOf reference. But type-nodes
can technically have several hasSubType references to implement multiple
inheritance. Issues of (multiple) inheritance in the constructor need to be
solved by the user.
When a node is destroyed, the node-type destructor is called before the global destructor. So the overall node lifecycle is as follows:
Global Constructor (set in the server config)
Node-Type Constructor (for VariableType or ObjectTypes)
(Usage-period of the Node)
Node-Type Destructor
Global Destructor
The constructor and destructor callbacks can be set to NULL and are not
used in that case. If the node-type constructor fails, the global destructor
will be called before removing the node. The destructors are assumed to never
fail.
Every node carries a user-context and a constructor-context pointer. The
user-context is used to attach custom data to a node. But the (user-defined)
constructors and destructors may replace the user-context pointer if they
wish to do so. The initial value for the constructor-context is NULL.
When the AddNodes service is used over the network, the user-context
pointer of the new node is also initially set to NULL.
Global Node Lifecycle¶
Global constructor and destructor callbacks used for every node type. To be set in the server config.
typedef struct {
/* Can be NULL. May replace the nodeContext */
UA_StatusCode (*constructor)(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeId, void **nodeContext);
/* Can be NULL. The context cannot be replaced since the node is destroyed
* immediately afterwards anyway. */
void (*destructor)(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *nodeId, void *nodeContext);
/* Can be NULL. Called during recursive node instantiation. While mandatory
* child nodes are automatically created if not already present, optional child
* nodes are not. This callback can be used to define whether an optional child
* node should be created.
*
* @param server The server executing the callback
* @param sessionId The identifier of the session
* @param sessionContext Additional data attached to the session in the
* access control layer
* @param sourceNodeId Source node from the type definition. If the new node
* shall be created, it will be a copy of this node.
* @param targetParentNodeId Parent of the potential new child node
* @param referenceTypeId Identifies the reference type which that the parent
* node has to the new node.
* @return Return UA_TRUE if the child node shall be instantiated,
* UA_FALSE otherwise. */
UA_Boolean (*createOptionalChild)(UA_Server *server,
const UA_NodeId *sessionId,
void *sessionContext,
const UA_NodeId *sourceNodeId,
const UA_NodeId *targetParentNodeId,
const UA_NodeId *referenceTypeId);
/* Can be NULL. Called when a node is to be copied during recursive
* node instantiation. Allows definition of the NodeId for the new node.
* If the callback is set to NULL or the resulting NodeId is UA_NODEID_NUMERIC(X,0)
* an unused nodeid in namespace X will be used. E.g. passing UA_NODEID_NULL will
* result in a NodeId in namespace 0.
*
* @param server The server executing the callback
* @param sessionId The identifier of the session
* @param sessionContext Additional data attached to the session in the
* access control layer
* @param sourceNodeId Source node of the copy operation
* @param targetParentNodeId Parent node of the new node
* @param referenceTypeId Identifies the reference type which that the parent
* node has to the new node. */
UA_StatusCode (*generateChildNodeId)(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *sourceNodeId,
const UA_NodeId *targetParentNodeId,
const UA_NodeId *referenceTypeId,
UA_NodeId *targetNodeId);
} UA_GlobalNodeLifecycle;
Node Type Lifecycle¶
Constructor and destructors for specific object and variable types.
typedef struct {
/* Can be NULL. May replace the nodeContext */
UA_StatusCode (*constructor)(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *typeNodeId, void *typeNodeContext,
const UA_NodeId *nodeId, void **nodeContext);
/* Can be NULL. May replace the nodeContext. */
void (*destructor)(UA_Server *server,
const UA_NodeId *sessionId, void *sessionContext,
const UA_NodeId *typeNodeId, void *typeNodeContext,
const UA_NodeId *nodeId, void **nodeContext);
} UA_NodeTypeLifecycle;
ReferenceType Bitfield Representation¶
ReferenceTypes have an alternative represention as an index into a bitfield for fast comparison. The index is generated when the corresponding ReferenceTypeNode is added. By bounding the number of ReferenceTypes that can exist in the server, the bitfield can represent a set of an combination of ReferenceTypes.
Every ReferenceTypeNode contains a bitfield with the set of all its subtypes. This speeds up the Browse services substantially.
The following ReferenceTypes have a fixed index. The NS0 bootstrapping creates these ReferenceTypes in-order.
#define UA_REFERENCETYPEINDEX_REFERENCES 0
#define UA_REFERENCETYPEINDEX_HASSUBTYPE 1
#define UA_REFERENCETYPEINDEX_AGGREGATES 2
#define UA_REFERENCETYPEINDEX_HIERARCHICALREFERENCES 3
#define UA_REFERENCETYPEINDEX_NONHIERARCHICALREFERENCES 4
#define UA_REFERENCETYPEINDEX_HASCHILD 5
#define UA_REFERENCETYPEINDEX_ORGANIZES 6
#define UA_REFERENCETYPEINDEX_HASEVENTSOURCE 7
#define UA_REFERENCETYPEINDEX_HASMODELLINGRULE 8
#define UA_REFERENCETYPEINDEX_HASENCODING 9
#define UA_REFERENCETYPEINDEX_HASDESCRIPTION 10
#define UA_REFERENCETYPEINDEX_HASTYPEDEFINITION 11
#define UA_REFERENCETYPEINDEX_GENERATESEVENT 12
#define UA_REFERENCETYPEINDEX_HASPROPERTY 13
#define UA_REFERENCETYPEINDEX_HASCOMPONENT 14
#define UA_REFERENCETYPEINDEX_HASNOTIFIER 15
#define UA_REFERENCETYPEINDEX_HASORDEREDCOMPONENT 16
#define UA_REFERENCETYPEINDEX_HASINTERFACE 17
/* The maximum number of ReferrenceTypes. Must be a multiple of 32. */
#define UA_REFERENCETYPESET_MAX 128
typedef struct {
UA_UInt32 bits[UA_REFERENCETYPESET_MAX / 32];
} UA_ReferenceTypeSet;
extern const UA_ReferenceTypeSet UA_REFERENCETYPESET_NONE;
extern const UA_ReferenceTypeSet UA_REFERENCETYPESET_ALL;
static UA_INLINE void
UA_ReferenceTypeSet_init(UA_ReferenceTypeSet *set) {
memset(set, 0, sizeof(UA_ReferenceTypeSet));
}
static UA_INLINE UA_ReferenceTypeSet
UA_REFTYPESET(UA_Byte index) {
UA_Byte i = index / 32, j = index % 32;
UA_ReferenceTypeSet set;
UA_ReferenceTypeSet_init(&set);
set.bits[i] |= ((UA_UInt32)1) << j;
return set;
}
static UA_INLINE UA_ReferenceTypeSet
UA_ReferenceTypeSet_union(const UA_ReferenceTypeSet setA,
const UA_ReferenceTypeSet setB) {
UA_ReferenceTypeSet set;
for(size_t i = 0; i < UA_REFERENCETYPESET_MAX / 32; i++)
set.bits[i] = setA.bits[i] | setB.bits[i];
return set;
}
static UA_INLINE UA_Boolean
UA_ReferenceTypeSet_contains(const UA_ReferenceTypeSet *set, UA_Byte index) {
UA_Byte i = index / 32, j = index % 32;
return !!(set->bits[i] & (((UA_UInt32)1) << j));
}
Node Pointer¶
The “native” format for reference between nodes is the ExpandedNodeId. That is, references can also point to external servers. In practice, most references point to local nodes using numerical NodeIds from the standard-defined namespace zero. In order to save space (and time), pointer-tagging is used for compressed “NodePointer” representations. Numerical NodeIds are immediately contained in the pointer. Full NodeIds and ExpandedNodeIds are behind a pointer indirection. If the Nodestore supports it, a NodePointer can also be an actual pointer to the target node.
Depending on the processor architecture, some numerical NodeIds don’t fit into an immediate encoding and are kept as pointers. ExpandedNodeIds may be internally translated to “normal” NodeIds. Use the provided functions to generate NodePointers that fit the assumptions for the local architecture.
/* Forward declaration. All node structures begin with the NodeHead. */
struct UA_NodeHead;
typedef struct UA_NodeHead UA_NodeHead;
/* Tagged Pointer structure. */
typedef union {
uintptr_t immediate; /* 00: Small numerical NodeId */
const UA_NodeId *id; /* 01: Pointer to NodeId */
const UA_ExpandedNodeId *expandedId; /* 10: Pointer to ExternalNodeId */
const UA_NodeHead *node; /* 11: Pointer to a node */
} UA_NodePointer;
/* Sets the pointer to an immediate NodeId "ns=0;i=0" similar to a freshly
* initialized UA_NodeId */
static UA_INLINE void
UA_NodePointer_init(UA_NodePointer *np) { np->immediate = 0; }
/* NodeId and ExpandedNodeId targets are freed */
void
UA_NodePointer_clear(UA_NodePointer *np);
/* Makes a deep copy */
UA_StatusCode
UA_NodePointer_copy(UA_NodePointer in, UA_NodePointer *out);
/* Test if an ExpandedNodeId or a local NodeId */
UA_Boolean
UA_NodePointer_isLocal(UA_NodePointer np);
UA_Order
UA_NodePointer_order(UA_NodePointer p1, UA_NodePointer p2);
static UA_INLINE UA_Boolean
UA_NodePointer_equal(UA_NodePointer p1, UA_NodePointer p2) {
return (UA_NodePointer_order(p1, p2) == UA_ORDER_EQ);
}
/* Cannot fail. The resulting NodePointer can point to the memory from the
* NodeId. Make a deep copy if required. */
UA_NodePointer
UA_NodePointer_fromNodeId(const UA_NodeId *id);
/* Cannot fail. The resulting NodePointer can point to the memory from the
* ExpandedNodeId. Make a deep copy if required. */
UA_NodePointer
UA_NodePointer_fromExpandedNodeId(const UA_ExpandedNodeId *id);
/* Can point to the memory from the NodePointer */
UA_ExpandedNodeId
UA_NodePointer_toExpandedNodeId(UA_NodePointer np);
/* Can point to the memory from the NodePointer. Discards the ServerIndex and
* NamespaceUri of a potential ExpandedNodeId inside the NodePointer. Test
* before if the NodePointer is local. */
UA_NodeId
UA_NodePointer_toNodeId(UA_NodePointer np);
Base Node Attributes¶
Nodes contain attributes according to their node type. The base node attributes are common to all node types. In the OPC UA Services, attributes are referred to via the NodeId of the containing node and an integer Attribute Id.
Internally, open62541 uses UA_Node in places where the exact node type is
not known or not important. The nodeClass attribute is used to ensure the
correctness of casting from UA_Node to a specific node type.
typedef struct {
UA_NodePointer targetId; /* Has to be the first entry */
UA_UInt32 targetNameHash; /* Hash of the target's BrowseName. Set to zero
* if the target is remote. */
} UA_ReferenceTarget;
typedef struct UA_ReferenceTargetTreeElem {
UA_ReferenceTarget target; /* Has to be the first entry */
UA_UInt32 targetIdHash; /* Hash of the targetId */
struct {
struct UA_ReferenceTargetTreeElem *left;
struct UA_ReferenceTargetTreeElem *right;
} idTreeEntry;
struct {
struct UA_ReferenceTargetTreeElem *left;
struct UA_ReferenceTargetTreeElem *right;
} nameTreeEntry;
} UA_ReferenceTargetTreeElem;
/* List of reference targets with the same reference type and direction. Uses
* either an array or a tree structure. The SDK will not change the type of
* reference target structure internally. The nodestore implementations may
* switch internally when a node is updated.
*
* The recommendation is to switch to a tree once the number of refs > 8. */
typedef struct {
union {
/* Organize the references in an array. Uses less memory, but incurs
* lookups in linear time. Recommended if the number of references is
* known to be small. */
UA_ReferenceTarget *array;
/* Organize the references in a tree for fast lookup. Use
* UA_Node_addReference and UA_Node_deleteReference to modify the
* tree-structure. The binary tree implementation (and absolute ordering
* / duplicate browseNames are allowed) are not exposed otherwise in the
* public API. */
struct {
UA_ReferenceTargetTreeElem *idRoot; /* Lookup based on target id */
UA_ReferenceTargetTreeElem *nameRoot; /* Lookup based on browseName*/
} tree;
} targets;
size_t targetsSize;
UA_Boolean hasRefTree; /* RefTree or RefArray? */
UA_Byte referenceTypeIndex;
UA_Boolean isInverse;
} UA_NodeReferenceKind;
/* Iterate over the references. Aborts when the first callback return a non-NULL
* pointer and returns that pointer. Do not modify the reference targets during
* the iteration. */
typedef void *
(*UA_NodeReferenceKind_iterateCallback)(void *context, UA_ReferenceTarget *target);
void *
UA_NodeReferenceKind_iterate(UA_NodeReferenceKind *rk,
UA_NodeReferenceKind_iterateCallback callback,
void *context);
/* Returns the entry for the targetId or NULL if not found */
const UA_ReferenceTarget *
UA_NodeReferenceKind_findTarget(const UA_NodeReferenceKind *rk,
const UA_ExpandedNodeId *targetId);
/* Switch between array and tree representation. Does nothing upon error (e.g.
* out-of-memory). */
UA_StatusCode
UA_NodeReferenceKind_switch(UA_NodeReferenceKind *rk);
/* Singly-linked LocalizedText list */
typedef struct UA_LocalizedTextListEntry {
struct UA_LocalizedTextListEntry *next;
UA_LocalizedText localizedText;
} UA_LocalizedTextListEntry;
/* Every Node starts with these attributes */
struct UA_NodeHead {
UA_NodeId nodeId;
UA_NodeClass nodeClass;
UA_QualifiedName browseName;
/* A node can have different localizations for displayName and description.
* The server selects a suitable localization depending on the locale ids
* that are set for the current session.
*
* Locales are added simply by writing a LocalizedText value with a new
* locale. A locale can be removed by writing a LocalizedText value of the
* corresponding locale with an empty text field. */
UA_LocalizedTextListEntry *displayName;
UA_LocalizedTextListEntry *description;
UA_UInt32 writeMask;
size_t referencesSize;
UA_NodeReferenceKind *references;
/* Members specific to open62541 */
void *context;
UA_Boolean constructed; /* Constructors were called */
#ifdef UA_ENABLE_SUBSCRIPTIONS
UA_MonitoredItem *monitoredItems; /* MonitoredItems for Events and immediate
* DataChanges (no sampling interval). */
#endif
};
VariableNode¶
/* Indicates whether a variable contains data inline or whether it points to an
* external data source */
typedef enum {
UA_VALUESOURCE_DATA,
UA_VALUESOURCE_DATASOURCE
} UA_ValueSource;
typedef struct {
/* Called before the value attribute is read. It is possible to write into the
* value attribute during onRead (using the write service). The node is
* re-opened afterwards so that changes are considered in the following read
* operation.
*
* @param handle Points to user-provided data for the callback.
* @param nodeid The identifier of the node.
* @param data Points to the current node value.
* @param range Points to the numeric range the client wants to read from
* (or NULL). */
void (*onRead)(UA_Server *server, const UA_NodeId *sessionId,
void *sessionContext, const UA_NodeId *nodeid,
void *nodeContext, const UA_NumericRange *range,
const UA_DataValue *value);
/* Called after writing the value attribute. The node is re-opened after
* writing so that the new value is visible in the callback.
*
* @param server The server executing the callback
* @sessionId The identifier of the session
* @sessionContext Additional data attached to the session
* in the access control layer
* @param nodeid The identifier of the node.
* @param nodeUserContext Additional data attached to the node by
* the user.
* @param nodeConstructorContext Additional data attached to the node
* by the type constructor(s).
* @param range Points to the numeric range the client wants to write to (or
* NULL). */
void (*onWrite)(UA_Server *server, const UA_NodeId *sessionId,
void *sessionContext, const UA_NodeId *nodeId,
void *nodeContext, const UA_NumericRange *range,
const UA_DataValue *data);
} UA_ValueCallback;
typedef struct {
/* Copies the data from the source into the provided value.
*
* !! ZERO-COPY OPERATIONS POSSIBLE !!
* It is not required to return a copy of the actual content data. You can
* return a pointer to memory owned by the user. Memory can be reused
* between read callbacks of a DataSource, as the result is already encoded
* on the network buffer between each read operation.
*
* To use zero-copy reads, set the value of the `value->value` Variant
* without copying, e.g. with `UA_Variant_setScalar`. Then, also set
* `value->value.storageType` to `UA_VARIANT_DATA_NODELETE` to prevent the
* memory being cleaned up. Don't forget to also set `value->hasValue` to
* true to indicate the presence of a value.
*
* @param server The server executing the callback
* @param sessionId The identifier of the session
* @param sessionContext Additional data attached to the session in the
* access control layer
* @param nodeId The identifier of the node being read from
* @param nodeContext Additional data attached to the node by the user
* @param includeSourceTimeStamp If true, then the datasource is expected to
* set the source timestamp in the returned value
* @param range If not null, then the datasource shall return only a
* selection of the (nonscalar) data. Set
* UA_STATUSCODE_BADINDEXRANGEINVALID in the value if this does not
* apply
* @param value The (non-null) DataValue that is returned to the client. The
* data source sets the read data, the result status and optionally a
* sourcetimestamp.
* @return Returns a status code for logging. Error codes intended for the
* original caller are set in the value. If an error is returned,
* then no releasing of the value is done
*/
UA_StatusCode (*read)(UA_Server *server, const UA_NodeId *sessionId,
void *sessionContext, const UA_NodeId *nodeId,
void *nodeContext, UA_Boolean includeSourceTimeStamp,
const UA_NumericRange *range, UA_DataValue *value);
/* Write into a data source. This method pointer can be NULL if the
* operation is unsupported.
*
* @param server The server executing the callback
* @param sessionId The identifier of the session
* @param sessionContext Additional data attached to the session in the
* access control layer
* @param nodeId The identifier of the node being written to
* @param nodeContext Additional data attached to the node by the user
* @param range If not NULL, then the datasource shall return only a
* selection of the (nonscalar) data. Set
* UA_STATUSCODE_BADINDEXRANGEINVALID in the value if this does not
* apply
* @param value The (non-NULL) DataValue that has been written by the client.
* The data source contains the written data, the result status and
* optionally a sourcetimestamp
* @return Returns a status code for logging. Error codes intended for the
* original caller are set in the value. If an error is returned,
* then no releasing of the value is done
*/
UA_StatusCode (*write)(UA_Server *server, const UA_NodeId *sessionId,
void *sessionContext, const UA_NodeId *nodeId,
void *nodeContext, const UA_NumericRange *range,
const UA_DataValue *value);
} UA_DataSource;
Value Callback¶
Value Callbacks can be attached to variable and variable type nodes. If
not NULL, they are called before reading and after writing respectively.
typedef struct {
/* Called before the value attribute is read. The external value source can be
* be updated and/or locked during this notification call. After this function returns
* to the core, the external value source is readed immediately.
*/
UA_StatusCode (*notificationRead)(UA_Server *server, const UA_NodeId *sessionId,
void *sessionContext, const UA_NodeId *nodeid,
void *nodeContext, const UA_NumericRange *range);
/* Called after writing the value attribute. The node is re-opened after
* writing so that the new value is visible in the callback.
*
* @param server The server executing the callback
* @sessionId The identifier of the session
* @sessionContext Additional data attached to the session
* in the access control layer
* @param nodeid The identifier of the node.
* @param nodeUserContext Additional data attached to the node by
* the user.
* @param nodeConstructorContext Additional data attached to the node
* by the type constructor(s).
* @param range Points to the numeric range the client wants to write to (or
* NULL). */
UA_StatusCode (*userWrite)(UA_Server *server, const UA_NodeId *sessionId,
void *sessionContext, const UA_NodeId *nodeId,
void *nodeContext, const UA_NumericRange *range,
const UA_DataValue *data);
} UA_ExternalValueCallback;
typedef enum {
UA_VALUEBACKENDTYPE_NONE,
UA_VALUEBACKENDTYPE_INTERNAL,
UA_VALUEBACKENDTYPE_DATA_SOURCE_CALLBACK,
UA_VALUEBACKENDTYPE_EXTERNAL
} UA_ValueBackendType;
typedef struct {
UA_ValueBackendType backendType;
union {
struct {
UA_DataValue value;
UA_ValueCallback callback;
} internal;
UA_DataSource dataSource;
struct {
UA_DataValue **value;
UA_ExternalValueCallback callback;
} external;
} backend;
} UA_ValueBackend;
#define UA_NODE_VARIABLEATTRIBUTES \
/* Constraints on possible values */ \
UA_NodeId dataType; \
UA_Int32 valueRank; \
size_t arrayDimensionsSize; \
UA_UInt32 *arrayDimensions; \
\
UA_ValueBackend valueBackend; \
\
/* The current value */ \
UA_ValueSource valueSource; \
union { \
struct { \
UA_DataValue value; \
UA_ValueCallback callback; \
} data; \
UA_DataSource dataSource; \
} value;
typedef struct {
UA_NodeHead head;
UA_NODE_VARIABLEATTRIBUTES
UA_Byte accessLevel;
UA_Double minimumSamplingInterval;
UA_Boolean historizing;
/* Members specific to open62541 */
UA_Boolean isDynamic; /* Some variables are "static" in the sense that they
* are not attached to a dynamic process in the
* background. Only dynamic variables conserve source
* and server timestamp for the value attribute.
* Static variables have timestamps of "now". */
} UA_VariableNode;
VariableTypeNode¶
typedef struct {
UA_NodeHead head;
UA_NODE_VARIABLEATTRIBUTES
UA_Boolean isAbstract;
/* Members specific to open62541 */
UA_NodeTypeLifecycle lifecycle;
} UA_VariableTypeNode;
MethodNode¶
typedef UA_StatusCode
(*UA_MethodCallback)(UA_Server *server, const UA_NodeId *sessionId,
void *sessionContext, const UA_NodeId *methodId,
void *methodContext, const UA_NodeId *objectId,
void *objectContext, size_t inputSize,
const UA_Variant *input, size_t outputSize,
UA_Variant *output);
typedef struct {
UA_NodeHead head;
UA_Boolean executable;
/* Members specific to open62541 */
UA_MethodCallback method;
#if UA_MULTITHREADING >= 100
UA_Boolean async; /* Indicates an async method call */
#endif
} UA_MethodNode;
ObjectNode¶
typedef struct {
UA_NodeHead head;
UA_Byte eventNotifier;
} UA_ObjectNode;
ObjectTypeNode¶
typedef struct {
UA_NodeHead head;
UA_Boolean isAbstract;
/* Members specific to open62541 */
UA_NodeTypeLifecycle lifecycle;
} UA_ObjectTypeNode;
ReferenceTypeNode¶
typedef struct {
UA_NodeHead head;
UA_Boolean isAbstract;
UA_Boolean symmetric;
UA_LocalizedText inverseName;
/* Members specific to open62541 */
UA_Byte referenceTypeIndex;
UA_ReferenceTypeSet subTypes; /* contains the type itself as well */
} UA_ReferenceTypeNode;
DataTypeNode¶
typedef struct {
UA_NodeHead head;
UA_Boolean isAbstract;
} UA_DataTypeNode;
ViewNode¶
typedef struct {
UA_NodeHead head;
UA_Byte eventNotifier;
UA_Boolean containsNoLoops;
} UA_ViewNode;
Node Union¶
A union that represents any kind of node. The node head can always be used. Check the NodeClass before accessing specific content.
typedef union {
UA_NodeHead head;
UA_VariableNode variableNode;
UA_VariableTypeNode variableTypeNode;
UA_MethodNode methodNode;
UA_ObjectNode objectNode;
UA_ObjectTypeNode objectTypeNode;
UA_ReferenceTypeNode referenceTypeNode;
UA_DataTypeNode dataTypeNode;
UA_ViewNode viewNode;
} UA_Node;
Nodestore¶
The following definitions are used for implementing custom node storage backends. Most users will want to use the default nodestore and don’t need to work with the nodestore API.
Outside of custom nodestore implementations, users should not manually edit nodes. Please use the OPC UA services for that. Otherwise, all consistency checks are omitted. This can crash the application eventually.
typedef void (*UA_NodestoreVisitor)(void *visitorCtx, const UA_Node *node);
typedef struct {
/* Nodestore context and lifecycle */
void *context;
void (*clear)(void *nsCtx);
/* The following definitions are used to create empty nodes of the different
* node types. The memory is managed by the nodestore. Therefore, the node
* has to be removed via a special deleteNode function. (If the new node is
* not added to the nodestore.) */
UA_Node * (*newNode)(void *nsCtx, UA_NodeClass nodeClass);
void (*deleteNode)(void *nsCtx, UA_Node *node);
/* ``Get`` returns a pointer to an immutable node. Call ``releaseNode`` to
* indicate when the pointer is no longer accessed.
*
* It can be indicated if only a subset of the attributes and referencs need
* to be accessed. That is relevant when the nodestore accesses a slow
* storage backend for the attributes. The attribute mask is a bitfield with
* ORed entries from UA_NodeAttributesMask.
*
* The returned node always contains the context-pointer and other fields
* specific to open626541 (not official attributes).
*
* The NodeStore does not complain if attributes and references that don't
* exist (for that node) are requested. Attributes and references in
* addition to those specified can be returned. For example, if the full
* node already is kept in memory by the Nodestore. */
const UA_Node * (*getNode)(void *nsCtx, const UA_NodeId *nodeId,
UA_UInt32 attributeMask,
UA_ReferenceTypeSet references,
UA_BrowseDirection referenceDirections);
/* Similar to the normal ``getNode``. But it can take advantage of the
* NodePointer structure, e.g. if it contains a direct pointer. */
const UA_Node * (*getNodeFromPtr)(void *nsCtx, UA_NodePointer ptr,
UA_UInt32 attributeMask,
UA_ReferenceTypeSet references,
UA_BrowseDirection referenceDirections);
/* Release a node that has been retrieved with ``getNode`` or
* ``getNodeFromPtr``. */
void (*releaseNode)(void *nsCtx, const UA_Node *node);
/* Returns an editable copy of a node (needs to be deleted with the
* deleteNode function or inserted / replaced into the nodestore). */
UA_StatusCode (*getNodeCopy)(void *nsCtx, const UA_NodeId *nodeId,
UA_Node **outNode);
/* Inserts a new node into the nodestore. If the NodeId is zero, then a
* fresh numeric NodeId is assigned. If insertion fails, the node is
* deleted. */
UA_StatusCode (*insertNode)(void *nsCtx, UA_Node *node,
UA_NodeId *addedNodeId);
/* To replace a node, get an editable copy of the node, edit and replace
* with this function. If the node was already replaced since the copy was
* made, UA_STATUSCODE_BADINTERNALERROR is returned. If the NodeId is not
* found, UA_STATUSCODE_BADNODEIDUNKNOWN is returned. In both error cases,
* the editable node is deleted. */
UA_StatusCode (*replaceNode)(void *nsCtx, UA_Node *node);
/* Removes a node from the nodestore. */
UA_StatusCode (*removeNode)(void *nsCtx, const UA_NodeId *nodeId);
/* Maps the ReferenceTypeIndex used for the references to the NodeId of the
* ReferenceType. The returned pointer is stable until the Nodestore is
* deleted. */
const UA_NodeId * (*getReferenceTypeId)(void *nsCtx, UA_Byte refTypeIndex);
/* Execute a callback for every node in the nodestore. */
void (*iterate)(void *nsCtx, UA_NodestoreVisitor visitor,
void *visitorCtx);
} UA_Nodestore;
/* Attributes must be of a matching type (VariableAttributes, ObjectAttributes,
* and so on). The attributes are copied. Note that the attributes structs do
* not contain NodeId, NodeClass and BrowseName. The NodeClass of the node needs
* to be correctly set before calling this method. UA_Node_clear is called on
* the node when an error occurs internally. */
UA_StatusCode
UA_Node_setAttributes(UA_Node *node, const void *attributes,
const UA_DataType *attributeType);
/* Reset the destination node and copy the content of the source */
UA_StatusCode
UA_Node_copy(const UA_Node *src, UA_Node *dst);
/* Allocate new node and copy the values from src */
UA_Node *
UA_Node_copy_alloc(const UA_Node *src);
/* Add a single reference to the node */
UA_StatusCode
UA_Node_addReference(UA_Node *node, UA_Byte refTypeIndex, UA_Boolean isForward,
const UA_ExpandedNodeId *targetNodeId,
UA_UInt32 targetBrowseNameHash);
/* Delete a single reference from the node */
UA_StatusCode
UA_Node_deleteReference(UA_Node *node, UA_Byte refTypeIndex, UA_Boolean isForward,
const UA_ExpandedNodeId *targetNodeId);
/* Deletes references from the node which are not matching any type in the given
* array. Could be used to e.g. delete all the references, except
* 'HASMODELINGRULE' */
void
UA_Node_deleteReferencesSubset(UA_Node *node, const UA_ReferenceTypeSet *keepSet);
/* Delete all references of the node */
void
UA_Node_deleteReferences(UA_Node *node);
/* Remove all malloc'ed members of the node and reset */
void
UA_Node_clear(UA_Node *node);