tria_iterator.h

Go to the documentation of this file.

// -----------------------------------------------------------------------------
//
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception OR LGPL-2.1-or-later
// Copyright (C) 1998 - 2025 by the deal.II authors
//
// This file is part of the deal.II library.
//
// Detailed license information governing the source code and contributions
// can be found in LICENSE.md and CONTRIBUTING.md at the top level directory.
//
// -----------------------------------------------------------------------------
 
#ifndef dealii_tria_iterator_h
#define dealii_tria_iterator_h
 
 
#include <deal.II/base/config.h>
 
#include <deal.II/base/exceptions.h>
#include <deal.II/base/point.h>
#include <deal.II/base/template_constraints.h>
 
#include <deal.II/grid/tria_iterator_base.h>
 
#include <iterator>
#include <ostream>
 
DEAL_II_NAMESPACE_OPEN
 
// Forward declarations
#ifndef DOXYGEN
template <int dim, int spacedim>
DEAL_II_CXX20_REQUIRES((concepts::is_valid_dim_spacedim<dim, spacedim>))
class Triangulation;
template <int, int, int>
class TriaAccessorBase;
 
template <typename>
class TriaIterator;
template <typename>
class TriaActiveIterator;
#endif
 
 
 
template <typename Accessor>
class TriaRawIterator
{
public:
  using AccessorType = Accessor;
 
  TriaRawIterator();
 
  TriaRawIterator(const TriaRawIterator &);
 
  explicit TriaRawIterator(const Accessor &a);
 
  template <typename OtherAccessor>
  explicit TriaRawIterator(const OtherAccessor &a);
 
  TriaRawIterator(
    const Triangulation<Accessor::dimension, Accessor::space_dimension> *parent,
    const int                                                            level,
    const int                                                            index,
    const typename AccessorType::AccessorData *local_data = nullptr);
 
  template <typename OtherAccessor>
  TriaRawIterator(const TriaRawIterator<OtherAccessor> &i);
 
  TriaRawIterator(
    const TriaAccessorBase<Accessor::structure_dimension,
                           Accessor::dimension,
                           Accessor::space_dimension> &tria_accessor,
    const typename Accessor::AccessorData             *local_data);
 
  template <typename OtherAccessor>
  TriaRawIterator(const TriaIterator<OtherAccessor> &i);
 
  template <typename OtherAccessor>
  TriaRawIterator(const TriaActiveIterator<OtherAccessor> &i);
 
  Accessor
  operator*() const;
 
  const Accessor *
  operator->() const;
 
  Accessor *
  operator->();
 
 
  const Accessor &
  access_any() const;
 
  TriaRawIterator &
  operator=(const TriaRawIterator &);
 
  template <typename OtherAccessor = Accessor>
  std::enable_if_t<std::is_convertible_v<OtherAccessor, Accessor>, bool>
  operator==(const TriaRawIterator<OtherAccessor> &) const;
 
  bool
  operator!=(const TriaRawIterator &) const;
 
  bool
  operator<(const TriaRawIterator &) const;
 
  bool
  operator>(const TriaRawIterator &) const;
 
  TriaRawIterator &
  operator++();
 
  TriaRawIterator
  operator++(int);
 
  TriaRawIterator &
  operator--();
 
  TriaRawIterator
  operator--(int);
  IteratorState::IteratorStates
  state() const;
 
  template <typename StreamType>
  void
  print(StreamType &out) const;
 
 
  std::size_t
  memory_consumption() const;
 
  using iterator_category = std::bidirectional_iterator_tag;
  using value_type        = Accessor;
  using difference_type   = int;
  using pointer           = Accessor *;
  using reference         = Accessor &;
 
  DeclException1(ExcDereferenceInvalidCell,
                 Accessor,
                 << "You tried to dereference a cell iterator for which this "
                 << "is not possible. More information on this iterator: "
                 << "level=" << arg1.level() << ", index=" << arg1.index()
                 << ", state="
                 << (arg1.state() == IteratorState::valid ?
                       "valid" :
                       (arg1.state() == IteratorState::past_the_end ?
                          "past_the_end" :
                          "invalid")));
 
