collection_compares_with.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) 2019-2026 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_PATTERNS_COLLECTION_COMPARES_WITH_HPP
#define OPENKALMAN_PATTERNS_COLLECTION_COMPARES_WITH_HPP

#include "collections/collections.hpp"
#include "pattern_collection.hpp"
#include "compares_with.hpp"
#include "patterns/descriptors/Dimensions.hpp"

namespace OpenKalman::patterns
{
  namespace detail
  {
    template<typename T, typename PU, auto comp, applicability a, std::size_t i = 0>
    constexpr bool
    collection_compares_with_iter_T()
    {
      if constexpr (i < collections::size_of_v<T>)
      {
        using Ti = std::decay_t<collections::collection_element_t<i, T>>;
        if constexpr (compares_with<Ti, PU, comp, a>)
          return collection_compares_with_iter_T<T, PU, comp, a, i + 1>();
        else
          return false;
      }
      else
      {
        return true;
      }
    }


    template<typename PT, typename U, auto comp, applicability a, std::size_t i = 0>
    constexpr bool
    collection_compares_with_iter_U()
    {
      if constexpr (i < collections::size_of_v<U>)
      {
        using Ui = std::decay_t<collections::collection_element_t<i, U>>;
        if constexpr (compares_with<PT, Ui, comp, a>)
          return collection_compares_with_iter_U<PT, U, comp, a, i + 1>();
        else
          return false;
      }
      else
      {
        return true;
      }
    }


    template<typename T, typename U, auto comp, applicability a, std::size_t i = 0>
    constexpr bool
    collection_compares_with_iter()
    {
      if constexpr (i < collections::size_of_v<T>)
      {
        if constexpr (i < collections::size_of_v<U>)
        {
          using Ti = std::decay_t<collections::collection_element_t<i, T>>;
          using Ui = std::decay_t<collections::collection_element_t<i, U>>;
          if constexpr (compares_with<Ti, Ui, comp, a>)
            return collection_compares_with_iter<T, U, comp, a, i + 1>();
          else
            return false;
        }
        else
        {
          return collection_compares_with_iter_T<T, Dimensions<1>, comp, a, i>();
        }
      }
      else if constexpr (i < collections::size_of_v<U>)
      {
        return collection_compares_with_iter_U<Dimensions<1>, U, comp, a, i>();
      }
      else
      {
        return true;
      }
    }


    template<typename T, typename U, auto comp, applicability a>
    constexpr bool
    collection_compares_with_impl()
    {
#ifndef __cpp_concepts
      if constexpr (pattern_collection<T> and pattern_collection<U>) {
#endif
      constexpr bool fixed_t = collections::sized<T> and not values::fixed_value_compares_with<collections::size_of<T>, stdex::dynamic_extent>;
      constexpr bool fixed_u = collections::sized<U> and not values::fixed_value_compares_with<collections::size_of<U>, stdex::dynamic_extent>;
      if constexpr (fixed_t and fixed_u)
        return detail::collection_compares_with_iter<T, U, comp, a>();
      else if constexpr (fixed_t)
        return detail::collection_compares_with_iter_T<T, stdex::ranges::range_value_t<U>, comp, a>();
      else if constexpr (fixed_u)
        return detail::collection_compares_with_iter_U<stdex::ranges::range_value_t<T>, U, comp, a>();
      else
        return compares_with<stdex::ranges::range_value_t<T>, stdex::ranges::range_value_t<U>, comp, a>;
#ifndef __cpp_concepts
      } else return false;
#endif
    }

  }


  template<typename T, typename U, auto comp = &stdex::is_eq, applicability a = applicability::guaranteed>
#ifdef __cpp_concepts
  concept collection_compares_with =
#else
  constexpr bool collection_compares_with =
#endif
    pattern_collection<T> and pattern_collection<U> and
    std::is_invocable_r_v<bool, decltype(comp), stdex::partial_ordering> and
    detail::collection_compares_with_impl<T, U, comp, a>();


}

#endif