Database.h

 
// Description: The abstract database class defines interface for databases.
 
#ifndef included_Database_h
#define included_Database_h
 
#include "Utilities.h"
#include <string>
#include <vector>
#include "mpi.h"
 
namespace CAROM {
 
bool fileExists(const std::string& name);
 
class Database
{
public:
    Database();
 
    virtual
    ~Database();
 
    virtual
    bool
    create(
        const std::string& file_name,
        const MPI_Comm comm=MPI_COMM_NULL);
 
    virtual
    bool
    open(
        const std::string& file_name,
        const std::string& type,
        const MPI_Comm comm=MPI_COMM_NULL);
 
    virtual
    bool
    close() = 0;
 
    void
    putInteger(
        const std::string& key,
        int data)
    {
        putIntegerArray(key, &data, 1);
    }
 
    virtual
    void
    putIntegerArray(
        const std::string& key,
        const int* const data,
        int nelements,
        const bool distributed=false) = 0;
 
    void
    putDouble(
        const std::string& key,
        double data)
    {
        putDoubleArray(key, &data, 1);
    }
 
    virtual
    void
    putDoubleArray(
        const std::string& key,
        const double* const data,
        int nelements,
        const bool distributed=false) = 0;
 
    virtual
    void
    putDoubleVector(
        const std::string& key,
        const std::vector<double>& data,
        int nelements,
        const bool distributed=false) = 0;
 
    void
    getInteger(
        const std::string& key,
        int& data)
    {
        getIntegerArray(key, &data, 1);
    }
 
    virtual
    void
    getIntegerArray(
        const std::string& key,
        int* data,
        int nelements,
        const bool distributed=false) = 0;
 
    void
    getDouble(
        const std::string& key,
        double& data)
    {
        getDoubleArray(key, &data, 1);
    }
 
    virtual
    int
    getDoubleArraySize(const std::string& key) = 0;
 
    virtual
    void
    getDoubleArray(
        const std::string& key,
        double* data,
        int nelements,
        const bool distributed=false) = 0;
 
    virtual
    void
    getDoubleArray(
        const std::string& key,
        double* data,
        int nelements,
        const std::vector<int>& idx,
        const bool distributed=false) = 0;
 
    virtual
    void
    getDoubleArray(
        const std::string& key,
        double* data,
        int nelements,
        int offset,
        int block_size,
        int stride,
        const bool distributed=false) = 0;
 
    enum class formats {
        HDF5,
        CSV,
        HDF5_MPIO
    };
 
private:
    Database(
        const Database& other);
 
    Database&
    operator = (
        const Database& rhs);
};
 
}
 
#endif