API improvements

README.md

@@ -54,19 +54,16 @@ int main(int argc, char** argv) {
     UA_Server_addNetworkLayer(server, nl);
 
     /* add a variable node */
-    UA_Int32 *myInteger = UA_Int32_new();
-    *myInteger = 42;
     UA_Variant *myIntegerVariant = UA_Variant_new();
-    UA_Variant_setValue(myIntegerVariant, myInteger, &UA_TYPES[UA_TYPES_INT32]);
+    UA_Int32 myInteger = 42;
+    UA_Variant_copySetScalar(myIntegerVariant, &myInteger, &UA_TYPES[UA_TYPES_INT32]);
     UA_QualifiedName myIntegerName;
     UA_QUALIFIEDNAME_ASSIGN(myIntegerName, "the answer");
-    UA_Server_addVariableNode(server,
-                              myIntegerVariant, /* the variant */
-                              &UA_NODEID_NULL, /* assign a new nodeid */
-                              &myIntegerName, /* the browse name */
-                              /* the parent node and the referencetype to the parent */
-                              &UA_NODEID_STATIC(0, UA_NS0ID_OBJECTSFOLDER),
-                              &UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
+    UA_NodeId myIntegerNodeId = UA_NODEID_NULL; /* assign a random free nodeid */
+    UA_NodeId parentNodeId = UA_NODEID_STATIC(0, UA_NS0ID_OBJECTSFOLDER);
+    UA_NodeId parentReferenceNodeId = UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES);
+    UA_Server_addVariableNode(server, myIntegerVariant, myIntegerName,
+                              myIntegerNodeId, parentNodeId, parentReferenceNodeId);
 
     /* run the server loop */
     UA_StatusCode retval = UA_Server_run(server, WORKER_THREADS, &running);

examples/server.c

@@ -69,15 +69,16 @@ int main(int argc, char** argv) {
     UA_Server_addRepeatedWorkItem(server, &work, 20000000, NULL); // call every 2 sec
 
 	// add a variable node to the adresspace
-    UA_Int32 *myInteger = UA_Int32_new();
-    *myInteger = 42;
     UA_Variant *myIntegerVariant = UA_Variant_new();
-    UA_Variant_setValue(myIntegerVariant, myInteger, &UA_TYPES[UA_TYPES_INT32]);
+    UA_Int32 myInteger = 42;
+    UA_Variant_copySetScalar(myIntegerVariant, &myInteger, &UA_TYPES[UA_TYPES_INT32]);
     UA_QualifiedName myIntegerName;
     UA_QUALIFIEDNAME_ASSIGN(myIntegerName, "the answer");
-    UA_Server_addVariableNode(server, myIntegerVariant, &UA_NODEID_NULL, &myIntegerName,
-                              &UA_NODEID_STATIC(0, UA_NS0ID_OBJECTSFOLDER),
-                              &UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
+    UA_NodeId myIntegerNodeId = UA_NODEID_NULL; /* assign a random free nodeid */
+    UA_NodeId parentNodeId = UA_NODEID_STATIC(0, UA_NS0ID_OBJECTSFOLDER);
+    UA_NodeId parentReferenceNodeId = UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES);
+    UA_Server_addVariableNode(server, myIntegerVariant, myIntegerName,
+                              myIntegerNodeId, parentNodeId, parentReferenceNodeId);
     
 #ifdef BENCHMARK
     UA_UInt32 nodeCount = 500;
@@ -86,13 +87,13 @@ int main(int argc, char** argv) {
         UA_Int32 *data = UA_Int32_new();
         *data = 42;
         UA_Variant *variant = UA_Variant_new();
-        UA_Variant_setValue(variant, data, &UA_TYPES[UA_TYPES_INT32]);
+        UA_Variant_setScalar(variant, data, &UA_TYPES[UA_TYPES_INT32]);
         UA_QualifiedName *nodeName = UA_QualifiedName_new();
         sprintf(str,"%d",i);
         UA_QualifiedName_copycstring(str, nodeName);
-        UA_Server_addVariableNode(server, variant, &UA_NODEID_NULL, nodeName,
-                                  &UA_NODEID_STATIC(0, UA_NS0ID_OBJECTSFOLDER),
-                                  &UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
+        UA_Server_addVariableNode(server, variant, nodeName, UA_NODEID_NULL, 
+                                  UA_NODEID_STATIC(0, UA_NS0ID_OBJECTSFOLDER),
+                                  UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
     }
 #endif
 

examples/server.cpp

@@ -28,20 +28,17 @@ int main()
 	UA_Server *server = UA_Server_new();
     UA_Server_addNetworkLayer(server, ServerNetworkLayerTCP_new(UA_ConnectionConfig_standard, 16664));
 
-	//add a node to the adresspace
-    UA_Int32 *myInteger = UA_Int32_new();
-    *myInteger = 42;
+	// add a variable node to the adresspace
     UA_Variant *myIntegerVariant = UA_Variant_new();
-    UA_Variant_setValue(myIntegerVariant, myInteger, UA_TYPES_INT32);
+    UA_Int32 myInteger = 42;
+    UA_Variant_copySetScalar(myIntegerVariant, &myInteger, &UA_TYPES[UA_TYPES_INT32]);
     UA_QualifiedName myIntegerName;
     UA_QUALIFIEDNAME_ASSIGN(myIntegerName, "the answer");
-    UA_NodeId nullnode, objects, organizes;
-    UA_NODEID_ASSIGN(nullnode, 0, 0);
-    UA_NODEID_ASSIGN(objects, UA_NS0ID_OBJECTSFOLDER, 0);
-    UA_NODEID_ASSIGN(organizes, UA_NS0ID_ORGANIZES, 0);
-    
-    UA_Server_addVariableNode(server, myIntegerVariant, &nullnode, &myIntegerName,
-                              &objects, &organizes);
+    UA_NodeId myIntegerNodeId = UA_NODEID_NULL; /* assign a random free nodeid */
+    UA_NodeId parentNodeId = UA_NODEID_STATIC(0, UA_NS0ID_OBJECTSFOLDER);
+    UA_NodeId parentReferenceNodeId = UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES);
+    UA_Server_addVariableNode(server, myIntegerVariant, myIntegerName,
+                              myIntegerNodeId, parentNodeId, parentReferenceNodeId);
 
     UA_Boolean running = UA_TRUE;
     UA_StatusCode retval = UA_Server_run(server, 1, &running);

examples/server_datasource.c

@@ -183,9 +183,9 @@ int main(int argc, char** argv) {
 		.write = NULL};
 	UA_QualifiedName dateName;
 	UA_QUALIFIEDNAME_ASSIGN(dateName, "current time");
-	UA_Server_addDataSourceVariableNode(server, dateDataSource, &UA_NODEID_NULL, &dateName,
-			&UA_NODEID_STATIC(0, UA_NS0ID_OBJECTSFOLDER),
-			&UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
+	UA_Server_addDataSourceVariableNode(server, dateDataSource, dateName, UA_NODEID_NULL,
+                                        UA_NODEID_STATIC(0, UA_NS0ID_OBJECTSFOLDER),
+                                        UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
 
 	if(!(temperatureFile = fopen("/sys/class/thermal/thermal_zone0/temp", "r"))){
 		UA_LOG_WARNING(logger, UA_LOGGERCATEGORY_USERLAND, "[Linux specific] Can not open temperature file, no temperature node will be added");
@@ -198,9 +198,9 @@ int main(int argc, char** argv) {
 			.write = NULL};
 		UA_QualifiedName ledName;
 		UA_QUALIFIEDNAME_ASSIGN(ledName, "cpu temperature");
-		UA_Server_addDataSourceVariableNode(server, temperatureDataSource, &UA_NODEID_NULL, &ledName,
-				&UA_NODEID_STATIC(0, UA_NS0ID_OBJECTSFOLDER),
-				&UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
+		UA_Server_addDataSourceVariableNode(server, temperatureDataSource, ledName, UA_NODEID_NULL, 
+                                            UA_NODEID_STATIC(0, UA_NS0ID_OBJECTSFOLDER),
+                                            UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
 	}
 
 	if (	!(triggerFile = fopen("/sys/class/leds/led0/trigger", "w"))
@@ -225,9 +225,9 @@ int main(int argc, char** argv) {
 		.write = writeLedStatus};
 	UA_QualifiedName statusName;
 	UA_QUALIFIEDNAME_ASSIGN(statusName, "status LED");
-	UA_Server_addDataSourceVariableNode(server, ledStatusDataSource, &UA_NODEID_NULL, &statusName,
-			&UA_NODEID_STATIC(0, UA_NS0ID_OBJECTSFOLDER),
-			&UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
+	UA_Server_addDataSourceVariableNode(server, ledStatusDataSource, statusName, UA_NODEID_NULL,
+                                        UA_NODEID_STATIC(0, UA_NS0ID_OBJECTSFOLDER),
+                                        UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
 
 	//start server
 	UA_StatusCode retval = UA_Server_run(server, 1, &running); //blocks until running=false

examples/server_udp.c

@@ -30,15 +30,16 @@ int main(int argc, char** argv) {
     UA_Server_addNetworkLayer(server, ServerNetworkLayerUDP_new(UA_ConnectionConfig_standard, 16664));
 
 	// add a variable node to the adresspace
-    UA_Int32 *myInteger = UA_Int32_new();
-    *myInteger = 42;
     UA_Variant *myIntegerVariant = UA_Variant_new();
-    UA_Variant_setValue(myIntegerVariant, myInteger, &UA_TYPES[UA_TYPES_INT32]);
+    UA_Int32 myInteger = 42;
+    UA_Variant_copySetScalar(myIntegerVariant, &myInteger, &UA_TYPES[UA_TYPES_INT32]);
     UA_QualifiedName myIntegerName;
     UA_QUALIFIEDNAME_ASSIGN(myIntegerName, "the answer");
-    UA_Server_addVariableNode(server, myIntegerVariant, &UA_NODEID_NULL, &myIntegerName,
-                              &UA_NODEID_STATIC(0, UA_NS0ID_OBJECTSFOLDER),
-                              &UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
+    UA_NodeId myIntegerNodeId = UA_NODEID_NULL; /* assign a random free nodeid */
+    UA_NodeId parentNodeId = UA_NODEID_STATIC(0, UA_NS0ID_OBJECTSFOLDER);
+    UA_NodeId parentReferenceNodeId = UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES);
+    UA_Server_addVariableNode(server, myIntegerVariant, myIntegerName,
+                              myIntegerNodeId, parentNodeId, parentReferenceNodeId);
 
     UA_StatusCode retval = UA_Server_run(server, 1, &running);
 	UA_Server_delete(server);

include/ua_server.h

@@ -79,14 +79,14 @@ typedef struct {
 /** Add a reference to the server's address space */
 UA_StatusCode UA_EXPORT UA_Server_addReference(UA_Server *server, const UA_AddReferencesItem *item);
 
-UA_StatusCode UA_EXPORT UA_Server_addVariableNode(UA_Server *server, UA_Variant *value, UA_NodeId *nodeId,
-                                                  UA_QualifiedName *browseName, const UA_NodeId *parentNodeId,
-                                                  const UA_NodeId *referenceTypeId);
-
-UA_StatusCode UA_EXPORT UA_Server_addDataSourceVariableNode(UA_Server *server, UA_DataSource dataSource,
-                                                            UA_NodeId *nodeId, UA_QualifiedName *browseName,
-                                                            const UA_NodeId *parentNodeId,
-                                                            const UA_NodeId *referenceTypeId);
+UA_StatusCode UA_EXPORT
+UA_Server_addVariableNode(UA_Server *server, UA_Variant *value, const UA_QualifiedName browseName, 
+                          UA_NodeId nodeId, const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId);
+
+UA_StatusCode UA_EXPORT
+UA_Server_addDataSourceVariableNode(UA_Server *server, UA_DataSource dataSource,
+                                    const UA_QualifiedName browseName, UA_NodeId nodeId,
+                                    const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId);
 
 /** Work that is run in the main loop (singlethreaded) or dispatched to a worker
     thread. */

include/ua_types.h

@@ -430,7 +430,7 @@ UA_StatusCode UA_EXPORT UA_Variant_copyRange(const UA_Variant *src, UA_Variant *
  * @param type The datatype of the value in question
  * @return Indicates whether the operation succeeded or returns an error code
  */
-UA_StatusCode UA_EXPORT UA_Variant_setValue(UA_Variant *v, void *p, const UA_DataType *type);
+UA_StatusCode UA_EXPORT UA_Variant_setScalar(UA_Variant *v, void *p, const UA_DataType *type);
 
 /**
  * Set the variant to a scalar value that is copied from an existing variable.
@@ -440,7 +440,7 @@ UA_StatusCode UA_EXPORT UA_Variant_setValue(UA_Variant *v, void *p, const UA_Dat
  * @param type The datatype of the value
  * @return Indicates whether the operation succeeded or returns an error code
  */
-UA_StatusCode UA_EXPORT UA_Variant_copySetValue(UA_Variant *v, const void *p, const UA_DataType *type);
+UA_StatusCode UA_EXPORT UA_Variant_copySetScalar(UA_Variant *v, const void *p, const UA_DataType *type);
 
 /**
  * Set the variant to an array that already resides in memory. The array takes on the lifecycle of

src/server/ua_server.c

@@ -759,21 +759,19 @@ UA_Server * UA_Server_new(void) {
 	   //add a scalar node for every built-in type
 	    void *value = UA_new(&UA_TYPES[type]);
 	    UA_Variant *variant = UA_Variant_new();
-	    UA_Variant_setValue(variant, value, &UA_TYPES[type]);
+	    UA_Variant_setScalar(variant, value, &UA_TYPES[type]);
 	    UA_QualifiedName myIntegerName;
 	    char name[15];
 	    sprintf(name, "%02d", type);
 	    UA_QUALIFIEDNAME_ASSIGN(myIntegerName, name);
-	    UA_Server_addVariableNode(server, variant, &UA_NODEID_STATIC(1, ++id), &myIntegerName,
-	                              &UA_NODEID_STATIC(1, SCALARID),
-	                              &UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
+	    UA_Server_addVariableNode(server, variant, myIntegerName, UA_NODEID_STATIC(1, ++id),
+	                              UA_NODEID_STATIC(1, SCALARID), UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
 
         //add an array node for every built-in type
         UA_Variant *arrayvar = UA_Variant_new();
         UA_Variant_setArray(arrayvar, UA_Array_new(&UA_TYPES[type], 10), 10, &UA_TYPES[type]);
-        UA_Server_addVariableNode(server, arrayvar, &UA_NODEID_STATIC(1, ++id), &myIntegerName,
-                                  &UA_NODEID_STATIC(1, ARRAYID),
-                                  &UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
+        UA_Server_addVariableNode(server, arrayvar, myIntegerName, UA_NODEID_STATIC(1, ++id),
+                                  UA_NODEID_STATIC(1, ARRAYID), UA_NODEID_STATIC(0, UA_NS0ID_ORGANIZES));
    }
 #endif
 

src/server/ua_server_addressspace.c

@@ -2,19 +2,19 @@
 #include "ua_server_internal.h"
 
 UA_StatusCode
-UA_Server_addVariableNode(UA_Server *server, UA_Variant *value, UA_NodeId *nodeId, UA_QualifiedName *browseName,
-                          const UA_NodeId *parentNodeId, const UA_NodeId *referenceTypeId)
+UA_Server_addVariableNode(UA_Server *server, UA_Variant *value, const UA_QualifiedName browseName, 
+                          UA_NodeId nodeId, const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId)
 {
     UA_VariableNode *node = UA_VariableNode_new();
     node->variable.variant = *value; // copy content
-    UA_NodeId_copy(nodeId, &node->nodeId);
-    UA_QualifiedName_copy(browseName, &node->browseName);
-    UA_String_copy(&browseName->name, &node->displayName.text);
+    UA_NodeId_copy(&nodeId, &node->nodeId);
+    UA_QualifiedName_copy(&browseName, &node->browseName);
+    UA_String_copy(&browseName.name, &node->displayName.text);
     UA_ExpandedNodeId parentId; // we need an expandednodeid
     UA_ExpandedNodeId_init(&parentId);
-    parentId.nodeId = *parentNodeId;
+    UA_NodeId_copy(&parentNodeId, &parentId.nodeId);
     UA_AddNodesResult res =
-        UA_Server_addNodeWithSession(server, &adminSession, (UA_Node*)node, &parentId, referenceTypeId);
+        UA_Server_addNodeWithSession(server, &adminSession, (UA_Node*)node, &parentId, &referenceTypeId);
     ADDREFERENCE(res.addedNodeId, UA_NODEID_STATIC(0, UA_NS0ID_HASTYPEDEFINITION),
                  UA_EXPANDEDNODEID_STATIC(0, value->type->typeId.identifier.numeric));
     if(res.statusCode != UA_STATUSCODE_GOOD) {
@@ -26,21 +26,21 @@ UA_Server_addVariableNode(UA_Server *server, UA_Variant *value, UA_NodeId *nodeI
 }
 
 UA_StatusCode
-UA_Server_addDataSourceVariableNode(UA_Server *server, UA_DataSource dataSource, UA_NodeId *nodeId,
-                                    UA_QualifiedName *browseName, const UA_NodeId *parentNodeId,
-                                    const UA_NodeId *referenceTypeId)
+UA_Server_addDataSourceVariableNode(UA_Server *server, UA_DataSource dataSource,
+                                    const UA_QualifiedName browseName, UA_NodeId nodeId,
+                                    const UA_NodeId parentNodeId, const UA_NodeId referenceTypeId)
 {
     UA_VariableNode *node = UA_VariableNode_new();
     node->variableType = UA_VARIABLENODETYPE_DATASOURCE;
     node->variable.dataSource = dataSource;
-    UA_NodeId_copy(nodeId, &node->nodeId);
-    UA_QualifiedName_copy(browseName, &node->browseName);
-    UA_String_copy(&browseName->name, &node->displayName.text);
+    UA_NodeId_copy(&nodeId, &node->nodeId);
+    UA_QualifiedName_copy(&browseName, &node->browseName);
+    UA_String_copy(&browseName.name, &node->displayName.text);
     UA_ExpandedNodeId parentId; // dummy exapndednodeid
     UA_ExpandedNodeId_init(&parentId);
-    parentId.nodeId = *parentNodeId;
+    UA_NodeId_copy(&parentNodeId, &parentId.nodeId);
     UA_AddNodesResult res =
-        UA_Server_addNodeWithSession(server, &adminSession, (UA_Node*)node, &parentId, referenceTypeId);
+        UA_Server_addNodeWithSession(server, &adminSession, (UA_Node*)node, &parentId, &referenceTypeId);
     ADDREFERENCE(res.addedNodeId, UA_NODEID_STATIC(0, UA_NS0ID_HASTYPEDEFINITION),
                  UA_EXPANDEDNODEID_STATIC(0, UA_NS0ID_BASEDATAVARIABLETYPE));
     if(res.statusCode != UA_STATUSCODE_GOOD)

src/server/ua_services_attribute.c

@@ -117,66 +117,66 @@ static void readValue(UA_Server *server, UA_TimestampsToReturn timestamps,
     switch(id->attributeId) {
     case UA_ATTRIBUTEID_NODEID:
         v->hasVariant = UA_TRUE;
-        retval |= UA_Variant_copySetValue(&v->value, &node->nodeId, &UA_TYPES[UA_TYPES_NODEID]);
+        retval |= UA_Variant_copySetScalar(&v->value, &node->nodeId, &UA_TYPES[UA_TYPES_NODEID]);
         break;
     case UA_ATTRIBUTEID_NODECLASS:
         v->hasVariant = UA_TRUE;
-        retval |= UA_Variant_copySetValue(&v->value, &node->nodeClass, &UA_TYPES[UA_TYPES_INT32]);
+        retval |= UA_Variant_copySetScalar(&v->value, &node->nodeClass, &UA_TYPES[UA_TYPES_INT32]);
         break;
     case UA_ATTRIBUTEID_BROWSENAME:
         v->hasVariant = UA_TRUE;
-        retval |= UA_Variant_copySetValue(&v->value, &node->browseName, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
+        retval |= UA_Variant_copySetScalar(&v->value, &node->browseName, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
         break;
     case UA_ATTRIBUTEID_DISPLAYNAME:
-        retval |= UA_Variant_copySetValue(&v->value, &node->displayName, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
+        retval |= UA_Variant_copySetScalar(&v->value, &node->displayName, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
         if(retval == UA_STATUSCODE_GOOD)
             v->hasVariant = UA_TRUE;
         break;
     case UA_ATTRIBUTEID_DESCRIPTION:
         v->hasVariant = UA_TRUE;
-        retval |= UA_Variant_copySetValue(&v->value, &node->description, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
+        retval |= UA_Variant_copySetScalar(&v->value, &node->description, &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
         break;
     case UA_ATTRIBUTEID_WRITEMASK:
         v->hasVariant = UA_TRUE;
-        retval |= UA_Variant_copySetValue(&v->value, &node->writeMask, &UA_TYPES[UA_TYPES_UINT32]);
+        retval |= UA_Variant_copySetScalar(&v->value, &node->writeMask, &UA_TYPES[UA_TYPES_UINT32]);
         break;
     case UA_ATTRIBUTEID_USERWRITEMASK:
         v->hasVariant = UA_TRUE;
-        retval |= UA_Variant_copySetValue(&v->value, &node->userWriteMask, &UA_TYPES[UA_TYPES_UINT32]);
+        retval |= UA_Variant_copySetScalar(&v->value, &node->userWriteMask, &UA_TYPES[UA_TYPES_UINT32]);
         break;
     case UA_ATTRIBUTEID_ISABSTRACT:
         CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE | UA_NODECLASS_OBJECTTYPE | UA_NODECLASS_VARIABLETYPE |
                         UA_NODECLASS_DATATYPE);
         v->hasVariant = UA_TRUE;
-        retval |= UA_Variant_copySetValue(&v->value, &((const UA_ReferenceTypeNode *)node)->isAbstract,
+        retval |= UA_Variant_copySetScalar(&v->value, &((const UA_ReferenceTypeNode *)node)->isAbstract,
                                           &UA_TYPES[UA_TYPES_BOOLEAN]);
         break;
     case UA_ATTRIBUTEID_SYMMETRIC:
         CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
         v->hasVariant = UA_TRUE;
-        retval |= UA_Variant_copySetValue(&v->value, &((const UA_ReferenceTypeNode *)node)->symmetric,
+        retval |= UA_Variant_copySetScalar(&v->value, &((const UA_ReferenceTypeNode *)node)->symmetric,
                                           &UA_TYPES[UA_TYPES_BOOLEAN]);
         break;
     case UA_ATTRIBUTEID_INVERSENAME:
         CHECK_NODECLASS(UA_NODECLASS_REFERENCETYPE);
         v->hasVariant = UA_TRUE;
-        retval |= UA_Variant_copySetValue(&v->value, &((const UA_ReferenceTypeNode *)node)->inverseName,
+        retval |= UA_Variant_copySetScalar(&v->value, &((const UA_ReferenceTypeNode *)node)->inverseName,
                                           &UA_TYPES[UA_TYPES_LOCALIZEDTEXT]);
         break;
     case UA_ATTRIBUTEID_CONTAINSNOLOOPS:
         CHECK_NODECLASS(UA_NODECLASS_VIEW);
         v->hasVariant = UA_TRUE;
-        retval |= UA_Variant_copySetValue(&v->value, &((const UA_ViewNode *)node)->containsNoLoops,
+        retval |= UA_Variant_copySetScalar(&v->value, &((const UA_ViewNode *)node)->containsNoLoops,
                                           &UA_TYPES[UA_TYPES_BOOLEAN]);
         break;
     case UA_ATTRIBUTEID_EVENTNOTIFIER:
         CHECK_NODECLASS(UA_NODECLASS_VIEW | UA_NODECLASS_OBJECT);
         v->hasVariant = UA_TRUE;
         if(node->nodeClass == UA_NODECLASS_VIEW){
-        	retval |= UA_Variant_copySetValue(&v->value, &((const UA_ViewNode *)node)->eventNotifier,
+        	retval |= UA_Variant_copySetScalar(&v->value, &((const UA_ViewNode *)node)->eventNotifier,
                                           	  &UA_TYPES[UA_TYPES_BYTE]);
         } else {
-        	retval |= UA_Variant_copySetValue(&v->value, &((const UA_ObjectNode *)node)->eventNotifier,
+        	retval |= UA_Variant_copySetScalar(&v->value, &((const UA_ObjectNode *)node)->eventNotifier,
                                               &UA_TYPES[UA_TYPES_BYTE]);
         }
         break;
@@ -237,13 +237,13 @@ static void readValue(UA_Server *server, UA_TimestampsToReturn timestamps,
 		CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
 		v->hasVariant = UA_TRUE;
 		if(node->nodeClass == UA_NODECLASS_VARIABLETYPE){
-			retval |= UA_Variant_copySetValue(&v->value,
+			retval |= UA_Variant_copySetScalar(&v->value,
 											  &((const UA_VariableTypeNode *)node)->value.type->typeId,
 											  &UA_TYPES[UA_TYPES_NODEID]);
 		} else {
 			const UA_VariableNode *vn = (const UA_VariableNode*)node;
 			if(vn->variableType == UA_VARIABLENODETYPE_VARIANT)
-				retval |= UA_Variant_copySetValue(&v->value, &vn->variable.variant.type->typeId,
+				retval |= UA_Variant_copySetScalar(&v->value, &vn->variable.variant.type->typeId,
 												  &UA_TYPES[UA_TYPES_NODEID]);
 			else {
 				UA_DataValue val;
@@ -251,7 +251,7 @@ static void readValue(UA_Server *server, UA_TimestampsToReturn timestamps,
 				retval |= vn->variable.dataSource.read(vn->variable.dataSource.handle, UA_FALSE, &val);
 				if(retval != UA_STATUSCODE_GOOD)
 					break;
-				retval |= UA_Variant_copySetValue(&v->value, &val.value.type->typeId,
+				retval |= UA_Variant_copySetScalar(&v->value, &val.value.type->typeId,
 												  &UA_TYPES[UA_TYPES_NODEID]);
 				vn->variable.dataSource.release(vn->variable.dataSource.handle, &val);
 				if(retval != UA_STATUSCODE_GOOD)
@@ -263,7 +263,7 @@ static void readValue(UA_Server *server, UA_TimestampsToReturn timestamps,
     case UA_ATTRIBUTEID_VALUERANK:
         CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
         v->hasVariant = UA_TRUE;
-        retval |= UA_Variant_copySetValue(&v->value, &((const UA_VariableTypeNode *)node)->valueRank,
+        retval |= UA_Variant_copySetScalar(&v->value, &((const UA_VariableTypeNode *)node)->valueRank,
                                           &UA_TYPES[UA_TYPES_INT32]);
         break;
 
@@ -304,42 +304,42 @@ static void readValue(UA_Server *server, UA_TimestampsToReturn timestamps,
     case UA_ATTRIBUTEID_ACCESSLEVEL:
         CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
         v->hasVariant = UA_TRUE;
-        retval |= UA_Variant_copySetValue(&v->value, &((const UA_VariableNode *)node)->accessLevel,
+        retval |= UA_Variant_copySetScalar(&v->value, &((const UA_VariableNode *)node)->accessLevel,
                                           &UA_TYPES[UA_TYPES_BYTE]);
         break;
 
     case UA_ATTRIBUTEID_USERACCESSLEVEL:
         CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
         v->hasVariant = UA_TRUE;
-        retval |= UA_Variant_copySetValue(&v->value, &((const UA_VariableNode *)node)->userAccessLevel,
+        retval |= UA_Variant_copySetScalar(&v->value, &((const UA_VariableNode *)node)->userAccessLevel,
                                           &UA_TYPES[UA_TYPES_BYTE]);
         break;
 
     case UA_ATTRIBUTEID_MINIMUMSAMPLINGINTERVAL:
         CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
         v->hasVariant = UA_TRUE;
-        retval |= UA_Variant_copySetValue(&v->value, &((const UA_VariableNode *)node)->minimumSamplingInterval,
+        retval |= UA_Variant_copySetScalar(&v->value, &((const UA_VariableNode *)node)->minimumSamplingInterval,
                                           &UA_TYPES[UA_TYPES_DOUBLE]);
         break;
 
     case UA_ATTRIBUTEID_HISTORIZING:
         CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
         v->hasVariant = UA_TRUE;
-        retval |= UA_Variant_copySetValue(&v->value, &((const UA_VariableNode *)node)->historizing,
+        retval |= UA_Variant_copySetScalar(&v->value, &((const UA_VariableNode *)node)->historizing,
                                           &UA_TYPES[UA_TYPES_BOOLEAN]);
         break;
 
     case UA_ATTRIBUTEID_EXECUTABLE:
         CHECK_NODECLASS(UA_NODECLASS_METHOD);
         v->hasVariant = UA_TRUE;
-        retval |= UA_Variant_copySetValue(&v->value, &((const UA_MethodNode *)node)->executable,
+        retval |= UA_Variant_copySetScalar(&v->value, &((const UA_MethodNode *)node)->executable,
                                           &UA_TYPES[UA_TYPES_BOOLEAN]);
         break;
 
     case UA_ATTRIBUTEID_USEREXECUTABLE:
         CHECK_NODECLASS(UA_NODECLASS_METHOD);
         v->hasVariant = UA_TRUE;
-        retval |= UA_Variant_copySetValue(&v->value, &((const UA_MethodNode *)node)->userExecutable,
+        retval |= UA_Variant_copySetScalar(&v->value, &((const UA_MethodNode *)node)->userExecutable,
                                           &UA_TYPES[UA_TYPES_BOOLEAN]);
         break;
 

src/ua_types.c

@@ -700,11 +700,11 @@ UA_StatusCode UA_Variant_copyRange(const UA_Variant *src, UA_Variant *dst, const
     return UA_STATUSCODE_GOOD;
 }
 
-UA_StatusCode UA_Variant_setValue(UA_Variant *v, void *p, const UA_DataType *type) {
+UA_StatusCode UA_Variant_setScalar(UA_Variant *v, void *p, const UA_DataType *type) {
     return UA_Variant_setArray(v, p, -1, type);
 }
 
-UA_StatusCode UA_Variant_copySetValue(UA_Variant *v, const void *p, const UA_DataType *type) {
+UA_StatusCode UA_Variant_copySetScalar(UA_Variant *v, const void *p, const UA_DataType *type) {
     void *new = UA_malloc(type->memSize);
     if(!new)
         return UA_STATUSCODE_BADOUTOFMEMORY;