added missing files

examples/nodestoreAccessExample.c

@@ -0,0 +1,229 @@
+/*
+ * nodestoreAccessExample.c
+ *
+ *  Created on: Oct 16, 2014
+ *      Author: opcua
+ */
+
+
+
+
+
+#include "ua_statuscodes.h"
+
+
+#include "ua_namespace_0.h"
+#include "ua_util.h"
+#include "nodestoreAccessExample.h"
+
+
+
+enum UA_AttributeId {
+    UA_ATTRIBUTEID_NODEID                  = 1,
+    UA_ATTRIBUTEID_NODECLASS               = 2,
+    UA_ATTRIBUTEID_BROWSENAME              = 3,
+    UA_ATTRIBUTEID_DISPLAYNAME             = 4,
+    UA_ATTRIBUTEID_DESCRIPTION             = 5,
+    UA_ATTRIBUTEID_WRITEMASK               = 6,
+    UA_ATTRIBUTEID_USERWRITEMASK           = 7,
+    UA_ATTRIBUTEID_ISABSTRACT              = 8,
+    UA_ATTRIBUTEID_SYMMETRIC               = 9,
+    UA_ATTRIBUTEID_INVERSENAME             = 10,
+    UA_ATTRIBUTEID_CONTAINSNOLOOPS         = 11,
+    UA_ATTRIBUTEID_EVENTNOTIFIER           = 12,
+    UA_ATTRIBUTEID_VALUE                   = 13,
+    UA_ATTRIBUTEID_DATATYPE                = 14,
+    UA_ATTRIBUTEID_VALUERANK               = 15,
+    UA_ATTRIBUTEID_ARRAYDIMENSIONS         = 16,
+    UA_ATTRIBUTEID_ACCESSLEVEL             = 17,
+    UA_ATTRIBUTEID_USERACCESSLEVEL         = 18,
+    UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL = 19,
+    UA_ATTRIBUTEID_HISTORIZING             = 20,
+    UA_ATTRIBUTEID_EXECUTABLE              = 21,
+    UA_ATTRIBUTEID_USEREXECUTABLE          = 22
+};
+
+#define CHECK_NODECLASS(CLASS)                                 \
+    if(!(node->nodeClass & (CLASS))) {                         \
+        v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_STATUSCODE; \
+        v[i].status       = UA_STATUSCODE_BADNOTREADABLE;         \
+        break;                                                 \
+    }                                                          \
+
+
+UA_Int32 readNodes(UA_ReadValueId * readValueIds, UA_UInt32 readValueIdsSize, UA_DataValue *v, UA_Boolean timeStampToReturn, UA_DiagnosticInfo *diagnosticInfo)
+{
+	UA_ReadValueId *id;
+	UA_Int32 retval = UA_SUCCESS;
+	for(UA_UInt32 i = 0; i<readValueIdsSize; i++){
+		id = &readValueIds[i];
+
+
+
+		UA_DataValue_init(&v[i]);
+
+		UA_Node const *node   = UA_NULL;
+
+		/*Access Node here */
+
+		/*  */
+		switch(id->attributeId) {
+		case UA_ATTRIBUTEID_NODEID:
+			v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
+			retval |= UA_Variant_copySetValue(&v[i].value, &UA_[UA_NODEID], &node->nodeId);
+			break;
+
+		case UA_ATTRIBUTEID_NODECLASS:
+			v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
+			retval |= UA_Variant_copySetValue(&v[i].value, &UA_[UA_INT32], &node->nodeClass);
+			break;
+
+		case UA_ATTRIBUTEID_BROWSENAME:
+			v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
+			retval |= UA_Variant_copySetValue(&v[i].value, &UA_[UA_QUALIFIEDNAME], &node->browseName);
+			break;
+
+		case UA_ATTRIBUTEID_DISPLAYNAME:
+			v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
+			retval |= UA_Variant_copySetValue(&v[i].value, &UA_[UA_LOCALIZEDTEXT],
+											  &node->displayName);
+			break;
+
+		case UA_ATTRIBUTEID_DESCRIPTION:
+			v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
+			retval |= UA_Variant_copySetValue(&v[i].value, &UA_[UA_LOCALIZEDTEXT],
+											  &node->description);
+			break;
+
+		case UA_ATTRIBUTEID_WRITEMASK:
+			v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
+			retval |= UA_Variant_copySetValue(&v[i].value, &UA_[UA_UINT32], &node->writeMask);
+			break;
+
+		case UA_ATTRIBUTEID_USERWRITEMASK:
+			v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
+			retval |= UA_Variant_copySetValue(&v[i].value, &UA_[UA_UINT32], &node->userWriteMask);
+			break;
+
+		case UA_ATTRIBUTEID_ISABSTRACT:
+			CHECK_NODECLASS(
+				UA_NODECLASS_REFERENCETYPE | UA_NODECLASS_OBJECTTYPE | UA_NODECLASS_VARIABLETYPE |
+				UA_NODECLASS_DATATYPE);
+			v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
+			retval |=
+				UA_Variant_copySetValue(&v[i].value, &UA_[UA_BOOLEAN],
+										&((UA_ReferenceTypeNode *)node)->isAbstract);
+			break;
+
+		case UA_ATTRIBUTEID_SYMMETRIC:
+			CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
+			v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
+			retval |= UA_Variant_copySetValue(&v[i].value, &UA_[UA_BOOLEAN],
+											  &((UA_ReferenceTypeNode *)node)->symmetric);
+			break;
+
+		case UA_ATTRIBUTEID_INVERSENAME:
+			CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
+			v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
+			retval |= UA_Variant_copySetValue(&v[i].value, &UA_[UA_LOCALIZEDTEXT],
+											  &((UA_ReferenceTypeNode *)node)->inverseName);
+			break;
+
+		case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
+			CHECK_NODECLASS(UA_NODECLASS_VIEW);
+			v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
+			retval |= UA_Variant_copySetValue(&v[i].value, &UA_[UA_BOOLEAN],
+											  &((UA_ViewNode *)node)->containsNoLoops);
+			break;
+
+		case UA_ATTRIBUTEID_EVENTNOTIFIER:
+			CHECK_NODECLASS(UA_NODECLASS_VIEW | UA_NODECLASS_OBJECT);
+			v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
+			retval |= UA_Variant_copySetValue(&v[i].value, &UA_[UA_BYTE],
+											  &((UA_ViewNode *)node)->eventNotifier);
+			break;
+
+		case UA_ATTRIBUTEID_VALUE:
+			CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
+			v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
+			retval |= UA_Variant_copy(&((UA_VariableNode *)node)->value, &v[i].value); // todo: zero-copy
+			break;
+
+		case UA_ATTRIBUTEID_DATATYPE:
+			CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
+			v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
+			retval |= UA_Variant_copySetValue(&v[i].value, &UA_[UA_NODEID],
+											  &((UA_VariableTypeNode *)node)->dataType);
+			break;
+
+		case UA_ATTRIBUTEID_VALUERANK:
+			CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
+			v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
+			retval |= UA_Variant_copySetValue(&v[i].value, &UA_[UA_INT32],
+											  &((UA_VariableTypeNode *)node)->valueRank);
+			break;
+
+		case UA_ATTRIBUTEID_ARRAYDIMENSIONS:
+			CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
+			v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
+			UA_Variant_copySetArray(&v[i].value, &UA_[UA_UINT32],
+									((UA_VariableTypeNode *)node)->arrayDimensionsSize,
+									&((UA_VariableTypeNode *)node)->arrayDimensions);
+			break;
+
+		case UA_ATTRIBUTEID_ACCESSLEVEL:
+			CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
+			v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
+			retval |= UA_Variant_copySetValue(&v[i].value, &UA_[UA_BYTE],
+											  &((UA_VariableNode *)node)->accessLevel);
+			break;
+
+		case UA_ATTRIBUTEID_USERACCESSLEVEL:
+			CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
+			v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
+			retval |= UA_Variant_copySetValue(&v[i].value, &UA_[UA_BYTE],
+											  &((UA_VariableNode *)node)->userAccessLevel);
+			break;
+
+		case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
+			CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
+			v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
+			retval |= UA_Variant_copySetValue(&v[i].value, &UA_[UA_DOUBLE],
+											  &((UA_VariableNode *)node)->minimumSamplingInterval);
+			break;
+
+		case UA_ATTRIBUTEID_HISTORIZING:
+			CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
+			v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
+			retval |= UA_Variant_copySetValue(&v[i].value, &UA_[UA_BOOLEAN],
+											  &((UA_VariableNode *)node)->historizing);
+			break;
+
+		case UA_ATTRIBUTEID_EXECUTABLE:
+			CHECK_NODECLASS(UA_NODECLASS_METHOD);
+			v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
+			retval |= UA_Variant_copySetValue(&v[i].value, &UA_[UA_BOOLEAN],
+											  &((UA_MethodNode *)node)->executable);
+			break;
+
+		case UA_ATTRIBUTEID_USEREXECUTABLE:
+			CHECK_NODECLASS(UA_NODECLASS_METHOD);
+			v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_VARIANT;
+			retval |= UA_Variant_copySetValue(&v[i].value, &UA_[UA_BOOLEAN],
+											  &((UA_MethodNode *)node)->userExecutable);
+			break;
+
+		default:
+			v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_STATUSCODE;
+			v[i].status       = UA_STATUSCODE_BADATTRIBUTEIDINVALID;
+			break;
+		}
+
+		if(retval != UA_SUCCESS) {
+			v[i].encodingMask = UA_DATAVALUE_ENCODINGMASK_STATUSCODE;
+			v[i].status       = UA_STATUSCODE_BADNOTREADABLE;
+		}
+
+	}
+	return retval;
+}

