Pvt/main

.gitignore

@@ -33,6 +33,6 @@ build/
 /src/main/resources/*.h5
 /src/main/resources/*.csv
 
-*.h5
 *.exe
-
+/*.h5
+hdf5/*/*.h5

hdf5/alltypesexample/.vscode/c_cpp_properties.json

@@ -0,0 +1,20 @@
+{
+    "configurations": [
+        {
+            "name": "MINGW64",
+            "intelliSenseMode": "gcc-x64",
+            "compilerPath": "C:/msys64/mingw64/bin/g++.exe",
+            "includePath": [
+                "C:/msys64/mingw64/include/**",
+                "${workspaceFolder}/**"
+            ],
+            "defines": [
+                "_DEBUG",
+                "_CONSOLE"
+            ],
+            "cStandard": "c11",
+            "cppStandard": "c++17"
+        }
+    ],
+    "version": 4
+}

hdf5/alltypesexample/.vscode/launch.json

@@ -0,0 +1,27 @@
+{
+    "version": "0.2.0",
+    "configurations": [
+      {
+        "name": "Debug Active File",
+        "type": "cppdbg",
+        "request": "launch",
+        "program": "${fileDirname}/${fileBasenameNoExtension}.exe",
+        "args": [],
+        "stopAtEntry": false,
+        "cwd": "${fileDirname}",
+        "environment": [],
+        "externalConsole": false,
+        "MIMode": "gdb",
+        "miDebuggerPath": "C:/msys64/mingw64/bin/gdb.exe",
+        "setupCommands": [
+          {
+            "description": "Enable pretty-printing for gdb",
+            "text": "-enable-pretty-printing",
+            "ignoreFailures": true
+          }
+        ],
+        "preLaunchTask": "Build Active File"
+      }
+    ]
+  }
+

hdf5/alltypesexample/.vscode/settings.json

@@ -0,0 +1,59 @@
+{
+    "files.associations": {
+        "array": "cpp",
+        "atomic": "cpp",
+        "bit": "cpp",
+        "*.tcc": "cpp",
+        "cctype": "cpp",
+        "charconv": "cpp",
+        "cinttypes": "cpp",
+        "clocale": "cpp",
+        "cmath": "cpp",
+        "compare": "cpp",
+        "concepts": "cpp",
+        "cstdarg": "cpp",
+        "cstddef": "cpp",
+        "cstdint": "cpp",
+        "cstdio": "cpp",
+        "cstdlib": "cpp",
+        "cstring": "cpp",
+        "ctime": "cpp",
+        "cwchar": "cpp",
+        "cwctype": "cpp",
+        "deque": "cpp",
+        "string": "cpp",
+        "unordered_map": "cpp",
+        "vector": "cpp",
+        "exception": "cpp",
+        "algorithm": "cpp",
+        "functional": "cpp",
+        "iterator": "cpp",
+        "memory": "cpp",
+        "memory_resource": "cpp",
+        "numeric": "cpp",
+        "optional": "cpp",
+        "random": "cpp",
+        "string_view": "cpp",
+        "system_error": "cpp",
+        "tuple": "cpp",
+        "type_traits": "cpp",
+        "utility": "cpp",
+        "format": "cpp",
+        "initializer_list": "cpp",
+        "iomanip": "cpp",
+        "iosfwd": "cpp",
+        "iostream": "cpp",
+        "istream": "cpp",
+        "limits": "cpp",
+        "new": "cpp",
+        "numbers": "cpp",
+        "ostream": "cpp",
+        "span": "cpp",
+        "sstream": "cpp",
+        "stdexcept": "cpp",
+        "streambuf": "cpp",
+        "text_encoding": "cpp",
+        "typeinfo": "cpp",
+        "variant": "cpp"
+    }
+}

hdf5/alltypesexample/.vscode/tasks.json

