matrixIterator.hh

Go to the documentation of this file.

 
#ifndef matrixIterator_hh
#define matrixIterator_hh
 
#include <cstddef>
#include <bits/stl_iterator_base_types.h>
#include "basics/exceptions.hh"
#include "basics/outputOperator.hh"
 
namespace concepts {
 
  // forward declaration
  template<class F>
  class Matrix;
 
  // ************************************************* _Matrix_iterator_base **
 
  template <class _Tp, class _Ref, class _Ptr>
  class _Matrix_iterator_base : public virtual OutputOperator {
  public:
    typedef _Matrix_iterator_base<_Tp, _Tp&, _Tp*>             iterator;
    typedef _Matrix_iterator_base<_Tp, const _Tp&, const _Tp*> const_iterator;
 
    template<class _Tp_>
    struct ReturnType;
 
    typedef _Tp                              value_type;
    typedef _Ptr                             pointer;
    typedef _Ref                             reference;
    typedef size_t                           size_type;
    typedef ptrdiff_t                        difference_type;
    typedef typename ReturnType<_Ref>::type  return_type;
    typedef _Matrix_iterator_base            _Self;
 
    _Matrix_iterator_base(const unsigned int nofRows, const unsigned int nofCols,
        const unsigned int r, const unsigned int c);
    _Matrix_iterator_base();
    template<class _RefR, class _PtrR>
    _Matrix_iterator_base(const _Matrix_iterator_base<_Tp, _RefR, _PtrR>& __x)
      : nofRows_(__x.nofRows()), nofCols_(__x.nofCols()), 
  row_(__x.row()), col_(__x.col()), last_(__x.last()) {}
 
    inline const unsigned int nofRows() const { return nofRows_; }
    inline const unsigned int nofCols() const { return nofCols_; }
    inline unsigned int row() const { return row_; }
    inline unsigned int col() const { return col_; }
    inline bool last() const { return last_; }
 
    _Self& operator=(const iterator& __x) {
      conceptsAssert(nofRows_ == __x.nofRows() && nofCols_ == __x.nofCols(),
         Assertion());
      row_ = __x.row();
      col_ = __x.col();
      last_ = __x.last();
      return *this;
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
    const unsigned int nofRows_, nofCols_;
    unsigned int row_, col_;
    bool last_;
  };
 
  template <class _Tp, class _Ref, class _Ptr>
  template<class _Tp_>
  struct _Matrix_iterator_base<_Tp, _Ref, _Ptr>::ReturnType {
    typedef _Tp_ type;
  };
 
  template <class _Tp, class _Ref, class _Ptr>
  template<class _Tp_>
  struct _Matrix_iterator_base<_Tp, _Ref, _Ptr>::ReturnType<const _Tp_&> {
    typedef const _Tp_ type;
  };
 
  template <class _Tp, class _Ref, class _Ptr>
  std::ostream&
  _Matrix_iterator_base<_Tp, _Ref, _Ptr>::info(std::ostream& os) const {
    os << "_Matrix_iterator_base(pos = ";
    if (!last_)
      os << "(" << row_ << ", " << col_ << ")";
    else os << "end)";
    return os;
  }
 
  //                 *************
 
  template <class _Tp, class _Ref, class _Ptr>
  inline bool
  operator==(const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __x,
       const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __y)
  {
    return (__x.last() && __y.last()) ||
      (!__x.last() && !__y.last() && 
       __x.row() == __y.row() && __x.col() == __y.col());
  }
 
  template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR>
  inline bool
  operator==(const _Matrix_iterator_base<_Tp, _RefL, _PtrL>& __x,
       const _Matrix_iterator_base<_Tp, _RefR, _PtrR>& __y)
  {
    return (__x.last() && __y.last()) ||
      (!__x.last() && !__y.last() && 
       __x.row() == __y.row() && __x.col() == __y.col());
  }
 
  template <class _Tp, class _Ref, class _Ptr>
  inline bool
  operator!=(const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __x,
       const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __y)
  {
    return !(__x == __y);
  }
 
  template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR>
  inline bool
  operator!=(const _Matrix_iterator_base<_Tp, _RefL, _PtrL>& __x,
       const _Matrix_iterator_base<_Tp, _RefR, _PtrR>& __y)
  {
    return !(__x == __y);
  }
 
