common/intersectioniterator.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_GRID_COMMON_INTERSECTIONITERATOR_HH
#define DUNE_GRID_COMMON_INTERSECTIONITERATOR_HH

#include <dune/common/iteratorfacades.hh>
#include <dune/common/proxymemberaccess.hh>

#include <dune/grid/common/intersection.hh>

namespace Dune
{

  template< class GridImp, class IntersectionIteratorImp, class IntersectionImp >
  class IntersectionIterator
  {
  public:
    typedef IntersectionIteratorImp Implementation;

    Implementation &impl () { return realIterator; }

    const Implementation &impl () const { return realIterator; }

  protected:
    Implementation realIterator;

  public:
    typedef Dune::Intersection< GridImp, IntersectionImp > Intersection;

    //===========================================================
    //===========================================================

    // The behavior when dereferencing the IntersectionIterator facade depends on
    // the way the grid implementation handles returning intersections. The implementation
    // may either return a reference to an intersection stored inside the IntersectionIterator
    // implementation or a temporary Intersection object. This object has to be forwarded through
    // the facade to the user, which requires a little trickery, especially for operator->().
    //
    // In order to avoid confusing users reading the Doxygen documentation, we provide "clean"
    // function signatures to Doxygen and hide the actual implementations.

#ifdef DOXYGEN

    Intersection operator*() const;

    const Intersection* operator->() const;

#else // DOXYGEN

    typename std::conditional<
      std::is_lvalue_reference<
        decltype(realIterator.dereference())
        >::value,
      const Intersection&,
      Intersection
      >::type
    operator*() const
    {
      return this->realIterator.dereference();
    }

    decltype(handle_proxy_member_access(realIterator.dereference()))
    operator->() const
    {
      return handle_proxy_member_access(realIterator.dereference());
    }

#endif // DOXYGEN



    //===========================================================
    //===========================================================

    bool operator==(const IntersectionIterator& rhs) const
    {
      return rhs.equals(*this);
    }

    bool operator!=(const IntersectionIterator& rhs) const
    {
      return ! rhs.equals(*this);
    }

    IntersectionIterator& operator++()
    {
      this->realIterator.increment();
      return *this;
    }

    IntersectionIterator operator++(int)
    {
      IntersectionIterator copy(*this);
      this->realIterator.increment();
      return copy;
    }

    IntersectionIterator()
    {}

    //===========================================================
    //===========================================================

    bool equals(const IntersectionIterator& rhs) const
    {
      return this->realIterator.equals(rhs.realIterator);
    }

    IntersectionIterator ( const Implementation &impl )
      : realIterator( impl )
    {}
  };

} // namespace Dune


namespace std
{

  template< class GridImp, class IntersectionIteratorImp, class IntersectionImp >
  struct iterator_traits< Dune::IntersectionIterator< GridImp, IntersectionIteratorImp, IntersectionImp > >
  {
    typedef ptrdiff_t difference_type;
    typedef const typename Dune::Intersection< GridImp, IntersectionImp > value_type;
    typedef value_type *pointer;
    typedef value_type &reference;
    typedef forward_iterator_tag iterator_category;
  };

} // namespace std

#include "intersection.hh"

#endif // DUNE_GRID_COMMON_INTERSECTIONITERATOR_HH