/* This Source Code Form is subject to the terms of the Mozilla Public

 * License, v. 2.0. If a copy of the MPL was not distributed with this

 * file, You can obtain one at http://mozilla.org/MPL/2.0/.

 *

 *    Copyright 2014-2025 (c) Fraunhofer IOSB (Author: Julius Pfrommer)

 *    Copyright 2015-2016 (c) Sten Grüner

 *    Copyright 2014-2015, 2017 (c) Florian Palm

 *    Copyright 2015-2016 (c) Chris Iatrou

 *    Copyright 2015-2016 (c) Oleksiy Vasylyev

 *    Copyright 2016-2017 (c) Stefan Profanter, fortiss GmbH

 *    Copyright 2017 (c) Henrik Norrman

 *    Copyright 2018 (c) Fabian Arndt, Root-Core

 *    Copyright 2017-2020 (c) HMS Industrial Networks AB (Author: Jonas Green)

 *    Copyright 2020-2022 (c) Christian von Arnim, ISW University of Stuttgart  (for VDW and umati)

 */

#ifndef UA_SERVER_H_

#define UA_SERVER_H_

#include <open62541/common.h>

#include <open62541/util.h>

#include <open62541/types.h>

#include <open62541/client.h>

#include <open62541/plugin/log.h>

#include <open62541/plugin/certificategroup.h>

#include <open62541/plugin/eventloop.h>

#include <open62541/plugin/accesscontrol.h>

#include <open62541/plugin/securitypolicy.h>

#ifdef UA_ENABLE_HISTORIZING

#include <open62541/plugin/historydatabase.h>

#endif

#ifdef UA_ENABLE_PUBSUB

#include <open62541/server_pubsub.h>

#endif

/* Forward Declarations */

struct UA_Nodestore;

typedef struct UA_Nodestore UA_Nodestore;

struct UA_ServerConfig;

typedef struct UA_ServerConfig UA_ServerConfig;

_UA_BEGIN_DECLS

/**

 * .. _server:

 *

 * Server

 * ======

 * An OPC UA server contains an object-oriented information model and makes it

 * accessible to clients over the network via the OPC UA :ref:`services`. The

 * information model can be used either used to store "passive data" or as an

 * "active database" that integrates with data-sources and devices. For the

 * latter, user-defined callbacks can be attached to VariableNodes and

 * MethodNodes.

 *

 * .. _server-lifecycle:

 *

 * Server Lifecycle

 * ----------------

 * This section describes the API for creating, running and deleting a server.

 * At runtime, the server continuously listens on the network, acceppts incoming

 * connections and processes received messages. Furthermore, timed (cyclic)

 * callbacks are executed. */

/* Create a new server with a default configuration that adds plugins for

 * networking, security, logging and so on. See the "server_config_default.h"

 * for more detailed options.

 *

 * The default configuration can be used as the starting point to adjust the

 * server configuration to individual needs. UA_Server_new is implemented in the

 * /plugins folder under the CC0 license. Furthermore the server confiugration

 * only uses the public server API.

 *

 * Returns the configured server or NULL if an error occurs. */

UA_EXPORT UA_Server *

UA_Server_new(void);

/* Creates a new server. Moves the config into the server with a shallow copy.

 * The config content is cleared together with the server. */

UA_EXPORT UA_Server *

UA_Server_newWithConfig(UA_ServerConfig *config);

/* Delete the server and its configuration */

UA_EXPORT UA_StatusCode

UA_Server_delete(UA_Server *server);

/* Get the configuration. Always succeeds as this simplfy resolves a pointer.

 * Attention! Do not adjust the configuration while the server is running! */

UA_EXPORT UA_ServerConfig *

UA_Server_getConfig(UA_Server *server);

/* Get the current server lifecycle state */

UA_EXPORT UA_LifecycleState

UA_Server_getLifecycleState(UA_Server *server);

/* Runs the server until until "running" is set to false. The logical sequence

 * is as follows:

 *

 * - UA_Server_run_startup

 * - Loop UA_Server_run_iterate while "running" is true

 * - UA_Server_run_shutdown */

UA_EXPORT UA_StatusCode

UA_Server_run(UA_Server *server, const volatile UA_Boolean *running);

/* Runs the server until interrupted. On Unix/Windows this registers an

 * interrupt for SIGINT (ctrl-c). The method only returns after having received

 * the interrupt or upon an error condition. The logical sequence is as follows:

 *

 * - Register the interrupt

 * - UA_Server_run_startup

 * - Loop until interrupt: UA_Server_run_iterate

 * - UA_Server_run_shutdown

 * - Deregister the interrupt

 *

 * Attention! This method is implemented individually for the different

 * platforms (POSIX/Win32/etc.). The default implementation is in

 * /plugins/ua_config_default.c under the CC0 license. Adjust as needed. */

UA_EXPORT UA_StatusCode

UA_Server_runUntilInterrupt(UA_Server *server);

/* The prologue part of UA_Server_run (no need to use if you call

 * UA_Server_run or UA_Server_runUntilInterrupt) */

UA_EXPORT UA_StatusCode

UA_Server_run_startup(UA_Server *server);

/* Executes a single iteration of the server's main loop.

 *

 * @param server The server object.

 * @param waitInternal Should we wait for messages in the networklayer?

 *        Otherwise, the timeouts for the networklayers are set to zero.

 *        The default max wait time is 200ms.

 * @return Returns how long we can wait until the next scheduled

 *         callback (in ms) */

