Update bsp_matrix_t to have proper error handling, update parsing

functions.

Author: BenBrock

examples/bsp-ls.c

@@ -18,7 +18,13 @@ void print_group_info(hid_t g, const char* name) {
   H5E_END_TRY;
 
   if (bsp_json != H5I_INVALID_HID) {
-    char* json_string = bsp_read_attribute(g, "binsparse");
+    char* json_string;
+    bsp_error_t error = bsp_read_attribute(&json_string, g, "binsparse");
+    if (error != BSP_SUCCESS) {
+      printf("Error reading binsparse attribute: %s\n",
+             bsp_get_error_string(error));
+      return;
+    }
 
     cJSON* j = cJSON_Parse(json_string);
 

examples/simple_read.c

@@ -11,7 +11,13 @@ int main(int argc, char** argv) {
 
   hid_t f = H5Fopen(file_name, H5F_ACC_RDWR, H5P_DEFAULT);
 
-  bsp_array_t array = bsp_read_array(f, "test");
+  bsp_array_t array;
+  bsp_error_t error = bsp_read_array(&array, f, "test");
+  if (error != BSP_SUCCESS) {
+    printf("Error reading array: %s\n", bsp_get_error_string(error));
+    H5Fclose(f);
+    return 1;
+  }
 
   int* values = (int*) array.data;
 

examples/simple_write.c

@@ -12,12 +12,7 @@ int main(int argc, char** argv) {
   hid_t f = H5Fcreate(file_name, H5F_ACC_TRUNC, H5P_DEFAULT, H5P_DEFAULT);
 
   bsp_array_t array;
-  bsp_error_t error = bsp_construct_array_t(&array, 1000, BSP_INT32);
-  if (error != BSP_SUCCESS) {
-    printf("Error: Failed to allocate array\n");
-    H5Fclose(f);
-    return 1;
-  }
+  bsp_construct_array_t(&array, 1000, BSP_INT32);
 
   int* values = (int*) array.data;
 

include/binsparse/hdf5_wrapper.h

@@ -21,12 +21,13 @@
 
 // Write an array to a dataset / file
 // Returns 0 on success, nonzero on error.
-static inline int bsp_write_array(hid_t f, const char* label, bsp_array_t array,
-                                  int compression_level) {
+static inline bsp_error_t bsp_write_array(hid_t f, const char* label,
+                                          bsp_array_t array,
+                                          int compression_level) {
   if (array.type == BSP_COMPLEX_FLOAT32 || array.type == BSP_COMPLEX_FLOAT64) {
     bsp_error_t error = bsp_complex_array_to_fp(&array);
     if (error != BSP_SUCCESS) {
-      return -3; // Type conversion error
+      return BSP_ERROR_TYPE;
     }
   }
 
@@ -59,52 +60,63 @@ static inline int bsp_write_array(hid_t f, const char* label, bsp_array_t array,
       H5Dcreate2(f, label, hdf5_standard_type, fspace, lcpl, dcpl, H5P_DEFAULT);
 
   if (dset == H5I_INVALID_HID) {
-    return -1;
+    H5Sclose(fspace);
+    H5Pclose(lcpl);
+    H5Pclose(dcpl);
+    return BSP_ERROR_IO;
   }
 
   hid_t hdf5_native_type = bsp_get_hdf5_native_type(array.type);
 
   hid_t r = H5Dwrite(dset, hdf5_native_type, H5S_ALL, fspace, H5P_DEFAULT,
                      array.data);
 
-  if (r == H5I_INVALID_HID) {
-    return -2;
+  if (r < 0) {
+    H5Dclose(dset);
+    H5Sclose(fspace);
+    H5Pclose(lcpl);
+    H5Pclose(dcpl);
+    return BSP_ERROR_IO;
   }
 
   H5Sclose(fspace);
+  H5Dclose(dset);
   H5Pclose(lcpl);
   H5Pclose(dcpl);
 
-  return 0;
+  return BSP_SUCCESS;
 }
 
 #if __STDC_VERSION__ >= 201112L
-static inline bsp_array_t bsp_read_array_parallel(hid_t f, const char* label,
+static inline bsp_error_t bsp_read_array_parallel(bsp_array_t* array, hid_t f,
+                                                  const char* label,
                                                   int num_threads) {
   hid_t dset = H5Dopen2(f, label, H5P_DEFAULT);
 
   if (dset == H5I_INVALID_HID) {
-    bsp_array_t empty_array;
-    bsp_construct_default_array_t(&empty_array);
-    return empty_array;
+    H5Dclose(dset);
+    bsp_construct_default_array_t(array);
+    return BSP_ERROR_IO;
   }
 
   hid_t fspace = H5Dget_space(dset);
 
   if (fspace == H5I_INVALID_HID) {
-    bsp_array_t empty_array;
-    bsp_construct_default_array_t(&empty_array);
-    return empty_array;
+    H5Sclose(fspace);
+    H5Dclose(dset);
+    bsp_construct_default_array_t(array);
+    return BSP_ERROR_IO;
   }
 
   hsize_t dims[3];
 
   int r = H5Sget_simple_extent_dims(fspace, dims, NULL);
 
   if (r < 0) {
-    bsp_array_t empty_array;
-    bsp_construct_default_array_t(&empty_array);
-    return empty_array;
+    H5Sclose(fspace);
+    H5Dclose(dset);
+    bsp_construct_default_array_t(array);
+    return BSP_ERROR_IO;
   }
 
   hid_t hdf5_type = H5Dget_type(dset);
@@ -113,10 +125,9 @@ static inline bsp_array_t bsp_read_array_parallel(hid_t f, const char* label,
 
   // Array will be written into a POSIX shared memory.
   bsp_shm_t array_shm = bsp_shm_new(dims[0] * bsp_type_size(type));
-  bsp_array_t array;
-  array.type = type;
-  array.size = dims[0];
-  array.allocator = bsp_shm_allocator;
+  array->type = type;
+  array->size = dims[0];
+  array->allocator = bsp_shm_allocator;
 
   bsp_shm_t active_children_shm = bsp_shm_new(sizeof(_Atomic int));
 
@@ -140,35 +151,35 @@ static inline bsp_array_t bsp_read_array_parallel(hid_t f, const char* label,
     }
   }
 
-  array.data = bsp_shm_attach(array_shm);
+  array->data = bsp_shm_attach(array_shm);
   if (thread_num == 0) {
     bsp_shm_delete(array_shm);
   }
 
-  hsize_t chunk_size = (array.size + num_threads - 1) / num_threads;
-  hsize_t start = (chunk_size * thread_num < array.size)
+  hsize_t chunk_size = (array->size + num_threads - 1) / num_threads;
+  hsize_t start = (chunk_size * thread_num < array->size)
                       ? chunk_size * thread_num
-                      : array.size;
+                      : array->size;
   hsize_t count =
-      (start + chunk_size <= array.size) ? chunk_size : array.size - start;
+      (start + chunk_size <= array->size) ? chunk_size : array->size - start;
 
   if (count > 0) {
     H5Sselect_hyperslab(fspace, H5S_SELECT_SET, &start, NULL, &count, NULL);
 
     hid_t memspace_id = H5Screate_simple(1, &count, NULL);
 
     H5Dread(dset, bsp_get_hdf5_native_type(type), memspace_id, fspace,
-            H5P_DEFAULT, ((char*) array.data) + start * bsp_type_size(type));
+            H5P_DEFAULT, ((char*) array->data) + start * bsp_type_size(type));
     H5Sclose(memspace_id);
   }
 
-  H5Dclose(dset);
   H5Sclose(fspace);
+  H5Dclose(dset);
 
   if (thread_num > 0) {
     atomic_fetch_add_explicit(active_children, -1, memory_order_relaxed);
     bsp_shm_detach(active_children);
-    bsp_shm_detach(array.data);
+    bsp_shm_detach(array->data);
     exit(0);
   }
 
@@ -178,73 +189,69 @@ static inline bsp_array_t bsp_read_array_parallel(hid_t f, const char* label,
   }
   bsp_shm_detach(active_children);
 
-  return array;
+  return BSP_SUCCESS;
 }
 #endif
 
-static inline bsp_array_t bsp_read_array(hid_t f, const char* label) {
+static inline bsp_error_t bsp_read_array(bsp_array_t* array, hid_t f,
+                                         const char* label) {
   hid_t dset = H5Dopen2(f, label, H5P_DEFAULT);
 
   if (dset == H5I_INVALID_HID) {
-    bsp_array_t empty_array;
-    bsp_construct_default_array_t(&empty_array);
-    return empty_array;
+    bsp_construct_default_array_t(array);
+    return BSP_ERROR_IO;
   }
 
   hid_t fspace = H5Dget_space(dset);
 
   if (fspace == H5I_INVALID_HID) {
-    bsp_array_t empty_array;
-    bsp_construct_default_array_t(&empty_array);
-    return empty_array;
+    H5Sclose(fspace);
+    H5Dclose(dset);
+    bsp_construct_default_array_t(array);
+    return BSP_ERROR_IO;
   }
 
   hsize_t dims[3];
 
   int r = H5Sget_simple_extent_dims(fspace, dims, NULL);
 
   if (r < 0) {
-    bsp_array_t empty_array;
-    bsp_construct_default_array_t(&empty_array);
-    return empty_array;
+    H5Dclose(dset);
+    H5Sclose(fspace);
+    bsp_construct_default_array_t(array);
+    return BSP_ERROR_IO;
   }
 
   hid_t hdf5_type = H5Dget_type(dset);
 
   bsp_type_t type = bsp_get_bsp_type(hdf5_type);
 
-  bsp_array_t array;
-  bsp_construct_default_array_t(&array);
-
-  bsp_error_t error = bsp_construct_array_t(&array, dims[0], type);
+  bsp_error_t error = bsp_construct_array_t(array, dims[0], type);
   if (error != BSP_SUCCESS) {
-    bsp_destroy_array_t(&array);
     H5Dclose(dset);
     H5Sclose(fspace);
-    bsp_array_t empty_array;
-    bsp_construct_default_array_t(&empty_array);
-    return empty_array;
+    bsp_construct_default_array_t(array);
+    return BSP_ERROR_MEMORY;
   }
 
   herr_t status = H5Dread(dset, bsp_get_hdf5_native_type(type), H5S_ALL,
-                          H5S_ALL, H5P_DEFAULT, array.data);
+                          H5S_ALL, H5P_DEFAULT, array->data);
 
   if (status < 0) {
-    bsp_destroy_array_t(&array);
-    H5Dclose(dset);
+    bsp_destroy_array_t(array);
     H5Sclose(fspace);
-    bsp_array_t empty_array;
-    bsp_construct_default_array_t(&empty_array);
-    return empty_array;
+    H5Dclose(dset);
+    bsp_construct_default_array_t(array);
+    return BSP_ERROR_IO;
   }
 
-  H5Dclose(dset);
   H5Sclose(fspace);
-  return array;
+  H5Dclose(dset);
+  return BSP_SUCCESS;
 }
 
-static inline void bsp_write_attribute(hid_t f, const char* label,
-                                       const char* string) {
+static inline bsp_error_t bsp_write_attribute(hid_t f, const char* label,
+                                              const char* string) {
   hid_t strtype = H5Tcopy(H5T_C_S1);
   H5Tset_size(strtype, strlen(string));
   H5Tset_cset(strtype, H5T_CSET_UTF8);
@@ -258,23 +265,28 @@ static inline void bsp_write_attribute(hid_t f, const char* label,
   H5Tclose(strtype);
   H5Aclose(attribute);
   H5Sclose(dataspace);
+
+  return BSP_SUCCESS;
 }
 
-static inline char* bsp_read_attribute(hid_t f, const char* label) {
+static inline bsp_error_t bsp_read_attribute(char** string, hid_t f,
+                                             const char* label) {
   hid_t attribute = H5Aopen(f, label, H5P_DEFAULT);
-  hid_t strtype = H5Aget_type(attribute);
 
-  hid_t type_class = H5Tget_class(strtype);
-  assert(type_class == H5T_STRING);
+  if (attribute == H5I_INVALID_HID) {
+    return BSP_ERROR_FORMAT;
+  }
+
+  hid_t strtype = H5Aget_type(attribute);
 
   size_t size = H5Tget_size(strtype);
 
-  char* string = (char*) malloc(size + 1);
+  *string = (char*) malloc(size + 1);
 
-  H5Aread(attribute, strtype, string);
+  H5Aread(attribute, strtype, *string);
 
   H5Aclose(attribute);
   H5Tclose(strtype);
 
-  return string;
+  return BSP_SUCCESS;
 }

include/binsparse/write_matrix.h

@@ -18,12 +18,13 @@ extern "C" {
 #ifdef BSP_USE_HDF5
 #include <hdf5.h>
 
-int bsp_write_matrix_to_group(hid_t f, bsp_matrix_t matrix, cJSON* user_json,
-                              int compression_level);
+bsp_error_t bsp_write_matrix_to_group(hid_t f, bsp_matrix_t matrix,
+                                      cJSON* user_json, int compression_level);
 #endif
 
-int bsp_write_matrix(const char* fname, bsp_matrix_t matrix, const char* group,
-                     cJSON* user_json, int compression_level);
+bsp_error_t bsp_write_matrix(const char* fname, bsp_matrix_t matrix,
+                             const char* group, cJSON* user_json,
+                             int compression_level);
 
 #ifdef __cplusplus
 }