GeneralMatchers.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_GENERAL_MATCHERS_HPP
#define MIMICPP_MATCHERS_GENERAL_MATCHERS_HPP
 
#pragma once
 
#include "mimic++/Fwd.hpp"
#include "mimic++/config/Config.hpp"
#include "mimic++/matchers/Common.hpp"
#include "mimic++/printing/Format.hpp"
#include "mimic++/printing/Fwd.hpp"
#include "mimic++/printing/StatePrinter.hpp"
#include "mimic++/utilities/Concepts.hpp"
 
#ifndef MIMICPP_DETAIL_IS_MODULE
    #include <functional>
    #include <tuple>
    #include <type_traits>
    #include <utility>
#endif
 
namespace mimicpp::detail
{
    template <typename Arg, typename MatchesProjection = std::identity, typename DescribeProjection = printing::PrintFn>
    struct arg_storage
    {
        using matches_reference = std::invoke_result_t<MatchesProjection, const Arg&>;
        using describe_reference = std::invoke_result_t<DescribeProjection, const Arg&>;
 
        Arg arg;
 
        decltype(auto) as_matches_arg() const noexcept(std::is_nothrow_invocable_v<MatchesProjection, const Arg&>)
        {
            return std::invoke(MatchesProjection{}, arg);
        }
 
        decltype(auto) as_describe_arg() const noexcept(std::is_nothrow_invocable_v<DescribeProjection, const Arg&>)
        {
            return std::invoke(DescribeProjection{}, arg);
        }
    };
 
    template <typename T>
    struct to_arg_storage
    {
        using type = arg_storage<T>;
    };
 
    template <typename Arg, typename MatchesProjection, typename DescribeProjection>
    struct to_arg_storage<arg_storage<Arg, MatchesProjection, DescribeProjection>>
    {
        using type = arg_storage<Arg, MatchesProjection, DescribeProjection>;
    };
 