UA_EXPORT UA_UInt16

UA_Server_run_iterate(UA_Server *server, UA_Boolean waitInternal);

/* The epilogue part of UA_Server_run (no need to use if you call

 * UA_Server_run or UA_Server_runUntilInterrupt) */

UA_EXPORT UA_StatusCode

UA_Server_run_shutdown(UA_Server *server);

/**

 * Timed Callbacks

 * ---------------

 * Timed callback are executed at their defined timestamp. The callback can also

 * be registered with a cyclic repetition interval. */

typedef void (*UA_ServerCallback)(UA_Server *server, void *data);

/* Add a callback for execution at a specified time. If the indicated time lies

 * in the past, then the callback is executed at the next iteration of the

 * server's main loop.

 *

 * @param server The server object.

 * @param callback The callback that shall be added.

 * @param data Data that is forwarded to the callback.

 * @param date The timestamp for the execution time.

 * @param callbackId Set to the identifier of the repeated callback . This can

 *        be used to cancel the callback later on. If the pointer is null, the

 *        identifier is not set.

 * @return Upon success, ``UA_STATUSCODE_GOOD`` is returned. An error code

 *         otherwise. */

UA_StatusCode UA_EXPORT UA_THREADSAFE

UA_Server_addTimedCallback(UA_Server *server, UA_ServerCallback callback,

                           void *data, UA_DateTime date, UA_UInt64 *callbackId);

/* Add a callback for cyclic repetition to the server.

 *

 * @param server The server object.

 * @param callback The callback that shall be added.

 * @param data Data that is forwarded to the callback.

 * @param interval_ms The callback shall be repeatedly executed with the given

 *        interval (in ms). The interval must be positive. The first execution

 *        occurs at now() + interval at the latest.

 * @param callbackId Set to the identifier of the repeated callback . This can

 *        be used to cancel the callback later on. If the pointer is null, the

 *        identifier is not set.

 * @return Upon success, ``UA_STATUSCODE_GOOD`` is returned. An error code

 *         otherwise. */

UA_StatusCode UA_EXPORT UA_THREADSAFE

UA_Server_addRepeatedCallback(UA_Server *server, UA_ServerCallback callback,

                              void *data, UA_Double interval_ms,

                              UA_UInt64 *callbackId);

UA_StatusCode UA_EXPORT UA_THREADSAFE

UA_Server_changeRepeatedCallbackInterval(UA_Server *server, UA_UInt64 callbackId,

                                         UA_Double interval_ms);

/* Remove a repeated callback. Does nothing if the callback is not found. */

void UA_EXPORT UA_THREADSAFE

UA_Server_removeCallback(UA_Server *server, UA_UInt64 callbackId);

#define UA_Server_removeRepeatedCallback(server, callbackId) \

    UA_Server_removeCallback(server, callbackId)

/**

 * Application Notification

 * ------------------------

 * The server defines callbacks to notify the application on defined triggering

 * points. These callbacks are executed with the (re-entrant) server-mutex held.

 *

 * The different types of callback are disambiguated by their type enum. Besides

 * the global notification callback (which is always triggered), the server

 * configuration contains specialized callbacks that trigger only for specific

 * notifications. This can reduce the burden of high-frequency notifications.

 *

 * If a specialized notification callback is set, it always gets called before

 * the global notification callback for the same triggering point.

 *

 * See the section on the :ref:`Application Notification` enum for more

 * documentation on the notifications and their defined payload. */

typedef void (*UA_ServerNotificationCallback)(UA_Server *server,

                                              UA_ApplicationNotificationType type,

                                              const UA_KeyValueMap payload);

/**

 * .. _server-session-handling:

 *

 * Session Handling

 * ----------------

 * Sessions are managed via the OPC UA Session Service Set (CreateSession,

 * ActivateSession, CloseSession). The identifier of sessions is generated

 * internally in the server and is always a Guid-NodeId.

 *

 * The creation of sessions is passed to the :ref:`access-control`. There, the

 * authentication information is evaluated and a context-pointer is attached to

 * the new session. The context pointer (and the session identifier) are then

 * forwarded to all user-defined callbacks that can be triggere by a session.

 *

 * When the operations from the OPC UA Services are invoked locally via the

 * C-API, this implies that the operations are executed with the access rights

 * of the "admin-session" that is always present in a server. Any AccessControl

 * checks are omitted for the admin-session.

 *

 * The admin-session has the identifier

 * ``g=00000001-0000-0000-0000-000000000000``. Its session context pointer needs

 * to be manually set (NULL by default). */

void UA_EXPORT

UA_Server_setAdminSessionContext(UA_Server *server, void *context);

/* Manually close a session */

UA_EXPORT UA_StatusCode UA_THREADSAFE

UA_Server_closeSession(UA_Server *server, const UA_NodeId *sessionId);

/**

 * Besides the session context pointer from the AccessControl plugin, a session

 * carries attributes in a key-value map. Always defined (and read-only) session

 * attributes are:

 *

 * - ``0:localeIds`` (``UA_String``): List of preferred languages

 * - ``0:clientDescription`` (``UA_ApplicationDescription``): Client description

 * - ``0:sessionName`` (``String``): Client-defined name of the session

 * - ``0:clientUserId`` (``String``): User identifier used to activate the session

 *

 * Additional attributes can be set manually with the API below. */

/* Returns a shallow copy of the attribute (don't _clear or _delete manually).

 * While the method is thread-safe, the returned value is not protected. Only

 * use it in a (callback) context where the server is locked for the current

 * thread. */