  DeclException1(ExcDereferenceInvalidObject,
                 Accessor,
                 << "You tried to dereference an iterator for which this "
                 << "is not possible. More information on this iterator: "
                 << "index=" << arg1.index() << ", state="
                 << (arg1.state() == IteratorState::valid ?
                       "valid" :
                       (arg1.state() == IteratorState::past_the_end ?
                          "past_the_end" :
                          "invalid")));
 
  DeclException0(ExcAdvanceInvalidObject);
  DeclException0(ExcInvalidComparison);
 
protected:
  Accessor accessor;
 
 
  // Make all other iterator class templates friends of this class. This is
  // necessary for the implementation of conversion constructors.
  //
  // In fact, we would not need them to be friends if they were for different
  // dimensions, but the compiler dislikes giving a fixed dimension and
  // variable accessor since then it says that would be a partial
  // specialization.
  template <typename SomeAccessor>
  friend class TriaRawIterator;
  template <typename SomeAccessor>
  friend class TriaIterator;
  template <typename SomeAccessor>
  friend class TriaActiveIterator;
};
 
 
template <typename Accessor>
class TriaIterator : public TriaRawIterator<Accessor>
{
public:
  TriaIterator();
 
  TriaIterator(const TriaIterator<Accessor> &);
 
  TriaIterator(const TriaRawIterator<Accessor> &);
 
  TriaIterator(
    const Triangulation<Accessor::dimension, Accessor::space_dimension> *parent,
    const int                                                            level,
    const int                                                            index,
    const typename Accessor::AccessorData *local_data = nullptr);
 
  template <typename OtherAccessor>
  explicit TriaIterator(const OtherAccessor &a);
 
  template <typename OtherAccessor>
  TriaIterator(const TriaIterator<OtherAccessor> &i);
 
  TriaIterator(const TriaAccessorBase<Accessor::structure_dimension,
                                      Accessor::dimension,
                                      Accessor::space_dimension> &tria_accessor,
               const typename Accessor::AccessorData             *local_data);
 
  template <typename OtherAccessor>
  TriaIterator(const TriaRawIterator<OtherAccessor> &i);
 
  template <typename OtherAccessor>
  TriaIterator(const TriaActiveIterator<OtherAccessor> &i);
 
  TriaIterator<Accessor> &
  operator=(const TriaIterator<Accessor> &);
 
  TriaIterator<Accessor> &
  operator=(const TriaRawIterator<Accessor> &);
 
  template <class OtherAccessor>
  TriaIterator<Accessor> &
  operator=(const TriaIterator<OtherAccessor> &);
 
  template <class OtherAccessor>
  TriaIterator<Accessor> &
  operator=(const TriaRawIterator<OtherAccessor> &);
 
  TriaIterator<Accessor> &
  operator++();
 
  TriaIterator<Accessor>
  operator++(int);
 
  TriaIterator<Accessor> &
  operator--();
 
  TriaIterator<Accessor>
  operator--(int);
  using iterator_category =
    typename TriaRawIterator<Accessor>::iterator_category;
  using value_type      = typename TriaRawIterator<Accessor>::value_type;
  using pointer         = typename TriaRawIterator<Accessor>::pointer;
  using reference       = typename TriaRawIterator<Accessor>::reference;
  using difference_type = typename TriaRawIterator<Accessor>::difference_type;
 
  DeclException0(ExcAssignmentOfUnusedObject);
};
 
 
template <typename Accessor>
class TriaActiveIterator : public TriaIterator<Accessor>
{
public:
  TriaActiveIterator();
 
  TriaActiveIterator(const TriaActiveIterator<Accessor> &);
 
  TriaActiveIterator(const TriaRawIterator<Accessor> &);
 
  TriaActiveIterator(const TriaIterator<Accessor> &);
 
  TriaActiveIterator(
    const Triangulation<Accessor::dimension, Accessor::space_dimension> *parent,
    const int                                                            level,
    const int                                                            index,
    const typename Accessor::AccessorData *local_data = nullptr);
 
  template <typename OtherAccessor>
  TriaActiveIterator(const TriaActiveIterator<OtherAccessor> &i);
 
