DCDataSet.hpp

#ifndef DCDATASET_HPP
#define DCDATASET_HPP

#include <stdint.h>
#include <string>
#include <hdf5.h>

#include "splash/DCException.hpp"
#include "splash/Dimensions.hpp"
#include "splash/Selection.hpp"
#include "splash/CollectionType.hpp"
#include "splash/basetypes/ColTypeDim.hpp"

namespace splash
{
    enum DCDataType
    {
        DCDT_UNKNOWN,
        DCDT_FLOAT32,
        DCDT_FLOAT64,
        DCDT_INT32,
        DCDT_INT64,
        DCDT_UINT32,
        DCDT_UINT64
    };

    class DCDataSet
    {
    public:
        DCDataSet(const std::string name);

        virtual ~DCDataSet();

        bool open(hid_t group) throw (DCException);

        void close() throw (DCException);

        void create(const CollectionType& colType, hid_t group, const Dimensions size,
                uint32_t ndims, bool compression, bool extensible) throw (DCException);

        void createReference(hid_t refGroup, hid_t srcGroup, DCDataSet &srcDataSet)
        throw (DCException);

        void createReference(hid_t refGroup, hid_t srcGroup, DCDataSet &srcDataSet,
                Dimensions count,
                Dimensions offset,
                Dimensions stride) throw (DCException);

        void write(Selection srcSelect, Dimensions dstOffset, const void* data) throw (DCException);

        void read(Dimensions dstBuffer,
                Dimensions dstOffset,
                Dimensions &sizeRead,
                uint32_t& srcNDims,
                void* dst) throw (DCException);

        void read(Dimensions dstBuffer,
                Dimensions dstOffset,
                Dimensions srcSize,
                Dimensions srcOffset,
                Dimensions& sizeRead,
                uint32_t& srcNDims,
                void* dst) throw (DCException);

        void append(size_t count,
                size_t offset,
                size_t stride,
                const void* data) throw (DCException);

        size_t getNDims();

        hid_t getDataSpace() throw (DCException);

        Dimensions getSize() const;

        DCDataType getDCDataType() throw (DCException);


        size_t getDataTypeSize() throw (DCException);

        std::string getName();

        static void splitPath(const std::string fullName, std::string &path, std::string &name);

        static void getFullDataPath(const std::string fullUserName, const std::string pathBase,
                uint32_t id, std::string &path, std::string &name);

    protected:
        void setChunking(size_t typeSize) throw (DCException);
        void setCompression() throw (DCException);

        Dimensions& getLogicalSize();
        Dimensions getPhysicalSize();

        hid_t dataset;
        hid_t datatype;
        hid_t dataspace;
        hdset_reg_ref_t regionRef;
        Dimensions logicalSize;
        size_t ndims;
        std::string name;
        bool opened;
        bool isReference;
        bool checkExistence;

        // property lists
        hid_t dsetProperties;
        hid_t dsetWriteProperties;
        hid_t dsetReadProperties;

        bool compression;
    private:
        std::string getExceptionString(std::string msg);

        ColTypeDim dimType;
    };
}

#endif /* DCDATASET_HPP */