Dimensions.hpp

#ifndef DIMENSIONS_HPP
#define DIMENSIONS_HPP

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

#define DSP_DIM_MAX 3

namespace splash
{

    class Dimensions
    {
    private:
        hsize_t s[DSP_DIM_MAX];
    public:

        Dimensions(void)
        {
            set(1, 1, 1);
        }

        Dimensions(hsize_t x, hsize_t y, hsize_t z)
        {
            set(x, y, z);
        }

        hsize_t & operator[](const hsize_t t)
        {
            return s[t];
        }

        const hsize_t & operator[](const hsize_t t) const
        {
            return s[t];
        }

        Dimensions operator+(Dimensions const& other) const
        {
            return Dimensions(s[0] + other[0], s[1] + other[1], s[2] + other[2]);
        }

        Dimensions operator-(Dimensions const& other) const
        {
            return Dimensions(s[0] - other[0], s[1] - other[1], s[2] - other[2]);
        }

        Dimensions operator*(Dimensions const& other) const
        {
            return Dimensions(s[0] * other[0], s[1] * other[1], s[2] * other[2]);
        }

        Dimensions operator/(Dimensions const& other) const
        {
            return Dimensions(s[0] / other[0], s[1] / other[1], s[2] / other[2]);
        }

        Dimensions operator+=(Dimensions const& rhs)
        {
            *this = *this + rhs;
            return *this;
        }

        Dimensions operator-=(Dimensions const& rhs)
        {
            *this = *this - rhs;
            return *this;
        }

        bool operator==(Dimensions const& other) const
        {
            return s[0] == other[0] && s[1] == other[1] && s[2] == other[2];
        }

        bool operator!=(Dimensions const& other) const
        {
            return !(*this == other);
        }

        std::string toString() const
        {
            std::stringstream stream;
            stream << "(" << s[0] << "," << s[1] << "," << s[2] << ")";
            return stream.str();
        }

        inline hsize_t *getPointer()
        {
            return s;
        }

        inline const hsize_t *getPointer() const
        {
            return s;
        }

        inline static size_t getSize()
        {
            return DSP_DIM_MAX * sizeof (hsize_t);
        }

        inline size_t getScalarSize() const
        {
            return s[0] * s[1] * s[2];
        }

        inline void set(hsize_t x, hsize_t y, hsize_t z)
        {
            s[0] = x;
            s[1] = y;
            s[2] = z;
        }

        inline void set(const Dimensions d)
        {
            s[0] = d[0];
            s[1] = d[1];
            s[2] = d[2];
        }

        inline uint32_t getDims(void) const
        {
            uint32_t dims = DSP_DIM_MAX;
            if (s[2] == 1)
            {
                dims = 2;
                if (s[1] == 1)
                    dims = 1;
            }

            return dims;
        }

        void swapDims(uint32_t dims)
        {
            hsize_t tmp1 = s[0];
            hsize_t tmp2[DSP_DIM_MAX] = {s[2], s[1], s[0]};

            switch (dims)
            {
                case 2:
                    s[0] = s[1];
                    s[1] = tmp1;
                    break;
                case 3:
                    for (uint32_t i = 0; i < 3; i++)
                        s[i] = tmp2[i];
                    break;
                default:
                    return;
            }
        }

    };

}

#endif /* DIMENSIONS_HPP */