  template <class _Tp, class _Ref, class _Ptr>
  inline bool
  operator<(const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __x,
      const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __y)
  {
    return !__x.last() && 
      (__y.last() || ((!__y.last() && __x.row() < __y.row()) || 
          (__x.row() == __y.row() && __x.col() < __y.col())));
  }
 
  template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR>
  inline bool
  operator<(const _Matrix_iterator_base<_Tp, _RefL, _PtrL>& __x,
      const _Matrix_iterator_base<_Tp, _RefR, _PtrR>& __y)
  {
    return !__x.last() && 
      (__y.last() || (!__y.last() && __x.row() < __y.row()) || 
          (__x.row() == __y.row() && __x.col() < __y.col()));
  }
 
  template <class _Tp, class _Ref, class _Ptr>
  inline bool
  operator>(const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __x,
      const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __y)
  {
    return __y < __x;
  }
 
  template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR>
  inline bool
  operator>(const _Matrix_iterator_base<_Tp, _RefL, _PtrL>& __x,
      const _Matrix_iterator_base<_Tp, _RefR, _PtrR>& __y)
  {
    return __y < __x;
  }
 
  template <class _Tp, class _Ref, class _Ptr>
  inline bool
  operator<=(const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __x,
       const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __y)
  {
    return !(__y < __x);
  }
 
  template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR>
  inline bool
  operator<=(const _Matrix_iterator_base<_Tp, _RefL, _PtrL>& __x,
       const _Matrix_iterator_base<_Tp, _RefR, _PtrR>& __y)
  {
    return !(__y < __x);
  }
 
  template <class _Tp, class _Ref, class _Ptr>
  inline bool
  operator>=(const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __x,
       const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __y)
  {
    return !(__x < __y);
  }
 
  template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR>
  inline bool
  operator>=(const _Matrix_iterator_base<_Tp, _RefL, _PtrL>& __x,
       const _Matrix_iterator_base<_Tp, _RefR, _PtrR>& __y)
  {
    return !(__x < __y);
  }
 
  template <typename _Tp, typename _RefL, typename _PtrL,
      typename _RefR, typename _PtrR>
  inline typename _Matrix_iterator_base<_Tp, _RefL, _PtrL>::difference_type
  operator-(const _Matrix_iterator_base<_Tp, _RefL, _PtrL>& __x,
      const _Matrix_iterator_base<_Tp, _RefR, _PtrR>& __y)
  {
    if (__x.last())
      if (__y.last()) return 0;
      else return __y.nofRows() * (__y.nofCols() - __y.row()) - __y.col();
    else if (__y.last())
      return __x.nofRows() * (__x.nofCols() - __x.row()) - __x.col();
    return typename _Matrix_iterator_base<_Tp, _RefL, _PtrL>::difference_type
      (__x.col() - __y.col() + __x.nofCols() * (__x.row() - __y.row()));
  }
 
  template <class _Tp, class _Ref, class _Ptr>
  inline _Matrix_iterator_base<_Tp, _Ref, _Ptr>
  operator+(ptrdiff_t __n, const _Matrix_iterator_base<_Tp, _Ref, _Ptr>& __x)
  {
    return __x + __n;
  }
 
  // ****************************************************** securePointer **
 
  template<class F, class G>
  F* securePointer(F& value, G* matrix) { return &value; }
 
  template<class F, class G>
  F* securePointer(const F value, const G* matrix) { 
    throw conceptsException(MissingFeature
          ("inapplicable for constant matrices"));
    return 0;
  }
 
  // ****************************************************** _Matrix_iterator **
 
  template <class _Tp, class _Ref, class _Ptr>
  class _Matrix_iterator : public _Matrix_iterator_base<_Tp, _Ref, _Ptr> {
  public:
    typedef _Matrix_iterator<_Tp, _Tp&, _Tp*>              iterator;
    typedef _Matrix_iterator<_Tp, const _Tp&, const _Tp*>  const_iterator;
 
    template<class _Tp_, class _Ref_, class _Ptr_>
    struct MatrixType;
 
    typedef std::random_access_iterator_tag                iterator_category;
    typedef _Tp                                            value_type;
    typedef _Ptr                                           pointer;
    typedef _Ref                                           reference;
    typedef size_t                                         size_type;
    typedef ptrdiff_t                                      difference_type;
    typedef _Matrix_iterator                               _Self;
    typedef _Matrix_iterator_base<_Tp, _Ref, _Ptr>         _Base;
    typedef typename MatrixType<_Tp, _Ref, _Ptr>::type     matrix_type;
    typedef typename _Base::return_type                    return_type;
 