examples/nodestoreAccessExample.h

@@ -0,0 +1,14 @@
+/*
+ * nodestoreAccessExample.h
+ *
+ *  Created on: Oct 16, 2014
+ *      Author: opcua
+ */
+
+#ifndef NODESTOREACCESSEXAMPLE_H_
+#define NODESTOREACCESSEXAMPLE_H_
+
+
+UA_Int32 readNodes(UA_ReadValueId * readValueIds, UA_UInt32 readValueIdsSize, UA_DataValue *v, UA_Boolean timeStampToReturn, UA_DiagnosticInfo *diagnosticInfo);
+
+#endif /* NODESTOREACCESSEXAMPLE_H_ */

src/server/ua_namespace_manager.c

@@ -0,0 +1,87 @@
+/*
+ * ua_namespace_manager.c
+ *
+ *  Created on: Oct 14, 2014
+ *      Author: opcua
+ */
+#include "ua_util.h"
+#include "ua_namespace_manager.h"
+
+
+struct namespace_list_entry {
+    UA_Namespace namespace;
+    LIST_ENTRY(namespace_list_entry) pointers;
+};
+
+struct UA_NamespaceManager {
+    LIST_HEAD(namespace_list, namespace_list_entry) namespaces;
+    UA_UInt32    currentNamespaceCount;
+};
+
+void UA_NamespaceManager_new(UA_NamespaceManager** namespaceManager)
+{
+	*namespaceManager = UA_alloc(sizeof(UA_NamespaceManager));
+	(*namespaceManager)->currentNamespaceCount = 0;
+
+}
+
+UA_Int32 UA_NamespaceManager_addNamespace(UA_NamespaceManager *namespaceManager, UA_UInt16 index, UA_NodeStore *nodeStore)
+{
+	if(namespaceManager->currentNamespaceCount<UA_UINT16_MAX){
+		namespaceManager->currentNamespaceCount++;
+		struct namespace_list_entry *newentry = UA_alloc(sizeof(struct namespace_list_entry));
+		newentry->namespace.index = index;
+		newentry->namespace.nodeStore = nodeStore;
+		LIST_INSERT_HEAD(&namespaceManager->namespaces, newentry, pointers);
+		return UA_SUCCESS;
+	}
+	return UA_ERROR;
+}
+
+UA_Int32 UA_NamespaceManager_removeNamespace(UA_NamespaceManager *namespaceManager,UA_UInt16 index)
+{
+	UA_Namespace *namespace;
+	UA_NamespaceManager_getNamespace(namespaceManager,index,&namespace);
+	if(namespace == UA_NULL)
+		return UA_ERROR;
+
+    struct namespace_list_entry *current = UA_NULL;
+    LIST_FOREACH(current, &namespaceManager->namespaces, pointers) {
+        if(current->namespace.index  == index)
+            break;
+    }
+
+    if(!current)
+        return UA_ERROR;
+	LIST_REMOVE(current, pointers);
+
+	return UA_SUCCESS;
+}
+
+UA_Int32 UA_NamespaceManager_getNamespace(UA_NamespaceManager *namespaceManager, UA_UInt16 index, UA_Namespace **ns)
+{
+
+    struct namespace_list_entry *current = UA_NULL;
+    LIST_FOREACH(current, &namespaceManager->namespaces, pointers) {
+        if(current->namespace.index == index)
+            break;
+    }
+    if(!current) {
+        *ns = UA_NULL;
+        return UA_ERROR;
+    }
+    *ns = &current->namespace;
+    return UA_SUCCESS;
+}
+
+UA_Int32 UA_NamespaceManager_setNodeStore(UA_NamespaceManager *namespaceManager,UA_UInt16 index, UA_NodeStore *nodeStore)
+{
+	UA_Namespace *namespace = UA_NULL;
+	UA_NamespaceManager_getNamespace(namespaceManager,index,&namespace);
+	if(namespace == UA_NULL)
+	{
+		return UA_ERROR;
+	}
+	namespace->nodeStore = nodeStore;
+	return UA_SUCCESS;
+}

