Add allocator wrapper for c-style allocation

Author: BenBrock

examples/c_style.cpp

@@ -0,0 +1,17 @@
+#include <binsparse/binsparse.hpp>
+#include <iostream>
+
+int main(int argc, char** argv) {
+
+  binsparse::allocator_wrapper<float> alloc(malloc, free);
+
+  auto mat = binsparse::read_coo_matrix<float, std::size_t>("data/matrix.hdf5", alloc);
+
+  for (size_t i = 0; i < mat.nnz; i++) {
+    std::cout << mat.rowind[i] << ", " << mat.colind[i] << ": " << mat.values[i] << std::endl;
+  }
+
+  // binsparse::write_coo_matrix("new_matrix.hdf5", mat);
+
+  return 0;
+}

include/binsparse/binsparse.hpp

@@ -5,6 +5,9 @@
 #include <binsparse/containers/matrices.hpp>
 #include "hdf5_tools.hpp"
 #include <memory>
+#include <type_traits>
+
+#include <binsparse/c_bindings/allocator_wrapper.hpp>
 
 namespace binsparse {
 
@@ -50,7 +53,7 @@ coo_matrix<T, I> read_coo_matrix(std::string fname, Allocator&& alloc) {
     auto ncols = data["shape"][1];
     auto nnz = data["nnz"];
 
-    typename std::allocator_traits<Allocator>:: template rebind_alloc<I> i_alloc(alloc);
+    typename std::allocator_traits<std::remove_cvref_t<Allocator>>:: template rebind_alloc<I> i_alloc(alloc);
 
     auto values = hdf5_tools::read_dataset<T>(f, "values", alloc);
     auto rows = hdf5_tools::read_dataset<I>(f, "indices_0", i_alloc);
@@ -62,7 +65,7 @@ coo_matrix<T, I> read_coo_matrix(std::string fname, Allocator&& alloc) {
   }
 }
 
-template <typename T, typename I = std::size_t>
+template <typename T, typename I>
 coo_matrix<T, I> read_coo_matrix(std::string fname) {
   return read_coo_matrix<T, I>(fname, std::allocator<T>{});
 }

include/binsparse/c_bindings/allocator_wrapper.hpp

@@ -0,0 +1,50 @@
+#pragma once
+
+namespace binsparse {
+
+template <typename T>
+class allocator_wrapper {
+public:
+  using value_type = T;
+  using pointer = T*;
+  using const_pointer = const T*;
+  using reference = T&;
+  using const_reference = const T&;
+  using size_type = std::size_t;
+  using difference_type = std::ptrdiff_t;
+
+  template <typename U>
+  allocator_wrapper(const allocator_wrapper<U> &other) noexcept
+      : malloc_fn_(other.malloc_fn_), free_fn_(other.free_fn_) {}
+
+  allocator_wrapper(void* (*malloc_fn)(size_t), void (*free_fn)(void*)) noexcept
+      : malloc_fn_(malloc_fn), free_fn_(free_fn) {}
+
+  allocator_wrapper(const allocator_wrapper &) = default;
+  allocator_wrapper &operator=(const allocator_wrapper &) = default;
+  ~allocator_wrapper() = default;
+
+  using is_always_equal = std::false_type;
+
+  pointer allocate(std::size_t size) {
+    return reinterpret_cast<T*>(malloc_fn_(size*sizeof(T)));
+  }
+
+  void deallocate(pointer ptr, std::size_t n) {
+    free_fn_(ptr);
+  }
+
+  bool operator==(const allocator_wrapper &) const = default;
+  bool operator!=(const allocator_wrapper &) const = default;
+
+  template <typename U> struct rebind {
+    using other = allocator_wrapper<U>;
+  };
+
+
+  void* (*malloc_fn_)(size_t);
+  void  (*free_fn_)(void*);
+};
+
+
+}

include/binsparse/c_bindings/read_coo_matrix.hpp

@@ -0,0 +1,12 @@
+#pragma once
+
+#include <allocator_wrapper.hpp>
+
+extern "C" {
+  
+template <typename T, typename I = std::size_t>
+coo_matrix<T, I> read_coo_matrix(std::string fname) {
+  return read_coo_matrix<T, I>(fname, std::allocator<T>{});
+}
+
+};