common/entityiterator.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_ENTITYITERATOR_HH
#define DUNE_GRID_COMMON_ENTITYITERATOR_HH
 
#include <cstddef>
#include <iterator>
 
namespace Dune
{
 
  template< int codim, class Grid, class IteratorImp >
  class EntityIterator
  {
  protected:
    IteratorImp realIterator;
 
  public:
    typedef IteratorImp Implementation;
 
    Implementation &impl () { return realIterator; }
    const Implementation &impl () const { return realIterator; }
 
    typedef typename Grid::template Codim< codim >::Entity Entity;
 
    typedef typename std::conditional<
      std::is_lvalue_reference<
        decltype(realIterator.dereference())
        >::value,
      const Entity&,
      Entity
      >::type Reference;
 
    EntityIterator &operator++ ()
    {
      realIterator.increment();
      return *this;
    }
 
    EntityIterator operator++ (int)
    {
      EntityIterator tmp(*this);
      realIterator.increment();
      return tmp;
    }
 
    // The behavior when dereferencing the EntityIterator facade depends on
    // the way the grid implementation handles returning entities. The implementation
    // may either return a reference to an entity stored inside the EntityIterator
    // implementation or a temporary Entity 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
 
    const Entity& operator*() const;
 
    const Entity& operator->() const;
 
#else // DOXYGEN
 
    typename std::conditional<
      std::is_lvalue_reference<
        decltype(realIterator.dereference())
        >::value,
      const Entity&,
      Entity
      >::type
    operator*() const
    {
      return realIterator.dereference();
    }
 
    decltype(handle_proxy_member_access(realIterator.dereference()))
    operator->() const
    {
      return handle_proxy_member_access(realIterator.dereference());
    }
 
#endif // DOXYGEN
 
 
    bool operator==(const EntityIterator& rhs) const
    {
      return this->realIterator.equals(rhs.realIterator);
    }
 
    bool operator!=(const EntityIterator& rhs) const
    {
      return !this->realIterator.equals(rhs.realIterator);
    }
 
 
    EntityIterator ( )
    {}
 
    EntityIterator ( const IteratorImp &imp )
      : realIterator( imp )
    {}
 
  };
 
} // namespace Dune
 
namespace std
{
 
  template< int codim, class Grid, class IteratorImp >
  struct iterator_traits< Dune::EntityIterator< codim, Grid, IteratorImp > >
  {
    typedef ptrdiff_t difference_type;
    typedef const typename IteratorImp::Entity value_type;
    typedef value_type *pointer;
    typedef value_type &reference;
    typedef forward_iterator_tag iterator_category;
  };
 
} // namespace std
 
#endif // #ifndef DUNE_GRID_COMMON_ENTITYITERATOR_HH