UA_EXPORT UA_StatusCode UA_THREADSAFE

UA_Server_getSessionAttribute(UA_Server *server, const UA_NodeId *sessionId,

                              const UA_QualifiedName key, UA_Variant *outValue);

/* Return a deep copy of the attribute */

UA_EXPORT UA_StatusCode UA_THREADSAFE

UA_Server_getSessionAttributeCopy(UA_Server *server, const UA_NodeId *sessionId,

                                  const UA_QualifiedName key, UA_Variant *outValue);

/* Returns NULL if the attribute is not defined or not a scalar or not of the

 * right datatype. Otherwise a shallow copy of the scalar value is created at

 * the target location of the void pointer (don't _clear or _delete manually).

 * While the method is thread-safe, the returned value is not protected. Only

 * use it in a (callback) context where the server is locked for the current

 * thread. */

UA_EXPORT UA_StatusCode UA_THREADSAFE

UA_Server_getSessionAttribute_scalar(UA_Server *server,

                                     const UA_NodeId *sessionId,

                                     const UA_QualifiedName key,

                                     const UA_DataType *type,

                                     void *outValue);

UA_EXPORT UA_StatusCode UA_THREADSAFE

UA_Server_setSessionAttribute(UA_Server *server, const UA_NodeId *sessionId,

                              const UA_QualifiedName key,

                              const UA_Variant *value);

UA_EXPORT UA_StatusCode UA_THREADSAFE

UA_Server_deleteSessionAttribute(UA_Server *server, const UA_NodeId *sessionId,

                                 const UA_QualifiedName key);

/**

 * Attribute Service Set

 * ---------------------

 * The functions for reading and writing node attributes call the regular read

 * and write service in the background that are also used over the network.

 *

 * The following attributes cannot be read, since the local "admin" user always

 * has full rights.

 *

 * - UserWriteMask

 * - UserAccessLevel

 * - UserExecutable */

/* Read an attribute of a node. Returns a deep copy. */

UA_DataValue UA_EXPORT UA_THREADSAFE

UA_Server_read(UA_Server *server, const UA_ReadValueId *item,

               UA_TimestampsToReturn timestamps);

/**

 * The following specialized read methods are a shorthand for the regular read

 * and set a deep copy of the attribute to the ``out`` pointer (when

 * successful). */

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_readNodeId(UA_Server *server, const UA_NodeId nodeId,

                     UA_NodeId *out);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_readNodeClass(UA_Server *server, const UA_NodeId nodeId,

                        UA_NodeClass *out);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_readBrowseName(UA_Server *server, const UA_NodeId nodeId,

                         UA_QualifiedName *out);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_readDisplayName(UA_Server *server, const UA_NodeId nodeId,

                          UA_LocalizedText *out);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_readDescription(UA_Server *server, const UA_NodeId nodeId,

                          UA_LocalizedText *out);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_readWriteMask(UA_Server *server, const UA_NodeId nodeId,

                        UA_UInt32 *out);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_readIsAbstract(UA_Server *server, const UA_NodeId nodeId,

                         UA_Boolean *out);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_readSymmetric(UA_Server *server, const UA_NodeId nodeId,

                        UA_Boolean *out);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_readInverseName(UA_Server *server, const UA_NodeId nodeId,

                          UA_LocalizedText *out);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_readContainsNoLoops(UA_Server *server, const UA_NodeId nodeId,

                              UA_Boolean *out);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_readEventNotifier(UA_Server *server, const UA_NodeId nodeId,

                            UA_Byte *out);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_readValue(UA_Server *server, const UA_NodeId nodeId,

                    UA_Variant *out);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_readDataType(UA_Server *server, const UA_NodeId nodeId,

                       UA_NodeId *out);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_readValueRank(UA_Server *server, const UA_NodeId nodeId,

                        UA_Int32 *out);

/* Returns a variant with an uint32 array */

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_readArrayDimensions(UA_Server *server, const UA_NodeId nodeId,

                              UA_Variant *out);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_readAccessLevel(UA_Server *server, const UA_NodeId nodeId,

                          UA_Byte *out);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_readAccessLevelEx(UA_Server *server, const UA_NodeId nodeId,

                            UA_UInt32 *out);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_readMinimumSamplingInterval(UA_Server *server, const UA_NodeId nodeId,

                                      UA_Double *out);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_readHistorizing(UA_Server *server, const UA_NodeId nodeId,

                          UA_Boolean *out);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_readExecutable(UA_Server *server, const UA_NodeId nodeId,

                         UA_Boolean *out);

/**

 * The following node attributes cannot be written once a node has been created:

 *

 * - NodeClass

 * - NodeId

 * - Symmetric

 * - ContainsNoLoops

 *

 * The following attributes cannot be written from C-API, as they are specific

 * to the session (context set by the access control callback):

 *

 * - UserWriteMask

 * - UserAccessLevel

 * - UserExecutable

 */

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_write(UA_Server *server, const UA_WriteValue *value);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_writeBrowseName(UA_Server *server, const UA_NodeId nodeId,

                          const UA_QualifiedName browseName);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_writeDisplayName(UA_Server *server, const UA_NodeId nodeId,

                           const UA_LocalizedText displayName);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_writeDescription(UA_Server *server, const UA_NodeId nodeId,

                           const UA_LocalizedText description);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_writeWriteMask(UA_Server *server, const UA_NodeId nodeId,

                         const UA_UInt32 writeMask);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_writeIsAbstract(UA_Server *server, const UA_NodeId nodeId,

                          const UA_Boolean isAbstract);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_writeInverseName(UA_Server *server, const UA_NodeId nodeId,

                           const UA_LocalizedText inverseName);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_writeEventNotifier(UA_Server *server, const UA_NodeId nodeId,

                             const UA_Byte eventNotifier);

