Simple properties attributes and metadata reading

examples/CMakeLists.txt

@@ -11,9 +11,11 @@ set(EXAMPLE_SOURCES
     read_with_formatted_timestamps.c
     print_data_descriptor_and_calculater_sample_rate.c
     create_and_read_sample_rate_buffers.c
+    simple_properties_display_handling.c
+    basic_conversions_example.c
+    advanced_conversions_example.c
     multi_reader_read_same_rates.c)
 
-
 foreach(src ${EXAMPLE_SOURCES})
     get_filename_component(exec_name ${src} NAME_WLE)
     add_executable(${exec_name} ${src})

examples/advanced_conversions_example.c

@@ -0,0 +1,156 @@
+/*
+ * Example that shows how to create conversion functions for custom defined in openDAQ.
+ * Functions demonstrate conversions to and from openDAQ structure to its 
+ * equivalent in native C.
+ */
+#include <daq_example_utils.h>
+
+// 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 daqExample_Coordinates daqExample_fromDaqCoordinates(daqStruct* daq)
+{
+    struct daqExample_Coordinates native = { 0,0,0 };
+
+    daqBaseObject* value = NULL;
+    daqBaseObject* integerValue = NULL;
+
+    daqString* fieldName = exdaq_toDaqString("x");
+    daqStruct_get(daq, fieldName, &value);
+    daqQueryInterface(value, DAQ_INTEGER_INTF_ID, &integerValue);
+    native.x = exdaq_fromDaqInteger((daqInteger*) integerValue);
+    daqReleaseRef(integerValue);
+    daqReleaseRef(value);
+    daqReleaseRef(fieldName);
+
+    fieldName = exdaq_toDaqString("y");
+    daqStruct_get(daq, fieldName, &value);
+    daqQueryInterface(value, DAQ_INTEGER_INTF_ID, &integerValue);
+    native.y = exdaq_fromDaqInteger((daqInteger*) integerValue);
+    daqReleaseRef(integerValue);
+    daqReleaseRef(value);
+    daqReleaseRef(fieldName);
+
+    fieldName = exdaq_toDaqString("z");
+    daqStruct_get(daq, fieldName, &value);
+    daqQueryInterface(value, DAQ_INTEGER_INTF_ID, &integerValue);
+    native.z = exdaq_fromDaqInteger((daqInteger*) integerValue);
+    daqReleaseRef(integerValue);
+    daqReleaseRef(value);
+    daqReleaseRef(fieldName);
+
+    return native;
+}
+
+daqStruct* daqExample_toDaqCoordinates(struct daqExample_Coordinates native, daqTypeManager* typeManager)
+{
+    daqStructBuilder* builder = NULL;
+    daqStructBuilder_createStructBuilder(&builder, exdaq_toDaqString("DAQ_Coordinates"), typeManager);
+
+    daqString* fieldName = NULL;
+    daqInteger* fieldValue = NULL;
+
+    fieldName = exdaq_toDaqString("x");
+    fieldValue = exdaq_toDaqInteger(native.x);
+    daqStructBuilder_set(builder, fieldName, (daqBaseObject*) fieldValue);
+    daqReleaseRef(fieldName);
+    daqReleaseRef(fieldValue);
+
+    fieldName = exdaq_toDaqString("y");
+    fieldValue = exdaq_toDaqInteger(native.y);
+    daqStructBuilder_set(builder, fieldName, (daqBaseObject*) fieldValue);
+    daqReleaseRef(fieldName);
+    daqReleaseRef(fieldValue);
+
+    fieldName = exdaq_toDaqString("z");
+    fieldValue = exdaq_toDaqInteger(native.z);
+    daqStructBuilder_set(builder, fieldName, (daqBaseObject*) fieldValue);
+    daqReleaseRef(fieldName);
+    daqReleaseRef(fieldValue);
+
+    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 daqExample_ComponentStatusTypeEnum daqExample_fromDaqCompStatusTypeEnum(daqEnumeration* daq)
+{
+    int64_t intValue = -1;
+    daqEnumeration_getIntValue(daq, &intValue);
+
+    return intValue;
+}
+
+daqEnumeration* daqExample_toCompStatusTypeEnum(enum daqExample_ComponentStatusTypeEnum native, daqTypeManager* typeManager)
+{
+    daqEnumeration* daq = NULL;
+    daqInteger* valueInt = exdaq_toDaqInteger(native);
+    daqString* valueName = exdaq_toDaqString("ComponentStatusType");
+
+    daqEnumeration_createEnumerationWithIntValue(&daq, valueName, valueInt, typeManager);
+
+    daqReleaseRef(valueName);
+    daqReleaseRef(valueInt);
+    return daq;
+}
+
+int main()
+{
+    daqInstance* simulatorInstance = NULL;
+    setupSimulator(&simulatorInstance);
+    daqExmaple_addCustomTypes(simulatorInstance);
+
+    daqInstance* instance = NULL;
+    daqDevice* simulator = NULL;
+    addSimulator(&simulator, &instance);
+
+    daqContext* context = NULL;
+    daqComponent_getContext((daqComponent*)simulator, &context);
+    daqTypeManager* typeManager = NULL;
+    daqContext_getTypeManager(context, &typeManager);
+
+    enum daqExample_ComponentStatusTypeEnum enumStatusType = daqExample_ComponentStatusType_Error;
+    daqEnumeration* daqEnum = daqExample_toCompStatusTypeEnum(enumStatusType, typeManager);
+    enum daqExample_ComponentStatusTypeEnum enumStatusType2 = daqExample_fromDaqCompStatusTypeEnum(daqEnum);
+
+    if (enumStatusType == enumStatusType2)
+        printf("Structs are the same after transforming them to and from openDAQ.\n");
+    else
+        printf("Structs are different!\n");
+
+    struct daqExample_Coordinates nativeCoordinates = {4, 4, 4};
+    daqStruct* tempStruct = daqExample_toDaqCoordinates(nativeCoordinates, typeManager);
+    struct daqExample_Coordinates nativeCoordinates2 = daqExample_fromDaqCoordinates(tempStruct);
+
+    if (nativeCoordinates.x == nativeCoordinates2.x &&
+        nativeCoordinates.y == nativeCoordinates2.y && 
+        nativeCoordinates.z == nativeCoordinates2.z)
+        printf("Enums are the same after transforming them to and from openDAQ.\n");
+    else
+        printf("Enums are different!\n");
+
+    daqReleaseRef(typeManager);
+    daqReleaseRef(tempStruct);
+
+    daqReleaseRef(simulator);
+    daqReleaseRef(instance);
+    daqReleaseRef(simulatorInstance);
+
+    return 0;
+}

examples/basic_conversions_example.c

@@ -0,0 +1,50 @@
+/*
+ * Example that demonstrates conversions between native C types 
+ * and their openDAQ equvalents.
+ */
+#include <daq_c_conversions.h>
+
+int main()
+{
+    // Integer example
+    int64_t i = 10;
+    daqInteger* daqIn = exdaq_toDaqInteger(i);
+    int64_t i2 = daqExample_fromDaqInteger(daqIn);
+    printf("Integer is equal: %s\n", i == i2 ? "True": "False");
+    daqReleaseRef(daqIn);
+
+    // Float example
+    double j = 1.0;
+    daqFloatObject* daqFl = exdaq_toDaqFloat(j);
+    double j2 = exdaq_fromDaqFloat(daqFl);
+    printf("Float is equal: %s\n", j == j2 ? "True" : "False");
+    daqReleaseRef(daqFl);
+
+    // String example
+    char* k = "check";
+    daqString* daqStr = exdaq_toDaqString(k);
+    char* k2 = exdaq_fromDaqString(daqStr);
+    printf("String is equal: %s\n", strcmp(k, k2) == 0 ? "True" : "False");
+    daqReleaseRef(daqStr);
+
+    // Bool example
+    uint8_t l = True;
+    daqBoolean* daqBl = exdaq_toDaqBoolean(l);
+    uint8_t l2 = exdaq_fromDaqBoolean(daqBl);
+    printf("Boolean is equal: %s\n", l == l2 ? "True" : "False");
+    daqReleaseRef(daqBl);
+
+    // Complex Number example
+    struct exdaq_ComplexNumber m = { 1,5 };
+    daqComplexNumber* daqComplex = exdaq_toDaqComplex(&m);
+    struct exdaq_ComplexNumber m2 = exdaq_fromDaqComplex(daqComplex);
+    printf("Complex Number is equal: %s\n", ((m.imaginary == m2.imaginary) && (m.real == m2.real)) ? "True" : "False");
+    daqReleaseRef(daqComplex);
+
+    // Range example
+    struct daqExample_Range n = { 1,10 };
+    daqRange* daqRng = exdaq_toDaqRange(n);
+    struct daqExample_Range n2 = exdaq_fromDaqRange(daqRng);
+    printf("Range is equal: %s\n", ((n.max == n2.max) && (n.min == n2.min)) ? "True" : "False");
+    daqReleaseRef(daqRng);
+}

examples/simple_properties_display_handling.c

@@ -0,0 +1,70 @@
+/*
+ * Example that show how to properly display all relevant attributes and 
+ * metadata in properties.
+ */
+#include <daq_property_utils.h>
+
+void printPropertyTree(daqPropertyObject* propertyObject)
+{
+    daqList* visibleProperties = NULL;
+    daqPropertyObject_getVisibleProperties(propertyObject, &visibleProperties);
+
+    daqSizeT count = 0;
+    daqList_getCount(visibleProperties, &count);
+
+    for (daqSizeT i = 0; i < count; i++)
+    {
+        daqBaseObject* listItem = NULL;
+        daqProperty* property = NULL;
+
+        daqList_getItemAt(visibleProperties, i, &listItem);
+        daqQueryInterface(listItem, DAQ_PROPERTY_INTF_ID, &property);
+        daqReleaseRef(listItem);
+
+        daqCoreType valueType = daqCtUndefined;
+        daqProperty_getValueType(property, &valueType);
+
+        daqBaseObject* propertyValue;
+        daqProperty_getValue(property, &propertyValue);
+
+        printPropertyMetadata(property);
+
+        if (valueType == daqCtObject)
+        {
+            printf("---\n");
+            daqPropertyObject* childPropertyObject = NULL;
+            daqQueryInterface(propertyValue, DAQ_PROPERTY_OBJECT_INTF_ID, &childPropertyObject);
+            printPropertyTree(childPropertyObject);
+            printf("---\n\n");
+            daqReleaseRef(childPropertyObject);
+        }
+        else
+        {
+            printf("- Value: ");
+            printPropertyValueOrDefault(property, False);
+            printf("\n");
+        }
+
+        daqReleaseRef(propertyValue);
+        daqReleaseRef(property);
+    }
+
+    daqReleaseRef(visibleProperties);
+}
+
+int main()
+{
+    daqInstance* simulatorInstance = NULL;
+    setupSimulator(&simulatorInstance);
+
+    daqInstance* instance = NULL;
+    daqDevice* simulator = NULL;
+    addSimulator(&simulator, &instance);
+
+    printPropertyTree((daqPropertyObject*) simulator);
+
+    daqReleaseRef(simulator);
+    daqReleaseRef(instance);
+    daqReleaseRef(simulatorInstance);
+    return 0;
+}