From 6524936a20499cea977ea47900739f78568c000a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alja=C5=BE=20Zako=C5=A1ek?= Date: Wed, 28 Jan 2026 09:02:25 +0100 Subject: [PATCH 01/10] Added header openDAQ C conversions --- examples/util_headers/daq_c_conversions.h | 300 ++++++++++++++++++++++ 1 file changed, 300 insertions(+) create mode 100644 examples/util_headers/daq_c_conversions.h diff --git a/examples/util_headers/daq_c_conversions.h b/examples/util_headers/daq_c_conversions.h new file mode 100644 index 0000000..429b4ea --- /dev/null +++ b/examples/util_headers/daq_c_conversions.h @@ -0,0 +1,300 @@ +#include + +// Int conversion +/* + * The following two funtions represent the conversion between the openDAQ native + * daqInt type and its coresponding C integer type. + */ +int64_t openDAQIntConversion(daqInteger* integer) +{ + daqInt value = 0; + daqInteger_getValue(integer, &value); + return value; +} + +daqInteger* intOpenDAQConversion(int64_t integer) +{ + daqInteger* object = NULL; + daqInteger_createInteger(&object, integer); + return object; +} + +// String conversion +/* + * Conversion from and to openDAQ String (daqString) core type + * from C language (const char*). + */ +daqString* stringOpenDAQConversion(const char* str) +{ + daqString* strOut = NULL; + daqString_createString(&strOut, str); + return strOut; +} + +char* openDAQStringConversion(daqString* str) +{ + char* out = NULL; + daqString_getCharPtr(str, &out); + return out; +} + +// Bool conversion +/* + * Conversion from and to openDAQ Boolean (daqString) core type from C language (uint8_t). + */ +daqBoolean* booleanOpenDAQConversion(uint8_t value) +{ + daqBoolean* object = NULL; + daqBoolean_createBoolean(&object, value); + return object; +} + +uint8_t openDAQBooleanConversion(daqBoolean* boolean) +{ + uint8_t value = 0; + daqBoolean_getValue(boolean, &value); + return value; +} + +// Float conversion +/* + *Conversion from and to openDAQ String (daqFloat) core type from C language (double). + */ +daqFloatObject* floatOpenDAQConversion(double value) +{ + daqFloatObject* fl = 0; + daqFloatObject_createFloatObject(&fl, value); + return fl; +} + +double openDAQFloatConversion(daqFloatObject* value) +{ + double vl = 0; + daqFloatObject_getValue(value, &vl); + return vl; +} + +// Complex number conversion +/* + * Conversion from and to openDAQ Complex (daqComplex) core type + * from C language (struct ComplexNumber). + */ +struct ComplexNumber +{ + double real; + double complex; +}; + +struct ComplexNumber complexOpenDAQConversion(daqComplexNumber* complexNumber) +{ + struct ComplexNumber cmp; + double middle = 0; + daqComplexNumber_getReal(complexNumber, &middle); + cmp.real = middle; + daqComplexNumber_getImaginary(complexNumber, &middle); + cmp.complex = middle; + return cmp; +} + +daqComplexNumber* openDAQComplexConversion(struct ComplexNumber* complexNumber) +{ + daqComplexNumber* cmp = NULL; + daqComplexNumber_createComplexNumber(&cmp, complexNumber->real, complexNumber->complex); + return cmp; +} + +// Range conversion +/* + * Conversion from and to openDAQ String (daqRange) core type + * from C language (struct Range). + */ +struct Range +{ + double min; + double max; +}; + +struct Range rangeOpenDAQConversion(daqRange* range) +{ + struct Range rng; + daqNumber* number; + daqRange_getLowValue(range, &number); + double intermmidiate = 0; + daqNumber_getFloatValue(number, &intermmidiate); + rng.min = intermmidiate; + daqReleaseRef(number); + daqRange_getHighValue(range, &number); + daqNumber_getFloatValue(number, &intermmidiate); + rng.max = intermmidiate; + daqReleaseRef(number); + return rng; +} + +daqRange* openDAQRangeConversion(struct Range range) +{ + daqRange* rng = NULL; + daqNumber* lowValue = NULL; + daqNumber* highValue = NULL; + + daqFloatObject* lowFloat = NULL; + daqFloatObject_createFloatObject(&lowFloat, range.min); + daqFloatObject* highFloat = NULL; + daqFloatObject_createFloatObject(&highFloat, range.max); + + daqBaseObject* lowBaseObject = NULL; + daqQueryInterface(lowFloat, DAQ_BASE_OBJECT_INTF_ID, &lowBaseObject); + daqBaseObject* highBaseObject = NULL; + daqQueryInterface(highFloat, DAQ_BASE_OBJECT_INTF_ID, &highBaseObject); + + if (DAQ_SUPPORTS_INTERFACE(lowBaseObject, DAQ_NUMBER_INTF_ID)) + { + daqQueryInterface(lowBaseObject, DAQ_NUMBER_INTF_ID, &lowValue); + daqQueryInterface(highBaseObject, DAQ_NUMBER_INTF_ID, &highValue); + } + + daqReleaseRef(lowFloat); + daqReleaseRef(highFloat); + daqReleaseRef(lowBaseObject); + daqReleaseRef(highBaseObject); + + // Create and populate the daqRange object + daqRange_createRange(&rng, lowValue, highValue); + + daqReleaseRef(lowValue); + daqReleaseRef(highValue); + return rng; +} + +// Struct conversion +/* + * Conversion from and to daqStruct objects to C style structs. + * Warning: These types of conversions require prior knowledge of + * the struct structure and its definition in C. For conversion + * from C to openDAQ a pointer to the TypeManager is needed because + * of the way openDAQ structs are implemented. + */ +struct Coordinates +{ + int64_t x; + int64_t y; + int64_t z; +}; + +struct Coordinates structOpenDAQConvetsion(daqStruct* coordinates) +{ + daqList* values = NULL; + daqStruct_getFieldValues(coordinates, &values); + + struct Coordinates coordinate = {0,0,0}; + + daqInteger* value = NULL; + + daqSizeT count = 0; + daqList_getCount(values, &count); + + daqBaseObject* valueObj = NULL; + for (daqSizeT i = 0; i Date: Wed, 28 Jan 2026 09:40:06 +0100 Subject: [PATCH 02/10] Minor facelift --- examples/util_headers/daq_c_conversions.h | 60 +++++++++++------------ 1 file changed, 30 insertions(+), 30 deletions(-) diff --git a/examples/util_headers/daq_c_conversions.h b/examples/util_headers/daq_c_conversions.h index 429b4ea..8f16b12 100644 --- a/examples/util_headers/daq_c_conversions.h +++ b/examples/util_headers/daq_c_conversions.h @@ -26,16 +26,16 @@ daqInteger* intOpenDAQConversion(int64_t integer) */ daqString* stringOpenDAQConversion(const char* str) { - daqString* strOut = NULL; - daqString_createString(&strOut, str); - return strOut; + daqString* stringOutput = NULL; + daqString_createString(&stringOutput, str); + return stringOutput; } char* openDAQStringConversion(daqString* str) { - char* out = NULL; - daqString_getCharPtr(str, &out); - return out; + char* cString = NULL; + daqString_getCharPtr(str, &cString); + return cString; } // Bool conversion @@ -62,16 +62,16 @@ uint8_t openDAQBooleanConversion(daqBoolean* boolean) */ daqFloatObject* floatOpenDAQConversion(double value) { - daqFloatObject* fl = 0; - daqFloatObject_createFloatObject(&fl, value); - return fl; + daqFloatObject* floatObject = 0; + daqFloatObject_createFloatObject(&floatObject, value); + return floatObject; } double openDAQFloatConversion(daqFloatObject* value) { - double vl = 0; - daqFloatObject_getValue(value, &vl); - return vl; + double cDouble = 0; + daqFloatObject_getValue(value, &cDouble); + return cDouble; } // Complex number conversion @@ -82,25 +82,25 @@ double openDAQFloatConversion(daqFloatObject* value) struct ComplexNumber { double real; - double complex; + double imaginary; }; struct ComplexNumber complexOpenDAQConversion(daqComplexNumber* complexNumber) { - struct ComplexNumber cmp; - double middle = 0; - daqComplexNumber_getReal(complexNumber, &middle); - cmp.real = middle; - daqComplexNumber_getImaginary(complexNumber, &middle); - cmp.complex = middle; - return cmp; + struct ComplexNumber structComplexNumber; + double tempDouble= 0; + daqComplexNumber_getReal(complexNumber, &tempDouble); + structComplexNumber.real = tempDouble; + daqComplexNumber_getImaginary(complexNumber, &tempDouble); + structComplexNumber.imaginary = tempDouble; + return structComplexNumber; } daqComplexNumber* openDAQComplexConversion(struct ComplexNumber* complexNumber) { - daqComplexNumber* cmp = NULL; - daqComplexNumber_createComplexNumber(&cmp, complexNumber->real, complexNumber->complex); - return cmp; + daqComplexNumber* complexNumberObject = NULL; + daqComplexNumber_createComplexNumber(&complexNumberObject, complexNumber->real, complexNumber->imaginary); + return complexNumberObject; } // Range conversion @@ -116,23 +116,23 @@ struct Range struct Range rangeOpenDAQConversion(daqRange* range) { - struct Range rng; + struct Range rangeStruct; daqNumber* number; daqRange_getLowValue(range, &number); double intermmidiate = 0; daqNumber_getFloatValue(number, &intermmidiate); - rng.min = intermmidiate; + rangeStruct.min = intermmidiate; daqReleaseRef(number); daqRange_getHighValue(range, &number); daqNumber_getFloatValue(number, &intermmidiate); - rng.max = intermmidiate; + rangeStruct.max = intermmidiate; daqReleaseRef(number); - return rng; + return rangeStruct; } daqRange* openDAQRangeConversion(struct Range range) { - daqRange* rng = NULL; + daqRange* rangeObject = NULL; daqNumber* lowValue = NULL; daqNumber* highValue = NULL; @@ -158,11 +158,11 @@ daqRange* openDAQRangeConversion(struct Range range) daqReleaseRef(highBaseObject); // Create and populate the daqRange object - daqRange_createRange(&rng, lowValue, highValue); + daqRange_createRange(&rangeObject, lowValue, highValue); daqReleaseRef(lowValue); daqReleaseRef(highValue); - return rng; + return rangeObject; } // Struct conversion From 37f12bc815422a113248f7aac67f70f8fef6838f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alja=C5=BE=20Zako=C5=A1ek?= Date: Thu, 29 Jan 2026 11:16:42 +0100 Subject: [PATCH 03/10] Addressed code review --- examples/util_headers/daq_c_conversions.h | 272 +++++++++++++--------- 1 file changed, 158 insertions(+), 114 deletions(-) diff --git a/examples/util_headers/daq_c_conversions.h b/examples/util_headers/daq_c_conversions.h index 8f16b12..27022c5 100644 --- a/examples/util_headers/daq_c_conversions.h +++ b/examples/util_headers/daq_c_conversions.h @@ -1,22 +1,77 @@ #include +daqString* stringOpenDAQConversion(const char* native); +daqInteger* intOpenDAQConversion(daqInt native); + +// add types to typeManager +void addCoordinateStructToTypeManager(daqContext* context) +{ + daqTypeManager* typeManager = NULL; + daqContext_getTypeManager(context, &typeManager); + + daqList* names = NULL; + daqList_createList(&names); + + daqList_pushBack(names, (daqBaseObject*) stringOpenDAQConversion("x")); + daqList_pushBack(names, (daqBaseObject*) stringOpenDAQConversion("y")); + daqList_pushBack(names, (daqBaseObject*) stringOpenDAQConversion("z")); + + daqList* defaultValues = NULL; + daqList_createList(&defaultValues); + daqList_pushBack(defaultValues, (daqBaseObject*) intOpenDAQConversion(0)); + daqList_pushBack(defaultValues, (daqBaseObject*) intOpenDAQConversion(0)); + daqList_pushBack(defaultValues, (daqBaseObject*) intOpenDAQConversion(0)); + + daqSimpleType* simpleType = NULL; + + daqSimpleType_createSimpleType(&simpleType, daqCtInt); + + daqList* types = NULL; + daqList_createList(&types); + daqList_pushBack(types, simpleType); + daqList_pushBack(types, simpleType); + daqList_pushBack(types, simpleType); + daqReleaseRef(simpleType); + + daqStructType* newType = NULL; + daqStructType_createStructType(&newType, stringOpenDAQConversion("DAQ_Coordinates"), names, defaultValues, types); + + daqTypeManager_addType(typeManager, (daqType*) newType); + daqReleaseRef(newType); + + + daqBool check = False; + daqTypeManager_hasType(typeManager, stringOpenDAQConversion("DAQ_Coordinates"), &check); + + if(check) + printf("\nNew type added.\n"); + else + printf("\nFailed to add a new type.\n"); + + daqReleaseRef(types); + daqReleaseRef(defaultValues); + daqReleaseRef(names); + daqReleaseRef(typeManager); +} + + // Int conversion /* * The following two funtions represent the conversion between the openDAQ native * daqInt type and its coresponding C integer type. */ -int64_t openDAQIntConversion(daqInteger* integer) +daqInt openDAQIntConversion(daqInteger* daq) { - daqInt value = 0; - daqInteger_getValue(integer, &value); - return value; + daqInt native = 0; + daqInteger_getValue(daq, &native); + return native; } -daqInteger* intOpenDAQConversion(int64_t integer) +daqInteger* intOpenDAQConversion(daqInt native) { - daqInteger* object = NULL; - daqInteger_createInteger(&object, integer); - return object; + daqInteger* daq = NULL; + daqInteger_createInteger(&daq, native); + return daq; } // String conversion @@ -24,54 +79,54 @@ daqInteger* intOpenDAQConversion(int64_t integer) * Conversion from and to openDAQ String (daqString) core type * from C language (const char*). */ -daqString* stringOpenDAQConversion(const char* str) +daqString* stringOpenDAQConversion(const char* native) { - daqString* stringOutput = NULL; - daqString_createString(&stringOutput, str); - return stringOutput; + daqString* daq = NULL; + daqString_createString(&daq, native); + return daq; } -char* openDAQStringConversion(daqString* str) +char* openDAQStringConversion(daqString* daq) { - char* cString = NULL; - daqString_getCharPtr(str, &cString); - return cString; + char* native = NULL; + daqString_getCharPtr(daq, &native); + return native; } // Bool conversion /* * Conversion from and to openDAQ Boolean (daqString) core type from C language (uint8_t). */ -daqBoolean* booleanOpenDAQConversion(uint8_t value) +daqBoolean* booleanOpenDAQConversion(uint8_t native) { - daqBoolean* object = NULL; - daqBoolean_createBoolean(&object, value); - return object; + daqBoolean* daq = NULL; + daqBoolean_createBoolean(&daq, native); + return daq; } -uint8_t openDAQBooleanConversion(daqBoolean* boolean) +uint8_t openDAQBooleanConversion(daqBoolean* daq) { - uint8_t value = 0; - daqBoolean_getValue(boolean, &value); - return value; + uint8_t native = 0; + daqBoolean_getValue(daq, &native); + return native; } // Float conversion /* *Conversion from and to openDAQ String (daqFloat) core type from C language (double). */ -daqFloatObject* floatOpenDAQConversion(double value) +daqFloatObject* floatOpenDAQConversion(double native) { - daqFloatObject* floatObject = 0; - daqFloatObject_createFloatObject(&floatObject, value); - return floatObject; + daqFloatObject* daq = 0; + daqFloatObject_createFloatObject(&daq, native); + return daq; } -double openDAQFloatConversion(daqFloatObject* value) +double openDAQFloatConversion(daqFloatObject* daq) { - double cDouble = 0; - daqFloatObject_getValue(value, &cDouble); - return cDouble; + double native = 0; + daqFloatObject_getValue(daq, &native); + return native; } // Complex number conversion @@ -85,22 +140,22 @@ struct ComplexNumber double imaginary; }; -struct ComplexNumber complexOpenDAQConversion(daqComplexNumber* complexNumber) +struct ComplexNumber openDAQComplexConversion(daqComplexNumber* daq) { - struct ComplexNumber structComplexNumber; + struct ComplexNumber native; double tempDouble= 0; - daqComplexNumber_getReal(complexNumber, &tempDouble); - structComplexNumber.real = tempDouble; - daqComplexNumber_getImaginary(complexNumber, &tempDouble); - structComplexNumber.imaginary = tempDouble; - return structComplexNumber; + daqComplexNumber_getReal(daq, &tempDouble); + native.real = tempDouble; + daqComplexNumber_getImaginary(daq, &tempDouble); + native.imaginary = tempDouble; + return native; } -daqComplexNumber* openDAQComplexConversion(struct ComplexNumber* complexNumber) +daqComplexNumber* complexOpenDAQConversion(struct ComplexNumber* native) { - daqComplexNumber* complexNumberObject = NULL; - daqComplexNumber_createComplexNumber(&complexNumberObject, complexNumber->real, complexNumber->imaginary); - return complexNumberObject; + daqComplexNumber* daq = NULL; + daqComplexNumber_createComplexNumber(&daq, native->real, native->imaginary); + return daq; } // Range conversion @@ -114,55 +169,44 @@ struct Range double max; }; -struct Range rangeOpenDAQConversion(daqRange* range) +struct Range openDAQRangeConversion(daqRange* daq) { - struct Range rangeStruct; - daqNumber* number; - daqRange_getLowValue(range, &number); + struct Range native; + daqNumber* temp; + daqRange_getLowValue(daq, &temp); double intermmidiate = 0; - daqNumber_getFloatValue(number, &intermmidiate); - rangeStruct.min = intermmidiate; - daqReleaseRef(number); - daqRange_getHighValue(range, &number); - daqNumber_getFloatValue(number, &intermmidiate); - rangeStruct.max = intermmidiate; - daqReleaseRef(number); - return rangeStruct; + daqNumber_getFloatValue(temp, &intermmidiate); + native.min = intermmidiate; + daqReleaseRef(temp); + + daqRange_getHighValue(daq, &temp); + daqNumber_getFloatValue(temp, &intermmidiate); + native.max = intermmidiate; + daqReleaseRef(temp); + return native; } -daqRange* openDAQRangeConversion(struct Range range) +daqRange* RangeOpenDAQConversion(struct Range native) { - daqRange* rangeObject = NULL; + daqRange* daq = NULL; daqNumber* lowValue = NULL; daqNumber* highValue = NULL; - daqFloatObject* lowFloat = NULL; - daqFloatObject_createFloatObject(&lowFloat, range.min); - daqFloatObject* highFloat = NULL; - daqFloatObject_createFloatObject(&highFloat, range.max); - - daqBaseObject* lowBaseObject = NULL; - daqQueryInterface(lowFloat, DAQ_BASE_OBJECT_INTF_ID, &lowBaseObject); - daqBaseObject* highBaseObject = NULL; - daqQueryInterface(highFloat, DAQ_BASE_OBJECT_INTF_ID, &highBaseObject); + daqFloatObject* lowFloat = floatOpenDAQConversion(native.min); + daqFloatObject* highFloat = floatOpenDAQConversion(native.max); - if (DAQ_SUPPORTS_INTERFACE(lowBaseObject, DAQ_NUMBER_INTF_ID)) - { - daqQueryInterface(lowBaseObject, DAQ_NUMBER_INTF_ID, &lowValue); - daqQueryInterface(highBaseObject, DAQ_NUMBER_INTF_ID, &highValue); - } + daqQueryInterface(lowFloat, DAQ_NUMBER_INTF_ID, &lowValue); + daqQueryInterface(highFloat, DAQ_NUMBER_INTF_ID, &highValue); daqReleaseRef(lowFloat); daqReleaseRef(highFloat); - daqReleaseRef(lowBaseObject); - daqReleaseRef(highBaseObject); // Create and populate the daqRange object - daqRange_createRange(&rangeObject, lowValue, highValue); + daqRange_createRange(&daq, lowValue, highValue); daqReleaseRef(lowValue); daqReleaseRef(highValue); - return rangeObject; + return daq; } // Struct conversion @@ -180,65 +224,65 @@ struct Coordinates int64_t z; }; -struct Coordinates structOpenDAQConvetsion(daqStruct* coordinates) +struct Coordinates openDAQStructConversion(daqStruct* daq) { daqList* values = NULL; - daqStruct_getFieldValues(coordinates, &values); + daqStruct_getFieldValues(daq, &values); - struct Coordinates coordinate = {0,0,0}; + struct Coordinates native = {0,0,0}; - daqInteger* value = NULL; + daqInteger* temp = NULL; daqSizeT count = 0; daqList_getCount(values, &count); - daqBaseObject* valueObj = NULL; + daqBaseObject* tempObj = NULL; for (daqSizeT i = 0; i Date: Thu, 29 Jan 2026 11:40:15 +0100 Subject: [PATCH 04/10] Fixed handling of structs --- examples/util_headers/daq_c_conversions.h | 73 ++++++++--------------- 1 file changed, 24 insertions(+), 49 deletions(-) diff --git a/examples/util_headers/daq_c_conversions.h b/examples/util_headers/daq_c_conversions.h index 27022c5..7309dfc 100644 --- a/examples/util_headers/daq_c_conversions.h +++ b/examples/util_headers/daq_c_conversions.h @@ -224,69 +224,36 @@ struct Coordinates int64_t z; }; -struct Coordinates openDAQStructConversion(daqStruct* daq) +struct Coordinates openDAQCoordinatesStructConversion(daqStruct* daq) { - daqList* values = NULL; - daqStruct_getFieldValues(daq, &values); - struct Coordinates native = {0,0,0}; - daqInteger* temp = NULL; + daqBaseObject* tempObj = NULL; - daqSizeT count = 0; - daqList_getCount(values, &count); + daqStruct_get(daq, stringOpenDAQConversion("x"), tempObj); + native.x = openDAQIntConversion((daqInteger*) daqQueryInterfacePtr(tempObj, DAQ_INTEGER_INTF_ID)); + daqReleaseRef(tempObj); + + daqStruct_get(daq, stringOpenDAQConversion("y"), tempObj); + native.y = openDAQIntConversion((daqInteger*) daqQueryInterfacePtr(tempObj, DAQ_INTEGER_INTF_ID)); + daqReleaseRef(tempObj); + + daqStruct_get(daq, stringOpenDAQConversion("z"), tempObj); + native.z = openDAQIntConversion((daqInteger*) daqQueryInterfacePtr(tempObj, DAQ_INTEGER_INTF_ID)); + daqReleaseRef(tempObj); - daqBaseObject* tempObj = NULL; - for (daqSizeT i = 0; i Date: Thu, 29 Jan 2026 12:00:55 +0100 Subject: [PATCH 05/10] Updated enumeration handling --- examples/util_headers/daq_c_conversions.h | 39 ++++++++++++++++------- 1 file changed, 28 insertions(+), 11 deletions(-) diff --git a/examples/util_headers/daq_c_conversions.h b/examples/util_headers/daq_c_conversions.h index 7309dfc..ae07baa 100644 --- a/examples/util_headers/daq_c_conversions.h +++ b/examples/util_headers/daq_c_conversions.h @@ -38,12 +38,27 @@ void addCoordinateStructToTypeManager(daqContext* context) daqTypeManager_addType(typeManager, (daqType*) newType); daqReleaseRef(newType); + daqReleaseRef(names); + + daqList_createList(&names); + + daqList_pushBack(names, (daqBaseObject*) stringOpenDAQConversion("Error")); + daqList_pushBack(names, (daqBaseObject*) stringOpenDAQConversion("Ok")); + daqList_pushBack(names, (daqBaseObject*) stringOpenDAQConversion("Warning")); + + daqEnumerationType* enumType = NULL; + daqEnumerationType_createEnumerationType(&enumType, stringOpenDAQConversion("DAQ_ComponentStatusTypeEnum"), names, 0); + daqTypeManager_addType(typeManager, (daqType*) enumType); + daqReleaseRef(enumType); daqBool check = False; daqTypeManager_hasType(typeManager, stringOpenDAQConversion("DAQ_Coordinates"), &check); - if(check) + daqBool enumCheck = False; + daqTypeManager_hasType(typeManager, stringOpenDAQConversion("DAQ_ComponentStatusTypeEnum"), &enumCheck); + + if(check && enumCheck) printf("\nNew type added.\n"); else printf("\nFailed to add a new type.\n"); @@ -295,25 +310,27 @@ enum ComponentStatusTypeEnum Warning }; -enum ComponentStatusTypeEnum openDAQEnumConversion(daqEnumeration* componentStatusType) +enum ComponentStatusTypeEnum openDAQEnumConversion(daqEnumeration* daq) { - enum ComponentStatusTypeEnum compStatusType = Error; - daqInt check; - daqEnumeration_getIntValue(componentStatusType, &check); - if (check < 2) + enum ComponentStatusTypeEnum native = Error; + daqInt temp; + daqEnumeration_getIntValue(daq, &temp); + + if (temp < 2) { - compStatusType = check; + native = temp; } - return compStatusType; + + return native; } daqEnumeration* EnumOpenDAQConversion(enum ComponentStatusTypeEnum native, daqTypeManager* typeManager) { daqEnumeration* daq = NULL; - daqInteger* inp = intOpenDAQConversion(native); + daqInteger* temp = intOpenDAQConversion(native); - daqEnumeration_createEnumerationWithIntValue(&daq, stringOpenDAQConversion("ComponentStatusType"), inp, typeManager); + daqEnumeration_createEnumerationWithIntValue(&daq, stringOpenDAQConversion("ComponentStatusType"), temp, typeManager); - daqReleaseRef(inp); + daqReleaseRef(temp); return daq; } From f37fef970669c20249ecd42c30221267bc3a0077 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alja=C5=BE=20Zako=C5=A1ek?= Date: Thu, 29 Jan 2026 12:58:45 +0100 Subject: [PATCH 06/10] Added top of header description for helpers --- examples/util_headers/daq_c_conversions.h | 128 +++++++++++++--------- 1 file changed, 75 insertions(+), 53 deletions(-) diff --git a/examples/util_headers/daq_c_conversions.h b/examples/util_headers/daq_c_conversions.h index ae07baa..73a72bd 100644 --- a/examples/util_headers/daq_c_conversions.h +++ b/examples/util_headers/daq_c_conversions.h @@ -1,9 +1,66 @@ #include -daqString* stringOpenDAQConversion(const char* native); +struct ComplexNumber +{ + double real; + double imaginary; +}; + +struct Range +{ + double min; + double max; +}; + +struct Coordinates +{ + int64_t x; + int64_t y; + int64_t z; +}; + +enum ComponentStatusTypeEnum +{ + Error = 0, + Ok, + Warning +}; + +// Adds Coodinates struct and ComponentStatusTypeEnum to types in Type Manager +void addCoordinateStructToTypeManager(daqContext* context); + +// Int conversion +daqInt openDAQIntConversion(daqInteger* daq); daqInteger* intOpenDAQConversion(daqInt native); -// add types to typeManager +// String conversion +char* openDAQStringConversion(daqString* daq); +daqString* stringOpenDAQConversion(const char* native); + +// Bool conversion +daqBoolean* booleanOpenDAQConversion(uint8_t native); +uint8_t openDAQBooleanConversion(daqBoolean* daq); + +// Float conversion +daqFloatObject* floatOpenDAQConversion(double native); +double openDAQFloatConversion(daqFloatObject* daq); + +// Complex number conversion +struct ComplexNumber openDAQComplexConversion(daqComplexNumber* daq); +daqComplexNumber* complexOpenDAQConversion(struct ComplexNumber* native); + +// Range conversion +struct Range openDAQRangeConversion(daqRange* daq); +daqRange* RangeOpenDAQConversion(struct Range native); + +// Struct conversion +struct Coordinates openDAQCoordinatesStructConversion(daqStruct* daq); +daqStruct* coordinatesStructOpenDAQConversion(struct Coordinates native, daqTypeManager* typeManager); + +// Enumeration conversion +enum ComponentStatusTypeEnum openDAQEnumConversion(daqEnumeration* daq); +daqEnumeration* EnumOpenDAQConversion(enum ComponentStatusTypeEnum native, daqTypeManager* typeManager); + void addCoordinateStructToTypeManager(daqContext* context) { daqTypeManager* typeManager = NULL; @@ -69,8 +126,6 @@ void addCoordinateStructToTypeManager(daqContext* context) daqReleaseRef(typeManager); } - -// Int conversion /* * The following two funtions represent the conversion between the openDAQ native * daqInt type and its coresponding C integer type. @@ -89,7 +144,6 @@ daqInteger* intOpenDAQConversion(daqInt native) return daq; } -// String conversion /* * Conversion from and to openDAQ String (daqString) core type * from C language (const char*). @@ -108,7 +162,6 @@ char* openDAQStringConversion(daqString* daq) return native; } -// Bool conversion /* * Conversion from and to openDAQ Boolean (daqString) core type from C language (uint8_t). */ @@ -126,7 +179,6 @@ uint8_t openDAQBooleanConversion(daqBoolean* daq) return native; } -// Float conversion /* *Conversion from and to openDAQ String (daqFloat) core type from C language (double). */ @@ -144,20 +196,13 @@ double openDAQFloatConversion(daqFloatObject* daq) return native; } -// Complex number conversion /* * Conversion from and to openDAQ Complex (daqComplex) core type * from C language (struct ComplexNumber). */ -struct ComplexNumber -{ - double real; - double imaginary; -}; - struct ComplexNumber openDAQComplexConversion(daqComplexNumber* daq) { - struct ComplexNumber native; + struct ComplexNumber native = {0, 0}; double tempDouble= 0; daqComplexNumber_getReal(daq, &tempDouble); native.real = tempDouble; @@ -173,20 +218,13 @@ daqComplexNumber* complexOpenDAQConversion(struct ComplexNumber* native) return daq; } -// Range conversion /* * Conversion from and to openDAQ String (daqRange) core type * from C language (struct Range). */ -struct Range -{ - double min; - double max; -}; - struct Range openDAQRangeConversion(daqRange* daq) { - struct Range native; + struct Range native = {0, 0}; daqNumber* temp; daqRange_getLowValue(daq, &temp); double intermmidiate = 0; @@ -224,7 +262,6 @@ daqRange* RangeOpenDAQConversion(struct Range native) return daq; } -// Struct conversion /* * Conversion from and to daqStruct objects to C style structs. * Warning: These types of conversions require prior knowledge of @@ -232,13 +269,6 @@ daqRange* RangeOpenDAQConversion(struct Range native) * from C to openDAQ a pointer to the TypeManager is needed because * of the way openDAQ structs are implemented. */ -struct Coordinates -{ - int64_t x; - int64_t y; - int64_t z; -}; - struct Coordinates openDAQCoordinatesStructConversion(daqStruct* daq) { struct Coordinates native = {0,0,0}; @@ -267,17 +297,18 @@ daqStruct* coordinatesStructOpenDAQConversion(struct Coordinates native, daqType if (0) { - // Alternative way of setting the values in a struct - - daqList* valuesList = NULL; - daqList_createList(&valuesList); - - daqList_pushBack(valuesList, (daqBaseObject*) intOpenDAQConversion(native.x)); - daqList_pushBack(valuesList, (daqBaseObject*) intOpenDAQConversion(native.y)); - daqList_pushBack(valuesList, (daqBaseObject*) intOpenDAQConversion(native.z)); - - daqStructBuilder_setFieldValues(builder, valuesList); - daqReleaseRef(valuesList); + // We can set values in the struct either via directly assigning them to the + // corresponding struct values or adding them in the correct sequence + // to a daqList and setting the list. + daqList* values = NULL; + daqList_createList(&values); + + daqList_pushBack(values, (daqBaseObject*) intOpenDAQConversion(native.x)); + daqList_pushBack(values, (daqBaseObject*) intOpenDAQConversion(native.y)); + daqList_pushBack(values, (daqBaseObject*) intOpenDAQConversion(native.z)); + + daqStructBuilder_setFieldValues(builder, values); + daqReleaseRef(values); } else { @@ -294,7 +325,6 @@ daqStruct* coordinatesStructOpenDAQConversion(struct Coordinates native, daqType return daq; } -// Enumeration conversion (needs an additional run through) /* * Conversion from and to openDAQ String (daqEnumeration) core type * from C language (enum ComponentStutesTypeEnum). @@ -303,23 +333,15 @@ daqStruct* coordinatesStructOpenDAQConversion(struct Coordinates native, daqType * from C to openDAQ a pointer to the TypeManager is needed because * of the way openDAQ enumeration is implemented. */ -enum ComponentStatusTypeEnum -{ - Error = 0, - Ok, - Warning -}; - enum ComponentStatusTypeEnum openDAQEnumConversion(daqEnumeration* daq) { enum ComponentStatusTypeEnum native = Error; - daqInt temp; + uint8_t temp; daqEnumeration_getIntValue(daq, &temp); + // Sanity check if (temp < 2) - { native = temp; - } return native; } From 44ccd00e816cd8c3b8625e0228253fce379bfe79 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alja=C5=BE=20Zako=C5=A1ek?= Date: Thu, 29 Jan 2026 13:01:12 +0100 Subject: [PATCH 07/10] Grammar fixes --- examples/util_headers/daq_c_conversions.h | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/examples/util_headers/daq_c_conversions.h b/examples/util_headers/daq_c_conversions.h index 73a72bd..e773976 100644 --- a/examples/util_headers/daq_c_conversions.h +++ b/examples/util_headers/daq_c_conversions.h @@ -80,7 +80,6 @@ void addCoordinateStructToTypeManager(daqContext* context) daqList_pushBack(defaultValues, (daqBaseObject*) intOpenDAQConversion(0)); daqSimpleType* simpleType = NULL; - daqSimpleType_createSimpleType(&simpleType, daqCtInt); daqList* types = NULL; @@ -116,9 +115,9 @@ void addCoordinateStructToTypeManager(daqContext* context) daqTypeManager_hasType(typeManager, stringOpenDAQConversion("DAQ_ComponentStatusTypeEnum"), &enumCheck); if(check && enumCheck) - printf("\nNew type added.\n"); + printf("\nNew types added.\n"); else - printf("\nFailed to add a new type.\n"); + printf("\nFailed to add new types.\n"); daqReleaseRef(types); daqReleaseRef(defaultValues); From 169c7af5004486369489e8e115707ce3f38fc77a Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alja=C5=BE=20Zako=C5=A1ek?= Date: Fri, 30 Jan 2026 11:48:46 +0100 Subject: [PATCH 08/10] Moved custom struct type into its own example --- examples/CMakeLists.txt | 3 +- examples/custom_struct_type_conversion.c | 185 ++++++++++++++ examples/util_headers/daq_c_conversions.h | 294 +++++----------------- 3 files changed, 247 insertions(+), 235 deletions(-) create mode 100644 examples/custom_struct_type_conversion.c diff --git a/examples/CMakeLists.txt b/examples/CMakeLists.txt index 25c41dc..afc09fc 100644 --- a/examples/CMakeLists.txt +++ b/examples/CMakeLists.txt @@ -10,7 +10,8 @@ set(EXAMPLE_SOURCES stream_reader_read_in_loop.c read_with_formatted_timestamps.c print_data_descriptor_and_calculater_sample_rate.c - create_and_read_sample_rate_buffers.c) + create_and_read_sample_rate_buffers.c + custom_struct_type_conversion.c) foreach(src ${EXAMPLE_SOURCES}) diff --git a/examples/custom_struct_type_conversion.c b/examples/custom_struct_type_conversion.c new file mode 100644 index 0000000..b788536 --- /dev/null +++ b/examples/custom_struct_type_conversion.c @@ -0,0 +1,185 @@ +/* + * + */ +#include + + // Custom struct type +struct Coordinates +{ + int64_t x; + int64_t y; + int64_t z; +}; + +// Adds Coodinates struct and ComponentStatusTypeEnum to types in Type Manager +void addCoordinateStructToTypeManager(daqContext* context) +{ + daqTypeManager* typeManager = NULL; + daqContext_getTypeManager(context, &typeManager); + + daqList* names = NULL; + daqList_createList(&names); + + daqList_pushBack(names, (daqBaseObject*) daq_toDaqString("x")); + daqList_pushBack(names, (daqBaseObject*) daq_toDaqString("y")); + daqList_pushBack(names, (daqBaseObject*) daq_toDaqString("z")); + + daqSimpleType* simpleType = NULL; + daqSimpleType_createSimpleType(&simpleType, daqCtInt); + + daqList* types = NULL; + daqList_createList(&types); + daqList_pushBack(types, simpleType); + daqList_pushBack(types, simpleType); + daqList_pushBack(types, simpleType); + daqReleaseRef(simpleType); + + daqStructType* newType = NULL; + daqStructType_createStructTypeNoDefaults(&newType, daq_toDaqString("DAQ_Coordinates"), names, types); + + daqTypeManager_addType(typeManager, (daqType*) newType); + daqReleaseRef(newType); + daqReleaseRef(names); + + daqList_createList(&names); + + daqList_pushBack(names, (daqBaseObject*) daq_toDaqString("Error")); + daqList_pushBack(names, (daqBaseObject*) daq_toDaqString("Ok")); + daqList_pushBack(names, (daqBaseObject*) daq_toDaqString("Warning")); + + daqEnumerationType* enumType = NULL; + daqEnumerationType_createEnumerationType(&enumType, daq_toDaqString("DAQ_ComponentStatusTypeEnum"), names, 0); + + daqTypeManager_addType(typeManager, (daqType*) enumType); + daqReleaseRef(enumType); + + daqBool check = False; + daqTypeManager_hasType(typeManager, daq_toDaqString("DAQ_Coordinates"), &check); + + daqBool enumCheck = False; + daqTypeManager_hasType(typeManager, daq_toDaqString("DAQ_ComponentStatusTypeEnum"), &enumCheck); + + if (check && enumCheck) + printf("\nNew types added.\n"); + else + printf("\nFailed to add new types.\n"); + + daqReleaseRef(types); + daqReleaseRef(names); + daqReleaseRef(typeManager); +} + +// Struct conversion +/* + * Conversion from and to daqStruct objects to C style structs. + * Warning: These types of conversions require prior knowledge of + * the struct structure and its definition in C. For conversion + * from C to openDAQ a pointer to the TypeManager is needed because + * of the way openDAQ structs are implemented. + */ +struct Coordinates daq_fromDaqCoordinates(daqStruct* daq) +{ + struct Coordinates native = { 0,0,0 }; + + daqBaseObject* tempObj = NULL; + + daqStruct_get(daq, daq_toDaqString("x"), tempObj); + native.x = daq_fromDaqInteger((daqInteger*) daqQueryInterfacePtr(tempObj, DAQ_INTEGER_INTF_ID)); + daqReleaseRef(tempObj); + + daqStruct_get(daq, daq_toDaqString("y"), tempObj); + native.y = daq_fromDaqInteger((daqInteger*) daqQueryInterfacePtr(tempObj, DAQ_INTEGER_INTF_ID)); + daqReleaseRef(tempObj); + + daqStruct_get(daq, daq_toDaqString("z"), tempObj); + native.z = daq_fromDaqInteger((daqInteger*) daqQueryInterfacePtr(tempObj, DAQ_INTEGER_INTF_ID)); + daqReleaseRef(tempObj); + + return native; +} + +daqStruct* daq_toDaqCoordinates(struct Coordinates native, daqTypeManager* typeManager) +{ + daqStructBuilder* builder = NULL; + daqStructBuilder_createStructBuilder(&builder, daq_toDaqString("DAQ_Coordinates"), typeManager); + + if (0) + { + // We can set values in the struct either via directly assigning them to the + // corresponding struct values or adding them in the correct sequence + // to a daqList and setting the list. + daqList* values = NULL; + daqList_createList(&values); + + daqList_pushBack(values, (daqBaseObject*) daq_toDaqInteger(native.x)); + daqList_pushBack(values, (daqBaseObject*) daq_toDaqInteger(native.y)); + daqList_pushBack(values, (daqBaseObject*) daq_toDaqInteger(native.z)); + + daqStructBuilder_setFieldValues(builder, values); + daqReleaseRef(values); + } + else + { + daqStructBuilder_set(builder, daq_toDaqString("x"), (daqBaseObject*) daq_toDaqInteger(native.x)); + + daqStructBuilder_set(builder, daq_toDaqString("y"), (daqBaseObject*) daq_toDaqInteger(native.y)); + + daqStructBuilder_set(builder, daq_toDaqString("z"), (daqBaseObject*) daq_toDaqInteger(native.z)); + } + daqStruct* daq = NULL; + daqStructBuilder_build(builder, &daq); + daqReleaseRef(builder); + + return daq; +} + +// Enumeration conversion +/* + * Conversion from and to openDAQ String (daqEnumeration) core type + * from C language (enum ComponentStutesTypeEnum). + * Warning: These types of conversions require prior knowledge of + * the enumeration structure and its definition in C. For conversion + * from C to openDAQ a pointer to the TypeManager is needed because + * of the way openDAQ enumeration is implemented. + */ +enum ComponentStatusTypeEnum daq_fromDaqCompStatusTypeEnum(daqEnumeration* daq) +{ + enum ComponentStatusTypeEnum native = Error; + uint8_t temp; + daqEnumeration_getIntValue(daq, &temp); + + // Sanity check + if (temp < 2) + native = temp; + + return native; +} + +daqEnumeration* daq_toCompStatusTypeEnum(enum ComponentStatusTypeEnum native, daqTypeManager* typeManager) +{ + daqEnumeration* daq = NULL; + daqInteger* temp = daq_toDaqInteger(native); + + daqEnumeration_createEnumerationWithIntValue(&daq, daq_toDaqString("ComponentStatusType"), temp, typeManager); + + daqReleaseRef(temp); + return daq; +} + +int main() +{ + daqInstance* simulatorInstance = NULL; + setupSimulator(&simulatorInstance); + + daqInstance* instance = NULL; + daqDevice* simulator = NULL; + addSimulator(&simulator, &instance); + + + + daqReleaseRef(simulator); + daqReleaseRef(instance); + daqReleaseRef(simulatorInstance); + + return 0; +} \ No newline at end of file diff --git a/examples/util_headers/daq_c_conversions.h b/examples/util_headers/daq_c_conversions.h index e773976..1b17255 100644 --- a/examples/util_headers/daq_c_conversions.h +++ b/examples/util_headers/daq_c_conversions.h @@ -1,24 +1,20 @@ #include +// Core struct type struct ComplexNumber { double real; double imaginary; }; +// Core struct type struct Range { double min; double max; }; -struct Coordinates -{ - int64_t x; - int64_t y; - int64_t z; -}; - +// Standard enum enum ComponentStatusTypeEnum { Error = 0, @@ -26,180 +22,109 @@ enum ComponentStatusTypeEnum Warning }; -// Adds Coodinates struct and ComponentStatusTypeEnum to types in Type Manager -void addCoordinateStructToTypeManager(daqContext* context); - // Int conversion -daqInt openDAQIntConversion(daqInteger* daq); -daqInteger* intOpenDAQConversion(daqInt native); +/* + * The following two funtions represent the conversion between the openDAQ native + * daqInt type and its coresponding C integer type. + */ +daqInt daq_fromDaqInteger(daqInteger* daq); +daqInteger* daq_toDaqInteger(daqInt native); // String conversion -char* openDAQStringConversion(daqString* daq); -daqString* stringOpenDAQConversion(const char* native); +/* + * Conversion from and to openDAQ String (daqString) core type + * from C language (const char*). + */ +char* daq_fromDaqString(daqString* daq); +daqString* daq_toDaqString(const char* native); // Bool conversion -daqBoolean* booleanOpenDAQConversion(uint8_t native); -uint8_t openDAQBooleanConversion(daqBoolean* daq); +/* + * Conversion from and to openDAQ Boolean (daqString) core type from C language (uint8_t). + */ +uint8_t daq_fromDaqBoolean(daqBoolean* daq); +daqBoolean* daq_toDaqBoolean(uint8_t native); // Float conversion -daqFloatObject* floatOpenDAQConversion(double native); -double openDAQFloatConversion(daqFloatObject* daq); +/* + *Conversion from and to openDAQ String (daqFloat) core type from C language (double). + */ +double daq_fromDaqObject(daqFloatObject* daq); +daqFloatObject* daq_toDaqFloatObject(double native); // Complex number conversion -struct ComplexNumber openDAQComplexConversion(daqComplexNumber* daq); -daqComplexNumber* complexOpenDAQConversion(struct ComplexNumber* native); +/* + * Conversion from and to openDAQ Complex (daqComplex) core type + * from C language (struct ComplexNumber). + */ +struct ComplexNumber daq_fromDaqComplex(daqComplexNumber* daq); +daqComplexNumber* daq_toDaqComplex(struct ComplexNumber* native); // Range conversion -struct Range openDAQRangeConversion(daqRange* daq); -daqRange* RangeOpenDAQConversion(struct Range native); - -// Struct conversion -struct Coordinates openDAQCoordinatesStructConversion(daqStruct* daq); -daqStruct* coordinatesStructOpenDAQConversion(struct Coordinates native, daqTypeManager* typeManager); - -// Enumeration conversion -enum ComponentStatusTypeEnum openDAQEnumConversion(daqEnumeration* daq); -daqEnumeration* EnumOpenDAQConversion(enum ComponentStatusTypeEnum native, daqTypeManager* typeManager); - -void addCoordinateStructToTypeManager(daqContext* context) -{ - daqTypeManager* typeManager = NULL; - daqContext_getTypeManager(context, &typeManager); - - daqList* names = NULL; - daqList_createList(&names); - - daqList_pushBack(names, (daqBaseObject*) stringOpenDAQConversion("x")); - daqList_pushBack(names, (daqBaseObject*) stringOpenDAQConversion("y")); - daqList_pushBack(names, (daqBaseObject*) stringOpenDAQConversion("z")); - - daqList* defaultValues = NULL; - daqList_createList(&defaultValues); - daqList_pushBack(defaultValues, (daqBaseObject*) intOpenDAQConversion(0)); - daqList_pushBack(defaultValues, (daqBaseObject*) intOpenDAQConversion(0)); - daqList_pushBack(defaultValues, (daqBaseObject*) intOpenDAQConversion(0)); - - daqSimpleType* simpleType = NULL; - daqSimpleType_createSimpleType(&simpleType, daqCtInt); - - daqList* types = NULL; - daqList_createList(&types); - daqList_pushBack(types, simpleType); - daqList_pushBack(types, simpleType); - daqList_pushBack(types, simpleType); - daqReleaseRef(simpleType); - - daqStructType* newType = NULL; - daqStructType_createStructType(&newType, stringOpenDAQConversion("DAQ_Coordinates"), names, defaultValues, types); - - daqTypeManager_addType(typeManager, (daqType*) newType); - daqReleaseRef(newType); - daqReleaseRef(names); - - daqList_createList(&names); - - daqList_pushBack(names, (daqBaseObject*) stringOpenDAQConversion("Error")); - daqList_pushBack(names, (daqBaseObject*) stringOpenDAQConversion("Ok")); - daqList_pushBack(names, (daqBaseObject*) stringOpenDAQConversion("Warning")); - - daqEnumerationType* enumType = NULL; - daqEnumerationType_createEnumerationType(&enumType, stringOpenDAQConversion("DAQ_ComponentStatusTypeEnum"), names, 0); - - daqTypeManager_addType(typeManager, (daqType*) enumType); - daqReleaseRef(enumType); - - daqBool check = False; - daqTypeManager_hasType(typeManager, stringOpenDAQConversion("DAQ_Coordinates"), &check); - - daqBool enumCheck = False; - daqTypeManager_hasType(typeManager, stringOpenDAQConversion("DAQ_ComponentStatusTypeEnum"), &enumCheck); - - if(check && enumCheck) - printf("\nNew types added.\n"); - else - printf("\nFailed to add new types.\n"); - - daqReleaseRef(types); - daqReleaseRef(defaultValues); - daqReleaseRef(names); - daqReleaseRef(typeManager); -} - /* - * The following two funtions represent the conversion between the openDAQ native - * daqInt type and its coresponding C integer type. + * Conversion from and to openDAQ String (daqRange) core type + * from C language (struct Range). */ -daqInt openDAQIntConversion(daqInteger* daq) +struct Range daq_fromDaqRange(daqRange* daq); +daqRange* daq_toDaqRange(struct Range native); + +daqInt daq_fromDaqInteger(daqInteger* daq) { daqInt native = 0; daqInteger_getValue(daq, &native); return native; } -daqInteger* intOpenDAQConversion(daqInt native) +daqInteger* daq_toDaqInteger(daqInt native) { daqInteger* daq = NULL; daqInteger_createInteger(&daq, native); return daq; } -/* - * Conversion from and to openDAQ String (daqString) core type - * from C language (const char*). - */ -daqString* stringOpenDAQConversion(const char* native) -{ - daqString* daq = NULL; - daqString_createString(&daq, native); - return daq; -} - -char* openDAQStringConversion(daqString* daq) +char* daq_fromDaqString(daqString* daq) { char* native = NULL; daqString_getCharPtr(daq, &native); return native; } -/* - * Conversion from and to openDAQ Boolean (daqString) core type from C language (uint8_t). - */ -daqBoolean* booleanOpenDAQConversion(uint8_t native) +daqString* daq_toDaqString(const char* native) { - daqBoolean* daq = NULL; - daqBoolean_createBoolean(&daq, native); + daqString* daq = NULL; + daqString_createString(&daq, native); return daq; } -uint8_t openDAQBooleanConversion(daqBoolean* daq) +uint8_t daq_fromDaqBoolean(daqBoolean* daq) { uint8_t native = 0; daqBoolean_getValue(daq, &native); return native; } -/* - *Conversion from and to openDAQ String (daqFloat) core type from C language (double). - */ -daqFloatObject* floatOpenDAQConversion(double native) +daqBoolean* daq_toDaqBoolean(uint8_t native) { - daqFloatObject* daq = 0; - daqFloatObject_createFloatObject(&daq, native); + daqBoolean* daq = NULL; + daqBoolean_createBoolean(&daq, native); return daq; } -double openDAQFloatConversion(daqFloatObject* daq) +double daq_fromDaqObject(daqFloatObject* daq) { double native = 0; daqFloatObject_getValue(daq, &native); return native; } -/* - * Conversion from and to openDAQ Complex (daqComplex) core type - * from C language (struct ComplexNumber). - */ -struct ComplexNumber openDAQComplexConversion(daqComplexNumber* daq) +daqFloatObject* daq_toDaqFloatObject(double native) +{ + daqFloatObject* daq = 0; + daqFloatObject_createFloatObject(&daq, native); + return daq; +} + +struct ComplexNumber daq_fromDaqComplex(daqComplexNumber* daq) { struct ComplexNumber native = {0, 0}; double tempDouble= 0; @@ -210,18 +135,14 @@ struct ComplexNumber openDAQComplexConversion(daqComplexNumber* daq) return native; } -daqComplexNumber* complexOpenDAQConversion(struct ComplexNumber* native) +daqComplexNumber* daq_toDaqComplex(struct ComplexNumber* native) { daqComplexNumber* daq = NULL; daqComplexNumber_createComplexNumber(&daq, native->real, native->imaginary); return daq; } -/* - * Conversion from and to openDAQ String (daqRange) core type - * from C language (struct Range). - */ -struct Range openDAQRangeConversion(daqRange* daq) +struct Range daq_fromDaqRange(daqRange* daq) { struct Range native = {0, 0}; daqNumber* temp; @@ -238,14 +159,14 @@ struct Range openDAQRangeConversion(daqRange* daq) return native; } -daqRange* RangeOpenDAQConversion(struct Range native) +daqRange* daq_toDaqRange(struct Range native) { daqRange* daq = NULL; daqNumber* lowValue = NULL; daqNumber* highValue = NULL; - daqFloatObject* lowFloat = floatOpenDAQConversion(native.min); - daqFloatObject* highFloat = floatOpenDAQConversion(native.max); + daqFloatObject* lowFloat = daq_toDaqFloatObject(native.min); + daqFloatObject* highFloat = daq_toDaqFloatObject(native.max); daqQueryInterface(lowFloat, DAQ_NUMBER_INTF_ID, &lowValue); daqQueryInterface(highFloat, DAQ_NUMBER_INTF_ID, &highValue); @@ -260,98 +181,3 @@ daqRange* RangeOpenDAQConversion(struct Range native) daqReleaseRef(highValue); return daq; } - -/* - * Conversion from and to daqStruct objects to C style structs. - * Warning: These types of conversions require prior knowledge of - * the struct structure and its definition in C. For conversion - * from C to openDAQ a pointer to the TypeManager is needed because - * of the way openDAQ structs are implemented. - */ -struct Coordinates openDAQCoordinatesStructConversion(daqStruct* daq) -{ - struct Coordinates native = {0,0,0}; - - daqBaseObject* tempObj = NULL; - - daqStruct_get(daq, stringOpenDAQConversion("x"), tempObj); - native.x = openDAQIntConversion((daqInteger*) daqQueryInterfacePtr(tempObj, DAQ_INTEGER_INTF_ID)); - daqReleaseRef(tempObj); - - daqStruct_get(daq, stringOpenDAQConversion("y"), tempObj); - native.y = openDAQIntConversion((daqInteger*) daqQueryInterfacePtr(tempObj, DAQ_INTEGER_INTF_ID)); - daqReleaseRef(tempObj); - - daqStruct_get(daq, stringOpenDAQConversion("z"), tempObj); - native.z = openDAQIntConversion((daqInteger*) daqQueryInterfacePtr(tempObj, DAQ_INTEGER_INTF_ID)); - daqReleaseRef(tempObj); - - return native; -} - -daqStruct* coordinatesStructOpenDAQConversion(struct Coordinates native, daqTypeManager* typeManager) -{ - daqStructBuilder* builder = NULL; - daqStructBuilder_createStructBuilder(&builder, stringOpenDAQConversion("DAQ_Coordinates"), typeManager); - - if (0) - { - // We can set values in the struct either via directly assigning them to the - // corresponding struct values or adding them in the correct sequence - // to a daqList and setting the list. - daqList* values = NULL; - daqList_createList(&values); - - daqList_pushBack(values, (daqBaseObject*) intOpenDAQConversion(native.x)); - daqList_pushBack(values, (daqBaseObject*) intOpenDAQConversion(native.y)); - daqList_pushBack(values, (daqBaseObject*) intOpenDAQConversion(native.z)); - - daqStructBuilder_setFieldValues(builder, values); - daqReleaseRef(values); - } - else - { - daqStructBuilder_set(builder, stringOpenDAQConversion("x"), (daqBaseObject*) intOpenDAQConversion(native.x)); - - daqStructBuilder_set(builder, stringOpenDAQConversion("y"), (daqBaseObject*) intOpenDAQConversion(native.y)); - - daqStructBuilder_set(builder, stringOpenDAQConversion("z"), (daqBaseObject*) intOpenDAQConversion(native.z)); - } - daqStruct* daq = NULL; - daqStructBuilder_build(builder, &daq); - daqReleaseRef(builder); - - return daq; -} - -/* - * Conversion from and to openDAQ String (daqEnumeration) core type - * from C language (enum ComponentStutesTypeEnum). - * Warning: These types of conversions require prior knowledge of - * the enumeration structure and its definition in C. For conversion - * from C to openDAQ a pointer to the TypeManager is needed because - * of the way openDAQ enumeration is implemented. - */ -enum ComponentStatusTypeEnum openDAQEnumConversion(daqEnumeration* daq) -{ - enum ComponentStatusTypeEnum native = Error; - uint8_t temp; - daqEnumeration_getIntValue(daq, &temp); - - // Sanity check - if (temp < 2) - native = temp; - - return native; -} - -daqEnumeration* EnumOpenDAQConversion(enum ComponentStatusTypeEnum native, daqTypeManager* typeManager) -{ - daqEnumeration* daq = NULL; - daqInteger* temp = intOpenDAQConversion(native); - - daqEnumeration_createEnumerationWithIntValue(&daq, stringOpenDAQConversion("ComponentStatusType"), temp, typeManager); - - daqReleaseRef(temp); - return daq; -} From b46b6e916e02b52b42e6586ca59593d47ecb071d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alja=C5=BE=20Zako=C5=A1ek?= Date: Wed, 4 Feb 2026 14:11:24 +0100 Subject: [PATCH 09/10] Fixed memory leak when using conversion into openDAQ --- examples/custom_struct_type_conversion.c | 101 +++++++++++++++++----- examples/util_headers/daq_c_conversions.h | 10 +-- 2 files changed, 84 insertions(+), 27 deletions(-) diff --git a/examples/custom_struct_type_conversion.c b/examples/custom_struct_type_conversion.c index b788536..3784f9f 100644 --- a/examples/custom_struct_type_conversion.c +++ b/examples/custom_struct_type_conversion.c @@ -20,9 +20,16 @@ void addCoordinateStructToTypeManager(daqContext* context) daqList* names = NULL; daqList_createList(&names); - daqList_pushBack(names, (daqBaseObject*) daq_toDaqString("x")); - daqList_pushBack(names, (daqBaseObject*) daq_toDaqString("y")); - daqList_pushBack(names, (daqBaseObject*) daq_toDaqString("z")); + daqString* temp = daq_toDaqString("x"); + + daqList_pushBack(names, (daqBaseObject*)temp); + daqReleaseRef(temp); + temp = daq_toDaqString("y"); + daqList_pushBack(names, (daqBaseObject*) temp); + daqReleaseRef(temp); + temp = daq_toDaqString("z"); + daqList_pushBack(names, (daqBaseObject*)temp); + daqReleaseRef(temp); daqSimpleType* simpleType = NULL; daqSimpleType_createSimpleType(&simpleType, daqCtInt); @@ -43,9 +50,15 @@ void addCoordinateStructToTypeManager(daqContext* context) daqList_createList(&names); - daqList_pushBack(names, (daqBaseObject*) daq_toDaqString("Error")); - daqList_pushBack(names, (daqBaseObject*) daq_toDaqString("Ok")); - daqList_pushBack(names, (daqBaseObject*) daq_toDaqString("Warning")); + temp = daq_toDaqString("Error"); + daqList_pushBack(names, (daqBaseObject*) temp); + daqReleaseRef(temp); + temp = daq_toDaqString("Ok"); + daqList_pushBack(names, (daqBaseObject*) temp); + daqReleaseRef(temp); + temp = daq_toDaqString("Warning"); + daqList_pushBack(names, (daqBaseObject*) temp); + daqReleaseRef(temp); daqEnumerationType* enumType = NULL; daqEnumerationType_createEnumerationType(&enumType, daq_toDaqString("DAQ_ComponentStatusTypeEnum"), names, 0); @@ -82,18 +95,31 @@ struct Coordinates daq_fromDaqCoordinates(daqStruct* daq) struct Coordinates native = { 0,0,0 }; daqBaseObject* tempObj = NULL; + daqBaseObject* tempMid = NULL; - daqStruct_get(daq, daq_toDaqString("x"), tempObj); - native.x = daq_fromDaqInteger((daqInteger*) daqQueryInterfacePtr(tempObj, DAQ_INTEGER_INTF_ID)); + daqString* temp = daq_toDaqString("x"); + daqStruct_get(daq, temp, tempObj); + tempMid = daqQueryInterfacePtr(tempObj, DAQ_INTEGER_INTF_ID); + native.x = daq_fromDaqInteger((daqInteger*) tempMid); + daqReleaseRef(tempMid); daqReleaseRef(tempObj); + daqReleaseRef(temp); - daqStruct_get(daq, daq_toDaqString("y"), tempObj); - native.y = daq_fromDaqInteger((daqInteger*) daqQueryInterfacePtr(tempObj, DAQ_INTEGER_INTF_ID)); + temp = daq_toDaqString("y"); + daqStruct_get(daq, temp, tempObj); + tempMid = daqQueryInterfacePtr(tempObj, DAQ_INTEGER_INTF_ID); + native.y = daq_fromDaqInteger((daqInteger*) tempMid); + daqReleaseRef(tempMid); daqReleaseRef(tempObj); + daqReleaseRef(temp); - daqStruct_get(daq, daq_toDaqString("z"), tempObj); - native.z = daq_fromDaqInteger((daqInteger*) daqQueryInterfacePtr(tempObj, DAQ_INTEGER_INTF_ID)); + temp = daq_toDaqString("z"); + daqStruct_get(daq, temp, tempObj); + tempMid = daqQueryInterfacePtr(tempObj, DAQ_INTEGER_INTF_ID); + native.z = daq_fromDaqInteger((daqInteger*) tempMid); + daqReleaseRef(tempMid); daqReleaseRef(tempObj); + daqReleaseRef(temp); return native; } @@ -103,6 +129,8 @@ daqStruct* daq_toDaqCoordinates(struct Coordinates native, daqTypeManager* typeM daqStructBuilder* builder = NULL; daqStructBuilder_createStructBuilder(&builder, daq_toDaqString("DAQ_Coordinates"), typeManager); + daqString* temp = NULL; + daqInteger* tempInt = NULL; if (0) { // We can set values in the struct either via directly assigning them to the @@ -111,20 +139,39 @@ daqStruct* daq_toDaqCoordinates(struct Coordinates native, daqTypeManager* typeM daqList* values = NULL; daqList_createList(&values); - daqList_pushBack(values, (daqBaseObject*) daq_toDaqInteger(native.x)); - daqList_pushBack(values, (daqBaseObject*) daq_toDaqInteger(native.y)); - daqList_pushBack(values, (daqBaseObject*) daq_toDaqInteger(native.z)); + tempInt = daq_toDaqInteger(native.x); + daqList_pushBack(values, (daqBaseObject*) tempInt); + daqReleaseRef(tempInt); + tempInt = daq_toDaqInteger(native.y); + daqList_pushBack(values, (daqBaseObject*) tempInt); + daqReleaseRef(tempInt); + tempInt = daq_toDaqInteger(native.z); + daqList_pushBack(values, (daqBaseObject*) tempInt); + daqReleaseRef(tempInt); daqStructBuilder_setFieldValues(builder, values); daqReleaseRef(values); } else { - daqStructBuilder_set(builder, daq_toDaqString("x"), (daqBaseObject*) daq_toDaqInteger(native.x)); - daqStructBuilder_set(builder, daq_toDaqString("y"), (daqBaseObject*) daq_toDaqInteger(native.y)); - - daqStructBuilder_set(builder, daq_toDaqString("z"), (daqBaseObject*) daq_toDaqInteger(native.z)); + temp = daq_toDaqString("x"); + tempInt = daq_toDaqInteger(native.x); + daqStructBuilder_set(builder, temp, (daqBaseObject*) tempInt); + daqReleaseRef(temp); + daqReleaseRef(tempInt); + + temp = daq_toDaqString("y"); + tempInt = daq_toDaqInteger(native.y); + daqStructBuilder_set(builder, temp, (daqBaseObject*) tempInt); + daqReleaseRef(temp); + daqReleaseRef(tempInt); + + temp = daq_toDaqString("z"); + tempInt = daq_toDaqInteger(native.z); + daqStructBuilder_set(builder, temp, (daqBaseObject*) tempInt); + daqReleaseRef(temp); + daqReleaseRef(tempInt); } daqStruct* daq = NULL; daqStructBuilder_build(builder, &daq); @@ -158,11 +205,13 @@ enum ComponentStatusTypeEnum daq_fromDaqCompStatusTypeEnum(daqEnumeration* daq) daqEnumeration* daq_toCompStatusTypeEnum(enum ComponentStatusTypeEnum native, daqTypeManager* typeManager) { daqEnumeration* daq = NULL; - daqInteger* temp = daq_toDaqInteger(native); + daqInteger* tempInt = daq_toDaqInteger(native); + daqString* temp = daq_toDaqString("ComponentStatusType"); - daqEnumeration_createEnumerationWithIntValue(&daq, daq_toDaqString("ComponentStatusType"), temp, typeManager); + daqEnumeration_createEnumerationWithIntValue(&daq, temp, tempInt, typeManager); daqReleaseRef(temp); + daqReleaseRef(tempInt); return daq; } @@ -175,8 +224,16 @@ int main() daqDevice* simulator = NULL; addSimulator(&simulator, &instance); + daqContext* context = NULL; + daqComponent_getContext((daqComponent*) instance, &context); + addCoordinateStructToTypeManager(context); + daqReleaseRef(context); - + daqStructBuilder* builder = NULL; + + // Set a new property Object that is the new type and write its value and read it + // Might need to set up a custom simulator that will have daq_coordinates as a field + daqReleaseRef(simulator); daqReleaseRef(instance); daqReleaseRef(simulatorInstance); diff --git a/examples/util_headers/daq_c_conversions.h b/examples/util_headers/daq_c_conversions.h index 1b17255..4fb1468 100644 --- a/examples/util_headers/daq_c_conversions.h +++ b/examples/util_headers/daq_c_conversions.h @@ -49,8 +49,8 @@ daqBoolean* daq_toDaqBoolean(uint8_t native); /* *Conversion from and to openDAQ String (daqFloat) core type from C language (double). */ -double daq_fromDaqObject(daqFloatObject* daq); -daqFloatObject* daq_toDaqFloatObject(double native); +daqFloat daq_fromDaqObject(daqFloatObject* daq); +daqFloatObject* daq_toDaqFloatObject(daqFloat native); // Complex number conversion /* @@ -110,14 +110,14 @@ daqBoolean* daq_toDaqBoolean(uint8_t native) return daq; } -double daq_fromDaqObject(daqFloatObject* daq) +daqFloat daq_fromDaqObject(daqFloatObject* daq) { - double native = 0; + daqFloat native = 0; daqFloatObject_getValue(daq, &native); return native; } -daqFloatObject* daq_toDaqFloatObject(double native) +daqFloatObject* daq_toDaqFloatObject(daqFloat native) { daqFloatObject* daq = 0; daqFloatObject_createFloatObject(&daq, native); From 11f976333cd199ceb0edcf3ec99e65d3095bafaf Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Alja=C5=BE=20Zako=C5=A1ek?= Date: Thu, 5 Feb 2026 09:23:41 +0100 Subject: [PATCH 10/10] Removed redundant enumeration addition and Updated comment in String C conversion --- examples/custom_struct_type_conversion.c | 18 ------------------ examples/util_headers/daq_c_conversions.h | 3 ++- 2 files changed, 2 insertions(+), 19 deletions(-) diff --git a/examples/custom_struct_type_conversion.c b/examples/custom_struct_type_conversion.c index 3784f9f..264f289 100644 --- a/examples/custom_struct_type_conversion.c +++ b/examples/custom_struct_type_conversion.c @@ -48,24 +48,6 @@ void addCoordinateStructToTypeManager(daqContext* context) daqReleaseRef(newType); daqReleaseRef(names); - daqList_createList(&names); - - temp = daq_toDaqString("Error"); - daqList_pushBack(names, (daqBaseObject*) temp); - daqReleaseRef(temp); - temp = daq_toDaqString("Ok"); - daqList_pushBack(names, (daqBaseObject*) temp); - daqReleaseRef(temp); - temp = daq_toDaqString("Warning"); - daqList_pushBack(names, (daqBaseObject*) temp); - daqReleaseRef(temp); - - daqEnumerationType* enumType = NULL; - daqEnumerationType_createEnumerationType(&enumType, daq_toDaqString("DAQ_ComponentStatusTypeEnum"), names, 0); - - daqTypeManager_addType(typeManager, (daqType*) enumType); - daqReleaseRef(enumType); - daqBool check = False; daqTypeManager_hasType(typeManager, daq_toDaqString("DAQ_Coordinates"), &check); diff --git a/examples/util_headers/daq_c_conversions.h b/examples/util_headers/daq_c_conversions.h index 4fb1468..2d5a279 100644 --- a/examples/util_headers/daq_c_conversions.h +++ b/examples/util_headers/daq_c_conversions.h @@ -33,7 +33,8 @@ daqInteger* daq_toDaqInteger(daqInt native); // String conversion /* * Conversion from and to openDAQ String (daqString) core type - * from C language (const char*). + * from C language (const char*). The function that converts to native C return a non-owning pointer. + * Precautions should be taken, when using the received pointer. */ char* daq_fromDaqString(daqString* daq); daqString* daq_toDaqString(const char* native);