operator/hashedSMatrixIterator.hh

Go to the documentation of this file.

/* matrix iterator for hashed sparse matrices
 */

#ifndef hSparseMatrixIterator_hh
#define hSparseMatrixIterator_hh

#include "matrixIterator.hh"
#include "basics/debug.hh"

namespace concepts {

  // forward declaration
  template<class T>
  class HashedSparseMatrix;

//   template<class T>
//   struct HashedSparseMatrix<T>::Value;

  // *********************************************** _HashedSMatrix_iterator **

  template <class _Tp, class _Ref, class _Ptr>
  class _HashedSMatrix_iterator : 
    public _Matrix_iterator_base<_Tp, _Ref, _Ptr> {
  public:
    typedef _HashedSMatrix_iterator<_Tp, _Tp&, _Tp*>            iterator;
    typedef _HashedSMatrix_iterator<_Tp, const _Tp&,const _Tp*> const_iterator;

    template<class _Tp_, class _Ref_, class _Ptr_>
    struct MatrixType;

    typedef std::forward_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 _HashedSMatrix_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;

    _HashedSMatrix_iterator(matrix_type& m, const uint r = 0);
    _HashedSMatrix_iterator();
    template<class _RefR, class _PtrR>
    _HashedSMatrix_iterator
    (const _HashedSMatrix_iterator<_Tp, _RefR, _PtrR>& __x)
      : _Base(__x), v_(__x.v()), hashBits_(__x.hashBits()),
  pPerRow_(__x.pPerRow()), nofPages_(__x.nofPages()), 
  p_(__x.p()), pNextRow_(__x.pNextRow()), page_(__x.page()) {
      conceptsAssert(v_ == 0 || v_->val != 0.0, Assertion());
    }

    /*return_type*/ reference operator*() const { 
      conceptsAssert(v_ != 0 && v_->val != 0.0, Assertion());
      return v_->val;
    }
    pointer operator->() const {
      conceptsAssert(v_ != 0 && v_->val != 0.0, Assertion());
      return &v_->val;
    }

    template<class _RefR, class _PtrR>
    _Self& operator=(const _HashedSMatrix_iterator<_Tp, _RefR, _PtrR>& __x) {
      _Base::operator=(__x);
      v_ = __x.v(); hashBits_ = __x.hashBits();
      pPerRow_ = __x.pPerRow(); nofPages_ = __x.nofPages(); 
      p_ = __x.p(); pNextRow_ = __x.pNextRow(); page_ = __x.page();
      conceptsAssert(v_ == 0 || v_->val != 0.0, Assertion());
      return *this;
    }

    _Self& operator++();
    _Self operator++(int);

    typename HashedSparseMatrix<_Tp>::Value* v() const { return v_; }
    int hashBits() const { return hashBits_; }
    int pPerRow() const { return pPerRow_; }
    int nofPages() const { return nofPages_; }
    int p() const { return p_; }
    int pNextRow() const { return pNextRow_; }
    typename HashedSparseMatrix<_Tp>::Value** page() const { return page_; }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    typename HashedSparseMatrix<_Tp>::Value* v_;
    int hashBits_, pPerRow_, nofPages_;
    int p_, pNextRow_;
    typename HashedSparseMatrix<_Tp>::Value** page_;
  };

  template <class _Tp, class _Ref, class _Ptr>
  template<class _Tp_, class _Ref_, class _Ptr_>
  struct _HashedSMatrix_iterator<_Tp, _Ref, _Ptr>::MatrixType {
    typedef HashedSparseMatrix<_Tp_> type;
  };

  template <class _Tp, class _Ref, class _Ptr>
  template<class _Tp_>
  struct _HashedSMatrix_iterator<_Tp, _Ref, _Ptr>::
    MatrixType<_Tp_, const _Tp_&, const _Tp_*>
  {
    typedef const HashedSparseMatrix<_Tp_> type;
  };

} // namespace concepts

#endif // hSparseMatrixIterator_hh