concat.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_CONCAT_HPP
#define OPENKALMAN_COLLECTIONS_VIEWS_CONCAT_HPP

#include "values/values.hpp"
#include "collections/concepts/uniformly_gettable.hpp"
#include "collections/traits/collection_element.hpp"
#include "collections/views/all.hpp"

namespace OpenKalman::collections
{
  namespace detail
  {
    template<std::size_t i>
    constexpr auto concat_tuple_view_indices()
    {
      return std::pair {std::integral_constant<std::size_t, 0_uz>{}, std::integral_constant<std::size_t, 0_uz>{}};
    }

    template<std::size_t i, typename T, typename...Ts>
    constexpr auto concat_tuple_view_indices()
    {
      constexpr std::size_t size = size_of_v<T>;
      if constexpr (i < size)
      {
        return std::pair {std::integral_constant<std::size_t, 0_uz>{}, std::integral_constant<std::size_t, i>{}};
      }
      else
      {
        auto [a, b] = concat_tuple_view_indices<i - size, Ts...>();
        return std::pair {std::integral_constant<std::size_t, 1_uz + decltype(a)::value>{}, b};
      }
    }
  };


#ifdef __cpp_concepts
  template<uniformly_gettable...Ts>
#else
  template<typename...Ts>
#endif
  struct concat_tuple_view
  {
#ifdef __cpp_concepts
    constexpr concat_tuple_view() requires (... and std::default_initializable<Ts>) = default;
#else
    template<bool Enable = true, std::enable_if_t<Enable and (... and stdex::default_initializable<Ts>), int> = 0>
    constexpr concat_tuple_view() {};
#endif


#ifdef __cpp_concepts
    template<typename...Args> requires (... and std::constructible_from<Ts, Args&&>)
#else
    template<typename...Args, std::enable_if_t<(... and stdex::constructible_from<Ts, Args&&>), int> = 0>
#endif
    explicit constexpr concat_tuple_view(Args&&...args) : tup {std::forward<Args>(args)...} {}


#ifdef __cpp_explicit_this_parameter
    template<std::size_t i>
    constexpr decltype(auto)
    get(this auto&& self) noexcept
    {
      static_assert(i < (0_uz + ... + size_of_v<Ts>), "Index out of range");
      auto [element, index] = std::decay_t<decltype(detail::concat_tuple_view_indices<i, Ts...>())>();
      return get_element(get_element(std::forward<decltype(self)>(self).tup, element).get(), index);
    }
#else
    template<std::size_t i>
    constexpr decltype(auto)
    get() &
    {
      static_assert(i < (0_uz + ... + size_of_v<Ts>), "Index out of range");
      auto [element, index] = std::decay_t<decltype(detail::concat_tuple_view_indices<i, Ts...>())>();
      return get_element(get_element(tup, element).get(), index);
    }

    template<std::size_t i>
    constexpr decltype(auto)
    get() const &
    {
      static_assert(i < (0_uz + ... + size_of_v<Ts>), "Index out of range");
      auto [element, index] = std::decay_t<decltype(detail::concat_tuple_view_indices<i, Ts...>())>();
      return get_element(get_element(tup, element).get(), index);
    }

    template<std::size_t i>
    constexpr decltype(auto)
    get() && noexcept
    {
      static_assert(i < (0_uz + ... + size_of_v<Ts>), "Index out of range");
      auto [element, index] = std::decay_t<decltype(detail::concat_tuple_view_indices<i, Ts...>())>();
      return get_element(get_element(std::move(*this).tup, element).get(), index);
    }

    template<std::size_t i>
    constexpr decltype(auto)
    get() const && noexcept
    {
      static_assert(i < (0_uz + ... + size_of_v<Ts>), "Index out of range");
      auto [element, index] = std::decay_t<decltype(detail::concat_tuple_view_indices<i, Ts...>())>();
      return get_element(get_element(std::move(*this).tup, element).get(), index);
    }
#endif

  private:

    std::tuple<internal::movable_wrapper<Ts>...> tup;
  };


  template<typename...Args>
  concat_tuple_view(Args&&...) -> concat_tuple_view<Args...>;

}


namespace std
{
  template<typename...Ts>
  struct tuple_size<OpenKalman::collections::concat_tuple_view<Ts...>>
    : std::integral_constant<std::size_t, (0 + ... + OpenKalman::collections::size_of_v<Ts>)> {};


  template<std::size_t i, typename...Ts>
  struct tuple_element<i, OpenKalman::collections::concat_tuple_view<Ts...>>
  {
  private:
    static_assert(i < (0 + ... + OpenKalman::collections::size_of_v<Ts>));
    using indices = decltype(OpenKalman::collections::detail::concat_tuple_view_indices<i, Ts...>());
    using element = OpenKalman::collections::collection_element_t<0, indices>;
    using index = OpenKalman::collections::collection_element_t<1, indices>;
  public:
    using type = OpenKalman::collections::collection_element_t<index::value,
      OpenKalman::collections::collection_element_t<element::value, std::tuple<Ts...>>>;
  };
}


namespace OpenKalman::collections::views
{
  namespace detail
  {
    struct concat_adaptor
    {
  #ifdef __cpp_concepts
      template<viewable_collection...R> requires (sizeof...(R) > 0)
  #else
      template<typename...R, std::enable_if_t<(sizeof...(R) > 0) and (... and viewable_collection<R>), int> = 0>
  #endif
      constexpr decltype(auto)
      operator() (R&&...r) const
      {
        if constexpr (sizeof...(R) == 1)
          return all(std::forward<R>(r)...);
        else if constexpr ((... and (uniformly_gettable<R>)))
          return concat_tuple_view {std::forward<R>(r)...} | all;
        else
          return stdex::ranges::views::concat(all(std::forward<R>(r))...) | all;
      }

    };

  }


  inline constexpr detail::concat_adaptor concat;

}


#endif