indexedarrayview.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_ISTL_EXPERIMENTAL_INDEXEDARRAYVIEW_HH
#define DUNE_ISTL_EXPERIMENTAL_INDEXEDARRAYVIEW_HH
 
#include "indexrange.hh"
#include "../istlexception.hh"
 
#include <dune/common/iteratorfacades.hh>
#include <dune/common/rangeutilities.hh>
 
#include <cassert>
#include <cstddef>
#include <iterator>
#include <ranges>
#include <type_traits>
#include <utility>
 
namespace Dune::Experimental {
 
template<std::random_access_iterator T, Concepts::BorrowedOrderedIndexRange R>
class IndexedArrayView
{
public:
  using index_range_type = R;
  using member_type = std::iter_value_t<T>;
  using index_type = typename OrderedIndexRangeTraits<index_range_type>::index_type;
  using size_type = typename OrderedIndexRangeTraits<index_range_type>::size_type;
  using reference = std::iter_reference_t<T>;
#if __cpp_lib_ranges_as_const >= 202207L
  using const_reference = std::iter_const_reference_t<T>;
#else
  using const_reference = std::common_reference_t<const std::iter_value_t<T>&&,
                                                  std::iter_reference_t<T>>;
#endif
 
  reference operator[](index_type i)
  {
    const size_type offset = OrderedIndexRangeTraits<index_range_type>::offset(index_set_, i);
#ifdef DUNE_ISTL_WITH_CHECKING
    if (offset >= size() || index_set_[offset] != i)
      DUNE_THROW(ISTLError, "index " << i << " not in base array index set");
#endif
    return data_[offset];
  }
 
  const_reference operator[](index_type i) const
  {
    const size_type offset = OrderedIndexRangeTraits<index_range_type>::offset(index_set_, i);
#ifdef DUNE_ISTL_WITH_CHECKING
    if (offset >= size() || index_set_[offset] != i)
      DUNE_THROW(ISTLError, "index " << i << " not in base array index set");
#endif
    return data_[offset];
  }
 
private:
  class ConstIterator;
 
  class Iterator
    : public Dune::IteratorFacade<Iterator,
                                  std::random_access_iterator_tag,
                                  std::remove_reference_t<reference>,
                                  reference>
  {
    using Facade = Dune::IteratorFacade<Iterator,
                                        std::random_access_iterator_tag,
                                        std::remove_reference_t<reference>,
                                        reference>;
 
  public:
    using offset_type = typename OrderedIndexRangeTraits<index_range_type>::size_type;
 
    constexpr Iterator() noexcept = default;
    constexpr Iterator(const Iterator&) = default;
    constexpr Iterator& operator=(const Iterator&) = default;
 
    explicit constexpr Iterator(
      T data,
      index_range_type index_set_,
      offset_type
        offset) noexcept(std::is_nothrow_copy_constructible_v<T> &&
                         std::is_nothrow_copy_constructible_v<index_range_type> &&
                         std::is_nothrow_copy_constructible_v<offset_type>)
      : data_(data)
      , index_set_(index_set_)
      , offset_(offset)
    {
    }
 
    constexpr index_type index() const { return index_set_[offset_]; }
    constexpr offset_type offset() const { return offset_; }
 
    // Reference to the component at the current iterator position.
    constexpr typename Facade::reference operator*() const { return data_[offset_]; }
 
  private:
    friend Dune::IteratorFacadeAccess;
    friend ConstIterator;
 
    constexpr const offset_type& baseIterator() const { return offset_; }
    constexpr offset_type& baseIterator() { return offset_; }
 
    T data_;
    index_range_type index_set_;
    offset_type offset_;
  };
 
  class ConstIterator
    : public Dune::IteratorFacade<ConstIterator,
                                  std::random_access_iterator_tag,
                                  std::remove_reference_t<const_reference>,
                                  const_reference>
  {
    using Facade =
      Dune::IteratorFacade<ConstIterator,
                           std::random_access_iterator_tag,
                           std::remove_reference_t<const_reference>,
                           const_reference>;
 
  public:
    using offset_type = typename OrderedIndexRangeTraits<index_range_type>::size_type;
 
    constexpr ConstIterator() noexcept = default;
    constexpr ConstIterator(const ConstIterator& other) = default;
    constexpr ConstIterator& operator=(const ConstIterator& other) = default;
 
    constexpr ConstIterator(const Iterator& it) noexcept(std::is_nothrow_copy_constructible_v<Iterator>)
      : it_(it)
    {}
 
    constexpr ConstIterator& operator=(const Iterator& it) noexcept(std::is_nothrow_copy_assignable_v<Iterator>)
    {
      it_ = it;
      return *this;
    }
 
    constexpr index_type index() const { return it_.index(); }
    constexpr offset_type offset() const { return it_.offset(); }
 
    constexpr typename Facade::reference operator*() const { return *it_; }
 
  private:
    friend Dune::IteratorFacadeAccess;
    friend Iterator;
 
    constexpr const offset_type& baseIterator() const { return it_.baseIterator(); }
    constexpr offset_type& baseIterator() { return it_.baseIterator(); }
 
    Iterator it_;
  };
 
public:
  using iterator = Iterator;
  using const_iterator = ConstIterator;
 
  constexpr iterator begin() noexcept(
    noexcept(iterator(data_, index_set_, size_type{})))
  {
    return iterator(data_, index_set_, size_type{ 0 });
  }
 
  constexpr iterator end() noexcept(
    noexcept(iterator(data_, index_set_, size_type{})))
  {
    return iterator(data_, index_set_, size());
  }
 
  iterator find(size_type i)
  {
    const size_type ofs = OrderedIndexRangeTraits<index_range_type>::offset(index_set_, i);
    return (ofs == size() || std::cmp_not_equal(index_set_[ofs], i)) ? end() : iterator(data_, index_set_, ofs);
  }
 
  bool contains(index_type i) const
  {
    const size_type ofs = OrderedIndexRangeTraits<index_range_type>::offset(index_set_, i);
    return ofs != size() && index_set_[ofs] == i;
  }
 
  constexpr const_iterator begin() const
    noexcept(noexcept(iterator(data_, index_set_, size_type{})))
  {
    return iterator(data_, index_set_, size_type{ 0 });
  }
 
  constexpr const_iterator end() const
    noexcept(noexcept(iterator(data_, index_set_, size_type{})))
  {
    return iterator(data_, index_set_, size());
  }
 
  const_iterator find(size_type i) const
  {
    const size_type ofs = OrderedIndexRangeTraits<index_range_type>::offset(index_set_, i);
    return (ofs == size() || index_set_[ofs] != i) ? end() : const_iterator{iterator{data_, index_set_, ofs}};
  }
 
  //===== sizes
 
  constexpr size_type size() const
    noexcept(noexcept(std::ranges::size(index_set_)))
  {
    return std::ranges::size(index_set_);
  }
 
  constexpr index_range_type indexSet() const
  {
    return index_set_;
  }
 
  IndexedArrayView(T data, index_range_type index_set) noexcept(
    std::is_nothrow_copy_constructible_v<T> &&
    std::is_nothrow_copy_constructible_v<index_range_type>)
    : data_(data)
    , index_set_(index_set) {};
 
private:
  T data_;
  index_range_type index_set_;
};
 
} // namespace Dune::Experimental
 
#endif // DUNE_ISTL_EXPERIMENTAL_INDEXEDARRAYVIEW_HH