  TriaActiveIterator(
    const TriaAccessorBase<Accessor::structure_dimension,
                           Accessor::dimension,
                           Accessor::space_dimension> &tria_accessor,
    const typename Accessor::AccessorData             *local_data);
 
  template <typename OtherAccessor>
  TriaActiveIterator(const TriaRawIterator<OtherAccessor> &i);
 
  TriaActiveIterator<Accessor> &
  operator=(const TriaActiveIterator<Accessor> &);
 
  TriaActiveIterator<Accessor> &
  operator=(const TriaIterator<Accessor> &);
 
  TriaActiveIterator<Accessor> &
  operator=(const TriaRawIterator<Accessor> &);
 
  template <class OtherAccessor>
  TriaActiveIterator<Accessor> &
  operator=(const TriaActiveIterator<OtherAccessor> &);
 
  template <class OtherAccessor>
  TriaActiveIterator<Accessor> &
  operator=(const TriaRawIterator<OtherAccessor> &);
 
  template <class OtherAccessor>
  TriaActiveIterator<Accessor> &
  operator=(const TriaIterator<OtherAccessor> &);
 
  TriaActiveIterator<Accessor> &
  operator++();
 
  TriaActiveIterator<Accessor>
  operator++(int);
 
  TriaActiveIterator<Accessor> &
  operator--();
 
  TriaActiveIterator<Accessor>
  operator--(int);
  using iterator_category = typename TriaIterator<Accessor>::iterator_category;
  using value_type        = typename TriaIterator<Accessor>::value_type;
  using pointer           = typename TriaIterator<Accessor>::pointer;
  using reference         = typename TriaIterator<Accessor>::reference;
  using difference_type   = typename TriaIterator<Accessor>::difference_type;
 
  DeclException0(ExcAssignmentOfInactiveObject);
};
 
 
/*----------------------- Inline functions -------------------*/
 
 
template <typename Accessor>
inline TriaRawIterator<Accessor>::TriaRawIterator(const Accessor &a)
  : accessor(a)
{}
 
 
 
template <typename Accessor>
template <typename OtherAccessor>
inline TriaRawIterator<Accessor>::TriaRawIterator(const OtherAccessor &a)
  : accessor(a)
{}
 
 
 
template <typename Accessor>
template <typename OtherAccessor>
inline TriaRawIterator<Accessor>::TriaRawIterator(
  const TriaRawIterator<OtherAccessor> &i)
  : accessor(i.accessor)
{}
 
 
 
template <typename Accessor>
template <typename OtherAccessor>
inline TriaRawIterator<Accessor>::TriaRawIterator(
  const TriaIterator<OtherAccessor> &i)
  : accessor(i.accessor)
{}
 
 
 
template <typename Accessor>
template <typename OtherAccessor>
inline TriaRawIterator<Accessor>::TriaRawIterator(
  const TriaActiveIterator<OtherAccessor> &i)
  : accessor(i.accessor)
{}
 
 
 
template <typename Accessor>
inline Accessor
TriaRawIterator<Accessor>::operator*() const
{
  Assert(Accessor::structure_dimension != Accessor::dimension ||
           state() == IteratorState::valid,
         ExcDereferenceInvalidCell(accessor));
  Assert(Accessor::structure_dimension == Accessor::dimension ||
           state() == IteratorState::valid,
         ExcDereferenceInvalidObject(accessor));
 
  return accessor;
}
 
 
 
template <typename Accessor>
inline const Accessor &
TriaRawIterator<Accessor>::access_any() const
{
  return accessor;
}
 
 
 
template <typename Accessor>
inline const Accessor *
TriaRawIterator<Accessor>::operator->() const
{
  return &accessor;
}
 
 
 
template <typename Accessor>
inline Accessor *
TriaRawIterator<Accessor>::operator->()
{
  return &accessor;
}
 
 
 
template <typename Accessor>
inline IteratorState::IteratorStates
TriaRawIterator<Accessor>::state() const
{
  return accessor.state();
}
 
 
 
