replicate.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_REPLICATE_HPP
#define OPENKALMAN_COLLECTIONS_VIEWS_REPLICATE_HPP

#include <type_traits>
#ifdef __cpp_lib_ranges
#include <ranges>
#else
#include "basics/compatibility/language-features.hpp"
#include "basics/compatibility/ranges.hpp"
#include "basics/compatibility/views/view_interface.hpp"
#endif
#include "values/concepts/index.hpp"
#include "values/concepts/fixed.hpp"
#include "collections/concepts/collection.hpp"
#include "collections/functions/get_size.hpp"
#include "collections/functions/get.hpp"
#include "collections/functions/compare.hpp"
#include "all.hpp"

namespace OpenKalman::collections
{
#ifdef __cpp_lib_ranges
  template<collection V, values::index Factor> requires std::same_as<std::decay_t<Factor>, Factor>
  struct replicate_view : std::ranges::view_interface<replicate_view<V, Factor>>
#else
  template<typename V, typename Factor>
  struct replicate_view : ranges::view_interface<replicate_view<V, Factor>>
#endif
  {
  private:

    template<bool Const, typename T>
    using maybe_const = std::conditional_t<Const, const T, T>;

  public:

    template<bool Const>
    struct iterator
    {
    private:

      using Parent = maybe_const<Const, replicate_view>;

    public:

      using iterator_concept = std::random_access_iterator_tag;
      using iterator_category = std::random_access_iterator_tag;
#ifdef __cpp_lib_ranges
      using value_type = std::ranges::range_value_t<V>;
      using reference = std::ranges::range_reference_t<V>;
#else
      using value_type = ranges::range_value_t<V>;
      using reference = ranges::range_reference_t<V>;
#endif
      using difference_type = std::ptrdiff_t;
      using pointer = void;

      constexpr iterator() = default;

      constexpr iterator(Parent& parent, difference_type p) : parent_ {std::addressof(parent)}, current_{p} {}

      constexpr iterator(iterator<not Const> i) : parent_ {std::move(i.parent_)}, current_ {std::move(i.current_)} {}

      constexpr decltype(auto) operator*() { return collections::get(parent_->v_, current_ % get_size(parent_->v_)); }
      constexpr decltype(auto) operator*() const { return collections::get(parent_->v_, current_ % get_size(parent_->v_)); }
      constexpr decltype(auto) operator[](difference_type offset) { return collections::get(parent_->v_, (current_ + offset) % get_size(parent_->v_)); }
      constexpr decltype(auto) operator[](difference_type offset) const { return collections::get(parent_->v_, (current_ + offset) % get_size(parent_->v_)); }

      constexpr auto& operator++() noexcept { ++current_; return *this; }
      constexpr auto operator++(int) noexcept { auto temp = *this; ++*this; return temp; }
      constexpr auto& operator--() noexcept { --current_; return *this; }
      constexpr auto operator--(int) noexcept { auto temp = *this; --*this; return temp; }
      constexpr auto& operator+=(const difference_type diff) noexcept { current_ += diff; return *this; }
      constexpr auto& operator-=(const difference_type diff) noexcept { current_ -= diff; return *this; }
      friend constexpr auto operator+(const iterator& it, const difference_type diff) noexcept
      { return iterator {*it.parent_, it.current_ + diff}; }
      friend constexpr auto operator+(const difference_type diff, const iterator& it) noexcept
      { return iterator {*it.parent_, diff + it.current_}; }
      friend constexpr auto operator-(const iterator& it, const difference_type diff)
      { return iterator {*it.parent_, it.current_ - diff}; }
      friend constexpr difference_type operator-(const iterator& it, const iterator& other) noexcept
      { return it.current_ - other.current_; }
      friend constexpr bool operator==(const iterator& it, const iterator& other) noexcept
      { return it.current_ == other.current_; }
#ifdef __cpp_impl_three_way_comparison
      constexpr auto operator<=>(const iterator& other) const noexcept { return current_ <=> other.current_; }
#else
      constexpr bool operator!=(const iterator& other) const noexcept { return current_ != other.current_; }
      constexpr bool operator<(const iterator& other) const noexcept { return current_ < other.current_; }
      constexpr bool operator>(const iterator& other) const noexcept { return current_ > other.current_; }
      constexpr bool operator<=(const iterator& other) const noexcept { return current_ <= other.current_; }
      constexpr bool operator>=(const iterator& other) const noexcept { return current_ >= other.current_; }
#endif

    private:

      Parent * parent_;
      difference_type current_;

    };


#ifdef __cpp_concepts
    constexpr
    replicate_view() = default;
#else
    template<bool Enable = true, std::enable_if_t<Enable and
      std::is_default_constructible_v<V> and std::is_default_constructible_v<Factor>, int> = 0>
    constexpr
    replicate_view() {}
#endif


    constexpr
    replicate_view(V& v, Factor f) : v_ {v}, f_ {std::move(f)} {}


    constexpr
    replicate_view(V&& v, Factor f) : v_ {std::move(v)}, f_ {std::move(f)} {}


#ifdef __cpp_explicit_this_parameter
    constexpr decltype(auto)
    base(this auto&& self) noexcept { return std::forward<decltype(self)>(self).v_; }
#else
    constexpr V& base() & { return this->v_; }
    constexpr const V& base() const & { return this->v_; }
    constexpr V&& base() && noexcept { return std::move(*this).v_; }
    constexpr const V&& base() const && noexcept { return std::move(*this).v_; }
#endif


    constexpr auto
    begin() { return iterator<false> {*this, 0_uz}; }

#ifdef __cpp_lib_ranges
    constexpr auto
    begin() const requires std::ranges::range<const V>
#else
    template<bool Enable = true, std::enable_if_t<Enable and ranges::range<const V>, int> = 0>
    constexpr auto begin() const
#endif
    { return iterator<true> {*this, 0_uz}; }


    constexpr auto
    end() { return iterator<false> {*this, static_cast<std::ptrdiff_t>(values::to_number(size()))}; }


#ifdef __cpp_lib_ranges
    constexpr auto
    end() const requires std::ranges::range<const V>
#else
    template<bool Enable = true, std::enable_if_t<Enable and ranges::range<const V>, int> = 0>
    constexpr auto
    end() const noexcept
#endif
    {
      return iterator<true> {*this, static_cast<std::ptrdiff_t>(values::to_number(size()))};
    }


#ifdef __cpp_concepts
    constexpr values::index auto size() const
#else
    constexpr auto size() const
#endif
    {
      return values::operation {std::multiplies{}, get_size(v_), f_};
    }


#ifdef __cpp_explicit_this_parameter
    template<std::size_t i>
    constexpr decltype(auto)
    get(this auto&& self) noexcept
    {
      if constexpr (size_of_v<V> != dynamic_size and values::fixed<Factor>)
        static_assert(i < size_of_v<V> * values::fixed_number_of_v<Factor>, "Index out of range");
      return collections::get(std::forward<decltype(self)>(self).v_,
        values::operation {std::modulus{}, std::integral_constant<std::size_t, i>{}, get_size(self.v_)});
    }
#else
    template<std::size_t i>
    constexpr decltype(auto)
    get() &
    {
      if constexpr (size_of_v<V> != dynamic_size and values::fixed<Factor>)
        static_assert(i < size_of_v<V> * values::fixed_number_of_v<Factor>, "Index out of range");
      return collections::get(v_,
        values::operation {std::modulus{}, std::integral_constant<std::size_t, i>{}, get_size(v_)});
    }

    template<std::size_t i>
    constexpr decltype(auto)
    get() const &
    {
      if constexpr (size_of_v<V> != dynamic_size and values::fixed<Factor>)
        static_assert(i < size_of_v<V> * values::fixed_number_of_v<Factor>, "Index out of range");
      return collections::get(v_,
        values::operation {std::modulus{}, std::integral_constant<std::size_t, i>{}, get_size(v_)});
    }

    template<std::size_t i>
    constexpr decltype(auto)
    get() && noexcept
    {
      if constexpr (size_of_v<V> != dynamic_size and values::fixed<Factor>)
        static_assert(i < size_of_v<V> * values::fixed_number_of_v<Factor>, "Index out of range");
      return collections::get(std::move(*this).v_,
        values::operation {std::modulus{}, std::integral_constant<std::size_t, i>{}, get_size(std::move(*this).v_)});
    }

    template<std::size_t i>
    constexpr decltype(auto)
    get() const && noexcept
    {
      if constexpr (size_of_v<V> != dynamic_size and values::fixed<Factor>)
        static_assert(i < size_of_v<V> * values::fixed_number_of_v<Factor>, "Index out of range");
      return collections::get(std::move(*this).v_,
        values::operation {std::modulus{}, std::integral_constant<std::size_t, i>{}, get_size(std::move(*this).v_)});
    }
#endif

  private:

    V v_;
    Factor f_;
  };


