Packed3DArray.h

Go to the documentation of this file.

#ifndef PACKED3DARRAY_H
#define PACKED3DARRAY_H

#include <iostream>

namespace cryph
{

template <typename T>
class Packed3DArray
{
public:
    Packed3DArray(int dim1=2, int dim2=2, int dim3=2, const T* initBuf=nullptr);

    Packed3DArray(const Packed3DArray<T>& t3da);

    virtual ~Packed3DArray();

    const T* getData() const { return mData; }

    T getDataElement(int i1, int i2, int i3) const;

    const T* getDataElementLoc(int i1, int i2, int i3) const;

    int getDim1() const { return mDim1; }

    int getDim2() const { return mDim2; }

    int getDim3() const { return mDim3; }

    T* getModifiableData() { return mData; }

    int getTotalNumberElements() const { return mDim1 * mDim2 * mDim3; }

    void setDataElement(int i1, int i2, int i3, const T& elem);

    static void setErrorReporting(bool r) { sReportErrors = r; }

    static void setOutOfBoundsValue(T defaultValue) { sOutOfBoundsValue = defaultValue; }

private:

    void copyDataFrom(const T* from);
    int     getOffset(const char* routine, int i1, int i2, int i3) const;

    T*      mData;
    int     mDim1;
    int     mDim2;
    int     mDim3;

    static  bool    sReportErrors;
    static  T       sOutOfBoundsValue;
};

template <typename T>
bool    Packed3DArray<T>::sReportErrors = true;

template <typename T>
T       Packed3DArray<T>::sOutOfBoundsValue;

template <typename T>
Packed3DArray<T>::Packed3DArray(int dim1, int dim2, int dim3, const T* initBuf) :
        mData(nullptr), mDim1(dim1), mDim2(dim2), mDim3(dim3)
{
    if ( (dim1 < 1) || (dim2 < 1) || (dim3 < 1) )
    {
        mDim1 = 0; mDim2 = 0; mDim3 = 0;
        if (Packed3DArray<T>::sReportErrors)
            std::cerr << "Invalid dimensions in constructor: ("
                 << dim1 << ", " << dim2 << ", " << dim3 << ')' << std::endl;
    }
    else
    {
        mData = new T[dim1*dim2*dim3];
        if (initBuf != nullptr)
            copyDataFrom(initBuf);
    }
}

template <typename T>
Packed3DArray<T>::Packed3DArray(const Packed3DArray<T>& t3da) :
        mData(nullptr), mDim1(t3da.mDim1), mDim2(t3da.mDim2), mDim3(t3da.mDim3)
{
    mData = new T[mDim1 * mDim2 * mDim3];
    copyDataFrom(t3da.mData);
}

template <typename T>
Packed3DArray<T>::~Packed3DArray()
{
    if (mData != nullptr)
    {
        delete [] mData;
        mData = nullptr;
        mDim1 = 0;
        mDim2 = 0;
        mDim3 = 0;
    }
}

template <typename T>
std::ostream& operator<<(std::ostream& os, const Packed3DArray<T>& t3da)
{
    int size = t3da.getTotalNumberElements();
    const T* Tarr = t3da.getData();
    for (int i=0 ; i<size ; i++)
    {
        // WARNING: Assuming integral type for now, hence cast to integer
        //          first. For example, if "typename T" is GLubyte, this ensures
        //          that full 8-bit ints are written as opposed to general
        //          ASCII chars.
        os << (int)Tarr[i];
        if ((i % 20) == 0)
            os << '\n';
        else
            os << ' ';
    }
    os << '\n';
    return os;
}

template <typename T>
std::istream& operator>>(std::istream& is, Packed3DArray<T>& t3da)
{
    int size = t3da.getTotalNumberElements();
    int temp = 0;
    T* Tarr = t3da.getModifiableData();
    for (int i=0 ; i<size ; i++)
    {
        // WARNING: See 'WARNING' in "operator<<" above.
        is >> temp;
        Tarr[i] = (T)temp;
    }
    return is;
}

template <typename T>
void Packed3DArray<T>::copyDataFrom(const T* from)
{
    int size = mDim1 * mDim2 * mDim3;
    for (int i=0 ; i<size ; i++)
        mData[i] = from[i];
}

template <typename T>
T Packed3DArray<T>::getDataElement(int i1, int i2, int i3) const
{
    int loc = getOffset("getDataElement",i1,i2,i3);
    if (loc < 0)
    {
        return Packed3DArray<T>::sOutOfBoundsValue;
    }
    return mData[loc];
}

template <typename T>
const T* Packed3DArray<T>::getDataElementLoc(int i1, int i2, int i3) const
{
    int loc = getOffset("getDataElementLoc",i1,i2,i3);
    if (loc < 0)
        return nullptr;
    return &mData[loc];
}

template <typename T>
int Packed3DArray<T>::getOffset(const char* routine, int i1, int i2, int i3)
    const
{
    if ( (i1 < 0) || (i1 >= mDim1) ||
         (i2 < 0) || (i2 >= mDim2) ||
         (i3 < 0) || (i3 >= mDim3) )
    {
        if (Packed3DArray<T>::sReportErrors)
            std::cerr << routine << ": Invalid data element reference: ("
                 << i1 << ", " << i2 << ", " << i3 << ')' << std::endl;
        return -1;
    }
    return (i1 * mDim2 * mDim3) + (i2 * mDim3) + i3;
}

template <typename T>
void Packed3DArray<T>::setDataElement(int i1, int i2, int i3, const T& elem)
{
    int loc = getOffset("setDataElement",i1,i2,i3);
    if (loc >= 0)
        mData[loc] = elem;
}

}

#endif