    _Matrix_iterator(matrix_type& m, const unsigned int r = 0, const unsigned int c = 0);
    _Matrix_iterator();
    template<class _RefR, class _PtrR>
    _Matrix_iterator(const _Matrix_iterator<_Tp, _RefR, _PtrR>& __x)
      : _Base(__x),  matrix_(__x.matrix()) {}
 
    return_type operator*() const { 
      conceptsAssert(matrix_, Assertion());
      return (*matrix_)(this->row_, this->col_);
    }
    pointer operator->() const {
      conceptsAssert(matrix_, Assertion());
      return securePointer((*matrix_)(this->row_, this->col_), matrix_);
    }
 
    inline matrix_type* matrix() const { return matrix_; }
 
    _Self& operator=(const iterator& __x) {
      conceptsAssert(matrix_ == __x.matrix(), Assertion());
      _Base::operator=(__x);
      return *this;
    }
 
    _Self& operator++() {
      if (!this->last_) {
        if (++this->col_ >= this->nofCols_) {
          ++this->row_;
          this->col_ = 0;
        }
        this->last_ = this->row_ >= this->nofRows_;
      }
      return *this; 
    }
    _Self operator++(int)  {
      _Self __tmp = *this;
      ++*this;
      return __tmp;
    }
 
    _Self& operator--() {
      if (this->last_) {
        conceptsAssert(matrix_, Assertion());
        this->col_ = this->nofCols_ - 1;
        this->row_ = this->nofRows_ - 1;
        this->last_ = false;
      } else {
        if (this->col_ > 0) --this->col_;
        else {
          conceptsAssert(this->row_ > 0, Assertion());
          --this->row_;
          this->col_ = this->nofCols_ - 1;
        }
      }
      return *this;
    }
    _Self operator--(int) {
      _Self __tmp = *this;
      --*this;
      return __tmp;
    }
 
    _Self& operator+=(difference_type __n)
    {
      if (this->last_ && __n < 0) {
        this->col_ = 0;
        this->row_ = this->nofRows_;
        this->last_ = false;
      }
      if (!this->last_) {
        conceptsAssert(this->nofCols_, Assertion());
        int col = __n + this->col_;
        int row = col / (int)this->nofCols_ + this->row_;
        conceptsAssert(row >= 0 , Assertion());
        this->row_ = row;
        this->col_ = col % this->nofCols_;
        this->last_ = this->row_ >= this->nofRows_;
      }
      return *this;
    }
 
    _Self operator+(difference_type __n) const
    {
      _Self __tmp = *this;
      return __tmp += __n;
    }
 
    _Self& operator-=(difference_type __n) { return *this += -__n; }
 
    _Self operator-(difference_type __n) const {
      _Self __tmp = *this;
      return __tmp -= __n;
    }
 
    return_type operator[](difference_type __n) const { 
      return *(*this + __n);
    }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    matrix_type* matrix_;
  };
 
  template <class _Tp, class _Ref, class _Ptr>
  template<class _Tp_, class _Ref_, class _Ptr_>
  struct _Matrix_iterator<_Tp, _Ref, _Ptr>::MatrixType {
    typedef Matrix<_Tp_> type;
  };
 
  template <class _Tp, class _Ref, class _Ptr>
  template<class _Tp_>
  struct _Matrix_iterator<_Tp, _Ref, _Ptr>::
    MatrixType<_Tp_, const _Tp_&, const _Tp_*>
  {
    typedef const Matrix<_Tp_> type;
  };
 