template <typename Accessor>
inline bool
TriaRawIterator<Accessor>::operator<(
  const TriaRawIterator<Accessor> &other) const
{
  Assert(state() != IteratorState::invalid,
         ExcDereferenceInvalidObject(accessor));
  Assert(other.state() != IteratorState::invalid,
         ExcDereferenceInvalidObject(other.accessor));
 
  Assert(&accessor.get_triangulation() == &other.accessor.get_triangulation(),
         ExcInvalidComparison());
 
  // Deal with iterators past end
  if (state() == IteratorState::past_the_end)
    return false;
  if (other.state() == IteratorState::past_the_end)
    return true;
 
  return ((**this) < (*other));
}
 
 
 
template <typename Accessor>
inline bool
TriaRawIterator<Accessor>::operator>(
  const TriaRawIterator<Accessor> &other) const
{
  return (other < *this);
}
 
 
 
template <typename Accessor>
inline TriaRawIterator<Accessor> &
TriaRawIterator<Accessor>::operator++()
{
  Assert(state() == IteratorState::valid, ExcAdvanceInvalidObject());
 
  ++accessor;
  return *this;
}
 
 
 
template <typename Accessor>
inline TriaRawIterator<Accessor> &
TriaRawIterator<Accessor>::operator--()
{
  Assert(state() == IteratorState::valid, ExcAdvanceInvalidObject());
 
  --accessor;
  return *this;
}
 
 
 
template <typename Accessor>
template <typename StreamType>
inline void
TriaRawIterator<Accessor>::print(StreamType &out) const
{
  if (Accessor::structure_dimension == Accessor::dimension)
    out << accessor.level() << '.' << accessor.index();
  else
    out << accessor.index();
}
 
 
 
template <typename Accessor>
inline std::size_t
TriaRawIterator<Accessor>::memory_consumption() const
{
  return sizeof(TriaRawIterator<Accessor>);
}
 
 
 
template <typename Accessor>
template <typename OtherAccessor>
inline TriaIterator<Accessor>::TriaIterator(
  const TriaIterator<OtherAccessor> &i)
  : TriaRawIterator<Accessor>(i.accessor)
{}
 
 
 
template <typename Accessor>
template <typename OtherAccessor>
inline TriaIterator<Accessor>::TriaIterator(
  const TriaActiveIterator<OtherAccessor> &i)
  : TriaRawIterator<Accessor>(i.accessor)
{}
 
 
 
template <typename Accessor>
template <typename OtherAccessor>
inline TriaIterator<Accessor>::TriaIterator(
  const TriaRawIterator<OtherAccessor> &i)
  : TriaRawIterator<Accessor>(i.accessor)
{
  if constexpr (running_in_debug_mode())
    {
      // do this like this, because:
      // if we write
      // "Assert (IteratorState::past_the_end || used)"
      // used() is called anyway, even if
      // state==IteratorState::past_the_end, and will then
      // throw the exception!
      if (this->state() != IteratorState::past_the_end)
        Assert(this->accessor.used(), ExcAssignmentOfUnusedObject());
    }
}
 
template <typename Accessor>
template <typename OtherAccessor>
TriaIterator<Accessor>::TriaIterator(const OtherAccessor &a)
  : TriaRawIterator<Accessor>(a)
{
  if constexpr (running_in_debug_mode())
    {
      // do this like this, because:
      // if we write
      // "Assert (IteratorState::past_the_end || used)"
      // used() is called anyway, even if
      // state==IteratorState::past_the_end, and will then
      // throw the exception!
      if (this->state() != IteratorState::past_the_end)
        Assert(this->accessor.used(), ExcAssignmentOfUnusedObject());
    }
}
 
template <typename Accessor>
template <typename OtherAccessor>
inline TriaActiveIterator<Accessor>::TriaActiveIterator(
  const TriaActiveIterator<OtherAccessor> &i)
  : TriaIterator<Accessor>(i.accessor)
{}
 
 
 
template <typename Accessor>
template <typename OtherAccessor>
inline TriaActiveIterator<Accessor>::TriaActiveIterator(
  const TriaRawIterator<OtherAccessor> &i)
  : TriaIterator<Accessor>(i)
{
  if constexpr (running_in_debug_mode())
    {
      // do this like this, because:
      // if we write
      // "Assert (IteratorState::past_the_end || !has_children())"
      // has_children() is called anyway, even if
      // state==IteratorState::past_the_end, and will then
      // throw the exception!
      if (this->state() != IteratorState::past_the_end)
        Assert(this->accessor.has_children() == false,
               ExcAssignmentOfInactiveObject());
    }
}
 
 
 