    template <typename T>
    using to_arg_storage_t = typename to_arg_storage<T>::type;
}
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp
{
    template <typename Predicate, typename... AdditionalArgs>
        requires std::is_move_constructible_v<Predicate>
              && (... && std::is_move_constructible_v<AdditionalArgs>)
    class PredicateMatcher
    {
    private:
        using storage_t = std::tuple<detail::to_arg_storage_t<AdditionalArgs>...>;
        template <typename T>
        using matches_reference_t = typename detail::to_arg_storage_t<T>::matches_reference;
 
    public:
        [[nodiscard]]
        explicit constexpr PredicateMatcher(
            Predicate predicate,
            StringViewT fmt,
            StringViewT invertedFmt,
            std::tuple<AdditionalArgs...> additionalArgs = {})
            noexcept(
                std::is_nothrow_move_constructible_v<Predicate>
                && (... && std::is_nothrow_move_constructible_v<AdditionalArgs>))
            : m_Predicate{std::move(predicate)},
              m_FormatString{std::move(fmt)},
              m_InvertedFormatString{std::move(invertedFmt)},
              m_AdditionalArgs{std::move(additionalArgs)}
        {
        }
 
        template <typename First, typename... Others>
            requires std::predicate<
                const Predicate&,
                First&,
                Others&...,
                matches_reference_t<AdditionalArgs>...>
        [[nodiscard]]
        constexpr bool matches(
            First& first,
            Others&... others) const
            noexcept(
                std::is_nothrow_invocable_v<
                    const Predicate&,
                    First&,
                    Others&...,
                    matches_reference_t<AdditionalArgs>...>)
        {
            return std::apply(
                [&, this](auto&... additionalArgs) {
                    return std::invoke(
                        m_Predicate,
                        first,
                        others...,
                        additionalArgs.as_matches_arg()...);
                },
                m_AdditionalArgs);
        }
 
        [[nodiscard]]
        constexpr StringT describe() const
        {
            return std::apply(
                [&, this](auto&... additionalArgs) {
                    return format::vformat(
                        m_FormatString,
                        format::make_format_args(
                            std::invoke(
                                // std::make_format_args requires lvalue-refs, so let's transform rvalue-refs to const lvalue-refs
                                [](auto&& val) noexcept -> const auto& { return val; },
                                additionalArgs.as_describe_arg())...));
                },
                m_AdditionalArgs);
        }
 
        [[nodiscard]]
        constexpr auto operator!() const&
            requires std::is_copy_constructible_v<Predicate>
                  && std::is_copy_constructible_v<storage_t>
        {
            return make_inverted(
                m_Predicate,
                m_InvertedFormatString,
                m_FormatString,
                m_AdditionalArgs);
        }
 
        [[nodiscard]]
        constexpr auto operator!() &&
        {
            return make_inverted(
                std::move(m_Predicate),
                std::move(m_InvertedFormatString),
                std::move(m_FormatString),
                std::move(m_AdditionalArgs));
        }
 
    private:
        [[no_unique_address]] Predicate m_Predicate;
        StringViewT m_FormatString;
        StringViewT m_InvertedFormatString;
        storage_t m_AdditionalArgs;
 
        template <typename Fn>
        [[nodiscard]]
        static constexpr auto make_inverted(
            Fn&& fn,
            StringViewT fmt,
            StringViewT invertedFmt,
            storage_t tuple)
        {
            using NotFnT = decltype(std::not_fn(std::forward<Fn>(fn)));
            return PredicateMatcher<NotFnT, detail::to_arg_storage_t<AdditionalArgs>...>{
                std::not_fn(std::forward<Fn>(fn)),
                std::move(fmt),
                std::move(invertedFmt),
                std::move(tuple)};
        }
    };

    class WildcardMatcher
    {
    public:
        [[nodiscard]]
        static constexpr bool matches([[maybe_unused]] auto&& target) noexcept
        {
            return true;
        }
 
        [[nodiscard]]
        static constexpr std::nullopt_t describe() noexcept
        {
            return std::nullopt;
        }
    };

    template <typename T>
    class TypeMatcher
    {
    public:
        template <typename U>
        using is_accepting = std::is_same<T, U>;
 
        [[nodiscard]]
        static constexpr bool matches([[maybe_unused]] auto&& target) noexcept
        {
            return true;
        }
 
        [[nodiscard]]
        static constexpr std::nullopt_t describe() noexcept
        {
            return std::nullopt;
        }
    };
}
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp::matches
{

    [[maybe_unused]] inline constexpr WildcardMatcher _{};

    template <typename T>
    [[maybe_unused]] inline constexpr TypeMatcher<T> type{};

    template <typename T>
    [[nodiscard]]
    constexpr auto eq(T&& value)
    {
        return PredicateMatcher{
            std::equal_to{},
            "== {}",
            "!= {}",
            std::make_tuple(std::forward<T>(value))};
    }

    template <typename T>
    [[nodiscard]]
    constexpr auto ne(T&& value)
    {
        return PredicateMatcher{
            std::not_equal_to{},
            "!= {}",
            "== {}",
            std::make_tuple(std::forward<T>(value))};
    }

    template <typename T>
    [[nodiscard]]
    constexpr auto lt(T&& value)
    {
        return PredicateMatcher{
            std::less{},
            "< {}",
            ">= {}",
            std::make_tuple(std::forward<T>(value))};
    }

    template <typename T>
    [[nodiscard]]
    constexpr auto le(T&& value)
    {
        return PredicateMatcher{
            std::less_equal{},
            "<= {}",
            "> {}",
            std::make_tuple(std::forward<T>(value))};
    }

    template <typename T>
    [[nodiscard]]
    constexpr auto gt(T&& value)
    {
        return PredicateMatcher{
            std::greater{},
            "> {}",
            "<= {}",
            std::make_tuple(std::forward<T>(value))};
    }

    template <typename T>
    [[nodiscard]]
    constexpr auto ge(T&& value)
    {
        return PredicateMatcher{
            std::greater_equal{},
            ">= {}",
            "< {}",
            std::make_tuple(std::forward<T>(value))};
    }

    template <typename UnaryPredicate>
    [[nodiscard]]
    constexpr auto predicate(
        UnaryPredicate&& predicate,
        StringViewT description = "passes predicate",
        StringViewT invertedDescription = "fails predicate")
    {
        return PredicateMatcher{
            std::forward<UnaryPredicate>(predicate),
            std::move(description),
            std::move(invertedDescription),
        };
    }

    template <util::satisfies<std::is_lvalue_reference> T>
    [[nodiscard]]
    constexpr auto instance(T&& instance) // NOLINT(cppcoreguidelines-missing-std-forward)
    {
        return PredicateMatcher{
            []<typename Other>(Other const& target, auto const* instancePtr) noexcept
                requires std::is_convertible_v<std::remove_cvref_t<T> const volatile*, Other const volatile*>
            {
                return std::addressof(target) == instancePtr;
            },
            "is instance at {}",
            "is not instance at {}",
            std::make_tuple(std::addressof(instance))};
    }

}
 
#endif