Array3D.h

Go to the documentation of this file.

#ifndef ARRAY_3D_H
#define ARRAY_3D_H
 
#include "Element.h"
#include "Array.h"
 
namespace bridges {
    namespace datastructure {
        template <typename E>
        class Array3D : public Array<E> {
            private:
                int num_slices, num_rows, num_cols;
 
                //preventing the creation of blank array3d
                Array3D() {
                    num_slices = num_rows = num_cols = 0;
                }
            public:
 
                virtual ~Array3D() {
                }
 
                Array3D(int slices, int rows, int columns)
                    : num_slices(slices), num_rows(rows), num_cols(columns) {
                    int dim[] = {slices, rows, columns};
                    this->setSize(3, dim);
                }
                int getNumRows () {
                    return num_rows;
                }
                int getNumColumns () {
                    return num_cols;
                }
                int getNumSlices () {
                    return num_slices;
                }
 
                Element<E>& getElement(int slice, int row, int col) {
                    return Array<E>::getElement(slice * num_cols * num_rows + row * num_cols + col);
                }
 
                Element<E> const & getElement(int slice, int row, int col) const {
                    return Array<E>::getElement(slice * num_cols * num_rows + row * num_rows + col);
                }
 
                void setElement(int slice, int row, int col, Element<E> el) {
                    setElement(slice * num_rows * num_cols + row * num_cols + col, el);
                }
 
                struct Bracket_helper2 {
                    Array3D<E>& arr;
                    int x;
                    int y;
                    Bracket_helper2(Array3D<E>& a, int x, int y) : arr(a), x(x), y(y) {}
 
                    E& operator[] (int z) {
                        return arr.getElement(x, y, z).getValue();
                    }
                };
 
                struct Bracket_helper {
                    Array3D<E>& arr;
                    int x;
                    Bracket_helper(Array3D<E>& a, int x) : arr(a), x(x) {}
 
                    Bracket_helper2 operator[] (int y) {
                        return Bracket_helper2(arr, x, y);
                    }
                };
 
                Bracket_helper operator[] (int index) {
                    return Bracket_helper(*this, index);
                }
 
                struct Bracket_helper2_const {
                    Array3D<E> const & arr;
                    int x;
                    int y;
                    Bracket_helper2_const(Array3D<E>& a, int x, int y) : arr(a), x(x), y(y) {}
 
                    E const & operator[] (int z) const {
                        return arr.getElement(x, y, z).getValue();
                    }
                };
 
                struct Bracket_helper_const {
                    Array3D<E> const& arr;
                    int x;
                    Bracket_helper_const(Array3D<E>& a, int x) : arr(a), x(x) {}
 
                    Bracket_helper2_const operator[] (int y) const {
                        return Bracket_helper2(arr, x, y);
                    }
                };
 
                Bracket_helper_const operator[] (int index) const {
                    return Bracket_helper_const(*this, index);
                }
 
        }; // Array3D
    }
}// end namespace bridges
 
#endif