src/server/ua_namespace_manager.h

@@ -0,0 +1,26 @@
+/*
+ * ua_namespace_manager.h
+ *
+ *  Created on: Oct 14, 2014
+ *      Author: opcua
+ */
+
+#ifndef UA_NAMESPACE_MANAGER_H_
+#define UA_NAMESPACE_MANAGER_H_
+#include "ua_server.h"
+#include "ua_nodestore.h"
+
+
+void UA_NamespaceManager_new(UA_NamespaceManager** namespaceManager);
+
+UA_Int32 UA_NamespaceManager_addNamespace(UA_NamespaceManager *namespaceManager, UA_UInt16 index, UA_NodeStore *nodeStore);
+
+UA_Int32 UA_NamespaceManager_removeNamespace(UA_NamespaceManager *namespaceManager,UA_UInt16 index);
+
+UA_Int32 UA_NamespaceManager_getNamespace(UA_NamespaceManager *namespaceManager, UA_UInt16 index, UA_Namespace **ns);
+
+UA_Int32 UA_NamespaceManager_setNodeStore(UA_NamespaceManager *namespaceManager,UA_UInt16 index, UA_NodeStore *nodeStore);
+
+
+
+#endif /* UA_NAMESPACE_MANAGER_H_ */

src/server/ua_nodestoreExample.c