/* The value attribute is a DataValue. Here only a variant is provided. The

 * StatusCode is set to UA_STATUSCODE_GOOD, sourceTimestamp and serverTimestamp

 * are set to UA_DateTime_now(). See below for setting the full DataValue. */

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_writeValue(UA_Server *server, const UA_NodeId nodeId,

                     const UA_Variant value);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_writeDataValue(UA_Server *server, const UA_NodeId nodeId,

                         const UA_DataValue value);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_writeDataType(UA_Server *server, const UA_NodeId nodeId,

                        const UA_NodeId dataType);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_writeValueRank(UA_Server *server, const UA_NodeId nodeId,

                         const UA_Int32 valueRank);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_writeArrayDimensions(UA_Server *server, const UA_NodeId nodeId,

                               const UA_Variant arrayDimensions);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_writeAccessLevel(UA_Server *server, const UA_NodeId nodeId,

                           const UA_Byte accessLevel);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_writeAccessLevelEx(UA_Server *server, const UA_NodeId nodeId,

                             const UA_UInt32 accessLevelEx);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_writeMinimumSamplingInterval(UA_Server *server, const UA_NodeId nodeId,

                                       const UA_Double miniumSamplingInterval);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_writeHistorizing(UA_Server *server, const UA_NodeId nodeId,

                           const UA_Boolean historizing);

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_writeExecutable(UA_Server *server, const UA_NodeId nodeId,

                          const UA_Boolean executable);

/**

 * .. _server-method-call:

 *

 * Method Service Set

 * ------------------

 *

 * The Method Service Set defines the means to invoke methods. A MethodNode is a

 * component of an ObjectNode or of an ObjectTypeNode. The input and output

 * arguments of a method are a list of ``UA_Variant``. The type- and

 * size-requirements of the arguments can be retrieved from the

 * **InputArguments** and **OutputArguments** variable below the MethodNode.

 *

 * For calling a method, both ``methodId`` and ``objectId`` need to be defined

 * by their NodeId. This is required because the same MethodNode can be

 * referenced from multiple objects.

 *

 * In this server implementation, when an object is instantiated from a an

 * ObjectType, all (mandatory) methods are automatically added to the new object

 * instance. This is done by adding an additional reference to the original

 * MethodNode. It is however possible to add a custom MethodNode directly to the

 * object instance. It is also possible to remove a (optional) MethodNode that

 * exists in the ObjectType from an instance.

 *

 * The ``methodId`` can point to a MethodNode that exists in the ObjectType but

 * not in the object instance. It is resolved to the actual MethodNode of the

 * object instance by taking the *BrowseName* attribute of the

 * ``methodId``-MethodNode and looking up the member of the ``objectId`` object

 * with the same BrowseName.

 *

 * The resolved MethodNode then is used to

 *

 * - Check permissions for the current Session to call the method

 * - Obtain the ``UA_MethodCallback`` to execute

 * - Forwarded as ``methodId`` to said callback

 *

 * To showcase the resolution of the MethodNode with an example, consider this

 * information model::

 *

 *      ObjectType                      ObjectType                     Object

 *    Creature (i=10)  <-isSubTypeOf-  Insect (i=20)  <-hasTypeDef-   Ant (i=30)

 *          |                               |                            |

 *     hasComponent                    hasComponent                 hasComponent

 *          |                               |                            |

 *          v                               v                            v

 *       Methods                         Methods                      Methods

 *    - Walk (i=11)                   - Walk (i=21)                - Walk (i=31)

 *    - Fly (i=12)                    - Fly (i=22)                 - Amount (i=33)

 *    - Amount (i=13)                 - Amount (i=23)

 *

 * The following table shows what ``methodId`` - ``objectId`` combinations are

 * allowed to be used as parameters for the Call service and the resolved

 * ``methodId``.

 *

 * ========  ========  ====================================  =================

 * objectId  methodId  Corresponds to in OO-languages        Resolved methodId

 * ========  ========  ====================================  =================

 * i=30      i=31      ``Ant a; a.Walk();``                  i=31

 * i=30      i=21      ``Ant a; Insect i = a; i.Walk();``    i=31

 * i=30      i=11      ``Ant a; Creature c = a; c.Walk();``  i=31

 * i=20      i=23      ``Insect::Amount();``                 i=23

 * i=10      i=13      ``Creature::Amount();``               i=13

 * ========  ========  ====================================  =================

 *

 * The next table shows ``methodId`` - ``objectId`` combinations that are not

 * allowed. Note that an ObjecType cannot execute a methodId from a subtype or

 * instance.

 *

 * ========  ========  =====================================================

 * objectId  methodId  Reason

 * ========  ========  =====================================================

 * i=30      i=22      Object "Ant" does not own a method "Fly"

 * i=30      i=12      Object "Ant" does not own a method "Fly"

 * i=10      i=23      The method is not owned by the object type "Creature"

 * i=20      i=13      The method is not owned by the object type "Insect"

 * ========  ========  ===================================================== */

#ifdef UA_ENABLE_METHODCALLS

