HDFDatabase.h

 
// Description: The concrete database implementation using HDF5.
 
#ifndef included_HDFDatabase_h
#define included_HDFDatabase_h
 
#include "Database.h"
#include "Utilities.h"
#include "hdf5.h"
#include <string>
 
namespace CAROM {
 
class HDFDatabase : public Database
{
public:
    HDFDatabase();
 
    virtual
    ~HDFDatabase();
 
    virtual
    bool
    create(
        const std::string& file_name,
        const MPI_Comm comm=MPI_COMM_NULL) override;
 
    virtual
    bool
    open(
        const std::string& file_name,
        const std::string& type,
        const MPI_Comm comm=MPI_COMM_NULL) override;
 
    virtual
    bool
    close();
 
    virtual
    void
    putIntegerArray(
        const std::string& key,
        const int* const data,
        int nelements,
        const bool distributed=false);
 
    virtual
    void
    putDoubleArray(
        const std::string& key,
        const double* const data,
        int nelements,
        const bool distributed=false);
 
    virtual
    void
    putDoubleVector(
        const std::string& key,
        const std::vector<double>& data,
        int nelements,
        const bool distributed=false);
 
    virtual
    void
    getIntegerArray(
        const std::string& key,
        int* data,
        int nelements,
        const bool distributed=false);
 
    virtual
    int
    getDoubleArraySize(const std::string& key);
 
    virtual
    void
    getDoubleArray(
        const std::string& key,
        double* data,
        int nelements,
        const bool distributed=false);
 
    virtual
    void
    getDoubleArray(
        const std::string& key,
        double* data,
        int nelements,
        const std::vector<int>& idx,
        const bool distributed=false);
 
    virtual
    void
    getDoubleArray(
        const std::string& key,
        double* data,
        int nelements,
        int offset,
        int block_size,
        int stride,
        const bool distributed=false);
 
protected:
 
    bool
    isInteger(
        const std::string& key);
 
    bool
    isDouble(
        const std::string& key);
 
    virtual
    void
    writeAttribute(
        int type_key,
        hid_t dataset_id);
 
    int
    readAttribute(
        hid_t dataset_id);
 
    bool d_is_file;
 
    hid_t d_file_id;
 
    hid_t d_group_id;
 
    static const int KEY_DOUBLE_ARRAY;
 
    static const int KEY_INT_ARRAY;
 
    int d_rank;
 
private:
    HDFDatabase(
        const HDFDatabase& other);
 
    HDFDatabase&
    operator = (
        const HDFDatabase& rhs);
};
 
}
 
#endif