matrix_iterator.h

// ---------------------------------------------------------------------
//
// Copyright (C) 1999 - 2017 by the deal.II authors
//
// This file is part of the deal.II library.
//
// The deal.II library is free software; you can use it, redistribute
// it, and/or modify it under the terms of the GNU Lesser General
// Public License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
// The full text of the license can be found in the file LICENSE at
// the top level of the deal.II distribution.
//
// ---------------------------------------------------------------------

#ifndef dealii_matrix_iterator_h
#define dealii_matrix_iterator_h


#include <deal.II/base/config.h>
#include <deal.II/base/exceptions.h>

DEAL_II_NAMESPACE_OPEN

template <class ACCESSOR>
class MatrixIterator
{
public:
  typedef types::global_dof_index size_type;

  typedef typename ACCESSOR::MatrixType MatrixType;

  MatrixIterator (MatrixType      *matrix,
                  const size_type  row = 0,
                  const size_type  index = 0);

  template <class OtherAccessor>
  MatrixIterator(const MatrixIterator<OtherAccessor> &other);

  MatrixIterator &operator++ ();

  MatrixIterator operator++ (int);

  const ACCESSOR &operator* () const;

  const ACCESSOR *operator-> () const;

  bool operator == (const MatrixIterator &) const;

  bool operator != (const MatrixIterator &) const;

  bool operator < (const MatrixIterator &) const;

  bool operator > (const MatrixIterator &) const;

private:
  ACCESSOR accessor;

  template <class OtherAccessor> friend class MatrixIterator;
};


//----------------------------------------------------------------------//

template <class ACCESSOR>
inline
MatrixIterator<ACCESSOR>::
MatrixIterator (MatrixType      *matrix,
                const size_type  r,
                const size_type  i)
  :
  accessor(matrix, r, i)
{}


template <class ACCESSOR>
template <class OtherAccessor>
inline
MatrixIterator<ACCESSOR>::
MatrixIterator (const MatrixIterator<OtherAccessor> &other)
  :
  accessor(other.accessor)
{}


template <class ACCESSOR>
inline
MatrixIterator<ACCESSOR> &
MatrixIterator<ACCESSOR>::operator++ ()
{
  accessor.advance ();
  return *this;
}


template <class ACCESSOR>
inline
MatrixIterator<ACCESSOR>
MatrixIterator<ACCESSOR>::operator++ (int)
{
  const MatrixIterator iter = *this;
  accessor.advance ();
  return iter;
}


template <class ACCESSOR>
inline
const ACCESSOR &
MatrixIterator<ACCESSOR>::operator* () const
{
  return accessor;
}


template <class ACCESSOR>
inline
const ACCESSOR *
MatrixIterator<ACCESSOR>::operator-> () const
{
  return &accessor;
}


template <class ACCESSOR>
inline
bool
MatrixIterator<ACCESSOR>::
operator == (const MatrixIterator &other) const
{
  return (accessor == other.accessor);
}


template <class ACCESSOR>
inline
bool
MatrixIterator<ACCESSOR>::
operator != (const MatrixIterator &other) const
{
  return ! (*this == other);
}


template <class ACCESSOR>
inline
bool
MatrixIterator<ACCESSOR>::
operator < (const MatrixIterator &other) const
{
  Assert (&accessor.get_matrix() == &other.accessor.get_matrix(),
          ExcInternalError());

  return (accessor < other.accessor);
}


template <class ACCESSOR>
inline
bool
MatrixIterator<ACCESSOR>::
operator > (const MatrixIterator &other) const
{
  return (other < *this);
}

DEAL_II_NAMESPACE_CLOSE

#endif