HDF5IO.hpp

Go to the documentation of this file.

#pragma once
 
#include <iostream>
#include <memory>
#include <string>
 
#include <H5Opublic.h>
 
#include "Types.hpp"
#include "io/BaseIO.hpp"
#include "io/ReadIO.hpp"
 
namespace H5
{
class DataSet;
class Attribute;
class H5File;
class DataType;
class Exception;
class CommonFG;
class PredType;
class DataSpace;
}  // namespace H5

namespace AQNWB::IO::HDF5
{
 
class HDF5RecordingData;  // forward declaration

class HDF5IO : public BaseIO
{
public:
  explicit HDF5IO(const std::string& fileName);

  ~HDF5IO() override;

  Status open() override;

  Status open(FileMode mode) override;

  Status close() override;

  Status flush() override;

  StorageObjectType getStorageObjectType(std::string path) const override;

  AQNWB::IO::DataBlockGeneric readDataset(const std::string& dataPath,
                                          const SizeArray& start = {},
                                          const SizeArray& count = {},
                                          const SizeArray& stride = {},
                                          const SizeArray& block = {}) override;

  AQNWB::IO::DataBlockGeneric readAttribute(
      const std::string& dataPath) const override;

  std::string readReferenceAttribute(
      const std::string& dataPath) const override;

  Status createAttribute(const IO::BaseDataType& type,
                         const void* data,
                         const std::string& path,
                         const std::string& name,
                         const SizeType& size = 1) override;

  Status createAttribute(const std::string& data,
                         const std::string& path,
                         const std::string& name,
                         const bool overwrite = false) override;

  Status createAttribute(const std::vector<std::string>& data,
                         const std::string& path,
                         const std::string& name,
                         const bool overwrite = false) override;

  Status createReferenceAttribute(const std::string& referencePath,
                                  const std::string& path,
                                  const std::string& name) override;

  Status createGroup(const std::string& path) override;

  Status createLink(const std::string& path,
                    const std::string& reference) override;

  Status createStringDataSet(const std::string& path,
                             const std::string& value) override;

  Status createStringDataSet(const std::string& path,
                             const std::vector<std::string>& values) override;

  Status createReferenceDataSet(
      const std::string& path,
      const std::vector<std::string>& references) override;

  Status startRecording() override;

  Status startRecording(bool disableSWMRMode);

  Status stopRecording() override;

  bool canModifyObjects() override;

  std::unique_ptr<IO::BaseRecordingData> createArrayDataSet(
      const IO::BaseArrayDataSetConfig& config,
      const std::string& path) override;

  std::shared_ptr<IO::BaseRecordingData> getDataSet(
      const std::string& path) override;

  SizeArray getStorageObjectShape(const std::string& path) const override;

  SizeArray getStorageObjectChunking(const std::string& path) const override;

  BaseDataType getStorageObjectDataType(const std::string& path) const override;

  bool objectExists(const std::string& path) const override;

  bool attributeExists(const std::string& path) const override;

  virtual std::vector<std::pair<std::string, StorageObjectType>>
  getStorageObjects(const std::string& path,
                    const StorageObjectType& objectType =
                        StorageObjectType::Undefined) const override;

  H5O_type_t getH5ObjectType(const std::string& path) const;

  static H5::DataType getNativeType(IO::BaseDataType type);

  static IO::BaseDataType getBaseDataType(const H5::DataType& nativeType);

  static H5::DataType getH5Type(IO::BaseDataType type);
 
protected:
  Status createGroupIfDoesNotExist(const std::string& path) override;
 
private:
  template<typename T, typename HDF5TYPE>
  std::vector<T> readDataHelper(const HDF5TYPE& dataSource,
                                size_t numElements,
                                const H5::DataSpace& memspace,
                                const H5::DataSpace& dataspace) const;

  template<typename T, typename HDF5TYPE>
  std::vector<T> readDataHelper(const HDF5TYPE& dataSource,
                                size_t numElements) const;

  template<typename HDF5TYPE>
  std::vector<std::string> readStringDataHelper(
      const HDF5TYPE& dataSource,
      size_t numElements,
      const H5::DataSpace& memspace,
      const H5::DataSpace& dataspace) const;

  template<typename HDF5TYPE>
  std::vector<std::string> readStringDataHelper(const HDF5TYPE& dataSource,
                                                size_t numElements) const;
 
  std::unique_ptr<H5::Attribute> getAttribute(const std::string& path) const;

  Status closeFileImpl();

  std::unique_ptr<H5::H5File> m_file;

  bool m_disableSWMRMode;
};
 
}  // namespace AQNWB::IO::HDF5