comparison.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_COORDINATES_VIEWS_COMPARISON_HPP
#define OPENKALMAN_COORDINATES_VIEWS_COMPARISON_HPP

#include "values/concepts/index.hpp"
#include "values/concepts/fixed.hpp"
#include "collections/concepts/sized_random_access_range.hpp"
#include "collections/functions/get_size.hpp"
#include "linear-algebra/coordinates/concepts/descriptor_collection.hpp"
#include "linear-algebra/coordinates/functions/internal/get_descriptor_collection_element.hpp"

namespace OpenKalman::coordinates
{
#ifdef __cpp_lib_ranges
  template<descriptor_collection T>
#else
  template<typename T>
#endif
  struct comparison_view : collections::collection_view_interface<comparison_view<T>>
  {
#ifdef __cpp_concepts
    constexpr comparison_view() requires std::default_initializable<T> = default;
#else
    template<typename aT = T, std::enable_if_t<std::is_default_constructible_v<aT>, int> = 0>
    constexpr comparison_view() {}
#endif


#ifdef __cpp_concepts
    template<typename Arg> requires std::constructible_from<T, Arg&&>
#else
    template<typename Arg, std::enable_if_t<std::is_constructible_v<T, Arg&&>, int> = 0>
#endif
    explicit constexpr comparison_view(Arg&& arg) : t {std::forward<Arg>(arg)} {}


#ifdef __cpp_explicit_this_parameter
    template<values::index I> requires (values::fixed<I> or sized_random_access_range<T>) and
      (values::dynamic<I> or collections::dimension_of_v<T> == dynamic_size or (values::fixed_number_of_v<I> < collections::dimension_of_v<T>))
    constexpr decltype(auto)
    operator[](this auto&& self, I i)
    {
      return internal::get_descriptor_collection_element(std::forward<decltype(self)>(self).t, std::move(i));
    }
#else
    template<typename I, std::enable_if_t<values::index<I> and (values::fixed<I> or sized_random_access_range<T>), int> = 0>
    constexpr decltype(auto)
    operator[](I i) const &
    {
      if constexpr(values::fixed<I> and collections::dimension_of_v<T> != dynamic_size) static_assert(values::fixed_number_of_v<I> < collections::dimension_of_v<T>);
      return internal::get_descriptor_collection_element(t, std::move(i));
    }


    template<typename I, std::enable_if_t<values::index<I> and (values::fixed<I> or sized_random_access_range<T>), int> = 0>
    constexpr decltype(auto)
    operator[](I i) &&
    {
      if constexpr(values::fixed<I> and collections::dimension_of_v<T> != dynamic_size) static_assert(values::fixed_number_of_v<I> < collections::dimension_of_v<T>);
      return internal::get_descriptor_collection_element(std::move(*this).t, std::move(i));
    }
#endif


#ifdef __cpp_concepts
    constexpr values::index auto size() const
#else
    constexpr auto size() const
#endif
    {
      return get_size(t);
    }

  private:

    T t;
  };


  template<typename Arg>
  comparison_view(Arg&&) -> comparison_view<Arg>;

} // namespace OpenKalman::coordinates


#ifndef __cpp_concepts
namespace std
{
  template<typename T>
  struct tuple_size<OpenKalman::coordinates::comparison_view<T>> : tuple_size<OpenKalman::collection_view_interface<OpenKalman::coordinates::comparison_view<T>>> {};

  template<size_t i, typename T>
  struct tuple_element<i, OpenKalman::coordinates::comparison_view<T>> : tuple_element<i, OpenKalman::collection_view_interface<OpenKalman::coordinates::comparison_view<T>>> {};
} // namespace std
#endif


namespace OpenKalman::coordinates::views
{
  namespace detail
  {
    struct comparison_impl
#if __cpp_lib_ranges >= 202202L
      : std::ranges::range_adaptor_closure<comparison_impl>
#endif
    {
#ifdef __cpp_concepts
      template<descriptor_collection R>
#else
      template<typename R, std::enable_if_t<descriptor_collection<R>, int> = 0>
#endif
      constexpr auto
      operator() [[nodiscard]] (R&& r) const { return comparison_view<R> {std::forward<R>(r)}; }
    };
  }


  inline constexpr detail::comparison_impl comparison;


} // namespace OpenKalman::coordinates


#endif //OPENKALMAN_COORDINATES_VIEWS_COMPARISON_HPP