RangeMatchers.hpp

Go to the documentation of this file.

//          Copyright Dominic (DNKpp) Koepke 2024 - 2025.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          https://www.boost.org/LICENSE_1_0.txt)
 
#ifndef MIMICPP_MATCHERS_RANGE_MATCHERS_HPP
#define MIMICPP_MATCHERS_RANGE_MATCHERS_HPP
 
#include "mimic++/Fwd.hpp"
#include "mimic++/config/Config.hpp"
#include "mimic++/matchers/Common.hpp"
#include "mimic++/matchers/GeneralMatchers.hpp"
 
#ifndef MIMICPP_DETAIL_IS_MODULE
    #include <algorithm>
    #include <concepts>
    #include <functional>
    #include <ranges>
    #include <tuple>
    #include <utility>
#endif
 
namespace mimicpp::matches::range::detail
{
#if MIMICPP_DETAIL_IS_GCC \
    && __GNUC__ <= 11
    // This is a small compatibility layer for gcc 11 and prior, because they do just provide a partial
    // implementation of `std::views::all`. In fact, the `std::ranges::owning_view` impl is completely missing.
    template <std::ranges::range Range>
    [[nodiscard]]
    constexpr auto store(Range&& range)
    {
        if constexpr (std::ranges::view<std::decay_t<Range>>)
        {
            return std::forward<Range>(range);
        }
        else if constexpr (requires { std::ranges::ref_view{std::declval<Range>()}; })
        {
            return std::ranges::ref_view{std::forward<Range>(range)};
        }
        else
        {
            return std::forward<Range>(range);
        }
    }
 
#else
    constexpr auto store = std::views::all;
#endif
}
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp::matches::range
{

    template <std::ranges::forward_range Range, typename Comparator = std::equal_to<>>
    [[nodiscard]]
    constexpr auto eq(Range&& expected, Comparator comparator = Comparator{})
    {
        return PredicateMatcher{
            [comp = std::move(comparator)]<typename Target>(Target&& target, auto& range) // NOLINT(cppcoreguidelines-missing-std-forward)
                requires std::predicate<
                             Comparator const&,
                             std::ranges::range_reference_t<Target>,
                             std::ranges::range_reference_t<Range>>
            {
                return std::ranges::equal(
                    target,
                    range,
                    std::ref(comp));
            },
            "elements are {}",
            "elements are not {}",
            std::make_tuple(detail::store(std::forward<Range>(expected)))};
    }

    template <std::ranges::forward_range Range, typename Comparator = std::equal_to<>>
    [[nodiscard]]
    constexpr auto unordered_eq(Range&& expected, Comparator comparator = Comparator{})
    {
        return PredicateMatcher{
            [comp = std::move(comparator)]<typename Target>(Target&& target, auto& range) // NOLINT(cppcoreguidelines-missing-std-forward)
                requires std::predicate<
                             Comparator const&,
                             std::ranges::range_reference_t<Target>,
                             std::ranges::range_reference_t<Range>>
            {
                return std::ranges::is_permutation(
                    target,
                    range,
                    std::ref(comp));
            },
            "is a permutation of {}",
            "is not a permutation of {}",
            std::make_tuple(detail::store(std::forward<Range>(expected)))};
    }

    template <typename Relation = std::ranges::less>
    [[nodiscard]]
    constexpr auto is_sorted(Relation relation = Relation{})
    {
        return PredicateMatcher{
            [rel = std::move(relation)]<typename Target>(Target&& target) // NOLINT(cppcoreguidelines-missing-std-forward)
                requires std::equivalence_relation<
                             const Relation&,
                             std::ranges::range_reference_t<Target>,
                             std::ranges::range_reference_t<Target>>
            {
                return std::ranges::is_sorted(
                    target,
                    std::ref(rel));
            },
            "is a sorted range",
            "is an unsorted range"};
    }

    [[nodiscard]]
    constexpr auto is_empty()
    {
        return PredicateMatcher{
            [](std::ranges::range auto&& target) {
                return std::ranges::empty(target);
            },
            "is an empty range",
            "is not an empty range"};
    }

    [[nodiscard]]
    constexpr auto has_size(const std::integral auto expected)
    {
        return PredicateMatcher{
            [](std::ranges::range auto&& target, const std::integral auto size) {
                return std::cmp_equal(
                    size,
                    std::ranges::size(target));
            },
            "has size of {}",
            "has different size than {}",
            std::make_tuple(expected)};
    }

    template <typename Matcher>
    [[nodiscard]]
    constexpr auto each_element(Matcher&& matcher)
    {
        using MatcherType = std::remove_cvref_t<Matcher>;
        using arg_storage = mimicpp::detail::arg_storage<
            MatcherType,
            std::identity,
            mimicpp::detail::describe_hook::describe_fn>;
 
        return PredicateMatcher{
            []<std::ranges::range Range>(Range&& target, MatcherType const& m) {
                return std::ranges::all_of(
                    std::forward<Range>(target),
                    [&](auto&& element) {
                        return mimicpp::detail::matches_hook::matches(m, element);
                    });
            },
            "each el in range: el {}",
            "not each el in range: el {}",
            std::tuple<arg_storage>{std::forward<Matcher>(matcher)}};
    }

    template <typename Matcher>
    [[nodiscard]]
    constexpr auto any_element(Matcher&& matcher)
    {
        using MatcherType = std::remove_cvref_t<Matcher>;
        using arg_storage = mimicpp::detail::arg_storage<
            MatcherType,
            std::identity,
            mimicpp::detail::describe_hook::describe_fn>;
 
        return PredicateMatcher{
            []<std::ranges::range Range>(Range&& target, MatcherType const& m) {
                return std::ranges::any_of(
                    std::forward<Range>(target),
                    [&](auto&& element) {
                        return mimicpp::detail::matches_hook::matches(m, element);
                    });
            },
            "any el in range: el {}",
            "none el in range: el {}",
            std::tuple<arg_storage>{std::forward<Matcher>(matcher)}};
    }

}
 
#endif