DataContainer.hpp

#ifndef DATACONTAINER_HPP
#define DATACONTAINER_HPP

#include <vector>

#include "splash/DCException.hpp"
#include "splash/Dimensions.hpp"
#include "splash/domains/DomainData.hpp"

namespace splash
{

    class DataContainer
    {
    public:

        DataContainer() :
        offset(0, 0, 0),
        size(1, 1, 1)
        {
        }

        virtual ~DataContainer()
        {
            for (std::vector<DomainData* >::iterator iter = subdomains.begin();
                    iter != subdomains.end(); ++iter)
            {
                if (*iter != NULL)
                    delete (*iter);
            }

            subdomains.clear();
        }

        void add(DomainData* entry)
        {
            if (entry == NULL)
                throw DCException("Entry in DataContainer must not be NULL.");

            if (entry->getData() == NULL)
                throw DCException("Data in entry in DataContainer must not be NULL.");

            const Dimensions &entryOffset = entry->getOffset();
            const Dimensions entryBack = entry->getBack(); // last index INSIDE

            for (uint32_t i = 0; i < DSP_DIM_MAX; ++i)
            {
                if (subdomains.empty())
                    offset[i] = entryOffset[i];
                else
                    offset[i] = std::min(entryOffset[i], offset[i]);
                size[i] = std::max(entryBack[i] + 1 - offset[i], size[i]);
            }

            subdomains.push_back(entry);
        }

        size_t getNumSubdomains()
        {
            return subdomains.size();
        }

        size_t getNumElements()
        {
            size_t num_elements = 0;

            for (std::vector<DomainData* >::const_iterator iter = subdomains.begin();
                    iter != subdomains.end(); ++iter)
            {
                num_elements += (*iter)->getElements().getScalarSize();
            }

            return num_elements;
        }

        Dimensions getSize() const
        {
            return size;
        }

        Dimensions getOffset() const
        {
            return offset;
        }

        Dimensions getBack() const
        {
            return offset + size - Dimensions(1, 1, 1);
        }

        DomainData* getIndex(size_t index)
        {
            if (subdomains.size() > index)
                return subdomains[index];

            throw DCException("Invalid index in DataContainer");
        }

        DomainData* get(size_t x)
        {
            if (x < size[0])
                return subdomains[x];

            throw DCException("Invalid entry in DataContainer (1)");
        }

        DomainData* get(size_t x, size_t y)
        {
            if (x < size[0] && y < size[1])
                return subdomains[y * size[0] + x];

            throw DCException("Invalid entry in DataContainer (2)");
        }

        DomainData* get(size_t x, size_t y, size_t z)
        {
            if (x < size[0] && y < size[1] && z < size[2])
                return subdomains[z * size[0] * size[1] + y * size[0] + x];

            throw DCException("Invalid entry in DataContainer (3)");
        }

        void* getElement(size_t index)
        {
            if (subdomains.size() == 0)
                return NULL;

            size_t elements = 0;

            for (size_t i = 0; i < subdomains.size(); ++i)
            {
                DomainData *subdomain = subdomains[i];
                size_t subdomain_elements = subdomain->getElements().getScalarSize();

                if (elements + subdomain_elements > index)
                {
                    size_t type_size = subdomain->getTypeSize();
                    size_t local_index = index - elements;

                    assert(subdomain->getData() != NULL);
                    if (subdomain->getData() == NULL)
                        return NULL;

                    return (((uint8_t*) (subdomain->getData())) + (type_size * local_index));
                } else
                    elements += subdomain_elements;
            }

            return NULL;
        }

    private:
        std::vector<DomainData* > subdomains;
        Dimensions offset;
        Dimensions size;
    };

}

#endif /* DATACONTAINER_HPP */