operator/subMatrixIterator.hh

Go to the documentation of this file.

/* iterator for sub matrices
 */

#ifndef submatrixiterator_hh
#define submatrixiterator_hh

#include "matrixIterator.hh"
#include "space/spaceSet.hh"

namespace concepts {

  template<class F>
  class SubMatrixN;

  // *************************************************** _SubMatrix_iterator **

  template <class F, class _Ref, class _Ptr>
  class _SubMatrix_iterator : 
    public _Matrix_iterator_base<typename F::type, _Ref, _Ptr> {
  public:

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

    typedef std::forward_iterator_tag                      iterator_category;
    typedef typename F::type                               value_type;
    typedef _Ptr                                           pointer;
    typedef _Ref                                           reference;
    typedef size_t                                         size_type;
    typedef ptrdiff_t                                      difference_type;
    typedef _SubMatrix_iterator                            _Self;
    typedef _Matrix_iterator_base<value_type, _Ref, _Ptr>  _Base;
    typedef typename MatrixType<F, _Ref, _Ptr>::type       matrix_type;
    typedef typename _Base::return_type                    return_type;

    typedef 
    _SubMatrix_iterator<F, value_type&, value_type*>            iterator;
    typedef 
    _SubMatrix_iterator<F, const value_type&,const value_type*> const_iterator;

    _SubMatrix_iterator(matrix_type& m, uint r = 0);
    _SubMatrix_iterator();
    template<class _RefR, class _PtrR>
    _SubMatrix_iterator(const _SubMatrix_iterator<F, _RefR, _PtrR>& __x)
      : _Base(__x), i_(0), iend_(0), iI_(0), lastI_(0), m_(__x.m()) {
      if (__x.i())
        i_.reset(new typename MatrixType<F, _Ref, _Ptr>::iterator(*__x.i()));
      if (__x.iend())
        iend_.reset
          (new typename MatrixType<F, _Ref, _Ptr>::iterator(*__x.iend()));
      if (__x.iI())
        iI_.reset(new Set<IndexRange>::index_iterator(*__x.iI()));
      if (__x.lastI())
        lastI_.reset(new Set<IndexRange>::index_iterator(*__x.lastI()));
    }

    return_type operator*() const {
      conceptsAssert(i_.get(), Assertion());
      return **i_;
    }
    pointer operator->() const {
      conceptsAssert(i_.get(), Assertion());
      return securePointer(**i_, m_);
    }

    template<class _RefR, class _PtrR>
    _Self& operator=(const _SubMatrix_iterator<F, _RefR, _PtrR>& __x) {
      _Base::operator=(__x);
      if (__x.i())
        i_.reset(new typename MatrixType<F, _Ref, _Ptr>::iterator(*__x.i()));
      else i_.reset(0);
      if (__x.iend())
        iend_.reset
          (new typename MatrixType<F, _Ref, _Ptr>::iterator(*__x.iend()));
      else iend_.reset(0);
      iI_ = __x.iI(); lastI_ = __x.lastI();
      m_ = __x.m();
      return *this;
    }

    _Self& operator++();
    _Self operator++(int) {
      _Self __tmp = *this;
      ++*this;
      return __tmp;
    }

    inline typename MatrixType<F, _Ref, _Ptr>::iterator* i() const {
      return i_.get();
    }
    inline const typename MatrixType<F, _Ref, _Ptr>::iterator* iend() const { 
      return iend_.get();
    }
    inline Set<IndexRange>::index_iterator* iI() const { return iI_.get(); }
    const Set<IndexRange>::index_iterator* lastI() const { 
      return lastI_.get();
    }
    inline matrix_type* m() const { return m_; }
  protected:
    virtual std::ostream& info(std::ostream& os) const;
  private:
    std::auto_ptr<typename MatrixType<F, _Ref, _Ptr>::iterator> i_;
    std::auto_ptr<const typename MatrixType<F, _Ref, _Ptr>::iterator> iend_;
    std::auto_ptr<Set<IndexRange>::index_iterator> iI_;
    std::auto_ptr<const Set<IndexRange>::index_iterator> lastI_;
    matrix_type* m_;

    _Self& next_();
  };

  template <class F, class _Ref, class _Ptr>
  template<class F_, class _Ref_, class _Ptr_>
  struct _SubMatrix_iterator<F, _Ref, _Ptr>::MatrixType {
    typedef SubMatrixN<F_> type;
    typedef typename F_::iterator iterator;
  };

  template <class F, class _Ref, class _Ptr>
  template<class F_>
  struct _SubMatrix_iterator<F, _Ref, _Ptr>::
    MatrixType<F_, const typename F::type&, const typename F::type*>
  {
    typedef const SubMatrixN<F_> type;
    typedef typename F_::const_iterator iterator;
  };

} // namespace concepts

#endif // submatrixiterator_hh