intersectionsetiterator.hh

Go to the documentation of this file.

// -*- tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set ts=8 sw=2 et sts=2:
 
// SPDX-FileCopyrightText: Copyright © DUNE-FUFEM Project contributors, see file AUTHORS.md
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception OR LGPL-3.0-or-later
 
#ifndef DUNE_FUFEM_DOMAINS_INTERSECTIONSETITERATOR_HH
#define DUNE_FUFEM_DOMAINS_INTERSECTIONSETITERATOR_HH
 
#include <iterator>
#include <optional>
#include <type_traits>
#include <utility>
#include <variant>
 
#include <dune/common/iteratorfacades.hh>
#include <dune/common/version.hh>
#if DUNE_VERSION_GTE(DUNE_FUNCTIONS, 2, 11)
#include <dune/common/std/no_unique_address.hh>
#endif
 
 
 
namespace Dune::Fufem {
 
 
 
template <class IS>
class IntersectionSetIterator
  : public Dune::IteratorFacade<IntersectionSetIterator<IS>, std::forward_iterator_tag, const typename IS::GridView::Intersection>
{
  using IntersectionSet = IS;
  using Facade = Dune::IteratorFacade<IntersectionSetIterator<IS>, std::forward_iterator_tag, const typename IS::GridView::Intersection>;
 
  using GridView = typename IntersectionSet::GridView;
  using Element = typename GridView::template Codim<0>::Entity;
  using ElementIterator = typename GridView::template Codim<0>::Iterator;
  using IntersectionIterator = typename GridView::IntersectionIterator;
  using Intersection = typename GridView::Intersection;
 
  // A grid implementations iteratrs may return elements and intersection by value or by reference.
  // Since we need the same dereferenced element and intersection multiple types, they
  // are cached internally in case the grid returns them by value.
  static constexpr bool cacheElement = not std::is_lvalue_reference_v<decltype(std::declval<ElementIterator>().operator*())>;
  static constexpr bool cacheIntersection = not std::is_lvalue_reference_v<decltype(std::declval<IntersectionIterator>().operator*())>;
 
  using ElementStorage = std::conditional_t<cacheElement, std::optional<Element>, std::monostate>;
  using IntersectionStorage = std::conditional_t<cacheIntersection, std::optional<Intersection>, std::monostate>;
 
  // Get current element by accessing the cache or dereferencing the iterator
  const Element& element () const
  {
    if constexpr (cacheElement)
      return *element_;
    else
      return *elementIt_;
  }
 
  void updateElement ()
  {
    if constexpr (cacheElement)
      element_ = *elementIt_;
  }
 
  // Get current intersection by accessing the cache or dereferencing the iterator
  const Intersection& intersection () const
  {
    if constexpr (cacheIntersection)
      return *intersection_;
    else
      return **iIt_;
  }
 
  void updateIntersection ()
  {
    if constexpr (cacheIntersection)
      intersection_ = **iIt_;
  }
 
public:
 
  using reference = const Intersection&;
 
  class SentinelIterator
  {};
 
  IntersectionSetIterator () = default;
 
  IntersectionSetIterator (const IntersectionSet& intersectionSet, ElementIterator elementBegin, ElementIterator elementEnd)
    : intersectionSet_(&intersectionSet)
    , elementIt_(std::move(elementBegin))
    , elementEnd_(std::move(elementEnd))
  {
    if (elementIt_ != elementEnd_)
    {
      updateElement();
      iIt_ = intersectionSet_->gridView().ibegin(element());
      updateIntersection();
      if (not intersectionSet_->contains(intersection()))
        ++(*this);
    }
  }
 
  IntersectionSetIterator (const IntersectionSet& intersectionSet, ElementIterator elementBegin)
    : IntersectionSetIterator(intersectionSet, elementBegin, intersectionSet.gridView().template end<0>())
  {}
 
  IntersectionSetIterator (const IntersectionSet& intersectionSet)
    : IntersectionSetIterator(intersectionSet, intersectionSet.gridView().template begin<0>())
  {}
 
  reference operator* () const
  {
    return intersection();
  }
 
  IntersectionSetIterator& operator++ ()
  {
    while (true)
    {
      ++(*iIt_);
      if (*iIt_ == intersectionSet_->gridView().iend(element()))
      {
        while (true)
        {
          ++elementIt_;
          if (elementIt_ == elementEnd_)
            return *this;
          updateElement();
          if (intersectionSet_->containsFaceOf(element()))
            break;
        }
        iIt_ = intersectionSet_->gridView().ibegin(element());
      }
      updateIntersection();
      if (intersectionSet_->contains(intersection()))
        return *this;
    }
    return *this;
  }
 
  friend bool operator== (const IntersectionSetIterator& it1, const IntersectionSetIterator& it2)
  {
    // If both iterators point to different elements, we can exit immediately.
    // Hence we return after one comparison, when comparing against an end
    // iterator during iteration.
    if (it1.elementIt_ != it2.elementIt_)
      return false;
    // If the iterators point to the same element and the latter is the element
    // end iterator, then both are end iterators and thus equal. Hence we return
    // after two comparisons when reaching the end.
    if (it1.elementIt_ == it1.elementEnd_)
      return true;
    // The comparison of the intersection iterators is left to the less frequent
    // case of comparing two non-end iterators.
    return (*(it1.iIt_) == *(it2.iIt_));
  }
 
  friend bool operator== (const IntersectionSetIterator& it1, const SentinelIterator& it2)
  {
    return it1.elementIt_ == it1.elementEnd_;
  }
 
private:
  const IntersectionSet* intersectionSet_ = nullptr;
  ElementIterator elementIt_;
  ElementIterator elementEnd_;
  std::optional<IntersectionIterator> iIt_;
#if DUNE_VERSION_GTE(DUNE_FUNCTIONS, 2, 11)
  DUNE_NO_UNIQUE_ADDRESS ElementStorage element_;
  DUNE_NO_UNIQUE_ADDRESS IntersectionStorage intersection_;
#else
  ElementStorage element_;
  IntersectionStorage intersection_;
#endif
};
 
 
 
} // namespace Dune::Fufem
 
 
 
#endif // DUNE_FUFEM_DOMAINS_INTERSECTIONSETITERATOR_HH