UA_CallMethodResult UA_EXPORT UA_THREADSAFE

UA_Server_call(UA_Server *server, const UA_CallMethodRequest *request);

#endif

/**

 * View Service Set

 * ----------------

 * The View Service Set allows Clients to discover Nodes by browsing the

 * information model. */

/* Browse the references of a particular node. See the definition of

 * BrowseDescription structure for details. */

UA_BrowseResult UA_EXPORT UA_THREADSAFE

UA_Server_browse(UA_Server *server, UA_UInt32 maxReferences,

                 const UA_BrowseDescription *bd);

UA_BrowseResult UA_EXPORT UA_THREADSAFE

UA_Server_browseNext(UA_Server *server, UA_Boolean releaseContinuationPoint,

                     const UA_ByteString *continuationPoint);

/* Non-standard version of the Browse service that recurses into child nodes.

 *

 * Possible loops (that can occur for non-hierarchical references) are handled

 * internally. Every node is added at most once to the results array.

 *

 * Nodes are only added if they match the NodeClassMask in the

 * BrowseDescription. However, child nodes are still recursed into if the

 * NodeClass does not match. So it is possible, for example, to get all

 * VariableNodes below a certain ObjectNode, with additional objects in the

 * hierarchy below. */

UA_StatusCode UA_EXPORT UA_THREADSAFE

UA_Server_browseRecursive(UA_Server *server, const UA_BrowseDescription *bd,

                          size_t *resultsSize, UA_ExpandedNodeId **results);

/* Translate abrowse path to (potentially several) NodeIds. Each browse path is

 * constructed of a starting Node and a RelativePath. The specified starting

 * Node identifies the Node from which the RelativePath is based. The

 * RelativePath contains a sequence of ReferenceTypes and BrowseNames. */

UA_BrowsePathResult UA_EXPORT UA_THREADSAFE

UA_Server_translateBrowsePathToNodeIds(UA_Server *server,

                                       const UA_BrowsePath *browsePath);

/* A simplified TranslateBrowsePathsToNodeIds based on the

 * SimpleAttributeOperand type (Part 4, 7.4.4.5).

 *

 * This specifies a relative path using a list of BrowseNames instead of the

 * RelativePath structure. The list of BrowseNames is equivalent to a

 * RelativePath that specifies forward references which are subtypes of the

 * HierarchicalReferences ReferenceType. All Nodes followed by the browsePath

 * shall be of the NodeClass Object or Variable. */

UA_BrowsePathResult UA_EXPORT UA_THREADSAFE

UA_Server_browseSimplifiedBrowsePath(UA_Server *server, const UA_NodeId origin,

                                     size_t browsePathSize,

                                     const UA_QualifiedName *browsePath);

#ifndef HAVE_NODEITER_CALLBACK

#define HAVE_NODEITER_CALLBACK

/* Iterate over all nodes referenced by parentNodeId by calling the callback

 * function for each child node (in ifdef because GCC/CLANG handle include order

 * differently) */

typedef UA_StatusCode

(*UA_NodeIteratorCallback)(UA_NodeId childId, UA_Boolean isInverse,

                           UA_NodeId referenceTypeId, void *handle);

#endif

UA_StatusCode UA_EXPORT UA_THREADSAFE

UA_Server_forEachChildNodeCall(UA_Server *server, UA_NodeId parentNodeId,

                               UA_NodeIteratorCallback callback, void *handle);

/**

 * .. _local-monitoreditems:

 *

 * MonitoredItem Service Set

 * -------------------------

 * MonitoredItems are used with the Subscription mechanism of OPC UA to

 * transported notifications for data changes and events. MonitoredItems can

 * also be registered locally. Notifications are then forwarded to a

 * user-defined callback instead of a remote client.

 *

 * Local MonitoredItems are delivered asynchronously. That is, the notification

 * is inserted as a *Delayed Callback* for the EventLoop. The callback is then

 * triggered when the control flow next returns to the EventLoop. */

#ifdef UA_ENABLE_SUBSCRIPTIONS

/* Delete a local MonitoredItem. Used for both DataChange- and

 * Event-MonitoredItems. */

UA_StatusCode UA_EXPORT UA_THREADSAFE

UA_Server_deleteMonitoredItem(UA_Server *server, UA_UInt32 monitoredItemId);

typedef void (*UA_Server_DataChangeNotificationCallback)

    (UA_Server *server, UA_UInt32 monitoredItemId, void *monitoredItemContext,

     const UA_NodeId *nodeId, void *nodeContext, UA_UInt32 attributeId,

     const UA_DataValue *value);

/**

 * DataChange MonitoredItem use a sampling interval and filter criteria to

 * notify the userland about value changes. Note that the sampling interval can

 * also be zero to be notified about changes "right away". For this we hook the

 * MonitoredItem into the observed Node and check the filter after every call of

 * the Write-Service. */

/* Create a local MonitoredItem to detect data changes.

 *

 * @param server The server executing the MonitoredItem

 * @param timestampsToReturn Shall timestamps be added to the value for the

 *        callback?

 * @param item The parameters of the new MonitoredItem. Note that the attribute

 *        of the ReadValueId (the node that is monitored) can not be

 *        ``UA_ATTRIBUTEID_EVENTNOTIFIER``. See below for event notifications.

 * @param monitoredItemContext A pointer that is forwarded with the callback

 * @param callback The callback that is executed on detected data changes

 * @return Returns a description of the created MonitoredItem. The structure

 *         also contains a StatusCode (in case of an error) and the identifier

 *         of the new MonitoredItem. */

