SerialDataCollector.hpp

#ifndef SERIALDATACOLLECTOR_H
#define SERIALDATACOLLECTOR_H

#include <hdf5.h>
#include <sstream>
#include <iostream>

#include "splash/DataCollector.hpp"
#include "splash/DCException.hpp"
#include "splash/core/HandleMgr.hpp"
#include "splash/sdc_defines.hpp"

namespace splash
{

    class DCGroup;

    class SerialDataCollector : public DataCollector
    {
    private:
        void setFileAccessParams(hid_t& fileAccProperties);

        bool fileExists(std::string filename);

        std::string getFullFilename(const Dimensions mpiPos, std::string baseFilename,
                bool isFullNameAllowed) const throw (DCException);

        std::string getExceptionString(std::string func, std::string msg, const char *info = NULL);

        static herr_t visitObjCallback(hid_t o_id, const char *name,
                const H5O_info_t *object_info, void *op_data);

        void openCustomGroup(DCGroup& group, Dimensions *mpiPosition = NULL) throw (DCException);
        hid_t openGroup(DCGroup& group, int32_t id, const char* name,
                Dimensions *mpiPosition = NULL) throw (DCException);

    protected:

        enum FileStatusType
        {
            FST_CLOSED, FST_WRITING, FST_READING, FST_CREATING, FST_MERGING
        };

        // internal HDF5 file handles
        HandleMgr handles;

        // property list for HDF5 file access
        hid_t fileAccProperties;

        // current file access type
        FileStatusType fileStatus;

        // id for last written iteration
        int32_t maxID;

        // the MPI topology for a distributed file
        Dimensions mpiTopology;

        // enable data compression
        bool enableCompression;

        void openCreate(const char *filename,
                FileCreationAttr &attr) throw (DCException);

        void openRead(const char *filename,
                FileCreationAttr &attr) throw (DCException);

        void openWrite(const char *filename,
                FileCreationAttr &attr) throw (DCException);

        void openMerge(const char *filename) throw (DCException);

        void readMerged(int32_t id,
                const CollectionType& type,
                const char* name,
                Dimensions dstBuffer,
                Dimensions dstOffset,
                Dimensions& srcBuffer,
                void* data) throw (DCException);

        size_t getNDims(H5Handle h5File,
                int32_t id,
                const char* name);

        void readCompleteDataSet(H5Handle h5File,
                int32_t id,
                const char* name,
                const Dimensions dstBuffer,
                const Dimensions dstOffset,
                const Dimensions srcOffset,
                Dimensions &sizeRead,
                uint32_t& srcDims,
                void* dst)
        throw (DCException);

        void readDataSet(H5Handle h5File,
                int32_t id,
                const char* name,
                const Dimensions dstBuffer,
                const Dimensions dstOffset,
                const Dimensions srcSize,
                const Dimensions srcOffset,
                Dimensions& sizeRead,
                uint32_t& srcDims,
                void* dst) throw (DCException);

        CollectionType* readDataSetMeta(H5Handle h5File,
                int32_t id,
                const char* name,
                const Dimensions dstBuffer,
                const Dimensions dstOffset,
                const Dimensions srcOffset,
                Dimensions &sizeRead,
                uint32_t& srcDims) throw (DCException);

        void readSizeInternal(H5Handle h5File,
                int32_t id,
                const char* name,
                Dimensions &sizeRead) throw (DCException);

        void writeDataSet(
                hid_t group,
                const CollectionType& datatype,
                uint32_t ndims,
                const Selection select,
                const char* name,
                const void* data) throw (DCException);

        void appendDataSet(
                hid_t group,
                const CollectionType& datatype,
                size_t count,
                size_t offset,
                size_t stride,
                const char *name,
                const void *data) throw (DCException);

        hid_t openDatasetHandle(int32_t id,
                const char *dsetName,
                Dimensions *mpiPosition = NULL) throw (DCException);

        void closeDatasetHandle(hid_t handle) throw (DCException);
    public:

        SerialDataCollector(uint32_t maxFileHandles);

        virtual ~SerialDataCollector();

        void open(const char *filename,
                FileCreationAttr& attr) throw (DCException);

        void close();

        int32_t getMaxID();

        void getMPISize(Dimensions& mpiSize);

        void getEntryIDs(int32_t *ids, size_t *count) throw (DCException);

        void getEntriesForID(int32_t id, DCEntry *entries, size_t *count) throw (DCException);

        void write(int32_t id,
                const CollectionType& type,
                uint32_t ndims,
                const Selection select,
                const char* name,
                const void* data) throw (DCException);

        void append(int32_t id,
                const CollectionType& type,
                size_t count,
                const char *name,
                const void *data) throw (DCException);

        void append(int32_t id,
                const CollectionType& type,
                size_t count,
                size_t offset,
                size_t striding,
                const char *name,
                const void *data) throw (DCException);

        void remove(int32_t id) throw (DCException);

        void remove(int32_t id,
                const char *name) throw (DCException);

        void createReference(int32_t srcID,
                const char *srcName,
                int32_t dstID,
                const char *dstName) throw (DCException);

        void createReference(int32_t srcID,
                const char *srcName,
                int32_t dstID,
                const char *dstName,
                Dimensions count,
                Dimensions offset,
                Dimensions stride) throw (DCException);

        AttributeInfo readGlobalAttributeInfo(
                int32_t id,
                const char *name,
                Dimensions *mpiPosition = NULL) throw (DCException);

        SPLASH_DEPRECATED("Use safer readGlobalAttributeInfo")
        void readGlobalAttribute(
                const char *name,
                void* data,
                Dimensions *mpiPosition = NULL) throw (DCException);

        void writeGlobalAttribute(const CollectionType& type,
                const char *name,
                const void* data) throw (DCException);

        void writeGlobalAttribute(const CollectionType& type,
                const char *name,
                uint32_t ndims,
                const Dimensions dims,
                const void* data) throw (DCException);

        AttributeInfo readAttributeInfo(int32_t id,
                const char *dataName,
                const char *attrName,
                Dimensions *mpiPosition = NULL) throw (DCException);

        SPLASH_DEPRECATED("Use safer readAttributeInfo")
        void readAttribute(int32_t id,
                const char *dataName,
                const char *attrName,
                void *data,
                Dimensions *mpiPosition = NULL) throw (DCException);

        void writeAttribute(int32_t id,
                const CollectionType& type,
                const char *dataName,
                const char *attrName,
                const void *data) throw (DCException);

        void writeAttribute(int32_t id,
                const CollectionType& type,
                const char *dataName,
                const char *attrName,
                uint32_t ndims,
                const Dimensions dims,
                const void *data) throw (DCException);

        void read(int32_t id,
                const char* name,
                Dimensions &sizeRead,
                void* data) throw (DCException);

        void read(int32_t id,
                const char* name,
                const Dimensions dstBuffer,
                const Dimensions dstOffset,
                Dimensions &sizeRead,
                void* data) throw (DCException);

        CollectionType* readMeta(int32_t id,
                const char* name,
                const Dimensions dstBuffer,
                const Dimensions dstOffset,
                Dimensions &sizeRead) throw (DCException);
    };

} // namespace DataCollector

#endif  /* SERIALDATACOLLECTOR_H */