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++/matchers/GeneralMatchers.hpp"
 
#include <algorithm>
#include <concepts>
#include <ranges>
#include <tuple>
#include <utility>
 
namespace mimicpp
{
    struct case_insensitive_t
    {
    } constexpr case_insensitive{};
}
 
namespace mimicpp::matches::detail
{
    template <string String>
    [[nodiscard]]
    constexpr auto make_view(String&& str)
    {
        using traits_t = string_traits<std::remove_cvref_t<String>>;
        return traits_t::view(std::forward<String>(str));
    }
 
    template <case_foldable_string String>
    [[nodiscard]]
    constexpr auto make_case_folded_string(String&& str)
    {
        return std::invoke(
            string_case_fold_converter<string_char_t<String>>{},
            detail::make_view(std::forward<String>(str)));
    }
 
    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.");
    }
}
 
namespace mimicpp::matches::str
{

    template <string Pattern>
    [[nodiscard]]
    constexpr auto eq(Pattern&& pattern)
    {
        return PredicateMatcher{
            []<string T, typename Stored>(T&& target, Stored&& stored) {
                detail::check_string_compatibility<T, Pattern>();
 
                return std::ranges::equal(
                    detail::make_view(std::forward<T>(target)),
                    detail::make_view(std::forward<Stored>(stored)));
            },
            "is equal to {}",
            "is not equal to {}",
            std::make_tuple(std::forward<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, typename Stored>(T&& target, Stored&& stored) {
                detail::check_string_compatibility<T, Pattern>();
 
                return std::ranges::equal(
                    detail::make_case_folded_string(std::forward<T>(target)),
                    detail::make_case_folded_string(std::forward<Stored>(stored)));
            },
            "is case-insensitively equal to {}",
            "is case-insensitively not equal to {}",
            std::make_tuple(std::forward<Pattern>(pattern))};
    }

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

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

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

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

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

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

}
 
#endif