DomainData.hpp

#ifndef DOMAINDATA_HPP
#define DOMAINDATA_HPP

#include <sstream>
#include <cassert>
#include <string>
#include <hdf5.h>

#include "splash/Dimensions.hpp"
#include "splash/domains/Domain.hpp"
#include "splash/core/DCDataSet.hpp"

namespace splash
{

    typedef struct
    {
        int dataClass;
        hid_t handle;
        int32_t id;
        std::string name;
        Dimensions dstBuffer;
        Dimensions dstOffset;
        Dimensions srcSize;
        Dimensions srcOffset;
    } DomainH5Ref;

    class DomainData : public Domain
    {
    public:

        DomainData(const Domain& domain_, const Dimensions elements_,
                size_t datatypeSize_, DCDataType datatype_) :
        Domain(domain_),
        elements(elements_),
        data(NULL),
        loadingReference(NULL),
        datatype(datatype_),
        datatypeSize(datatypeSize_)
        {
            data = new uint8_t[datatypeSize * elements.getScalarSize()];
            assert(data != NULL);
        }

        virtual ~DomainData()
        {
            if (loadingReference != NULL)
            {
                delete loadingReference;
                loadingReference = NULL;
            }

            freeData();
        }

        Dimensions &getElements()
        {
            return elements;
        }

        void* getData()
        {
            return data;
        }

        void freeData()
        {
            if (data != NULL)
            {
                delete[] data;
                data = NULL;
            }
        }

        size_t getTypeSize()
        {
            return datatypeSize;
        }

        DCDataType getDataType()
        {
            return datatype;
        }

        void setLoadingReference(int dataClass, hid_t handle, int32_t id,
                const char *name, const Dimensions dstBuffer,
                const Dimensions dstOffset, const Dimensions srcSize,
                const Dimensions srcOffset)
        {
            if (loadingReference != NULL)
            {
                delete loadingReference;
                loadingReference = NULL;
            }

            loadingReference = new DomainH5Ref();
            loadingReference->dataClass = dataClass;
            loadingReference->handle = handle;
            loadingReference->id = id;
            loadingReference->name = name;
            loadingReference->dstBuffer.set(dstBuffer);
            loadingReference->dstOffset.set(dstOffset);
            loadingReference->srcSize.set(srcSize);
            loadingReference->srcOffset.set(srcOffset);
        }

        DomainH5Ref *getLoadingReference()
        {
            return loadingReference;
        }

        std::string getFormatString() throw (DCException)
        {
            std::stringstream format_string;
            format_string << "%";

            switch (datatype)
            {
                case DCDT_FLOAT32:
                case DCDT_FLOAT64:
                    format_string << "f";
                    break;
                case DCDT_UINT32:
                    format_string << "u";
                    break;
                case DCDT_UINT64:
                    format_string << "lu";
                    break;
                case DCDT_INT32:
                    format_string << "d";
                    break;
                case DCDT_INT64:
                    format_string << "ld";
                    break;
                default:
                    throw DCException("cannot identify datatype");
            }

            return format_string.str();
        }

    protected:
        Dimensions elements;
        uint8_t* data;
        DomainH5Ref *loadingReference;

        DCDataType datatype;
        size_t datatypeSize;
    };

}

#endif /* DOMAINDATA_HPP */