indexrange.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_INDEXRANGE_HH
#define DUNE_ISTL_EXPERIMENTAL_INDEXRANGE_HH
 
#include <dune/common/rangeutilities.hh>
 
#include <algorithm>
#include <concepts>
#include <iterator>
#include <ranges>
 
 
namespace Dune::Experimental {
 
namespace Concepts {
 
template<class R>
concept OrderedIndexRange =
  std::ranges::random_access_range<R> &&
  std::totally_ordered<std::ranges::range_value_t<R>>;
 
template<class R>
concept BorrowedOrderedIndexRange = OrderedIndexRange<R> && std::ranges::borrowed_range<R>;
 
} // namespace Concepts
 
template<Concepts::OrderedIndexRange R>
struct OrderedIndexRangeTraits
{
  using index_range_type = R;
  using index_type = std::ranges::range_value_t<index_range_type>;
  using size_type = std::ranges::range_size_t<index_range_type>;
 
  constexpr static IntegralRange<index_type> range(const R& index_set)
  {
    auto it = std::cbegin(index_set);
    auto size = std::distance(it, std::cend(index_set));
    if (size == 0)
      return {0, 0};
    return { *it, *(it + (size - 1)) + 1 };
  }
 
  constexpr static size_type offset(const R& index_set,
                                    const index_type& value)
  {
    const auto lb = std::lower_bound(std::cbegin(index_set), std::cend(index_set), value);
    return static_cast<size_type>(std::distance(std::cbegin(index_set), lb));
  }
};
 
template<class T>
struct OrderedIndexRangeTraits<IntegralRange<T>>
{
  using index_type = T;
  using size_type = typename IntegralRange<T>::size_type;
 
  constexpr static IntegralRange<index_type> range(
    const IntegralRange<T>& index_set)
  {
    return index_set;
  }
 
  constexpr static size_type offset(const IntegralRange<T>& index_set,
                                    const index_type& value)
  {
    return static_cast<size_type>(value - *index_set.begin());
  }
};
 
} // namespace Dune::Experimental
 
#endif // DUNE_ISTL_EXPERIMENTAL_INDEXRANGE_HH