StringMatchers.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_STRING_MATCHERS_HPP
#define MIMICPP_MATCHERS_STRING_MATCHERS_HPP
 
#include "mimic++/Fwd.hpp"
#include "mimic++/String.hpp"
#include "mimic++/config/Config.hpp"
#include "mimic++/matchers/GeneralMatchers.hpp"
#include "mimic++/printing/StatePrinter.hpp"
 
#ifndef MIMICPP_DETAIL_IS_MODULE
    #include <algorithm>
    #include <concepts>
    #include <ranges>
    #include <tuple>
    #include <utility>
#endif
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp
{
    struct case_insensitive_t
    {
    } constexpr case_insensitive{};
}
 
namespace mimicpp::matches::detail
{
    template <string Target, string Pattern>
    constexpr void check_string_compatibility() noexcept
    {
        static_assert(
            std::same_as<
                string_char_t<Target>,
                string_char_t<Pattern>>,
            "Pattern and target string must have the same character-type.");
    }
 
    struct make_view_fn
    {
        template <string T>
        [[nodiscard]]
        constexpr auto operator()(T const& str) const
        {
            return string_traits<T>::view(str);
        }
    };
 
    template <string String>
    [[nodiscard]]
    constexpr auto make_view(String const& str)
    {
        return std::invoke(make_view_fn{}, str);
    }
 
    template <case_foldable_string String, std::ranges::borrowed_range View>
    [[nodiscard]]
    constexpr auto make_case_folded_string(View&& str)
    {
        return std::invoke(
            string_case_fold_converter<string_char_t<String>>{},
            std::forward<View>(str));
    }
 
    struct describe_fn
    {
        template <string T>
        [[nodiscard]]
        constexpr auto operator()(T const& str) const
        {
            return mimicpp::print(make_view(str));
        }
    };
 
    // This specialization is needed for raw char (const)* strings, for which the matcher loses information about
    // and wrongly treats as general raw-pointer.
    template <string T>
    using string_arg_storage = mimicpp::detail::arg_storage<
        T,
        make_view_fn,
        describe_fn>;
 
