genericiterator.hh

Go to the documentation of this file.

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
// SPDX-FileCopyrightInfo: Copyright © DUNE Project contributors, see file LICENSE.md in module root
// SPDX-License-Identifier: LicenseRef-GPL-2.0-only-with-DUNE-exception
#ifndef DUNE_GENERICITERATOR_HH
#define DUNE_GENERICITERATOR_HH
 
#include <dune/common/iteratorfacades.hh>
#include <cassert>
 
namespace Dune {
 
  template<class R>
  struct const_reference
  {
    typedef const R type;
  };
 
  template<class R>
  struct const_reference<const R>
  {
    typedef const R type;
  };
 
  template<class R>
  struct const_reference<R&>
  {
    typedef const R& type;
  };
 
  template<class R>
  struct const_reference<const R&>
  {
    typedef const R& type;
  };
 
  template<class R>
  struct mutable_reference
  {
    typedef R type;
  };
 
  template<class R>
  struct mutable_reference<const R>
  {
    typedef R type;
  };
 
  template<class R>
  struct mutable_reference<R&>
  {
    typedef R& type;
  };
 
  template<class R>
  struct mutable_reference<const R&>
  {
    typedef R& type;
  };
 
  template<class C, class T, class R=T&, class D = std::ptrdiff_t,
      template<class,class,class,class> class IteratorFacade=RandomAccessIteratorFacade>
  class GenericIterator :
    public IteratorFacade<GenericIterator<C,T,R,D,IteratorFacade>,T,R,D>
  {
    friend class GenericIterator<typename std::remove_const<C>::type, typename std::remove_const<T>::type, typename mutable_reference<R>::type, D, IteratorFacade>;
    friend class GenericIterator<const typename std::remove_const<C>::type, const typename std::remove_const<T>::type, typename const_reference<R>::type, D, IteratorFacade>;
 
    typedef GenericIterator<typename std::remove_const<C>::type, typename std::remove_const<T>::type, typename mutable_reference<R>::type, D, IteratorFacade> MutableIterator;
    typedef GenericIterator<const typename std::remove_const<C>::type, const typename std::remove_const<T>::type, typename const_reference<R>::type, D, IteratorFacade> ConstIterator;
 
  public:
 
    typedef C Container;
 
    typedef T Value;
 
    typedef D DifferenceType;
 
    typedef R Reference;
 
    // Constructors needed by the base iterators
    GenericIterator() : container_(0), position_(0)
    {}
 
    GenericIterator(Container& cont, DifferenceType pos)
      : container_(&cont), position_(pos)
    {}
 
    GenericIterator(const MutableIterator& other) : container_(other.container_), position_(other.position_)
    {}
 
    GenericIterator(const ConstIterator& other) : container_(other.container_), position_(other.position_)
    {}
 
    // Methods needed by the forward iterator
    bool equals(const MutableIterator & other) const
    {
      return position_ == other.position_ && container_ == other.container_;
    }
 
    bool equals(const ConstIterator & other) const
    {
      return position_ == other.position_ && container_ == other.container_;
    }
 
    Reference dereference() const {
      return container_->operator[](position_);
    }
 
    void increment(){
      ++position_;
    }
 
    // Additional function needed by BidirectionalIterator
    void decrement(){
      --position_;
    }
 
    // Additional function needed by RandomAccessIterator
    Reference elementAt(DifferenceType i) const {
      return container_->operator[](position_+i);
    }
 
    void advance(DifferenceType n){
      position_=position_+n;
    }
 
    DifferenceType distanceTo(const MutableIterator& other) const
    {
      assert(other.container_==container_);
      return other.position_ - position_;
    }
 
    DifferenceType distanceTo(const ConstIterator& other) const
    {
      assert(other.container_==container_);
      return other.position_ - position_;
    }
 
  private:
    Container *container_;
    DifferenceType position_;
  };
 
} // end namespace Dune
 
#endif