HDF_fwd.hpp

Go to the documentation of this file.

#ifndef MEDUSA_BITS_IO_HDF_FWD_HPP_
#define MEDUSA_BITS_IO_HDF_FWD_HPP_
 
#include <medusa/Config.hpp>
#include <medusa/bits/utils/print.hpp>
#include <hdf5.h>
#include <string>
#include <vector>
#include <fstream>
#include <ostream>
#include <type_traits>
 
namespace Eigen {
template <typename Derived>
class MatrixBase;
 
template<typename _Scalar, int _Rows, int _Cols, int _Options, int _MaxRows, int _MaxCols>
class Matrix;
}
 
template <template <typename...> class base, typename derived>
struct is_base_of_template_impl {
    template<typename... Ts>
    static constexpr std::true_type  test(const base<Ts...> *);
    static constexpr std::false_type test(...);
    using type = decltype(test(std::declval<derived*>()));
};
 
template <template <typename...> class base, typename derived>
using is_base_of_template = typename is_base_of_template_impl<base, derived>::type;
 
namespace mm {
 
class HDF {
    std::string filename_;  
    std::string group_name_;  
 
    hid_t file;  
    hid_t group;  
 
  public:
    enum Mode : unsigned {
        APPEND = 256,  
        DESTROY = 128,  
        READONLY = 64   
    };
  private:
    static std::string str(Mode mode);
 
  public:
    HDF() : filename_(), group_name_(), file(-1), group(-1) {}
    explicit HDF(std::string filename, Mode mode = APPEND) :
            filename_(std::move(filename)), group_name_("/"), file(-1), group(-1) {
        file = openFileHelper(filename_, mode);
        group = H5Gopen(file, "/", H5P_DEFAULT);
    }
    ~HDF() { close(); }
 
  private:
    static hid_t openFileHelper(const std::string& filename, Mode mode);
 
  public:
    void open(const std::string& filename, const std::string& group_name = "/",
              Mode mode = APPEND) {
        openFile(filename, mode);
        openGroup(group_name);
    }
 
    void openFile(const std::string& filename, Mode mode = APPEND) {
        closeFile();
        filename_ = filename;
        file = openFileHelper(filename, mode);
    }
 
    void reopenFile(Mode mode = APPEND) { openFile(filename_, mode); }
 
    void openGroup(std::string group_name);
    void reopenGroup() {
        if (!H5Iis_valid(group)) { openGroup(group_name_); }
    }
    void reopen(Mode mode = APPEND) { reopenFile(mode); reopenGroup(); }
    bool isFileOpen() const { return H5Iis_valid(file) != 0; }
    bool isGroupOpen() const { return H5Iis_valid(group) != 0; }
    void flush() const;
    void closeGroup() const;
    void closeFile() const;
    void close() const { closeFile(); }
    const std::string& filename() const { return filename_; }
    const std::string& fileName() const { return filename(); }
    void setFilename(const std::string& filename) { closeFile(); filename_ = filename; }
    void setFileName(const std::string& filename) { setFilename(filename); }
    const std::string& groupName() const { return group_name_; }
    void setGroupName(const std::string& group_name);
 
    template <class T>
    T readAttribute(const std::string& attr_name) const;
 
    template <class T>
    void writeAttribute(const std::string& attr_name, const T& value, const hid_t& type,
                        bool overwrite = false) const;
 
    template <typename T>
    std::pair<std::vector<hsize_t>, std::vector<T>>
    readLinearArray(const std::string& dataset_name) const;
 
    template<typename T>
    std::vector<T> read1DArray(const std::string& dataset_name) const;
 
    template<typename T>
    std::vector<std::vector<T>> read2DArray(const std::string& dataset_name) const;
 
    template<typename T>
    std::vector<std::vector<std::vector<T>>> read3DArray(const std::string& dataset_name) const;
 
    template<int dim, typename T>
    void writeLinearArray(const std::string& dataset_name, const T* value,
                          const std::array<hsize_t, dim>& sizes, hid_t type, bool overwrite) const;
 
    template<typename T, typename array_t>
    void write1DArray(const std::string& dataset_name, const array_t& value,
                      hid_t type, bool overwrite) const;
 
    template<typename T, class array_t>
    void write2DArray(const std::string& dataset_name, const array_t& value, hid_t type,
                      bool overwrite) const {
        write2DArray<T>(dataset_name, value, type, overwrite,
                        is_base_of_template<Eigen::MatrixBase, array_t>());
    }
 
  private:
    template<typename T, class array_t>
    void write2DArray(const std::string&, const array_t&, hid_t, bool, std::false_type) const;
 
    template<typename T, class array_t>
    void write2DArray(const std::string&, const array_t&, hid_t, bool, std::true_type) const {
        static_assert(!std::is_same<T, T>::value,
                "This function produces wrong results for Eigen matrices. Use writeEigen instead.");
    }
 
  public:
    template<typename T, class array_t>
    void write3DArray(const std::string& dataset_name, const array_t& value, hid_t type,
                      bool overwrite) const;
 