@@ -0,0 +1,29 @@
+{
+    "version": "2.0.0",
+    "tasks": [
+      {
+        "label": "Build Active File",
+        "type": "shell",
+        "command": "C:/msys64/mingw64/bin/g++.exe",
+        "args": [
+          "-g",
+          "${file}",
+          "-o",
+          "${fileDirname}/${fileBasenameNoExtension}.exe",
+          "-IC:/msys64/mingw64/include",
+          "-IC:/msys64/mingw64/include/hdf5",
+          "-LC:/msys64/mingw64/lib",
+          "-lhdf5_cpp",
+          "-lhdf5",
+          "-lz"
+        ],
+        "problemMatcher": ["$gcc"],
+        "group": {
+          "kind": "build",
+          "isDefault": true
+        },
+        "detail": "Builds currently open file with HDF5 support"
+      }
+    ]
+  }
+

hdf5/alltypesexample/alltypesgpt.cpp

@@ -0,0 +1,102 @@
+#include "hdf5.h"
+#include <iostream>
+#include <string>
+#include <vector>
+#include <cstring>
+
+const char* FILENAME = "example.h5";
+const char* DATASET = "/compound_example";
+
+int main() {
+    // Define the struct that matches our compound type
+    struct Record {
+        int32_t fixed_point;
+        float floating_point;
+        int64_t time;
+        char str[16];
+        uint8_t bitfield;
+        uint8_t opaque;
+        int32_t nested_fixed;
+        hobj_ref_t reference;
+        uint8_t enum_val;
+        hvl_t var_len;
+        int array[3];
+    };
+
+    // Fill in one example record
+    Record record = {
+        42,                            // Fixed-Point
+        3.14f,                         // Floating-Point
+        1234567890LL,                 // Time
+        "Hello HDF5",                 // String (fixed-length)
+        0b10101010,                   // Bit field
+        0xFF,                         // Opaque
+        7,                            // Compound (nested)
+        {},                           // Reference (set later)
+        1,                            // Enum
+        {},                           // Variable-Length (set later)
+        {1, 2, 3}                     // Array
+    };
+
+    // Create file and dataspace
+    hid_t file = H5Fcreate(FILENAME, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
+    hid_t space = H5Screate(H5S_SCALAR);  // One record
+
+    // === Build compound datatype ===
+    hid_t str_type = H5Tcopy(H5T_C_S1);
+    H5Tset_size(str_type, 16);
+
+    hid_t bitfield_type = H5Tcopy(H5T_STD_B8LE);
+    hid_t opaque_type = H5Tcreate(H5T_OPAQUE, 1);
+    H5Tset_tag(opaque_type, "byte");
+
+    hid_t nested_type = H5Tcreate(H5T_COMPOUND, sizeof(int32_t));
+    H5Tinsert(nested_type, "nested_fixed", 0, H5T_NATIVE_INT32);
+
+    hid_t ref_type = H5T_STD_REF_OBJ;
+
+    hid_t enum_type = H5Tcreate(H5T_ENUM, sizeof(uint8_t));
+    uint8_t enum_val0 = 0, enum_val1 = 1;
+    H5Tenum_insert(enum_type, "ZERO", &enum_val0);
+    H5Tenum_insert(enum_type, "ONE", &enum_val1);
+
+    hid_t vlen_type = H5Tvlen_create(H5T_NATIVE_INT);
+    int vl_data[] = {10, 20, 30};
+    record.var_len.len = 3;
+    record.var_len.p = vl_data;
+
+    hid_t array_type = H5Tarray_create(H5T_NATIVE_INT, 1, (hsize_t[]){3});
+
+    hid_t compound_type = H5Tcreate(H5T_COMPOUND, sizeof(Record));
+    H5Tinsert(compound_type, "fixed_point", HOFFSET(Record, fixed_point), H5T_NATIVE_INT32);
+    H5Tinsert(compound_type, "floating_point", HOFFSET(Record, floating_point), H5T_NATIVE_FLOAT);
+    H5Tinsert(compound_type, "time", HOFFSET(Record, time), H5T_NATIVE_INT64);
+    H5Tinsert(compound_type, "string", HOFFSET(Record, str), str_type);
+    H5Tinsert(compound_type, "bitfield", HOFFSET(Record, bitfield), bitfield_type);
+    H5Tinsert(compound_type, "opaque", HOFFSET(Record, opaque), opaque_type);
+    H5Tinsert(compound_type, "compound", HOFFSET(Record, nested_fixed), nested_type);
+    H5Tinsert(compound_type, "reference", HOFFSET(Record, reference), ref_type);
+    H5Tinsert(compound_type, "enum", HOFFSET(Record, enum_val), enum_type);
+    H5Tinsert(compound_type, "vlen", HOFFSET(Record, var_len), vlen_type);
+    H5Tinsert(compound_type, "array", HOFFSET(Record, array), array_type);
+
+    // Write dummy object to reference
+    hid_t ref_space = H5Screate(H5S_SCALAR);
+    hid_t ref_dset = H5Dcreate(file, "/dummy", H5T_NATIVE_INT, ref_space, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+    H5Rcreate(&record.reference, file, "/dummy", H5R_OBJECT, -1);
+    H5Sclose(ref_space);
+    H5Dclose(ref_dset);
+
+    // Write the compound data
+    hid_t dset = H5Dcreate(file, DATASET, compound_type, space, H5P_DEFAULT, H5P_DEFAULT, H5P_DEFAULT);
+    H5Dwrite(dset, compound_type, H5S_ALL, H5S_ALL, H5P_DEFAULT, &record);
+
+    // Cleanup
+    H5Dclose(dset);
+    H5Sclose(space);
+    H5Tclose(compound_type);
+    H5Fclose(file);
+
+    std::cout << "Done. Wrote " << FILENAME << std::endl;
+    return 0;
+}

hdf5/alltypesexample/alltypesgrok.cpp

@@ -0,0 +1,108 @@
+#include <H5Cpp.h>
+#include <H5Tpublic.h>
+#include <cstring>
+#include <iostream>
+
+using namespace H5;
+using namespace std;
+
+struct Record {
+    int32_t fixed_point;         // 4 bytes, offset 0
+    float floating_point;        // 4 bytes, offset 4
+    int64_t time;                // 8 bytes, offset 8
+    char string[16];             // 16 bytes, offset 16
+    uint8_t bit_field;           // 1 byte, offset 32
+    uint8_t opaque[4];           // 4 bytes, offset 33
+    struct {
+        int16_t nested_int;      // 2 bytes, offset 0 (relative)
+        double nested_double;    // 8 bytes, offset 8 (padded)
+    } compound;                  // 16 bytes total, offset 40
+    hobj_ref_t reference;        // 8 bytes, offset 56
+    int enumerated;              // 4 bytes, offset 64
+    int array[3];                // 12 bytes, offset 68
+    hvl_t variable_length;       // 16 bytes, offset 80
+};
+
+int main() {
+    cout << "sizeof(Record): " << sizeof(Record) << endl;
+    cout << "Offsets: " << HOFFSET(Record, fixed_point) << ", " << HOFFSET(Record, floating_point) << ", "
+         << HOFFSET(Record, time) << ", " << HOFFSET(Record, string) << ", " << HOFFSET(Record, bit_field) << ", "
+         << HOFFSET(Record, opaque) << ", " << HOFFSET(Record, compound) << ", " << HOFFSET(Record, compound.nested_int) << ", "
+         << HOFFSET(Record, compound.nested_double) << ", " << HOFFSET(Record, reference) << ", " << HOFFSET(Record, enumerated) << ", "
+         << HOFFSET(Record, array) << ", " << HOFFSET(Record, variable_length) << endl;
+
+    try {
+        H5File file("compound_example.h5", H5F_ACC_TRUNC);
+
+        // Create a simple dataset in the root group (like /dummy in example.h5)
+        hsize_t dims[1] = {1};
+        DataSpace scalar_space(1, dims);
+        DataSet dummy_dataset = file.createDataSet("/dummy", PredType::NATIVE_INT, scalar_space);
+        int dummy_value = 0;
+        dummy_dataset.write(&dummy_value, PredType::NATIVE_INT);
+
+        // Define the compound datatype
+        CompType compound_type(sizeof(Record));
+
+        compound_type.insertMember("fixed_point", HOFFSET(Record, fixed_point), PredType::NATIVE_INT32);
+        compound_type.insertMember("floating_point", HOFFSET(Record, floating_point), PredType::NATIVE_FLOAT);
+        compound_type.insertMember("time", HOFFSET(Record, time), PredType::NATIVE_INT64);
+        StrType str_type(PredType::C_S1, 16);
+        compound_type.insertMember("string", HOFFSET(Record, string), str_type);
+        IntType bitfield_type(H5Tcopy(H5T_STD_B8LE));
+        compound_type.insertMember("bit_field", HOFFSET(Record, bit_field), bitfield_type);
+        DataType opaque_type(H5T_OPAQUE, 4);
+        H5Tset_tag(opaque_type.getId(), "4-byte opaque data");
+        compound_type.insertMember("opaque", HOFFSET(Record, opaque), opaque_type);
+        CompType nested_type(static_cast<size_t>(16));
+        nested_type.insertMember("nested_int", 0, PredType::NATIVE_INT16);
+        nested_type.insertMember("nested_double", 8, PredType::NATIVE_DOUBLE);
+        compound_type.insertMember("compound", HOFFSET(Record, compound), nested_type);
+        compound_type.insertMember("reference", HOFFSET(Record, reference), PredType::STD_REF_OBJ);
+        EnumType enum_type(PredType::NATIVE_INT);
+        int val1 = 0, val2 = 1, val3 = 2;
+        enum_type.insert("LOW", &val1);
+        enum_type.insert("MEDIUM", &val2);
+        enum_type.insert("HIGH", &val3);
+        compound_type.insertMember("enumerated", HOFFSET(Record, enumerated), enum_type);
+        hsize_t array_dims[1] = {3};
+        ArrayType array_type(PredType::NATIVE_INT, 1, array_dims);
+        compound_type.insertMember("array", HOFFSET(Record, array), array_type);
+        VarLenType vlen_type(PredType::NATIVE_INT);
+        compound_type.insertMember("variable_length", HOFFSET(Record, variable_length), vlen_type);
+
+        // Create the dataset with the compound type
+        DataSpace dataspace(1, dims);
+        DataSet dataset = file.createDataSet("/myDataset", compound_type, dataspace);
+
+        // Prepare one record of data
+        Record data{};
+        data.fixed_point = 42;
+        data.floating_point = 3.14f;
+        data.time = 1698765432;
+        strcpy(data.string, "Hello HDF5!");
+        data.bit_field = 0b10101010; // 170, stored as a bitfield
+        memcpy(data.opaque, "ABCD", 4);
+        data.compound.nested_int = 123;
+        data.compound.nested_double = 2.718;
+        hid_t file_id = file.getId();
+        H5Rcreate(&data.reference, file_id, "/dummy", H5R_OBJECT, -1); // Point to /dummy dataset
+        data.enumerated = 1;
+        int vlen_data[3] = {10, 20, 30};
+        data.variable_length.p = vlen_data;
+        data.variable_length.len = 3;
+        data.array[0] = 1;
+        data.array[1] = 2;
+        data.array[2] = 3;
+
+        dataset.write(&data, compound_type);
+
+        cout << "HDF5 file created successfully with one compound record!" << endl;
+    }
+    catch (Exception& e) {
+        cerr << "Error: " << e.getDetailMsg() << endl;
+        return 1;
+    }
+
+    return 0;
+}