linear_index_iterator.h

Go to the documentation of this file.

// ---------------------------------------------------------------------
//
// Copyright (C) 2018 - 2020 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.md at
// the top level directory of deal.II.
//
// ---------------------------------------------------------------------
 
#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:
  using iterator_category = std::random_access_iterator_tag;
 
  using value_type = AccessorType;
 
  using difference_type = std::ptrdiff_t;
 
  using reference = const value_type &;
 
  using pointer = const value_type *;
 
  using size_type = typename value_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;
 
  template <typename OtherIterator>
  friend typename std::enable_if<
    std::is_convertible<OtherIterator, DerivedIterator>::value,
    bool>::type
  operator==(const LinearIndexIterator &left, const OtherIterator &right)
  {
    const auto &right_2 = static_cast<const DerivedIterator &>(right);
    return left.accessor == right_2.accessor;
  }
 
  template <typename OtherIterator>
  friend typename std::enable_if<
    std::is_convertible<OtherIterator, DerivedIterator>::value,
    bool>::type
  operator!=(const LinearIndexIterator &left, const OtherIterator &right)
  {
    return !(left == right);
  }
 
  bool
  operator<=(const DerivedIterator &) const;
 
  bool
  operator>=(const DerivedIterator &) const;
 
  bool
  operator<(const DerivedIterator &) const;
 
  bool
  operator>(const DerivedIterator &) const;
 
protected:
  /*
   * The inheriting class should have a default constructor.
   */
  LinearIndexIterator() = default; // NOLINT
 
  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
{
  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 < static_cast<const DerivedIterator &>(*this);
}
 
 
 
template <class DerivedIterator, class AccessorType>
inline LinearIndexIterator<DerivedIterator, AccessorType>::LinearIndexIterator(
  const AccessorType accessor)
  : accessor(accessor)
{}
 
 
DEAL_II_NAMESPACE_CLOSE
 
#endif