template <typename Accessor>
inline std::ostream &
operator<<(std::ostream &out, const TriaRawIterator<Accessor> &i)
{
  i.print(out);
  return out;
}
 
 
 
template <typename Accessor>
inline std::ostream &
operator<<(std::ostream &out, const TriaIterator<Accessor> &i)
{
  i.print(out);
  return out;
}
 
 
 
template <typename Accessor>
inline std::ostream &
operator<<(std::ostream &out, const TriaActiveIterator<Accessor> &i)
{
  i.print(out);
  return out;
}
 
 
#ifndef DOXYGEN
 
/*------------------------ Functions: TriaRawIterator ------------------*/
 
 
template <typename Accessor>
inline TriaRawIterator<Accessor>::TriaRawIterator()
  : accessor(nullptr, -2, -2, nullptr)
{}
 
 
template <typename Accessor>
inline TriaRawIterator<Accessor>::TriaRawIterator(
  const TriaRawIterator<Accessor> &i)
  : accessor(i.accessor)
{}
 
 
 
template <typename Accessor>
inline TriaRawIterator<Accessor>::TriaRawIterator(
  const Triangulation<Accessor::dimension, Accessor::space_dimension> *parent,
  const int                                                            level,
  const int                                                            index,
  const typename Accessor::AccessorData *local_data)
  : accessor(parent, level, index, local_data)
{}
 
 
template <typename Accessor>
inline TriaRawIterator<Accessor>::TriaRawIterator(
  const TriaAccessorBase<Accessor::structure_dimension,
                         Accessor::dimension,
                         Accessor::space_dimension> &tria_accessor,
  const typename Accessor::AccessorData             *local_data)
  : accessor(nullptr, -2, -2, local_data)
{
  accessor.copy_from(tria_accessor);
}
 
 
template <typename Accessor>
inline TriaRawIterator<Accessor> &
TriaRawIterator<Accessor>::operator=(const TriaRawIterator<Accessor> &i)
{
  accessor.copy_from(i.accessor);
 
  return *this;
}
 
 
 