@@ -0,0 +1,357 @@
+#include "ua_nodestoreExample.h"
+#include "ua_util.h"
+#include "ua_statuscodes.h"
+
+struct UA_NodeStoreExample {
+    const UA_Node **entries;
+    UA_UInt32       size;
+    UA_UInt32       count;
+    UA_UInt32       sizePrimeIndex;
+};
+
+typedef UA_UInt32 hash_t;
+/* The size of the hash-map is always a prime number. They are chosen to be
+   close to the next power of 2. So the size ca. doubles with each prime. */
+static hash_t const primes[] = {
+    7,         13,         31,         61,         127,         251,
+    509,       1021,       2039,       4093,       8191,        16381,
+    32749,     65521,      131071,     262139,     524287,      1048573,
+    2097143,   4194301,    8388593,    16777213,   33554393,    67108859,
+    134217689, 268435399,  536870909,  1073741789, 2147483647,  4294967291
+};
+
+static INLINE hash_t mod(hash_t h, hash_t size) {
+    return h % size;
+}
+static INLINE hash_t mod2(hash_t h, hash_t size) {
+    return 1 + (h % (size - 2));
+}
+
+static INLINE UA_Int16 higher_prime_index(hash_t n) {
+    UA_UInt16 low  = 0;
+    UA_UInt16 high = sizeof(primes) / sizeof(hash_t);
+    while(low != high) {
+        UA_UInt16 mid = low + (high - low) / 2;
+        if(n > primes[mid])
+            low = mid + 1;
+        else
+            high = mid;
+    }
+    return low;
+}
+
+/* Based on Murmur-Hash 3 by Austin Appleby (public domain, freely usable) */
+static INLINE hash_t hash_array(const UA_Byte *data, UA_UInt32 len, UA_UInt32 seed) {
+    const int32_t   nblocks = len / 4;
+    const uint32_t *blocks;
+
+    static const uint32_t c1 = 0xcc9e2d51;
+    static const uint32_t c2 = 0x1b873593;
+    static const uint32_t r1 = 15;
+    static const uint32_t r2 = 13;
+    static const uint32_t m  = 5;
+    static const uint32_t n  = 0xe6546b64;
+    hash_t hash = seed;
+
+    if(data == UA_NULL)
+        return 0;
+
+    blocks = (const uint32_t *)data;
+    for(int32_t i = 0;i < nblocks;i++) {
+        uint32_t k = blocks[i];
+        k    *= c1;
+        k     = (k << r1) | (k >> (32 - r1));
+        k    *= c2;
+        hash ^= k;
+        hash  = ((hash << r2) | (hash >> (32 - r2))) * m + n;
+    }
+
+    const uint8_t *tail = (const uint8_t *)(data + nblocks * 4);
+    uint32_t       k1   = 0;
+
+    switch(len & 3) {
+    case 3:
+        k1 ^= tail[2] << 16;
+
+    case 2:
+        k1 ^= tail[1] << 8;
+
+    case 1:
+        k1   ^= tail[0];
+        k1   *= c1;
+        k1    = (k1 << r1) | (k1 >> (32 - r1));
+        k1   *= c2;
+        hash ^= k1;
+    }
+
+    hash ^= len;
+    hash ^= (hash >> 16);
+    hash *= 0x85ebca6b;
+    hash ^= (hash >> 13);
+    hash *= 0xc2b2ae35;
+    hash ^= (hash >> 16);
+
+    return hash;
+}
+
+static INLINE hash_t hash(const UA_NodeId *n) {
+    switch(n->identifierType) {
+    case UA_NODEIDTYPE_NUMERIC:
+        /*  Knuth's multiplicative hashing */
+        return (n->identifier.numeric + n->namespaceIndex) * 2654435761;   // mod(2^32) is implicit
+
+    case UA_NODEIDTYPE_STRING:
+        return hash_array(n->identifier.string.data, n->identifier.string.length, n->namespaceIndex);
+
+    case UA_NODEIDTYPE_GUID:
+        return hash_array((UA_Byte *)&(n->identifier.guid), sizeof(UA_Guid), n->namespaceIndex);
+
+    case UA_NODEIDTYPE_BYTESTRING:
+        return hash_array((UA_Byte *)n->identifier.byteString.data, n->identifier.byteString.length, n->namespaceIndex);
+
+    default:
+        UA_assert(UA_FALSE);
+        return 0;
+    }
+}
+
+static INLINE void clear_entry(UA_NodeStoreExample *ns, const UA_Node **entry) {
+    const UA_Node *node;
+    if(entry == UA_NULL || *entry == UA_NULL)
+        return;
+
+    node = *entry;
+    switch(node->nodeClass) {
+    case UA_NODECLASS_OBJECT:
+        UA_ObjectNode_delete((UA_ObjectNode *)node);
+        break;
+
+    case UA_NODECLASS_VARIABLE:
+        UA_VariableNode_delete((UA_VariableNode *)node);
+        break;
+
+    case UA_NODECLASS_METHOD:
+        UA_MethodNode_delete((UA_MethodNode *)node);
+        break;
+
+    case UA_NODECLASS_OBJECTTYPE:
+        UA_ObjectTypeNode_delete((UA_ObjectTypeNode *)node);
+        break;
+
+    case UA_NODECLASS_VARIABLETYPE:
+        UA_VariableTypeNode_delete((UA_VariableTypeNode *)node);
+        break;
+
+    case UA_NODECLASS_REFERENCETYPE:
+        UA_ReferenceTypeNode_delete((UA_ReferenceTypeNode *)node);
+        break;
+
+    case UA_NODECLASS_DATATYPE:
+        UA_DataTypeNode_delete((UA_DataTypeNode *)node);
+        break;
+
+    case UA_NODECLASS_VIEW:
+        UA_ViewNode_delete((UA_ViewNode *)node);
+        break;
+
+    default:
+        UA_assert(UA_FALSE);
+        break;
+    }
+    entry = UA_NULL;
+    ns->count--;
+}
+
+/* Returns UA_SUCCESS if an entry was found. Otherwise, UA_ERROR is returned and the "entry"
+   argument points to the first free entry under the NodeId. */
+static INLINE UA_Int32 find_entry(const UA_NodeStoreExample *ns, const UA_NodeId *nodeid, const UA_Node ***entry) {
+    hash_t          h     = hash(nodeid);
+    UA_UInt32       size  = ns->size;
+    hash_t          index = mod(h, size);
+    const UA_Node **e     = &ns->entries[index];
+
+    if(*e == UA_NULL) {
+        *entry = e;
+        return UA_ERROR;
+    }
+
+    if(UA_NodeId_equal(&(*e)->nodeId, nodeid) == UA_EQUAL) {
+        *entry = e;
+        return UA_SUCCESS;
+    }
+
+    hash_t hash2 = mod2(h, size);
+    for(;;) {
+        index += hash2;
+        if(index >= size)
+            index -= size;
+
+        e = &ns->entries[index];
+
+        if(*e == UA_NULL) {
+            *entry = e;
+            return UA_ERROR;
+        }
+
+        if(UA_NodeId_equal(&(*e)->nodeId, nodeid) == UA_EQUAL) {
+            *entry = e;
+            return UA_SUCCESS;
+        }
+    }
+
+    /* NOTREACHED */
+    return UA_SUCCESS;
+}
+
+/* The following function changes size of memory allocated for the entries and
+   repeatedly inserts the table elements. The occupancy of the table after the
+   call will be about 50%. If memory allocation failures occur, this function
+   will return UA_ERROR. */
+static UA_Int32 expand(UA_NodeStoreExample *ns) {
+    const UA_Node **nentries;
+    int32_t nsize;
+    UA_UInt32       nindex;
+
+    const UA_Node **oentries = ns->entries;
+    int32_t osize = ns->size;
+    const UA_Node **olimit   = &oentries[osize];
+    int32_t count = ns->count;
+
+    /* Resize only when table after removal of unused elements is either too full or too empty.  */
+    if(count * 2 < osize && (count * 8 > osize || osize <= 32))
+        return UA_SUCCESS;
+
+    nindex = higher_prime_index(count * 2);
+    nsize  = primes[nindex];
+
+    if(!(nentries = UA_alloc(sizeof(UA_Node *) * nsize)))
+        return UA_STATUSCODE_BADOUTOFMEMORY;
+
+    memset(nentries, 0, nsize * sizeof(UA_Node *));
+    ns->entries = nentries;
+    ns->size    = nsize;
+    ns->sizePrimeIndex = nindex;
+
+    const UA_Node **p = oentries;
+    do {
+        if(*p != UA_NULL) {
+            const UA_Node **e;
+            find_entry(ns, &(*p)->nodeId, &e);  /* We know this returns an empty entry here */
+            *e = *p;
+        }
+        p++;
+    } while(p < olimit);
+
+    UA_free(oentries);
+    return UA_SUCCESS;
+}
+
+/**********************/
+/* Exported functions */
+/**********************/
+
+UA_Int32 UA_NodeStoreExample_new(UA_NodeStoreExample **result) {
+    UA_NodeStoreExample *ns;
+    UA_UInt32     sizePrimeIndex, size;
+    if(!(ns = UA_alloc(sizeof(UA_NodeStoreExample))))
+        return UA_STATUSCODE_BADOUTOFMEMORY;
+
+    sizePrimeIndex = higher_prime_index(32);
+    size = primes[sizePrimeIndex];
+    if(!(ns->entries = UA_alloc(sizeof(UA_Node *) * size))) {
+        UA_free(ns);
+        return UA_STATUSCODE_BADOUTOFMEMORY;
+    }
+
+    /* set entries to zero */
+    memset(ns->entries, 0, size * sizeof(UA_Node *));
+
+    *ns     = (UA_NodeStoreExample) {ns->entries, size, 0, sizePrimeIndex };
+    *result = ns;
+    return UA_SUCCESS;
+}
+
+UA_Int32 UA_NodeStoreExample_delete(UA_NodeStoreExample *ns) {
+    UA_UInt32       size    = ns->size;
+    const UA_Node **entries = ns->entries;
+
+    for(UA_UInt32 i = 0;i < size;i++)
+        clear_entry(ns, &entries[i]);
+
+    UA_free(ns->entries);
+    UA_free(ns);
+    return UA_SUCCESS;
+}
+
+UA_Int32 UA_NodeStoreExample_insert(UA_NodeStoreExample *ns, UA_Node **node, UA_Byte flags) {
+    if(ns == UA_NULL || node == UA_NULL || *node == UA_NULL)
+        return UA_ERROR;
+
+    if(ns->size * 3 <= ns->count * 4) {
+        if(expand(ns) != UA_SUCCESS)
+            return UA_ERROR;
+    }
+
+    const UA_Node **entry;
+    UA_Int32 found = find_entry(ns, &(*node)->nodeId, &entry);
+
+    if(flags & UA_NODESTORE_INSERT_UNIQUE) {
+        if(found == UA_SUCCESS)
+            return UA_ERROR;    /* There is already an entry for that nodeid */
+        else
+            *entry = *node;
+    } else {
+        if(found == UA_SUCCESS)
+            clear_entry(ns, entry);
+        *entry = *node;
+    }
+
+    if(!(flags & UA_NODESTORE_INSERT_GETMANAGED))
+        *node = UA_NULL;
+
+    ns->count++;
+    return UA_SUCCESS;
+}
+
+UA_Int32 UA_NodeStoreExample_get(const UA_NodeStoreExample *ns, const UA_NodeId *nodeid, const UA_Node **managedNode) {
+    const UA_Node **entry;
+    if(ns == UA_NULL || nodeid == UA_NULL || managedNode == UA_NULL)
+        return UA_ERROR;
+
+    if(find_entry(ns, nodeid, &entry) != UA_SUCCESS)
+        return UA_ERROR;
+
+    *managedNode = *entry;
+    return UA_SUCCESS;
+}
+
+UA_Int32 UA_NodeStoreExample_remove(UA_NodeStoreExample *ns, const UA_NodeId *nodeid) {
+    const UA_Node **entry;
+    if(find_entry(ns, nodeid, &entry) != UA_SUCCESS)
+        return UA_ERROR;
+
+    // Check before if deleting the node makes the UA_NodeStore inconsistent.
+    clear_entry(ns, entry);
+
+    /* Downsize the hashmap if it is very empty */
+    if(ns->count * 8 < ns->size && ns->size > 32)
+        expand(ns);
+
+    return UA_SUCCESS;
+}
+
+UA_Int32 UA_NodeStoreExample_iterate(const UA_NodeStoreExample *ns, UA_NodeStore_nodeVisitor visitor) {
+    if(ns == UA_NULL || visitor == UA_NULL)
+        return UA_ERROR;
+
+    for(UA_UInt32 i = 0;i < ns->size;i++) {
+        const UA_Node *node = ns->entries[i];
+        if(node != UA_NULL)
+            visitor(node);
+    }
+    return UA_SUCCESS;
+}
+
+void UA_NodeStoreExample_releaseManagedNode(const UA_Node *managed) {
+    ;
+}