  template<typename V, typename F>
  replicate_view(const V&, const F&) -> replicate_view<V, F>;


} // namespace OpenKalman::collections


#ifdef __cpp_lib_ranges
namespace std::ranges
#else
namespace OpenKalman::ranges
#endif
{
  template<typename V, typename F>
  constexpr bool enable_borrowed_range<OpenKalman::collections::replicate_view<V, F>> = enable_borrowed_range<V>;
}


#ifndef __cpp_lib_ranges
namespace OpenKalman::collections::detail
{
  template<typename V, typename F, typename = void>
  struct replicate_tuple_size {};

  template<typename V, typename F>
  struct replicate_tuple_size<V, F, std::enable_if_t<values::fixed<F> and (size_of<V>::value != dynamic_size)>>
    : std::integral_constant<std::size_t, size_of_v<V> * values::fixed_number_of_v<F>> {};


  template<std::size_t i, typename V, typename = void>
  struct replicate_tuple_element
  {
    using type = ranges::range_value_t<V>;
  };

  template<std::size_t i, typename V>
  struct replicate_tuple_element<i, V, std::enable_if_t<size_of<V>::value != dynamic_size>>
    : std::tuple_element<i % size_of_v<V>, std::decay_t<V>> {};

}
#endif


namespace std
{
#ifdef __cpp_lib_ranges
  template<typename V, OpenKalman::values::fixed F> requires (OpenKalman::collections::size_of_v<V> != OpenKalman::dynamic_size)
  struct tuple_size<OpenKalman::collections::replicate_view<V, F>>
    : integral_constant<std::size_t, std::tuple_size_v<std::decay_t<V>> * OpenKalman::values::fixed_number_of_v<F>> {};
#else
  template<typename V, typename F>
  struct tuple_size<OpenKalman::collections::replicate_view<V, F>>
    : OpenKalman::collections::detail::replicate_tuple_size<std::decay_t<V>, F> {};
#endif


#ifdef __cpp_lib_ranges
  template<size_t i, typename V, typename F> requires (OpenKalman::collections::size_of_v<V> != OpenKalman::dynamic_size)
  struct tuple_element<i, OpenKalman::collections::replicate_view<V, F>>
    : tuple_element<i % OpenKalman::collections::size_of_v<V>, decay_t<V>> {};