    int readIntAttribute(const std::string& attr_name) const;
    bool readBoolAttribute(const std::string& attr_name) const;
    double readDoubleAttribute(const std::string& attr_name) const;
    float readFloatAttribute(const std::string& attr_name) const;
    std::string readStringAttribute(const std::string& attr_name) const;
    std::string readNullTerminatedStringAttribute(const std::string& attr_name) const;
 
    void writeIntAttribute(const std::string& attr_name, int value, bool overwrite = false) const;
    void writeBoolAttribute(const std::string& attr_name, bool value, bool overwrite = false) const;
    void writeDoubleAttribute(const std::string& attr_name, double value,
                              bool overwrite = false) const;
    void writeFloatAttribute(const std::string& attr_name, float value,
                             bool overwrite = false) const;
    void writeStringAttribute(const std::string& attr_name, const std::string& value,
                              bool overwrite = false) const;
 
    std::vector<int> readIntArray(const std::string& dataset_name) const;
    std::vector<double> readDoubleArray(const std::string& dataset_name) const;
    std::vector<float> readFloatArray(const std::string& dataset_name) const;
 
    template <typename array_t>
    void writeIntArray(const std::string& dataset_name, const array_t& value,
                       bool overwrite = false) const;
    template <typename array_t>
    void writeDoubleArray(const std::string& dataset_name, const array_t& value,
                          bool overwrite = false) const;
    template <typename array_t>
    void writeFloatArray(const std::string& dataset_name, const array_t& value,
                         bool overwrite = false) const;
 
    std::vector<std::vector<int>> readInt2DArray(const std::string& dataset_name) const;
    std::vector<std::vector<double>> readDouble2DArray(const std::string& dataset_name) const;
    std::vector<std::vector<float>> readFloat2DArray(const std::string& dataset_name) const;
 
    template <typename array_t>
    void writeInt2DArray(const std::string& dataset_name, const array_t& value,
                         bool overwrite = false) const;
    template <typename array_t>
    void writeDouble2DArray(const std::string& dataset_name, const array_t& value,
                            bool overwrite = false) const;
    template <typename array_t>
    void writeFloat2DArray(const std::string& dataset_name, const array_t& value,
                           bool overwrite = false) const;
 
    std::vector<std::vector<std::vector<int>>> readInt3DArray(
            const std::string& dataset_name) const;
    std::vector<std::vector<std::vector<double>>> readDouble3DArray(
            const std::string& dataset_name) const;
    std::vector<std::vector<std::vector<float>>> readFloat3DArray(
            const std::string& dataset_name) const;
 
    template <typename array_t>
    void writeInt3DArray(const std::string& dataset_name, const array_t& value,
                         bool overwrite = false) const;
    template <typename array_t>
    void writeDouble3DArray(const std::string& dataset_name, const array_t& value,
                            bool overwrite = false) const;
    template <typename array_t>
    void writeFloat3DArray(const std::string& dataset_name, const array_t& value,
                           bool overwrite = false) const;
 
    template <typename scalar_t = double>
    Eigen::Matrix<scalar_t, -1, -1, 0, -1, -1> readEigen(const std::string& dataset_name) const;
 
    template <typename Derived>
    void writeEigen(const std::string& dataset_name, const Eigen::MatrixBase<Derived>& value,
                    bool overwrite = false) const;
 
    template <typename SparseMatrixType>
    void writeSparseMatrix(const std::string& name, SparseMatrixType& matrix, bool one_based = true,
                           bool overwrite = false);
 
    template <typename domain_t>
    void writeDomain(const std::string& name, const domain_t& domain, bool overwrite = false);
 
    template <typename timer_t>
    void writeTimer(const std::string& name, const timer_t& timer, bool overwrite = false);
 
    template <typename conf_t>
    void writeXML(const std::string& name, const conf_t& conf, bool overwrite = false);
 
    HDF atomic() const;
 
    hid_t getFileID() const { return file; }
    hid_t getGroupID() const { return group; }
 
  private:
    static herr_t memberIterateCallback(hid_t loc_id, const char* name,
                                        const H5L_info_t*, void* data);
 
  public:
    struct Members {
        std::vector<std::string> groups,  
                datasets,  
                datatypes,  
                unknowns;  
 
        friend std::ostream& operator<<(std::ostream& os, const Members& members) {
            os << "groups: " << members.groups << "\ndatasets: " << members.datasets
               << "\ndatatypes: " << members.datatypes << "\nunknowns: " << members.unknowns;
            return os;
        }
    };
 
    Members members() const;
 
    std::vector<std::string> groups() const { return members().groups; }
 
    std::vector<std::string> datasets() const { return members().datasets; }
 
    friend std::ostream& operator<<(std::ostream& os, const HDF& hdf) {
        os << "HDF reader for file '" << hdf.filename()
           << "' with current group '" << hdf.groupName() << "'. ";
        os << "The file is " << (hdf.isFileOpen() ? "open" : "closed")
           << " and the group is " << (hdf.isGroupOpen() ? "open" : "closed") << '.';
        return os;
    }
};
 
}  // namespace mm
 
#endif  // MEDUSA_BITS_IO_HDF_FWD_HPP_