    template <string String>
    [[nodiscard]]
    constexpr auto forward_store(std::remove_reference_t<String>& str)
    {
        return string_arg_storage<std::decay_t<String>>{
            std::forward<String>(str)};
    }
}
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp::matches::str
{

    template <string Pattern>
    [[nodiscard]]
    constexpr auto eq(Pattern&& pattern)
    {
        return PredicateMatcher{
            []<string T>(T&& target, auto const& patternView) {
                detail::check_string_compatibility<T, Pattern>();
 
                return std::ranges::equal(
                    detail::make_view(target),
                    patternView);
            },
            "is equal to {}",
            "is not equal to {}",
            std::make_tuple(detail::forward_store<Pattern>(pattern))};
    }

    template <case_foldable_string Pattern>
    [[nodiscard]]
    constexpr auto eq(Pattern&& pattern, [[maybe_unused]] const case_insensitive_t)
    {
        return PredicateMatcher{
            []<case_foldable_string T>(T&& target, auto const& patternView) {
                detail::check_string_compatibility<T, Pattern>();
 
                return std::ranges::equal(
                    detail::make_case_folded_string<T>(detail::make_view(target)),
                    detail::make_case_folded_string<Pattern>(patternView));
            },
            "is case-insensitively equal to {}",
            "is case-insensitively not equal to {}",
            std::make_tuple(detail::forward_store<Pattern>(pattern))};
    }

    template <string Pattern>
    [[nodiscard]]
    constexpr auto starts_with(Pattern&& pattern)
    {
        return PredicateMatcher{
            []<string T>(T&& target, auto const& patternView) {
                detail::check_string_compatibility<T, Pattern>();
 
                auto const [ignore, patternIter] = std::ranges::mismatch(
                    detail::make_view(target),
                    patternView);
 
                return patternIter == std::ranges::end(patternView);
            },
            "starts with {}",
            "starts not with {}",
            std::make_tuple(detail::forward_store<Pattern>(pattern))};
    }

    template <string Pattern>
    [[nodiscard]]
    constexpr auto starts_with(Pattern&& pattern, [[maybe_unused]] const case_insensitive_t)
    {
        return PredicateMatcher{
            []<case_foldable_string T>(T&& target, auto const& patternView) {
                detail::check_string_compatibility<T, Pattern>();
 
                auto const caseFoldedPattern = detail::make_case_folded_string<Pattern>(patternView);
                auto const [ignore, patternIter] = std::ranges::mismatch(
                    detail::make_case_folded_string<T>(detail::make_view(target)),
                    caseFoldedPattern);
 
                return patternIter == std::ranges::end(caseFoldedPattern);
            },
            "case-insensitively starts with {}",
            "case-insensitively starts not with {}",
            std::make_tuple(detail::forward_store<Pattern>(pattern))};
    }

    template <string Pattern>
    [[nodiscard]]
    constexpr auto ends_with(Pattern&& pattern)
    {
        return PredicateMatcher{
            []<string T>(T&& target, auto const& patternView) {
                detail::check_string_compatibility<T, Pattern>();
 
                auto reversedPattern = patternView | std::views::reverse;
                const auto [ignore, patternIter] = std::ranges::mismatch(
                    detail::make_view(target) | std::views::reverse,
                    reversedPattern);
 
                return patternIter == std::ranges::end(reversedPattern);
            },
            "ends with {}",
            "ends not with {}",
            std::make_tuple(detail::forward_store<Pattern>(pattern))};
    }

    template <string Pattern>
    [[nodiscard]]
    constexpr auto ends_with(Pattern&& pattern, [[maybe_unused]] const case_insensitive_t)
    {
        return PredicateMatcher{
            []<case_foldable_string T>(T&& target, auto const& patternView) {
                detail::check_string_compatibility<T, Pattern>();
 
                auto caseFoldedPattern = detail::make_case_folded_string<Pattern>(patternView);
                auto reversedCaseFoldedPattern = caseFoldedPattern | std::views::reverse;
                auto caseFoldedTargetPattern = detail::make_case_folded_string<T>(detail::make_view(target));
                const auto [ignore, patternIter] = std::ranges::mismatch(
                    caseFoldedTargetPattern | std::views::reverse,
                    reversedCaseFoldedPattern);
 
                return patternIter == std::ranges::end(reversedCaseFoldedPattern);
            },
            "case-insensitively ends with {}",
            "case-insensitively ends not with {}",
            std::make_tuple(detail::forward_store<Pattern>(pattern))};
    }

    template <string Pattern>
    [[nodiscard]]
    constexpr auto contains(Pattern&& pattern)
    {
        return PredicateMatcher{
            []<string T>(T&& target, auto const& patternView) {
                detail::check_string_compatibility<T, Pattern>();
 
                return std::ranges::empty(patternView)
                    || !std::ranges::empty(
                           std::ranges::search(
                               detail::make_view(target),
                               patternView));
            },
            "contains {}",
            "contains not {}",
            std::make_tuple(detail::forward_store<Pattern>(pattern))};
    }

    template <string Pattern>
    [[nodiscard]]
    constexpr auto contains(Pattern&& pattern, [[maybe_unused]] const case_insensitive_t)
    {
        return PredicateMatcher{
            []<case_foldable_string T>(T&& target, auto const& patternView) {
                detail::check_string_compatibility<T, Pattern>();
 
                auto caseFoldedPattern = detail::make_case_folded_string<Pattern>(patternView);
                auto targetView = detail::make_case_folded_string<T>(detail::make_view(target));
                return std::ranges::empty(caseFoldedPattern)
                    || !std::ranges::empty(std::ranges::search(targetView, caseFoldedPattern));
            },
            "case-insensitively contains {}",
            "case-insensitively contains not {}",
            std::make_tuple(detail::forward_store<Pattern>(pattern))};
    }

}
 
#endif