  //                 *************
 
//   template <class _Tp, class _Ref, class _Ptr, class G>
//   inline bool
//   operator==(const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __x,
//       const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __y)
//   {
//     return __x.last() && __y.last() ||
//       (!__x.last() && !__y.last() && 
//        __x.row() == __y.row() && __x.col() == __y.col());
//   }
 
//   template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR,
//      class G>
//   inline bool
//   operator==(const _Matrix_iterator<_Tp, _RefL, _PtrL, G>& __x,
//       const _Matrix_iterator<_Tp, _RefR, _PtrR, G>& __y)
//   {
//     return __x.last() && __y.last() ||
//       (!__x.last() && !__y.last() && 
//        __x.row() == __y.row() && __x.col() == __y.col());
//   }
 
//   template <class _Tp, class _Ref, class _Ptr, class G>
//   inline bool
//   operator!=(const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __x,
//       const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __y)
//   {
//     return !(__x == __y);
//   }
 
//   template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR,
//      class G>
//   inline bool
//   operator!=(const _Matrix_iterator<_Tp, _RefL, _PtrL, G>& __x,
//       const _Matrix_iterator<_Tp, _RefR, _PtrR, G>& __y)
//   {
//     return !(__x == __y);
//   }
 
//   template <class _Tp, class _Ref, class _Ptr, class G>
//   inline bool
//   operator<(const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __x,
//      const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __y)
//   {
//     return !__x.last() && 
//       (__y.last() || (!__y.last() && __x.row() < __y.row() || 
//          (__x.row() == __y.row() && __x.col() < __y.col())));
//   }
 
//   template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR,
//      class G>
//   inline bool
//   operator<(const _Matrix_iterator<_Tp, _RefL, _PtrL, G>& __x,
//      const _Matrix_iterator<_Tp, _RefR, _PtrR, G>& __y)
//   {
//     return !__x.last() && 
//       (__y.last() || (!__y.last() && __x.row() < __y.row() || 
//          (__x.row() == __y.row() && __x.col() < __y.col())));
//   }
 
//   template <class _Tp, class _Ref, class _Ptr, class G>
//   inline bool
//   operator>(const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __x,
//      const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __y)
//   {
//     return __y < __x;
//   }
 
//   template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR,
//      class G>
//   inline bool
//   operator>(const _Matrix_iterator<_Tp, _RefL, _PtrL, G>& __x,
//      const _Matrix_iterator<_Tp, _RefR, _PtrR, G>& __y)
//   {
//     return __y < __x;
//   }
 
//   template <class _Tp, class _Ref, class _Ptr, class G>
//   inline bool
//   operator<=(const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __x,
//       const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __y)
//   {
//     return !(__y < __x);
//   }
 
//   template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR,
//      class G>
//   inline bool
//   operator<=(const _Matrix_iterator<_Tp, _RefL, _PtrL, G>& __x,
//       const _Matrix_iterator<_Tp, _RefR, _PtrR, G>& __y)
//   {
//     return !(__y < __x);
//   }
 
//   template <class _Tp, class _Ref, class _Ptr, class G>
//   inline bool
//   operator>=(const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __x,
//       const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __y)
//   {
//     return !(__x < __y);
//   }
 
//   template <class _Tp, class _RefL, class _PtrL, class _RefR, class _PtrR,
//      class G>
//   inline bool
//   operator>=(const _Matrix_iterator<_Tp, _RefL, _PtrL, G>& __x,
//       const _Matrix_iterator<_Tp, _RefR, _PtrR, G>& __y)
//   {
//     return !(__x < __y);
//   }
 
//   template <typename _Tp, typename _RefL, typename _PtrL,
//      typename _RefR, typename _PtrR, typename G>
//   inline typename _Matrix_iterator<_Tp, _RefL, _PtrL, G>::difference_type
//   operator-(const _Matrix_iterator<_Tp, _RefL, _PtrL, G>& __x,
//      const _Matrix_iterator<_Tp, _RefR, _PtrR, G>& __y)
//   {
//     if (__x.last())
//       if (__y.last()) return 0;
//       else return __y.nofRows() * (__y.nofCols() - __y.row()) - __y.col();
//     else if (__y.last())
//       return __x.nofRows() * (__x.nofCols() - __x.row()) - __x.col();
//     return _Matrix_iterator<_Tp, _RefL, _PtrL, G>::difference_type
//       (__x.col() - __y.col() + __x.nofCols() * (__x.row() - __y.row()));
//   }
 
//   template <class _Tp, class _Ref, class _Ptr, class G>
//   inline _Matrix_iterator<_Tp, _Ref, _Ptr, G>
//   operator+(ptrdiff_t __n, const _Matrix_iterator<_Tp, _Ref, _Ptr, G>& __x)
//   {
//     return __x + __n;
//   }
 
} // namespace concepts
 
#endif // matrixIterator_hh