hdf5_reader.h

#pragma once
 
#include <tuple>
#include <vector>
 
#include <bbp/sonata/selection.h>
#include <highfive/H5File.hpp>
 
namespace bbp {
namespace sonata {
 
template <class T>
class Hdf5PluginRead1DInterface
{
  public:
    virtual ~Hdf5PluginRead1DInterface() = default;
 
    virtual std::vector<T> readSelection(const HighFive::DataSet& dset,
                                         const Selection& selection) const = 0;
};
 
template <class T>
class Hdf5PluginRead2DInterface
{
  public:
    virtual ~Hdf5PluginRead2DInterface() = default;
 
    virtual std::vector<std::array<uint64_t, 2>> readSelection(const HighFive::DataSet& dset,
                                                               const Selection& xsel,
                                                               const Selection& ysel) const = 0;
};
 
template <class T, class U>
class Hdf5PluginInterface;
 
template <class... Ts, class... Us>
class Hdf5PluginInterface<std::tuple<Ts...>, std::tuple<Us...>>
    : virtual public Hdf5PluginRead1DInterface<Ts>...,
      virtual public Hdf5PluginRead2DInterface<Us>...
{
  public:
    virtual HighFive::File openFile(const std::string& path) const = 0;
};
 
class SONATA_API Hdf5Reader
{
  public:
    // The issue here is that on a mac `size_t` is different from
    // `{,u}int{8,16,32,64}_t` but not on the other two OSes.
    using supported_1D_types = std::tuple<uint8_t,
                                          uint16_t,
                                          uint32_t,
                                          uint64_t,
                                          int8_t,
                                          int16_t,
                                          int32_t,
                                          int64_t,
                                          float,
                                          double,
#ifdef __APPLE__
                                          size_t,
#endif
                                          std::string>;
 
    using supported_2D_types = std::tuple<std::array<uint64_t, 2>>;
 
    Hdf5Reader();
 
    Hdf5Reader(std::shared_ptr<Hdf5PluginInterface<supported_1D_types, supported_2D_types>> impl);
 
    template <class T>
    std::vector<T> readSelection(const HighFive::DataSet& dset, const Selection& selection) const {
        return static_cast<const Hdf5PluginRead1DInterface<T>&>(*impl).readSelection(dset,
                                                                                     selection);
    }
 
    HighFive::File openFile(const std::string& filename) const;
 
    template <class T>
    std::vector<T> readSelection(const HighFive::DataSet& dset,
                                 const Selection& xsel,
                                 const Selection& ysel) const {
        return static_cast<const Hdf5PluginRead2DInterface<T>&>(*impl).readSelection(dset,
                                                                                     xsel,
                                                                                     ysel);
    }
 
  private:
    std::shared_ptr<Hdf5PluginInterface<supported_1D_types, supported_2D_types>> impl;
};
 
}  // namespace sonata
}  // namespace bbp