agglomeration_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) XXXX - YYYY by the polyDEAL authors
//
// This file is part of the polyDEAL library.
//
// Detailed license information governing the source code
// can be found in LICENSE.md at the top level directory.
//
// -----------------------------------------------------------------------------
 
#ifndef agglomeration_iterator_h
#define agglomeration_iterator_h
 
 
#include <agglomeration_accessor.h>
 

template <int dim, int spacedim = dim>
class AgglomerationIterator
{
public:
  using AgglomerationContainer =
    typename AgglomerationAccessor<dim, spacedim>::AgglomerationContainer;

  AgglomerationIterator();

  AgglomerationIterator(
    const typename Triangulation<dim, spacedim>::active_cell_iterator &cell,
    const AgglomerationHandler<dim, spacedim>                         *handler);

  AgglomerationIterator(
    const typename Triangulation<dim, spacedim>::active_cell_iterator
                                              &master_cell,
    const CellId                              &cell_id,
    const AgglomerationHandler<dim, spacedim> *handler);

  const AgglomerationAccessor<dim, spacedim> &
  operator*() const;

  AgglomerationAccessor<dim, spacedim> &
  operator*();

  const AgglomerationAccessor<dim, spacedim> *
  operator->() const;

  AgglomerationAccessor<dim, spacedim> *
  operator->();

  bool
  operator==(const AgglomerationIterator<dim, spacedim> &) const;

  bool
  operator!=(const AgglomerationIterator<dim, spacedim> &) const;

  AgglomerationIterator &
  operator++();

  AgglomerationIterator
  operator++(int);

  AgglomerationIterator &
  operator--();

  AgglomerationIterator
  operator--(int);

  IteratorState::IteratorStates
  state() const;

  const typename Triangulation<dim, spacedim>::active_cell_iterator &
  master_cell() const;

  using iterator_category = std::bidirectional_iterator_tag;
  using value_type        = AgglomerationAccessor<dim, spacedim>;
  using difference_type   = std::ptrdiff_t;
  using pointer           = AgglomerationAccessor<dim, spacedim> *;
  using reference         = AgglomerationAccessor<dim, spacedim> &;
 
private:
  AgglomerationAccessor<dim, spacedim> accessor;
};
 
 
 
// ------------------------------ inline functions -------------------------
 
template <int dim, int spacedim>
inline AgglomerationIterator<dim, spacedim>::AgglomerationIterator()
  : accessor()
{}
 
 
 
template <int dim, int spacedim>
inline AgglomerationIterator<dim, spacedim>::AgglomerationIterator(
  const typename Triangulation<dim, spacedim>::active_cell_iterator
                                            &master_cell,
  const AgglomerationHandler<dim, spacedim> *handler)
  : accessor(master_cell, handler)
{}
 
template <int dim, int spacedim>
inline AgglomerationIterator<dim, spacedim>::AgglomerationIterator(
  const typename Triangulation<dim, spacedim>::active_cell_iterator
                                            &master_cell,
  const CellId                              &cell_id,
  const AgglomerationHandler<dim, spacedim> *handler)
  : accessor(master_cell, cell_id, handler)
{}
 
 
 
template <int dim, int spacedim>
inline AgglomerationAccessor<dim, spacedim> &
AgglomerationIterator<dim, spacedim>::operator*()
{
  return accessor;
}
 
 
 
template <int dim, int spacedim>
inline AgglomerationAccessor<dim, spacedim> *
AgglomerationIterator<dim, spacedim>::operator->()
{
  return &(this->operator*());
}
 
 
 
template <int dim, int spacedim>
inline const AgglomerationAccessor<dim, spacedim> &
AgglomerationIterator<dim, spacedim>::operator*() const
{
  return accessor;
}
 
 
 
template <int dim, int spacedim>
inline const AgglomerationAccessor<dim, spacedim> *
AgglomerationIterator<dim, spacedim>::operator->() const
{
  return &(this->operator*());
}
 
 
 
template <int dim, int spacedim>
inline bool
AgglomerationIterator<dim, spacedim>::operator!=(
  const AgglomerationIterator<dim, spacedim> &other) const
{
  return accessor != other.accessor;
}
 
 
 
template <int dim, int spacedim>
inline bool
AgglomerationIterator<dim, spacedim>::operator==(
  const AgglomerationIterator<dim, spacedim> &other) const
{
  return accessor == other.accessor;
}
 
 
 
template <int dim, int spacedim>
inline AgglomerationIterator<dim, spacedim> &
AgglomerationIterator<dim, spacedim>::operator++()
{
  accessor.next();
  return *this;
}
 
 
 
template <int dim, int spacedim>
inline AgglomerationIterator<dim, spacedim>
AgglomerationIterator<dim, spacedim>::operator++(int)
{
  AgglomerationIterator tmp(*this);
  operator++();
 
  return tmp;
}
 
 
 
template <int dim, int spacedim>
inline AgglomerationIterator<dim, spacedim> &
AgglomerationIterator<dim, spacedim>::operator--()
{
  accessor.prev();
  return *this;
}
 
 
 
template <int dim, int spacedim>
inline AgglomerationIterator<dim, spacedim>
AgglomerationIterator<dim, spacedim>::operator--(int)
{
  AgglomerationIterator tmp(*this);
  operator--();
 
  return tmp;
}
 
 
 
template <int dim, int spacedim>
inline IteratorState::IteratorStates
AgglomerationIterator<dim, spacedim>::state() const
{
  return accessor.master_cell.state();
}
 
 
 
template <int dim, int spacedim>
inline const typename Triangulation<dim, spacedim>::active_cell_iterator &
AgglomerationIterator<dim, spacedim>::master_cell() const
{
  return accessor.master_cell;
}
 
 
 
#endif