common/intersectioniterator.hh

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (C) 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