improve variant set_ functions.

They now support any datatype (also custom ones) and not only standard-defined nodes

examples/server.c

@@ -67,7 +67,7 @@ int main(int argc, char** argv) {
     UA_Int32 *myInteger = UA_Int32_new();
     *myInteger = 42;
     UA_Variant *myIntegerVariant = UA_Variant_new();
-    UA_Variant_setValue(myIntegerVariant, myInteger, UA_TYPES_INT32);
+    UA_Variant_setValue(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,
@@ -81,7 +81,7 @@ 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_INT32);
+        UA_Variant_setValue(variant, data, &UA_TYPES[UA_TYPES_INT32]);
         UA_QualifiedName *nodeName = UA_QualifiedName_new();
         sprintf(str,"%d",i);
         UA_QualifiedName_copycstring(str, nodeName);

examples/server_udp.c

@@ -33,7 +33,7 @@ int main(int argc, char** argv) {
     UA_Int32 *myInteger = UA_Int32_new();
     *myInteger = 42;
     UA_Variant *myIntegerVariant = UA_Variant_new();
-    UA_Variant_setValue(myIntegerVariant, myInteger, UA_TYPES_INT32);
+    UA_Variant_setValue(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,

include/ua_types.h

@@ -396,23 +396,21 @@ UA_StatusCode UA_EXPORT UA_LocalizedText_copycstring(char const *src, UA_Localiz
  * lifecycle of the variant and is deleted with it.
  *
  * @param v The variant
- * @param p A pointer to the data
- * @param typeIndex The index of the datatype (from namespace 0) as defined in ua_types_generated.h.
- * For example, typeIndex == UA_TYPES_INT32
+ * @param p A pointer to the value data
+ * @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, UA_UInt16 typeIndex);
+UA_StatusCode UA_EXPORT UA_Variant_setValue(UA_Variant *v, void *p, const UA_DataType *type);
 
 /**
  * Set the variant to a scalar value that is copied from an existing variable.
  *
  * @param v The variant
- * @param p A pointer to the data
- * @param typeIndex The index of the datatype (from namespace 0) as defined in ua_types_generated.h.
- * For example, typeIndex == UA_TYPES_INT32
+ * @param p A pointer to the value data
+ * @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, UA_UInt16 typeIndex);
+UA_StatusCode UA_EXPORT UA_Variant_copySetValue(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
@@ -421,11 +419,11 @@ UA_StatusCode UA_EXPORT UA_Variant_copySetValue(UA_Variant *v, const void *p, UA
  * @param v The variant
  * @param array A pointer to the array data
  * @param noElements The size of the array
- * @param typeIndex The index of the datatype (from namespace 0) as defined in ua_types_generated.h.
- * For example, typeIndex == UA_TYPES_INT32
+ * @param type The datatype of the array
  * @return Indicates whether the operation succeeded or returns an error code
  */
-UA_StatusCode UA_EXPORT UA_Variant_setArray(UA_Variant *v, void *array, UA_Int32 noElements, UA_UInt16 typeIndex);
+UA_StatusCode UA_EXPORT UA_Variant_setArray(UA_Variant *v, void *array,
+                                            UA_Int32 noElements, const UA_DataType *type);
 
 /**
  * Set the variant to an array that is copied from an existing array.
@@ -433,11 +431,11 @@ UA_StatusCode UA_EXPORT UA_Variant_setArray(UA_Variant *v, void *array, UA_Int32
  * @param v The variant
  * @param array A pointer to the array data
  * @param noElements The size of the array
- * @param typeIndex The index of the datatype (from namespace 0) as defined in ua_types_generated.h.
- * For example, typeIndex == UA_TYPES_INT32
+ * @param type The datatype of the array
  * @return Indicates whether the operation succeeded or returns an error code
  */
-UA_StatusCode UA_EXPORT UA_Variant_copySetArray(UA_Variant *v, const void *array, UA_Int32 noElements, UA_UInt16 typeIndex);
+UA_StatusCode UA_EXPORT UA_Variant_copySetArray(UA_Variant *v, const void *array,
+                                                UA_Int32 noElements, const UA_DataType *type);
 
 /****************************/
 /* Structured Type Handling */

src/server/ua_services_attribute.c

@@ -27,38 +27,38 @@ static void readValue(UA_Server *server, const UA_ReadValueId *id, UA_DataValue
     switch(id->attributeId) {
     case UA_ATTRIBUTEID_NODEID:
         v->hasVariant = UA_TRUE;
-        retval |= UA_Variant_copySetValue(&v->value, &node->nodeId, UA_TYPES_NODEID);
+        retval |= UA_Variant_copySetValue(&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_INT32);
+        retval |= UA_Variant_copySetValue(&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_QUALIFIEDNAME);
+        retval |= UA_Variant_copySetValue(&v->value, &node->browseName, &UA_TYPES[UA_TYPES_QUALIFIEDNAME]);
         break;
 
     case UA_ATTRIBUTEID_DISPLAYNAME:
-        retval |= UA_Variant_copySetValue(&v->value, &node->displayName, UA_TYPES_LOCALIZEDTEXT);
+        retval |= UA_Variant_copySetValue(&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_LOCALIZEDTEXT);
+        retval |= UA_Variant_copySetValue(&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_UINT32);
+        retval |= UA_Variant_copySetValue(&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_UINT32);
+        retval |= UA_Variant_copySetValue(&v->value, &node->userWriteMask, &UA_TYPES[UA_TYPES_UINT32]);
         break;
 
     case UA_ATTRIBUTEID_ISABSTRACT:
@@ -66,35 +66,35 @@ static void readValue(UA_Server *server, const UA_ReadValueId *id, UA_DataValue
                         UA_NODECLASS_DATATYPE);
         v->hasVariant = UA_TRUE;
         retval |= UA_Variant_copySetValue(&v->value, &((const UA_ReferenceTypeNode *)node)->isAbstract,
-                                          UA_TYPES_BOOLEAN);
+                                          &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,
-                                          UA_TYPES_BOOLEAN);
+                                          &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,
-                                          UA_TYPES_LOCALIZEDTEXT);
+                                          &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,
-                                          UA_TYPES_BOOLEAN);
+                                          &UA_TYPES[UA_TYPES_BOOLEAN]);
         break;
 
     case UA_ATTRIBUTEID_EVENTNOTIFIER:
         CHECK_NODECLASS(UA_NODECLASS_VIEW | UA_NODECLASS_OBJECT);
         v->hasVariant = UA_TRUE;
         retval |= UA_Variant_copySetValue(&v->value, &((const UA_ViewNode *)node)->eventNotifier,
-                                          UA_TYPES_BYTE);
+                                          &UA_TYPES[UA_TYPES_BYTE]);
         break;
 
     case UA_ATTRIBUTEID_VALUE:
@@ -130,19 +130,20 @@ static void readValue(UA_Server *server, const UA_ReadValueId *id, UA_DataValue
         if(node->nodeClass == UA_NODECLASS_VARIABLETYPE)
             retval |= UA_Variant_copySetValue(&v->value,
                                               &((const UA_VariableTypeNode *)node)->value.type->typeId,
-                                              UA_TYPES_NODEID);
+                                              &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,
-                                                  UA_TYPES_NODEID);
+                                                  &UA_TYPES[UA_TYPES_NODEID]);
             else {
                 UA_DataValue val;
                 UA_DataValue_init(&val);
                 retval |= vn->variable.dataSource.read(vn->variable.dataSource.handle, &val);
                 if(retval != UA_STATUSCODE_GOOD)
                     break;
-                retval |= UA_Variant_copySetValue(&v->value, &val.value.type->typeId, UA_TYPES_NODEID);
+                retval |= UA_Variant_copySetValue(&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)
                     break;
@@ -154,7 +155,7 @@ static void readValue(UA_Server *server, const UA_ReadValueId *id, UA_DataValue
         CHECK_NODECLASS(UA_NODECLASS_VARIABLE | UA_NODECLASS_VARIABLETYPE);
         v->hasVariant = UA_TRUE;
         retval |= UA_Variant_copySetValue(&v->value, &((const UA_VariableTypeNode *)node)->valueRank,
-                                          UA_TYPES_INT32);
+                                          &UA_TYPES[UA_TYPES_INT32]);
         break;
 
     case UA_ATTRIBUTEID_ARRAYDIMENSIONS:
@@ -163,7 +164,8 @@ static void readValue(UA_Server *server, const UA_ReadValueId *id, UA_DataValue
             const UA_VariableNode *vn = (const UA_VariableNode *)node;
             if(vn->variableType == UA_VARIABLENODETYPE_VARIANT) {
                 retval = UA_Variant_copySetArray(&v->value, vn->variable.variant.arrayDimensions,
-                                                 vn->variable.variant.arrayDimensionsSize, UA_TYPES_INT32);
+                                                 vn->variable.variant.arrayDimensionsSize,
+                                                 &UA_TYPES[UA_TYPES_INT32]);
                 if(retval == UA_STATUSCODE_GOOD)
                     v->hasVariant = UA_TRUE;
             } else {
@@ -178,7 +180,7 @@ static void readValue(UA_Server *server, const UA_ReadValueId *id, UA_DataValue
                     break;
                 }
                 retval = UA_Variant_copySetArray(&v->value, val.value.arrayDimensions,
-                                                 val.value.arrayDimensionsSize, UA_TYPES_INT32);
+                                                 val.value.arrayDimensionsSize, &UA_TYPES[UA_TYPES_INT32]);
                 vn->variable.dataSource.release(vn->variable.dataSource.handle, &val);
             }
         }