UA_MonitoredItemCreateResult UA_EXPORT UA_THREADSAFE

UA_Server_createDataChangeMonitoredItem(UA_Server *server,

          UA_TimestampsToReturn timestampsToReturn,

          const UA_MonitoredItemCreateRequest item,

          void *monitoredItemContext,

          UA_Server_DataChangeNotificationCallback callback);

/**

 * See the section on :ref`events` for how to emit events in the server.

 *

 * Event-MonitoredItems emit notifications with a list of "fields" (variants).

 * The fields are specified as *SimpleAttributeOperands* in the select-clause of

 * the MonitoredItem's event filter. For the local event callback, instead of

 * using a list of variants, we use a key-value map for the event fields. They

 * key names are generated with ``UA_SimpleAttributeOperand_print`` to get a

 * human-readable representation.

 *

 * The received event-fields map could look like this::

 *

 *   /Severity   => UInt16(1000)

 *   /Message    => LocalizedText("en-US", "My Event Message")

 *   /EventType  => NodeId(i=50831)

 *   /SourceNode => NodeId(i=2253)

 *

 * The order of the keys is identical to the order of SimpleAttributeOperands in

 * the select-clause. This feature requires the build flag ``UA_ENABLE_PARSING``

 * enabled. Otherwise the key-value map uses empty keys (the order of fields is

 * still the same as the specified select-clauses). */

#ifdef UA_ENABLE_SUBSCRIPTIONS_EVENTS

typedef void (*UA_Server_EventNotificationCallback)

    (UA_Server *server, UA_UInt32 monitoredItemId, void *monitoredItemContext,

     const UA_KeyValueMap eventFields);

/* Create a local MonitoredItem for Events. The API is simplifed compared to a

 * UA_MonitoredItemCreateRequest. The unavailable options are not relevant for

 * local MonitoredItems (e.g. the queue size) or not relevant for Event

 * MonitoredItems (e.g. the sampling interval).

 *

 * @param server The server executing the MonitoredItem

 * @param nodeId The node where events are collected. Note that events "bubble

 *        up" to their parents (via hierarchical references).

 * @param filter The filter defined which event fields are selected (select

 *        clauses) and which events are considered for this particular

 *        MonitoredItem (where clause).

 * @param monitoredItemContext A pointer that is forwarded with the callback

 * @param callback The callback that is executed for each event

 * @return Returns a description of the created MonitoredItem. The structure

 *         also contains a StatusCode (in case of an error) and the identifier

 *         of the new MonitoredItem. */

UA_MonitoredItemCreateResult UA_EXPORT UA_THREADSAFE

UA_Server_createEventMonitoredItem(UA_Server *server, const UA_NodeId nodeId,

                                   const UA_EventFilter filter,

                                   void *monitoredItemContext,

                                   UA_Server_EventNotificationCallback callback);

/* Extended version UA_Server_createEventMonitoredItem that allows setting of

 * uncommon parameters (for local MonitoredItems) like the MonitoringMode and

 * queue sizes.

 *

 * @param server The server executing the MonitoredItem

 * @param item The description of the MonitoredItem. Must use

 *        UA_ATTRIBUTEID_EVENTNOTIFIER and an EventFilter.

 * @param monitoredItemContext A pointer that is forwarded with the callback

 * @param callback The callback that is executed for each event

 * @return Returns a description of the created MonitoredItem. The structure

 *         also contains a StatusCode (in case of an error) and the identifier

 *         of the new MonitoredItem. */

UA_MonitoredItemCreateResult UA_EXPORT UA_THREADSAFE

UA_Server_createEventMonitoredItemEx(UA_Server *server,

                                     const UA_MonitoredItemCreateRequest item,

                                     void *monitoredItemContext,

                                     UA_Server_EventNotificationCallback callback);

#endif /* UA_ENABLE_SUBSCRIPTIONS_EVENTS */

#endif /* UA_ENABLE_SUBSCRIPTIONS */

/**

 * .. _server-node-management:

 *

 * Node Management Service Set

 * ---------------------------

 * When creating dynamic node instances at runtime, chances are that you will

 * not care about the specific NodeId of the new node, as long as you can

 * reference it later. When passing numeric NodeIds with a numeric identifier 0,

 * the stack evaluates this as "select a random unassigned numeric NodeId in

 * that namespace". To find out which NodeId was actually assigned to the new

 * node, you may pass a pointer `outNewNodeId`, which will (after a successful

 * node insertion) contain the nodeId of the new node. You may also pass a

 * ``NULL`` pointer if this result is not needed.

 *

 * See the Section :ref:`node-lifecycle` on constructors and on attaching

 * user-defined data to nodes.

 *

 * The Section :ref:`default-node-attributes` contains useful starting points

 * for defining node attributes. Forgetting to set the ValueRank or the

 * AccessLevel leads to errors that can be hard to track down for new users. The

 * default attributes have a high likelihood to "do the right thing".

 *

 * The methods for node addition and deletion take mostly const arguments that

 * are not modified. When creating a node, a deep copy of the node identifier,

 * node attributes, etc. is created. Therefore, it is possible to call for

 * example ``UA_Server_addVariablenode`` with a value attribute (a

 * :ref:`variant`) pointing to a memory location on the stack.

 *

 * .. _variable-node:

 *

 * VariableNode

 * ~~~~~~~~~~~~

 * Variables store values as well as contraints for possible values. There are

 * three options for storing the value: Internal in the VariableNode data

 * structure itself, external with a double-pointer (to switch to an updated

 * value with an atomic pointer-replacing operation) or with a callback

 * registered by the application. */

