range-concepts.hpp

Go to the documentation of this file.

/* This file is part of OpenKalman, a header-only C++ library for
 * Kalman filters and other recursive filters.
 *
 * Copyright (c) 2025 Christopher Lee Ogden <ogden@gatech.edu>
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at https://mozilla.org/MPL/2.0/.
 */

#ifndef OPENKALMAN_RANGES_RANGE_CONCEPTS_HPP
#define OPENKALMAN_RANGES_RANGE_CONCEPTS_HPP

#ifndef __cpp_lib_ranges

#include "basics/compatibility/language-features.hpp"
#include "basics/compatibility/iterator.hpp"
#include "range-access.hpp"

namespace OpenKalman::ranges
{
  // ---
  // range
  // ---

  namespace detail
  {
    template<typename T, typename = void>
    struct is_range : std::false_type {};

    template<typename T>
    struct is_range<T, std::void_t<iterator_t<T>, sentinel_t<T>>> : std::true_type {};
  }


  template<typename T>
  inline constexpr bool range = detail::is_range<T>::value;


  // ---
  // borrowed_range
  // ---

  namespace detail_borrowed_range
  {
#ifdef __cpp_lib_remove_cvref
    using std::remove_cvref_t;
#endif


    template<typename R, typename = void>
    struct is_borrowed_range : std::false_type {};

    template<typename R>
    struct is_borrowed_range<R, std::enable_if_t<range<R> and
      (std::is_lvalue_reference_v<R> or enable_borrowed_range<remove_cvref_t<R>>)>> : std::true_type {};
  }

  template<typename T>
  inline constexpr bool borrowed_range = detail_borrowed_range::is_borrowed_range<T>::value;


  // ---
  // sized_range
  // ---

  namespace detail
  {
    template<typename T, typename = void>
    struct is_sized_range : std::false_type {};

    template<typename T>
    struct is_sized_range<T, std::void_t<decltype(ranges::size(std::declval<T&>()))>> : std::true_type {};

  }

  template<typename T>
  inline constexpr bool sized_range = range<T> and detail::is_sized_range<T>::value;


  // ---
  // input_range
  // ---

  namespace detail
  {
    template<typename T, typename = void>
    struct has_input_iterator : std::false_type {};

    template<typename T>
    struct has_input_iterator<T, std::enable_if_t<input_iterator<iterator_t<T>>>> : std::true_type {};
  }


  template<typename T>
  inline constexpr bool input_range = range<T> and detail::has_input_iterator<T>::value;


  // ---
  // output_range
  // ---

  namespace detail
  {
    template<typename R, typename T, typename = void>
    struct has_output_iterator : std::false_type {};

    template<typename R, typename T>
    struct has_output_iterator<R, T, std::enable_if_t<output_iterator<iterator_t<R>, T>>> : std::true_type {};
  }


  template<typename R, typename T>
  inline constexpr bool output_range = range<R> and detail::has_output_iterator<R, T>::value;


  // ---
  // forward_range
  // ---

  namespace detail
  {
    template<typename T, typename = void>
    struct has_forward_iterator : std::false_type {};

    template<typename T>
    struct has_forward_iterator<T, std::enable_if_t<forward_iterator<iterator_t<T>>>> : std::true_type {};
  }


  template<typename T>
  inline constexpr bool forward_range = input_range<T> and detail::has_forward_iterator<T>::value;


  // ---
  // bidirectional_range
  // ---

  namespace detail
  {
    template<typename T, typename = void>
    struct has_bidirectional_iterator : std::false_type {};

    template<typename T>
    struct has_bidirectional_iterator<T, std::enable_if_t<bidirectional_iterator<iterator_t<T>>>> : std::true_type {};
  }


  template<typename T>
  inline constexpr bool bidirectional_range = forward_range<T> and detail::has_bidirectional_iterator<T>::value;


  // ---
  // random_access_range
  // ---

  namespace detail
  {
    template<typename T, typename = void>
    struct has_random_access_iterator : std::false_type {};

    template<typename T>
    struct has_random_access_iterator<T, std::enable_if_t<random_access_iterator<iterator_t<T>>>> : std::true_type {};
  }


  template<typename T>
  inline constexpr bool random_access_range = bidirectional_range<T> and detail::has_random_access_iterator<T>::value;


  // ---
  // common_range
  // ---

  namespace detail
  {
    template<typename T, typename = void>
    struct is_common_range : std::false_type {};

    template<typename T>
    struct is_common_range<T, std::enable_if_t<std::is_same_v<iterator_t<T>, sentinel_t<T>>>> : std::true_type {};
  }


  template<typename T>
  inline constexpr bool common_range = range<T> and detail::is_common_range<T>::value;



  // ---
  // Range primitives
  // ---

  template<typename R, std::enable_if_t<sized_range<R>, int> = 0>
  using range_size_t = decltype(size(std::declval<R&>()));

  template<typename R, std::enable_if_t<range<R>, int> = 0>
  using range_difference_t = iter_difference_t<iterator_t<R>>;

  template<typename R, std::enable_if_t<range<R>, int> = 0>
  using range_value_t = iter_value_t<iterator_t<R>>;


  template<typename R, std::enable_if_t<range<R>, int> = 0>
  using range_reference_t = iter_reference_t<iterator_t<R>>;

  template<typename R, std::enable_if_t<range<R>, int> = 0>
  using range_const_reference_t =  iter_const_reference_t<iterator_t<R>>;

  template<typename R, std::enable_if_t<range<R>, int> = 0>
  using range_rvalue_reference_t =  iter_rvalue_reference_t<iterator_t<R>>;

  template<typename R, std::enable_if_t<range<R>, int> = 0>
  using range_common_reference_t =  iter_common_reference_t<iterator_t<R>>;

} // namespace OpenKalman::ranges

#endif


#endif //OPENKALMAN_RANGES_RANGE_CONCEPTS_HPP