  template<size_t i, typename V, typename F> requires (OpenKalman::collections::size_of_v<V> == OpenKalman::dynamic_size)
  struct tuple_element<i, OpenKalman::collections::replicate_view<V, F>>
  {
    using type = ranges::range_value_t<V>;
  };
#else
  template<size_t i, typename V, typename F>
  struct tuple_element<i, OpenKalman::collections::replicate_view<V, F>>
    : OpenKalman::collections::detail::replicate_tuple_element<i, V> {};
#endif

} // namespace std


namespace OpenKalman::collections::views
{
  namespace detail
  {
    template<typename Factor>
    struct replicate_closure
#if __cpp_lib_ranges >= 202202L
      : std::ranges::range_adaptor_closure<replicate_closure<Factor>>
#else
      : ranges::range_adaptor_closure<replicate_closure<Factor>>
#endif
    {
      constexpr replicate_closure(Factor f) : factor_ {std::move(f)} {};

#ifdef __cpp_concepts
      template<viewable_collection R>
#else
      template<typename R, std::enable_if_t<viewable_collection<R>, int> = 0>
#endif
      constexpr auto
      operator() (R&& r) const
      {
        return replicate_view {all(std::forward<R>(r)), factor_};
      }

    private:
      Factor factor_;
    };


    struct replicate_adaptor
    {
#ifdef __cpp_concepts
      template<values::index Factor>
#else
      template<typename Factor, std::enable_if_t<values::index<Factor>, int> = 0>
#endif
      constexpr auto
      operator() (Factor factor) const
      {
        return replicate_closure<Factor> {std::move(factor)};
      }


#ifdef __cpp_concepts
      template<viewable_collection R, values::index Factor>
#else
      template<typename R, typename Factor, std::enable_if_t<viewable_collection<R> and values::index<Factor>, int> = 0>
#endif
      constexpr auto
      operator() (R&& r, Factor factor) const
      {
        return replicate_view {all(std::forward<R>(r)), std::move(factor)};
      }

    };

  }


  inline constexpr detail::replicate_adaptor replicate;

}


#endif //OPENKALMAN_COLLECTIONS_VIEWS_REPLICATE_HPP