linear_index_iterator.h

// ---------------------------------------------------------------------
//
// Copyright (C) 2018 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_linear_index_iterator_h
#define dealii_linear_index_iterator_h

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


DEAL_II_NAMESPACE_OPEN
template <class DerivedIterator, class AccessorType>
class LinearIndexIterator
{
public:
  typedef std::random_access_iterator_tag iterator_category;

  typedef
  AccessorType value_type;

  typedef std::ptrdiff_t difference_type;

  typedef const value_type &reference;

  typedef const value_type *pointer;

  typedef typename value_type::size_type size_type;

  DerivedIterator &
  operator = (const DerivedIterator &it);

  DerivedIterator &operator ++ ();

  DerivedIterator operator ++ (int);

  DerivedIterator &operator -- ();

  DerivedIterator operator -- (int);

  DerivedIterator operator + (const difference_type n) const;

  DerivedIterator operator - (const difference_type n) const;

  DerivedIterator &operator += (const difference_type n);

  DerivedIterator &operator -= (const difference_type n);

  difference_type operator - (const DerivedIterator &p) const;

  reference operator * () const;

  pointer operator -> () const;

  bool operator == (const DerivedIterator &) const;

  bool operator != (const DerivedIterator &) const;

  bool operator <= (const DerivedIterator &) const;

  bool operator >= (const DerivedIterator &) const;

  bool operator < (const DerivedIterator &) const;

  bool operator > (const DerivedIterator &) const;

protected:
  LinearIndexIterator () = default;

  LinearIndexIterator (const AccessorType accessor);

protected:
  AccessorType accessor;
};



template <class DerivedIterator, class AccessorType>
inline
DerivedIterator &
LinearIndexIterator<DerivedIterator, AccessorType>::operator = (const DerivedIterator &it)
{
  accessor.container = it.container;
  accessor.linear_index = it.linear_index;
  return static_cast<DerivedIterator &>(*this);
}



template <class DerivedIterator, class AccessorType>
inline
DerivedIterator &
LinearIndexIterator<DerivedIterator, AccessorType>::operator ++ ()
{
  return operator+=(1);
}



template <class DerivedIterator, class AccessorType>
inline
DerivedIterator
LinearIndexIterator<DerivedIterator, AccessorType>::operator ++ (int)
{
  const DerivedIterator copy(this->accessor);
  operator+=(1);
  return copy;
}



template <class DerivedIterator, class AccessorType>
inline
DerivedIterator &
LinearIndexIterator<DerivedIterator, AccessorType>::operator -- ()
{
  return operator+=(-1);
}



template <class DerivedIterator, class AccessorType>
inline
DerivedIterator
LinearIndexIterator<DerivedIterator, AccessorType>::operator -- (int)
{
  const DerivedIterator copy(this->accessor);
  operator+=(-1);
  return copy;
}



template <class DerivedIterator, class AccessorType>
inline
DerivedIterator
LinearIndexIterator<DerivedIterator, AccessorType>::
operator + (const difference_type n) const
{
  DerivedIterator copy(this->accessor);
  copy += n;
  return copy;
}



template <class DerivedIterator, class AccessorType>
inline
DerivedIterator
LinearIndexIterator<DerivedIterator, AccessorType>::
operator - (const difference_type n) const
{
  DerivedIterator copy(this->accessor);
  copy += -n;
  return copy;
}



template <class DerivedIterator, class AccessorType>
inline
DerivedIterator &
LinearIndexIterator<DerivedIterator, AccessorType>::operator += (const difference_type n)
{
  accessor.linear_index += n;
  return static_cast<DerivedIterator &>(*this);
}



template <class DerivedIterator, class AccessorType>
inline
DerivedIterator &
LinearIndexIterator<DerivedIterator, AccessorType>::operator -= (const difference_type n)
{
  return operator+=(-n);
}



template <class DerivedIterator, class AccessorType>
inline
typename LinearIndexIterator<DerivedIterator, AccessorType>::difference_type
LinearIndexIterator<DerivedIterator, AccessorType>::
operator - (const DerivedIterator &other) const
{
  Assert(this->accessor.container == other.accessor.container,
         ExcMessage("Only iterators pointing to the same container can be compared."));
  return this->accessor.linear_index - other.accessor.linear_index;
}



template <class DerivedIterator, class AccessorType>
inline
typename LinearIndexIterator<DerivedIterator, AccessorType>::reference
LinearIndexIterator<DerivedIterator, AccessorType>::operator * () const
{
  return accessor;
}



template <class DerivedIterator, class AccessorType>
inline
typename LinearIndexIterator<DerivedIterator, AccessorType>::pointer
LinearIndexIterator<DerivedIterator, AccessorType>::operator -> () const
{
  return &accessor;
}



template <class DerivedIterator, class AccessorType>
inline
bool
LinearIndexIterator<DerivedIterator, AccessorType>::
operator == (const DerivedIterator &other) const
{
  const auto &other_2 = static_cast<decltype(*this) &>(other);
  return accessor.container == other_2.accessor.container &&
         accessor.linear_index == other_2.accessor.linear_index;
}



template <class DerivedIterator, class AccessorType>
inline
bool
LinearIndexIterator<DerivedIterator, AccessorType>::
operator != (const DerivedIterator &other) const
{
  return !(*this == other);
}



template <class DerivedIterator, class AccessorType>
inline
bool
LinearIndexIterator<DerivedIterator, AccessorType>::
operator <= (const DerivedIterator &other) const
{
  return (*this == other) || (*this < other);
}



template <class DerivedIterator, class AccessorType>
inline
bool
LinearIndexIterator<DerivedIterator, AccessorType>::
operator >= (const DerivedIterator &other) const
{
  return !(*this < other);
}



template <class DerivedIterator, class AccessorType>
inline
bool
LinearIndexIterator<DerivedIterator, AccessorType>::
operator < (const DerivedIterator &other) const
{
  Assert(this->accessor.container == other.accessor.container,
         ExcMessage("Only iterators pointing to the same container can be compared."));
  return this->accessor.linear_index < other.accessor.linear_index;
}



template <class DerivedIterator, class AccessorType>
inline
bool
LinearIndexIterator<DerivedIterator, AccessorType>::
operator > (const DerivedIterator &other) const
{
  return other < *this;
}



template <class DerivedIterator, class AccessorType>
inline
LinearIndexIterator<DerivedIterator, AccessorType>::LinearIndexIterator
(const AccessorType accessor)
  :
  accessor(accessor)
{}


DEAL_II_NAMESPACE_CLOSE

#endif