index3D.h

Go to the documentation of this file.

#ifndef DLR_NUMERIC_INDEX3D_H
#define DLR_NUMERIC_INDEX3D_H

#include <iostream>
#include <dlrCommon/exception.h>

namespace dlr {

  namespace numeric {
    class Index3D {
    public:

      Index3D()
        : m_column(0), m_row(0), m_slice(0) {}
    

      Index3D(int slice, int row, int column)
        : m_column(column), m_row(row), m_slice(slice) {}


      Index3D(const Index3D& other)
        : m_column(other.m_column), m_row(other.m_row), m_slice(other.m_slice)
        {}


      ~Index3D() {}


      inline void setValue(int slice, int row, int column) {
        m_column = column; m_row = row; m_slice = slice;
      }


      inline int getColumn() const {return m_column;}


      inline int getRow() const {return m_row;}

    
      inline int getSlice() const {return m_slice;}

    
      inline int getU() const {return this->getColumn();}


      inline int getV() const {return this->getRow();}

    
      inline int getW() const {return this->getSlice();}

    
      Index3D& operator=(const Index3D& other) {
        // Self-assignment is OK.
        this->setValue(other.m_slice, other.m_row, other.m_column);
        return *this;
      }


      
      int operator[](size_t index) const {
        switch(index) {
        case 0: return this->getColumn(); break;
        case 1: return this->getRow(); break;
        }
        return this->getSlice();
      }
        

      Index3D& operator*=(int scalar) {
        m_column *= scalar; m_row *= scalar; m_slice *= scalar; return *this;
      }


      Index3D& operator/=(int scalar) {
        if (scalar == 0 ) {
          DLR_THROW(ValueException, "Index3D::operator/=()",
                    "Bad scalar: Divide by Zero\n");
        }
        m_column /= scalar; m_row /= scalar; m_slice /= scalar; return *this;
      }


      Index3D& operator+=(const Index3D& other) {
        m_column += other.m_column; m_row += other.m_row;
        m_slice += other.m_slice; return *this;
      }


      Index3D& operator-=(const Index3D& other) {
        m_column -= other.m_column; m_row -= other.m_row;
        m_slice -= other.m_slice; return *this;
      }

    
      Index3D operator-() {
        return Index3D(-m_row, -m_column, -m_slice);
      }
    
    private:

      // Private data members.
      int m_column;
      int m_row;
      int m_slice;
    }; // class Index3D


    /* ============== Non-member function declarations ============== */
  
    Index3D
    operator+(const Index3D& index0, const Index3D& index1);

    Index3D
    operator-(const Index3D& index0, const Index3D& index1);
  
    Index3D
    operator*(const Index3D& index0, const Index3D& index1);

    Index3D
    operator/(const Index3D& index0, const Index3D& index1);

    Index3D operator+(const Index3D& index0, int scalar0);

    Index3D operator-(const Index3D& index0, int scalar0);

    Index3D operator*(const Index3D& index0, int scalar0);

    Index3D operator/(const Index3D& index0, int scalar0);

    bool operator==(const Index3D& index0, const Index3D& index1);

    bool operator!=(const Index3D& index0, const Index3D& index1);


    Index3D operator+(int scalar0, const Index3D& index0);


    Index3D operator*(int scalar0, const Index3D& index0);

  
    std::ostream& operator<<(std::ostream& stream, const Index3D& index0);

  
    std::istream& operator>>(std::istream& stream, Index3D& index0);

  } // namespace numeric

} // namespace dlr


/* ============ Definitions of inline & template functions ============ */

namespace dlr {

  namespace numeric {
    
    inline Index3D operator+(int scalar0, const Index3D& index0)
    {
      return index0 + scalar0;
    }
  
    inline Index3D operator*(int scalar0, const Index3D& index0)
    {
      return index0 * scalar0;
    }

  } // namespace numeric

} // namespace dlr

#endif // #ifndef DLR_NUMERIC_INDEX3D_H