template <typename Accessor>
template <typename OtherAccessor>
inline std::enable_if_t<std::is_convertible_v<OtherAccessor, Accessor>, bool>
TriaRawIterator<Accessor>::operator==(
  const TriaRawIterator<OtherAccessor> &other) const
{
  return accessor == other.accessor;
}
 
 
template <typename Accessor>
inline bool
TriaRawIterator<Accessor>::operator!=(
  const TriaRawIterator<Accessor> &other) const
{
  return !(*this == other);
}
 
 
template <typename Accessor>
inline TriaRawIterator<Accessor>
TriaRawIterator<Accessor>::operator++(int)
{
  TriaRawIterator<Accessor> tmp(*this);
  operator++();
 
  return tmp;
}
 
 
template <typename Accessor>
inline TriaRawIterator<Accessor>
TriaRawIterator<Accessor>::operator--(int)
{
  TriaRawIterator<Accessor> tmp(*this);
  operator--();
 
  return tmp;
}
 
 
/*-----------------------  functions: TriaIterator ---------------*/
 
 
template <typename Accessor>
inline TriaIterator<Accessor>::TriaIterator()
  : TriaRawIterator<Accessor>()
{}
 
 
template <typename Accessor>
inline TriaIterator<Accessor>::TriaIterator(const TriaIterator<Accessor> &i)
  : TriaRawIterator<Accessor>(i.accessor)
{}
 
 
template <typename Accessor>
inline TriaIterator<Accessor>::TriaIterator(const TriaRawIterator<Accessor> &i)
  : TriaRawIterator<Accessor>(i.accessor)
{
  if constexpr (running_in_debug_mode())
    {
      // do this like this, because:
      // if we write
      // "Assert (IteratorState::past_the_end || used)"
      // used() is called anyway, even if
      // state==IteratorState::past_the_end, and will then
      // throw the exception!
      if (this->state() != IteratorState::past_the_end)
        Assert(this->accessor.used(), ExcAssignmentOfUnusedObject());
    }
}
 
 
template <typename Accessor>
inline TriaIterator<Accessor>::TriaIterator(
  const Triangulation<Accessor::dimension, Accessor::space_dimension> *parent,
  const int                                                            level,
  const int                                                            index,
  const typename Accessor::AccessorData *local_data)
  : TriaRawIterator<Accessor>(parent, level, index, local_data)
{
  if constexpr (running_in_debug_mode())
    {
      // do this like this, because:
      // if we write
      // "Assert (IteratorState::past_the_end || used)"
      // used() is called anyway, even if
      // state==IteratorState::past_the_end, and will then
      // throw the exception!
      if (this->state() != IteratorState::past_the_end)
        Assert(this->accessor.used(), ExcAssignmentOfUnusedObject());
    }
}
 
 
template <typename Accessor>
inline TriaIterator<Accessor>::TriaIterator(
  const TriaAccessorBase<Accessor::structure_dimension,
                         Accessor::dimension,
                         Accessor::space_dimension> &tria_accessor,
  const typename Accessor::AccessorData             *local_data)
  : TriaRawIterator<Accessor>(tria_accessor, local_data)
{
  if constexpr (running_in_debug_mode())
    {
      // do this like this, because:
      // if we write
      // "Assert (IteratorState::past_the_end || used)"
      // used() is called anyway, even if
      // state==IteratorState::past_the_end, and will then
      // throw the exception!
      if (this->state() != IteratorState::past_the_end)
        Assert(this->accessor.used(), ExcAssignmentOfUnusedObject());
    }
}
 
 
template <typename Accessor>
inline TriaIterator<Accessor> &
TriaIterator<Accessor>::operator=(const TriaIterator<Accessor> &i)
{
  this->accessor.copy_from(i.accessor);
  return *this;
}
 
 
template <typename Accessor>
template <typename OtherAccessor>
inline TriaIterator<Accessor> &
TriaIterator<Accessor>::operator=(const TriaIterator<OtherAccessor> &i)
{
  this->accessor.copy_from(i.accessor);
  return *this;
}
 
 
template <typename Accessor>
inline TriaIterator<Accessor> &
TriaIterator<Accessor>::operator=(const TriaRawIterator<Accessor> &i)
{
  this->accessor.copy_from(i.accessor);
  if constexpr (running_in_debug_mode())
    {
      // do this like this, because:
      // if we write
      // "Assert (IteratorState::past_the_end || used)"
      // used() is called anyway, even if
      // state==IteratorState::past_the_end, and will then
      // throw the exception!
      if (this->state() != IteratorState::past_the_end)
        Assert(this->accessor.used(), ExcAssignmentOfUnusedObject());
    }
  return *this;
}
 
 
template <typename Accessor>
template <typename OtherAccessor>
inline TriaIterator<Accessor> &
TriaIterator<Accessor>::operator=(const TriaRawIterator<OtherAccessor> &i)
{
  this->accessor.copy_from(i.accessor);
  if constexpr (running_in_debug_mode())
    {
      // do this like this, because:
      // if we write
      // "Assert (IteratorState::past_the_end || used)"
      // used() is called anyway, even if
      // state==IteratorState::past_the_end, and will then
      // throw the exception!
      if (this->state() != IteratorState::past_the_end)
        Assert(this->accessor.used(), ExcAssignmentOfUnusedObject());
    }
  return *this;
}
 
 
template <typename Accessor>
inline TriaIterator<Accessor> &
TriaIterator<Accessor>::operator++()
{
  while (TriaRawIterator<Accessor>::operator++(),
         (this->state() == IteratorState::valid))
    if (this->accessor.used() == true)
      return *this;
  return *this;
}
 
 
template <typename Accessor>
inline TriaIterator<Accessor>
TriaIterator<Accessor>::operator++(int)
{
  TriaIterator<Accessor> tmp(*this);
  operator++();
 
  return tmp;
}
 
 
template <typename Accessor>
inline TriaIterator<Accessor> &
TriaIterator<Accessor>::operator--()
{
  while (TriaRawIterator<Accessor>::operator--(),
         (this->state() == IteratorState::valid))
    if (this->accessor.used() == true)
      return *this;
  return *this;
}
 
 
template <typename Accessor>
inline TriaIterator<Accessor>
TriaIterator<Accessor>::operator--(int)
{
  TriaIterator<Accessor> tmp(*this);
  operator--();
 
  return tmp;
}
 
 
/*-----------------------  functions: TriaActiveIterator ---------------*/
 
 
template <typename Accessor>
inline TriaActiveIterator<Accessor>::TriaActiveIterator()
  : TriaIterator<Accessor>()
{}
 
 
template <typename Accessor>
inline TriaActiveIterator<Accessor>::TriaActiveIterator(
  const TriaActiveIterator<Accessor> &i)
  : TriaIterator<Accessor>(static_cast<TriaIterator<Accessor>>(i))
{}
 
 
template <typename Accessor>
inline TriaActiveIterator<Accessor>::TriaActiveIterator(
  const TriaRawIterator<Accessor> &i)
  : TriaIterator<Accessor>(i)
{
  if constexpr (running_in_debug_mode())
    {
      // do this like this, because:
      // if we write
      // "Assert (IteratorState::past_the_end || !has_children())"
      // has_children() is called anyway, even if
      // state==IteratorState::past_the_end, and will then
      // throw the exception!
      if (this->state() != IteratorState::past_the_end)
        Assert(this->accessor.has_children() == false,
               ExcAssignmentOfInactiveObject());
    }
}
 
 
template <typename Accessor>
inline TriaActiveIterator<Accessor>::TriaActiveIterator(
  const TriaIterator<Accessor> &i)
  : TriaIterator<Accessor>(i)
{
  if constexpr (running_in_debug_mode())
    {
      // do this like this, because:
      // if we write
      // "Assert (IteratorState::past_the_end || !has_children())"
      // has_children() is called anyway, even if
      // state==IteratorState::past_the_end, and will then
      // throw the exception!
      if (this->state() != IteratorState::past_the_end)
        Assert(this->accessor.has_children() == false,
               ExcAssignmentOfInactiveObject());
    }
}
 
 
template <typename Accessor>
inline TriaActiveIterator<Accessor>::TriaActiveIterator(
  const Triangulation<Accessor::dimension, Accessor::space_dimension> *parent,
  const int                                                            level,
  const int                                                            index,
  const typename Accessor::AccessorData *local_data)
  : TriaIterator<Accessor>(parent, level, index, local_data)
{
  if constexpr (running_in_debug_mode())
    {
      // do this like this, because:
      // if we write
      // "Assert (IteratorState::past_the_end || !has_children())"
      // has_children() is called anyway, even if
      // state==IteratorState::past_the_end, and will then
      // throw the exception!
      if (this->state() != IteratorState::past_the_end)
        Assert(this->accessor.has_children() == false,
               ExcAssignmentOfInactiveObject());
    }
}
 
 
template <typename Accessor>
inline TriaActiveIterator<Accessor>::TriaActiveIterator(
  const TriaAccessorBase<Accessor::structure_dimension,
                         Accessor::dimension,
                         Accessor::space_dimension> &tria_accessor,
  const typename Accessor::AccessorData             *local_data)
  : TriaIterator<Accessor>(tria_accessor, local_data)
{
  if constexpr (running_in_debug_mode())
    {
      // do this like this, because:
      // if we write
      // "Assert (IteratorState::past_the_end || !has_children())"
      // has_children() is called anyway, even if
      // state==IteratorState::past_the_end, and will then
      // throw the exception!
      if (this->state() != IteratorState::past_the_end)
        Assert(this->accessor.has_children() == false,
               ExcAssignmentOfInactiveObject());
    }
}
 
 
template <typename Accessor>
inline TriaActiveIterator<Accessor> &
TriaActiveIterator<Accessor>::operator=(const TriaActiveIterator<Accessor> &i)
{
  this->accessor.copy_from(i.accessor);
  return *this;
}
 
 
template <typename Accessor>
template <class OtherAccessor>
inline TriaActiveIterator<Accessor> &
TriaActiveIterator<Accessor>::operator=(
  const TriaActiveIterator<OtherAccessor> &i)
{
  this->accessor.copy_from(i.accessor);
  return *this;
}
 
 
template <typename Accessor>
inline TriaActiveIterator<Accessor> &
TriaActiveIterator<Accessor>::operator=(const TriaRawIterator<Accessor> &i)
{
  this->accessor.copy_from(i.accessor);
  if constexpr (running_in_debug_mode())
    {
      // do this like this, because:
      // if we write
      // "Assert (IteratorState::past_the_end || !has_children())"
      // has_children() is called anyway, even if
      // state==IteratorState::past_the_end, and will then
      // throw the exception!
      if (this->state() != IteratorState::past_the_end)
        Assert(this->accessor.used() && this->accessor.has_children() == false,
               ExcAssignmentOfInactiveObject());
    }
  return *this;
}
 
 
template <typename Accessor>
template <class OtherAccessor>
inline TriaActiveIterator<Accessor> &
TriaActiveIterator<Accessor>::operator=(const TriaRawIterator<OtherAccessor> &i)
{
  this->accessor.copy_from(i.accessor);
  if constexpr (running_in_debug_mode())
    {
      // do this like this, because:
      // if we write
      // "Assert (IteratorState::past_the_end || !has_children())"
      // has_children() is called anyway, even if
      // state==IteratorState::past_the_end, and will then
      // throw the exception!
      if (this->state() != IteratorState::past_the_end)
        Assert(this->accessor.used() && this->accessor.has_children() == false,
               ExcAssignmentOfInactiveObject());
    }
  return *this;
}
 
 
template <typename Accessor>
template <class OtherAccessor>
inline TriaActiveIterator<Accessor> &
TriaActiveIterator<Accessor>::operator=(const TriaIterator<OtherAccessor> &i)
{
  this->accessor.copy_from(i.accessor);
  if constexpr (running_in_debug_mode())
    {
      // do this like this, because:
      // if we write
      // "Assert (IteratorState::past_the_end || !has_children())"
      // has_children() is called anyway, even if
      // state==IteratorState::past_the_end, and will then
      // throw the exception!
      if (this->state() != IteratorState::past_the_end)
        Assert(this->accessor.has_children() == false,
               ExcAssignmentOfInactiveObject());
    }
  return *this;
}
 
 
template <typename Accessor>
inline TriaActiveIterator<Accessor> &
TriaActiveIterator<Accessor>::operator=(const TriaIterator<Accessor> &i)
{
  this->accessor.copy_from(i.accessor);
  if constexpr (running_in_debug_mode())
    {
      // do this like this, because:
      // if we write
      // "Assert (IteratorState::past_the_end || !has_children())"
      // has_children() is called anyway, even if
      // state==IteratorState::past_the_end, and will then
      // throw the exception!
      if (this->state() != IteratorState::past_the_end)
        Assert(this->accessor.has_children() == false,
               ExcAssignmentOfInactiveObject());
    }
  return *this;
}
 
 
template <typename Accessor>
inline TriaActiveIterator<Accessor> &
TriaActiveIterator<Accessor>::operator++()
{
  while (TriaIterator<Accessor>::operator++(),
         (this->state() == IteratorState::valid))
    if (this->accessor.has_children() == false)
      return *this;
  return *this;
}
 
 
template <typename Accessor>
inline TriaActiveIterator<Accessor>
TriaActiveIterator<Accessor>::operator++(int)
{
  TriaActiveIterator<Accessor> tmp(*this);
  operator++();
 
  return tmp;
}
 
 
template <typename Accessor>
inline TriaActiveIterator<Accessor> &
TriaActiveIterator<Accessor>::operator--()
{
  while (TriaIterator<Accessor>::operator--(),
         (this->state() == IteratorState::valid))
    if (this->accessor.has_children() == false)
      return *this;
  return *this;
}
 
 
template <typename Accessor>
inline TriaActiveIterator<Accessor>
TriaActiveIterator<Accessor>::operator--(int)
{
  TriaActiveIterator<Accessor> tmp(*this);
  operator--();
 
  return tmp;
}
 
#endif
 
DEAL_II_NAMESPACE_CLOSE
 
#endif