entityiterator.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_GRID_ENTITYITERATOR_HH
#define DUNE_GRID_ENTITYITERATOR_HH
 
#include <cstddef>
#include <iterator>
 
#include <dune/grid/common/entitypointer.hh>
 
namespace Dune
{
 
  template< int codim, class Grid, class IteratorImp >
  class EntityIterator
    : public EntityPointer< Grid, IteratorImp >
  {
    typedef EntityPointer< Grid, IteratorImp > Base;
 
  protected:
    using Base::realIterator;
 
  public:
    typedef typename Grid::template Codim< codim >::Entity Entity;
 
    EntityIterator &operator++ ()
    {
      realIterator.increment();
      return *this;
    }
 
    EntityIterator operator++ (int)
    {
      EntityIterator tmp(*this);
      realIterator.increment();
      return tmp;
    }
 
    // The dereferencing operators are overridden here to avoid calling
    // the deprecated versions in the EntityPointer facade.
 
    // 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 )
      : Base( 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_ENTITYITERATOR_HH