h5eigen.h

// -*- C++ -*-

#ifndef h5eigen_
#define h5eigen_

#include <type_traits>
#include <Eigen/Dense>
#include <memory>
#include <string>
#include <map>
#include "H5Cpp.h"

namespace h5eigen {
using std::string;
using std::shared_ptr;
using std::remove_reference;
using std::map;
using namespace H5;
using namespace Eigen;

struct HDF5 {
  shared_ptr<H5File> h5;
  void open(const char *name, bool rw = false) {
    if (rw) {
      h5.reset(new H5File(name, H5F_ACC_TRUNC));
    } else {
      h5.reset(new H5File(name, H5F_ACC_RDONLY));
    }
  }
  ~HDF5() { h5->close(); }
  H5::PredType pred_type(int) { return PredType::NATIVE_INT; }
  H5::PredType pred_type(float) { return PredType::NATIVE_FLOAT; }
  H5::PredType pred_type(double) { return PredType::NATIVE_DOUBLE; }
  bool exists(const char *name) {
    try {
      DataSet dataset = h5->openDataSet(name);
      return true;
    } catch (FileIException e) {
      return false;
    } catch (GroupIException e) {
      return false;
    }
  }
  template <class T>
  void get(T &a, const char *name) {
    DataSet dataset = h5->openDataSet(name);
    DataSpace space = dataset.getSpace();
    hsize_t offset[] = {0, 0, 0, 0, 0, 0};
    hsize_t count[] = {0, 0, 0, 0, 0, 0};
    int rank = space.getSimpleExtentDims(count);
    Matrix<float, Dynamic, Dynamic, RowMajor> temp;
    if (rank == 1)
      temp.resize(count[0], 1);
    else if (rank == 2)
      temp.resize(count[0], count[1]);
    else
      THROW("unsupported rank");
    space.selectHyperslab(H5S_SELECT_SET, count, offset);
    DataSpace mem(rank, count);
    mem.selectHyperslab(H5S_SELECT_SET, count, offset);
    dataset.read(&temp(0, 0), pred_type(temp(0, 0)), mem, space);
    a = temp;
  }
  template <class T>
  void get1d(T &a, const char *name) {
    DataSet dataset = h5->openDataSet(name);
    DataSpace space = dataset.getSpace();
    hsize_t offset[] = {0, 0, 0, 0, 0, 0};
    hsize_t count[] = {0, 0, 0, 0, 0, 0};
    int rank = space.getSimpleExtentDims(count);
    if (rank == 1)
      a.resize(count[0]);
    else if (rank == 2)
      a.resize(count[0] * count[1]);
    else if (rank == 3)
      a.resize(count[0] * count[1] * count[2]);
    else if (rank == 4)
      a.resize(count[0] * count[1] * count[2] * count[3]);
    else
      THROW("unsupported rank");
    space.selectHyperslab(H5S_SELECT_SET, count, offset);
    DataSpace mem(rank, count);
    mem.selectHyperslab(H5S_SELECT_SET, count, offset);
    dataset.read(&a[0], pred_type(a[0]), mem, space);
  }
  template <class T>
  void put(T &a, const char *name, int rank = 2) {
    Matrix<float, Dynamic, Dynamic, RowMajor> temp = a;
    DSetCreatPropList plist;  // setFillValue, etc.
    hsize_t rows = ROWS(temp);
    hsize_t cols = COLS(temp);
    hsize_t dim[] = {rows, cols, 0, 0, 0, 0};
    DataSpace fspace(rank, dim);
    DataSet dataset =
        h5->createDataSet(name, pred_type(temp(0, 0)), fspace, plist);
    hsize_t start[] = {0, 0, 0, 0, 0, 0};
    hsize_t count[] = {rows, cols, 0, 0, 0, 0};
    DataSpace mspace(rank, dim);
    fspace.selectHyperslab(H5S_SELECT_SET, count, start);
    mspace.selectHyperslab(H5S_SELECT_SET, count, start);
    dataset.write(&temp(0, 0), pred_type(temp(0, 0)), mspace, fspace);
  }
  template <class T>
  void getvlrow(T &a, int index, const char *name) {
    typedef typename remove_reference<decltype(a[0])>::type S;
    DataSet dataset = h5->openDataSet(name);
    DataSpace space = dataset.getSpace();
    hsize_t dims[] = {0, 0, 0, 0};
    int rank = space.getSimpleExtentDims(dims);
    if (rank != 1) THROW("wrong rank");
    hsize_t start0[] = {0, 0};
    hsize_t start[] = {hsize_t(index), 0};
    hsize_t count[] = {1, 0};
    DataSpace fspace(1, dims);
    DataSpace mspace(1, count);
    fspace.selectHyperslab(H5S_SELECT_SET, count, start);
    mspace.selectHyperslab(H5S_SELECT_SET, count, start0);
    hvl_t vl[1];
    DataType ftype(pred_type(S(0)));
    VarLenType dtype(&ftype);
    dataset.read(vl, dtype, mspace, fspace);
    S *data = (S *)vl[0].p;
    int N = vl[0].len;
    a.resize(N, 1);
    for (int i = 0; i < N; i++) a(i, 0) = data[i];
    dataset.vlenReclaim(dtype, mspace, DSetMemXferPropList::DEFAULT, vl);
  }
  void setAttr(string name, string value) {
    Group root(h5->openGroup("/"));
    StrType strdatatype(PredType::C_S1, 256);
    DataSpace attr_dataspace = DataSpace(H5S_SCALAR);
    H5std_string buffer(value);
    root.createAttribute(name, strdatatype, attr_dataspace)
        .write(strdatatype, buffer);
  }
  string getAttr(string name) {
    Group root(h5->openGroup("/"));
    StrType strdatatype(PredType::C_S1, 256);
    DataSpace attr_dataspace = DataSpace(H5S_SCALAR);
    H5std_string buffer;
    root.createAttribute(name, strdatatype, attr_dataspace)
        .read(strdatatype, buffer);
    return buffer;
  }
  void getAttrs(map<string, string> &result) {
    Group root(h5->openGroup("/"));
    StrType strdatatype(PredType::C_S1, 256);
    DataSpace attr_dataspace = DataSpace(H5S_SCALAR);
    H5std_string buffer;
    for (int i = 0; i < root.getNumAttrs(); i++) {
      Attribute a = root.openAttribute(i);
      string key = a.getName();
      a.read(strdatatype, buffer);
      result[key] = buffer;
    }
  }
};

inline HDF5 *make_HDF5() { return new HDF5(); }
}

#endif