iota.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_COLLECTIONS_VIEWS_IOTA_HPP
#define OPENKALMAN_COLLECTIONS_VIEWS_IOTA_HPP

#include <type_traits>
#ifdef __cpp_lib_ranges
#include <ranges>
#else
#include "basics/compatibility/ranges.hpp"
#endif
#include "values/concepts/index.hpp"
#include "values/concepts/size.hpp"
#include "values/concepts/fixed.hpp"
#include "values/traits/fixed_number_of.hpp"
#include "values/traits/number_type_of_t.hpp"
#include "collections/functions/compare.hpp"
#include "generate.hpp"

namespace OpenKalman::collections
{
  namespace detail
  {
    template<typename Start = std::integral_constant<std::size_t, 0>>
    struct iota_generator
    {
      constexpr iota_generator() = default;

      explicit constexpr iota_generator(Start start) : start_ {std::move(start)} {};

#ifdef __cpp_concepts
      template<values::index I>
#else
      template<typename I, std::enable_if_t<values::index<I>, int> = 0>
#endif
      constexpr auto
      operator() (I i) const
      {
        return values::operation {std::plus<std::size_t>{}, start_, std::move(i)};
      }

    private:

      Start start_;
    };

  }


#ifdef __cpp_concepts
  template<values::integral Start = std::integral_constant<std::size_t, 0>, values::size Size = std::unreachable_sentinel_t>
  requires (not values::index<Size> or std::convertible_to<values::number_type_of_t<Size>, values::number_type_of_t<Start>>) and
    std::same_as<Start, std::remove_reference_t<Start>> and
    std::same_as<Size, std::remove_reference_t<Size>>
#else
  template<typename Start = std::integral_constant<std::size_t, 0>, typename Size = unreachable_sentinel_t>
#endif
  struct iota_view : generate_view<detail::iota_generator<Start>, Size>
  {
  private:

    using Size_ = std::conditional_t<values::index<Size>, Size, std::monostate>;
    using view_base = generate_view<detail::iota_generator<Start>, Size>;

  public:

#ifdef __cpp_concepts
    constexpr
    iota_view(Start start, Size_ size) requires values::index<Size>
#else
    template<bool Enable = true, std::enable_if_t<Enable and values::index<Size>, int> = 0>
    constexpr iota_view(Start start, Size_ size)
#endif
      : view_base {detail::iota_generator{start}, std::move(size)} {}


#ifdef __cpp_concepts
    explicit constexpr
    iota_view(Size_ size) requires values::fixed<Start> and values::index<Size>
#else
    template<bool Enable = true, std::enable_if_t<Enable and values::fixed<Start> and values::index<Size>, int> = 0>
    explicit constexpr iota_view(Size_ size)
#endif
      : view_base {std::move(size)} {}


    constexpr
    iota_view() noexcept = default;

  };


  template<typename Start, typename Size>
  iota_view(const Start&, const Size&) -> iota_view<Start, Size>;

  template<typename Size>
  iota_view(const Size&) -> iota_view<std::integral_constant<std::size_t, 0>, Size>;

} // OpenKalman::values


#ifdef __cpp_lib_ranges
namespace std::ranges
#else
namespace OpenKalman::ranges
#endif
{
  template<typename Start, typename Size>
  constexpr bool enable_borrowed_range<OpenKalman::collections::iota_view<Start, Size>> = true;
}


namespace std
{
#ifdef __cpp_concepts
  template<typename Start, OpenKalman::values::fixed Size>
  struct tuple_size<OpenKalman::collections::iota_view<Start, Size>>
    : std::integral_constant<size_t, OpenKalman::values::fixed_number_of_v<Size>> {};
#else
  template<typename Start, typename Size>
  struct tuple_size<OpenKalman::collections::iota_view<Start, Size>>
    : tuple_size<OpenKalman::collections::generate_view<OpenKalman::collections::detail::iota_generator<Start>, Size>> {};
#endif


#ifdef __cpp_concepts
  template<std::size_t i, OpenKalman::values::fixed Start, typename Size>
  struct tuple_element<i, OpenKalman::collections::iota_view<Start, Size>>
  {
    static_assert(not OpenKalman::values::fixed<Size> or requires { requires i < OpenKalman::values::fixed_number_of<Size>::value; });
    using type = OpenKalman::values::operation<std::plus<>, Start, std::integral_constant<std::size_t, i>>;
  };
#else
  template<std::size_t i, typename Start, typename Size>
  struct tuple_element<i, OpenKalman::collections::iota_view<Start, Size>>
    : tuple_element<i, OpenKalman::collections::generate_view<OpenKalman::collections::detail::iota_generator<Start>, Size>> {};
#endif

} // namespace std


namespace OpenKalman::collections::views
{
  namespace detail
  {
    struct iota_adapter
    {
#ifdef __cpp_concepts
      template<values::index Start, values::index Size> requires
        std::convertible_to<values::number_type_of_t<Size>, values::number_type_of_t<Start>>
#else
      template<typename Start, typename Size, std::enable_if_t<values::index<Start> and values::index<Size> and
        std::is_convertible_v<values::number_type_of_t<Size>, values::number_type_of_t<Start>>, int> = 0>
#endif
      constexpr auto
      operator() (Start start, Size size) const
      {
        return iota_view<std::decay_t<Start>, std::decay_t<Size>>(std::move(start), std::move(size));
      }


#ifdef __cpp_concepts
      template<values::index Size>
#else
      template<typename Size, std::enable_if_t<values::index<Size>, int> = 0>
#endif
      constexpr auto
      operator() (Size size) const
      {
        return iota_view<std::integral_constant<std::size_t, 0>, std::decay_t<Size>>(std::move(size));
      }


      constexpr auto
      operator() () const
      {
        return iota_view<> {};
      }

    };
  }


  inline constexpr detail::iota_adapter iota;

}


#endif //OPENKALMAN_COLLECTIONS_VIEWS_IOTA_HPP