src/server/ua_nodestoreExample.h

@@ -0,0 +1,62 @@
+#ifndef UA_NODESTORE_H_
+#define UA_NODESTORE_H_
+
+#include "ua_server.h"
+
+/**
+   @ingroup server
+
+   @defgroup nodestore NodeStore
+
+   @brief The nodestore is the central storage for nodes in the UA address
+   space. Internally, the nodestore is realised as hash-map where nodes are
+   stored and retrieved with their nodeid.
+
+   The nodes in the nodestore are immutable. To change the content of a node, it
+   needs to be replaced as a whole. When a node is inserted into the namespace,
+   it gets replaced with a pointer to a managed node. Managed nodes shall never
+   be freed by the user. This is done by the namespace when the node is removed
+   and no readers (in other threads) access the node.
+
+   @{
+ */
+
+/** @brief Create a new namespace */
+UA_Int32 UA_NodeStoreExample_new(UA_NodeStoreExample **result);
+
+/** @brief Delete the namespace and all nodes in it */
+UA_Int32 UA_NodeStoreExample_delete(UA_NodeStoreExample *ns);
+
+#define UA_NODESTORE_INSERT_UNIQUE 1
+#define UA_NODESTORE_INSERT_GETMANAGED 2
+/** @brief Insert a new node into the namespace
+
+    With the UNIQUE flag, the node is only inserted if the nodeid does not
+    already exist. With the GETMANAGED flag, the node pointer is replaced with
+    the managed pointer. Otherwise, it is set to UA_NULL. */
+UA_Int32 UA_NodeStoreExample_insert(UA_NodeStoreExample *ns, UA_Node **node, UA_Byte flags);
+
+/** @brief Remove a node from the namespace. Always succeeds, even if the node
+    was not found. */
+UA_Int32 UA_NodeStoreExample_remove(UA_NodeStoreExample *ns, const UA_NodeId *nodeid);
+
+/** @brief Retrieve a node (read-only) from the namespace. Nodes are immutable.
+    They can only be replaced. After the Node is no longer used, the locked
+    entry needs to be released. */
+UA_Int32 UA_NodeStoreExample_get(const UA_NodeStoreExample *ns, const UA_NodeId *nodeid,
+                          const UA_Node **managedNode);
+
+/** @brief Release a managed node. Do never insert a node that isn't stored in a
+    namespace. */
+void UA_NodeStoreExample_releaseManagedNode(const UA_Node *managed);
+
+/** @brief A function that can be evaluated on all entries in a namespace via
+    UA_NodeStore_iterate. Note that the visitor is read-only on the nodes. */
+typedef void (*UA_NodeStore_nodeVisitor)(const UA_Node *node);
+
+/** @brief Iterate over all nodes in a namespace. */
+UA_Int32 UA_NodeStoreExample_iterate(const UA_NodeStoreExample *ns, UA_NodeStore_nodeVisitor visitor);
+
+/// @} /* end of group */
+
+#endif /* UA_NODESTORE_H_ */