index2D.h

Go to the documentation of this file.

#ifndef _DLR_NUMERIC_INDEX2D_H_
#define _DLR_NUMERIC_INDEX2D_H_

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

namespace dlr {

  namespace numeric {
    
    class Index2D {
    public:

      Index2D()
        : m_column(0), m_row(0) {}
    

      Index2D(int row, int column)
        : m_column(column), m_row(row) {}


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


      ~Index2D() {}


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


      inline int getColumn() const {return m_column;}


      inline int getRow() const {return m_row;}

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


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

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


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

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


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


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


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

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

      // Private data members.
      int m_column;
      int m_row;
    }; // class Index2D


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

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

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

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

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

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

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

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

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


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


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

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

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

  } // namespace numeric

} // namespace dlr


/* ======= Declarations to maintain compatibility with legacy code. ======= */

namespace dlr {

  using numeric::Index2D;

} // namespace dlr


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

namespace dlr {

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

  } // namespace numeric

} // namespace dlr

#endif // #ifndef _DLR_NUMERIC_INDEX2D_H_