indexediterator.hh

// -*- 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_COMMON_INDEXEDITERATOR_HH
#define DUNE_COMMON_INDEXEDITERATOR_HH
 
#include <iterator>
#include <type_traits>
 
#include <dune/common/iteratorfacades.hh>
 
namespace Dune
{
  template <class Iter>
  class IndexedIterator
      : public Iter
  {
    using Traits = std::iterator_traits<Iter>;
    static_assert(std::is_copy_constructible_v<Iter>);
    static_assert(std::is_base_of_v<std::forward_iterator_tag, typename Traits::iterator_category>);
 
  public:
    using size_type = typename Traits::difference_type;
 
    template <class I = Iter,
      std::enable_if_t<std::is_default_constructible_v<I>, bool> = true>
    constexpr IndexedIterator ()
          noexcept(std::is_nothrow_default_constructible_v<Iter>)
    {}
 
    constexpr IndexedIterator (Iter it, size_type index = 0)
          noexcept(std::is_nothrow_copy_constructible_v<Iter>)
      : Iter(it)
      , index_(index)
    {}
 
    [[nodiscard]] constexpr size_type index () const noexcept
    {
      return index_;
    }
 
    constexpr IndexedIterator& operator++ ()
    {
      Iter::operator++();
      ++index_;
      return *this;
    }
 
    constexpr IndexedIterator operator++ (int)
    {
      IndexedIterator tmp(*this);
      this->operator++();
      return tmp;
    }
 
    template <class I = Iter,
      decltype(--std::declval<I&>(), bool{}) = true>
    constexpr IndexedIterator& operator-- ()
    {
      Iter::operator--();
      --index_;
      return *this;
    }
 
    template <class I = Iter,
      decltype(std::declval<I&>()--, bool{}) = true>
    constexpr IndexedIterator operator-- (int)
    {
      IndexedIterator tmp(*this);
      this->operator--();
      return tmp;
    }
 
    template <class I = Iter,
      decltype(std::declval<I&>()+=1, bool{}) = true>
    constexpr IndexedIterator& operator+= (typename Iter::difference_type n)
    {
      Iter::operator+=(n);
      index_ += n;
      return *this;
    }
 
    template <class I = Iter,
      decltype(std::declval<I&>()-=1, bool{}) = true>
    constexpr IndexedIterator& operator-= (typename Iter::difference_type n)
    {
      Iter::operator-=(n);
      index_ -= n;
      return *this;
    }
 
  private:
    size_type index_ = 0;
  };
 
 
  template <class T>
  class IndexedIterator<T*>
    : public Dune::IteratorFacade<IndexedIterator<T*>, std::random_access_iterator_tag, T>
  {
    using Facade = Dune::IteratorFacade<IndexedIterator<T*>, std::random_access_iterator_tag, T>;
 
  public:
    using reference = typename Facade::reference;
    using difference_type = typename Facade::difference_type;
    using iterator_type = T*;
 
    constexpr explicit IndexedIterator (T* ptr, difference_type index = 0)
      : ptr_(ptr)
      , index_(index)
    {}
 
    constexpr reference operator* () const { return *ptr_; }
 
    constexpr IndexedIterator& operator+= (typename Facade::difference_type d)
    {
      ptr_ += d;
      index_ += d;
      return *this;
    }
 
    friend constexpr difference_type operator- (const IndexedIterator& it1, const IndexedIterator& it2)
    {
      return it1.ptr_ - it2.ptr_;
    }
 
    friend constexpr bool operator== (const IndexedIterator& it1, const IndexedIterator& it2)
    {
      return it1.ptr_ == it2.ptr_;
    }
 
    [[nodiscard]] constexpr difference_type index () const noexcept
    {
      return index_;
    }
 
  private:
    T* ptr_ = nullptr;
    difference_type index_ = 0;
  };
 
} // end namespace Dune
 
#endif // DUNE_COMMON_INDEXEDITERATOR_HH