typedef enum {

    UA_VALUESOURCETYPE_INTERNAL = 0,

    UA_VALUESOURCETYPE_EXTERNAL = 1,

    UA_VALUESOURCETYPE_CALLBACK = 2

} UA_ValueSourceType;

typedef struct {

    /* Notify the application before the value attribute is read. Ignored if

     * NULL. It is possible to write into the value attribute during onRead

     * (using the write service). The node is re-retrieved from the Nodestore

     * 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);

    /* Notify the application after writing the value attribute. Ignored if

     * NULL. The node is re-retrieved 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_ValueSourceNotifications;

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.

     *

     * To make an async read, return UA_STATUSCODE_GOODCOMPLETESASYNCHRONOUSLY.

     * The result can then be set at a later time using

     * UA_Server_setAsyncReadResult. Note that the server might cancel the async

     * read by calling serverConfig->asyncOperationCancelCallback.

     *

     * @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.

     *

     * To make an async write, return UA_STATUSCODE_GOODCOMPLETESASYNCHRONOUSLY.

     * The result can then be set at a later time using

     * UA_Server_setAsyncWriteResult. Note that the server might cancel the

     * async read by calling serverConfig->asyncOperationCancelCallback.

     *

     * @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_CallbackValueSource;

/**

 * By default, when adding a VariableNode, the value from the

 * ``UA_VariableAttributes`` is used. The methods following afterwards can be

 * used to override the value source. */

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_addVariableNode(UA_Server *server, const UA_NodeId requestedNewNodeId,

                          const UA_NodeId parentNodeId,

                          const UA_NodeId referenceTypeId,

                          const UA_QualifiedName browseName,

                          const UA_NodeId typeDefinition,

                          const UA_VariableAttributes attr,

                          void *nodeContext, UA_NodeId *outNewNodeId);

/* Add a VariableNode with a callback value-source */

UA_StatusCode UA_EXPORT UA_THREADSAFE

UA_Server_addCallbackValueSourceVariableNode(UA_Server *server,

                                             const UA_NodeId requestedNewNodeId,

                                             const UA_NodeId parentNodeId,

                                             const UA_NodeId referenceTypeId,

                                             const UA_QualifiedName browseName,

                                             const UA_NodeId typeDefinition,

                                             const UA_VariableAttributes attr,

                                             const UA_CallbackValueSource evs,

                                             void *nodeContext, UA_NodeId *outNewNodeId);

/* Legacy API */

#define UA_Server_addDataSourceVariableNode(server, requestedNewNodeId, parentNodeId,    \

                                            referenceTypeId, browseName, typeDefinition, \

                                            attr, dataSource, nodeContext, outNewNodeId) \

    UA_Server_addCallbackValueSourceVariableNode(server, requestedNewNodeId,             \

                                                 parentNodeId, referenceTypeId,          \

                                                 browseName, typeDefinition,             \

                                                 attr, dataSource, nodeContext,          \

                                                 outNewNodeId)

/* Set an internal value source. Both the value argument and the notifications

 * argument can be NULL. If value is NULL, the Read service is used to get the

 * latest value before switching from a callback to an internal value source. If

 * notifications is NULL, then all onRead/onWrite notifications are disabled. */

UA_StatusCode UA_EXPORT UA_THREADSAFE

UA_Server_setVariableNode_internalValueSource(UA_Server *server,

    const UA_NodeId nodeId, const UA_DataValue *value,

    const UA_ValueSourceNotifications *notifications);

/* For the external value, no initial copy is made. The node "just" points to

 * the provided double-pointer. Otherwise identical to the internal data

 * source. */

UA_StatusCode UA_EXPORT UA_THREADSAFE

UA_Server_setVariableNode_externalValueSource(UA_Server *server,

    const UA_NodeId nodeId, UA_DataValue **value,

    const UA_ValueSourceNotifications *notifications);

/* It is expected that the read callback is implemented. Whenever the value

 * attribute is read, the function will be called and asked to fill a

 * UA_DataValue structure that contains the value content and additional

 * metadata like timestamps.

 *

 * The write callback can be set to a null-pointer. Then writing into the value

 * is disabled. */

UA_StatusCode UA_EXPORT UA_THREADSAFE

UA_Server_setVariableNode_callbackValueSource(UA_Server *server,

    const UA_NodeId nodeId, const UA_CallbackValueSource evs);

/* Deprecated API */

typedef UA_CallbackValueSource UA_DataSource;

#define UA_Server_setVariableNode_dataSource(server, nodeId, dataSource) \

    UA_Server_setVariableNode_callbackValueSource(server, nodeId, dataSource)

/* Deprecated API */

typedef UA_ValueSourceNotifications UA_ValueCallback;

#define UA_Server_setVariableNode_valueCallback(server, nodeId, callback) \

    UA_Server_setVariableNode_internalValueSource(server, nodeId, NULL, &callback)

/* VariableNodes that are "dynamic" (default for user-created variables) receive

 * and store a SourceTimestamp. For non-dynamic VariableNodes the current time

 * is used for the SourceTimestamp. */

UA_StatusCode UA_EXPORT UA_THREADSAFE