@@ -188,42 +190,42 @@ static void readValue(UA_Server *server, const UA_ReadValueId *id, UA_DataValue
         CHECK_NODECLASS(UA_NODECLASS_VARIABLE);
         v->hasVariant = UA_TRUE;
         retval |= UA_Variant_copySetValue(&v->value, &((const UA_VariableNode *)node)->accessLevel,
-                                          UA_TYPES_BYTE);
+                                          &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,
-                                          UA_TYPES_BYTE);
+                                          &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,
-                                          UA_TYPES_DOUBLE);
+                                          &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,
-                                          UA_TYPES_BOOLEAN);
+                                          &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,
-                                          UA_TYPES_BOOLEAN);
+                                          &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,
-                                          UA_TYPES_BOOLEAN);
+                                          &UA_TYPES[UA_TYPES_BOOLEAN]);
         break;
 
     default:

src/ua_types.c

@@ -619,43 +619,35 @@ UA_StatusCode UA_Variant_copy(UA_Variant const *src, UA_Variant *dst) {
     return retval;
 }
 
-UA_StatusCode UA_Variant_setValue(UA_Variant *v, void *p, UA_UInt16 typeIndex) {
-    return UA_Variant_setArray(v, p, 1, typeIndex);
+UA_StatusCode UA_Variant_setValue(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, UA_UInt16 typeIndex) {
-    if(typeIndex >= UA_TYPES_COUNT)
-        return UA_STATUSCODE_BADINTERNALERROR;
-    const UA_DataType *type = &UA_TYPES[typeIndex];
+UA_StatusCode UA_Variant_copySetValue(UA_Variant *v, const void *p, const UA_DataType *type) {
     void *new = UA_malloc(type->memSize);
     if(!new)
         return UA_STATUSCODE_BADOUTOFMEMORY;
-    UA_StatusCode retval = UA_copy(p, new, &UA_TYPES[typeIndex]);
+    UA_StatusCode retval = UA_copy(p, new, type);
     if(retval != UA_STATUSCODE_GOOD)
         return retval;
-    return UA_Variant_setArray(v, new, 1, typeIndex);
+    return UA_Variant_setArray(v, new, 1, type);
 }
 
 UA_StatusCode UA_Variant_setArray(UA_Variant *v, void *array, UA_Int32 noElements,
-                                  UA_UInt16 typeIndex) {
-    if(typeIndex >= UA_TYPES_COUNT)
-        return UA_STATUSCODE_BADINTERNALERROR;
-
-    v->type = &UA_TYPES[typeIndex];
+                                  const UA_DataType *type) {
+    v->type = type;
     v->arrayLength = noElements;
     v->dataPtr = array;
     return UA_STATUSCODE_GOOD;
 }
 
 UA_StatusCode UA_Variant_copySetArray(UA_Variant *v, const void *array, UA_Int32 noElements,
-                                      UA_UInt16 typeIndex) {
-    if(typeIndex >= UA_TYPES_COUNT)
-        return UA_STATUSCODE_BADINTERNALERROR;
+                                      const UA_DataType *type) {
     void *new;
-    UA_StatusCode retval = UA_Array_copy(array, &new, &UA_TYPES[typeIndex], noElements);
+    UA_StatusCode retval = UA_Array_copy(array, &new, type, noElements);
     if(retval != UA_STATUSCODE_GOOD)
         return retval;
-    return UA_Variant_setArray(v, new, noElements, typeIndex);
+    return UA_Variant_setArray(v, new, noElements, type);
 }
 
 /* DiagnosticInfo */