UA_Server_setVariableNodeDynamic(UA_Server *server, const UA_NodeId nodeId,

                                 UA_Boolean isDynamic);

/**

 * VariableTypeNode

 * ~~~~~~~~~~~~~~~~ */

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_addVariableTypeNode(UA_Server *server,

                              const UA_NodeId requestedNewNodeId,

                              const UA_NodeId parentNodeId,

                              const UA_NodeId referenceTypeId,

                              const UA_QualifiedName browseName,

                              const UA_NodeId typeDefinition,

                              const UA_VariableTypeAttributes attr,

                              void *nodeContext, UA_NodeId *outNewNodeId);

/**

 * MethodNode

 * ~~~~~~~~~~

 * Please refer to the :ref:`Method Service Set <server-method-call>` to get

 * information about which MethodNodes may get executed and would thus require

 * callbacks to be registered. */

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);

#ifdef UA_ENABLE_METHODCALLS

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_addMethodNode(UA_Server *server, const UA_NodeId requestedNewNodeId,

                        const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId,

                        const UA_QualifiedName browseName, const UA_MethodAttributes attr,

                        UA_MethodCallback method,

                        size_t inputArgumentsSize, const UA_Argument *inputArguments,

                        size_t outputArgumentsSize, const UA_Argument *outputArguments,

                        void *nodeContext, UA_NodeId *outNewNodeId);

/* Extended version, allows the additional definition of fixed NodeIds for the

 * InputArgument/OutputArgument child variables */

UA_StatusCode UA_EXPORT UA_THREADSAFE

UA_Server_addMethodNodeEx(UA_Server *server, const UA_NodeId requestedNewNodeId,

                          const UA_NodeId parentNodeId,

                          const UA_NodeId referenceTypeId,

                          const UA_QualifiedName browseName,

                          const UA_MethodAttributes attr, UA_MethodCallback method,

                          size_t inputArgumentsSize, const UA_Argument *inputArguments,

                          const UA_NodeId inputArgumentsRequestedNewNodeId,

                          UA_NodeId *inputArgumentsOutNewNodeId,

                          size_t outputArgumentsSize, const UA_Argument *outputArguments,

                          const UA_NodeId outputArgumentsRequestedNewNodeId,

                          UA_NodeId *outputArgumentsOutNewNodeId,

                          void *nodeContext, UA_NodeId *outNewNodeId);

UA_StatusCode UA_EXPORT UA_THREADSAFE

UA_Server_setMethodNodeCallback(UA_Server *server,

                                const UA_NodeId methodNodeId,

                                UA_MethodCallback methodCallback);

/* Backwards compatibility definition */

#define UA_Server_setMethodNode_callback(server, methodNodeId, methodCallback) \

    UA_Server_setMethodNodeCallback(server, methodNodeId, methodCallback)

UA_StatusCode UA_EXPORT UA_THREADSAFE

UA_Server_getMethodNodeCallback(UA_Server *server,

                                const UA_NodeId methodNodeId,

                                UA_MethodCallback *outMethodCallback);

#endif

/**

 * ObjectNode

 * ~~~~~~~~~~ */

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_addObjectNode(UA_Server *server, const UA_NodeId requestedNewNodeId,

                        const UA_NodeId parentNodeId,

                        const UA_NodeId referenceTypeId,

                        const UA_QualifiedName browseName,

                        const UA_NodeId typeDefinition,

                        const UA_ObjectAttributes attr,

                        void *nodeContext, UA_NodeId *outNewNodeId);

/**

 * ObjectTypeNode

 * ~~~~~~~~~~~~~~ */

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_addObjectTypeNode(UA_Server *server, const UA_NodeId requestedNewNodeId,

                            const UA_NodeId parentNodeId,

                            const UA_NodeId referenceTypeId,

                            const UA_QualifiedName browseName,

                            const UA_ObjectTypeAttributes attr,

                            void *nodeContext, UA_NodeId *outNewNodeId);

/**

 * ReferenceTypeNode

 * ~~~~~~~~~~~~~~~~~ */

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_addReferenceTypeNode(UA_Server *server,

                               const UA_NodeId requestedNewNodeId,

                               const UA_NodeId parentNodeId,

                               const UA_NodeId referenceTypeId,

                               const UA_QualifiedName browseName,

                               const UA_ReferenceTypeAttributes attr,

                               void *nodeContext, UA_NodeId *outNewNodeId);

/**

 * DataTypeNode

 * ~~~~~~~~~~~~ */

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_addDataTypeNode(UA_Server *server,

                          const UA_NodeId requestedNewNodeId,

                          const UA_NodeId parentNodeId,

                          const UA_NodeId referenceTypeId,

                          const UA_QualifiedName browseName,

                          const UA_DataTypeAttributes attr,

                          void *nodeContext, UA_NodeId *outNewNodeId);

/**

 * ViewNode

 * ~~~~~~~~ */

UA_EXPORT UA_THREADSAFE UA_StatusCode

UA_Server_addViewNode(UA_Server *server, const UA_NodeId requestedNewNodeId,

                      const UA_NodeId parentNodeId,

                      const UA_NodeId referenceTypeId,

                      const UA_QualifiedName browseName,

                      const UA_ViewAttributes attr,

                      void *nodeContext, UA_NodeId *outNewNodeId);

/**

 * .. _node-lifecycle:

 *

 * Node Lifecycle: Constructors, Destructors and Node Contexts

 * ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

 * To finalize the instantiation of a node, a (user-defined) constructor