SideEffectPolicies.hpp

Go to the documentation of this file.

//          Copyright Dominic (DNKpp) Koepke 2024-2026.
// 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_EXPECTATION_POLICIES_SIDE_EFFECT_POLICIES_HPP
#define MIMICPP_EXPECTATION_POLICIES_SIDE_EFFECT_POLICIES_HPP
 
#pragma once
 
#include "mimic++/Fwd.hpp"
#include "mimic++/config/Config.hpp"
#include "mimic++/expectation/Common.hpp"
#include "mimic++/expectation/policies/ArgumentList.hpp"
 
#ifndef MIMICPP_DETAIL_IS_MODULE
    #include <concepts>
    #include <cstddef>
    #include <functional>
    #include <type_traits>
    #include <utility>
#endif
 
namespace mimicpp::expectation::policies
{
    template <typename Action>
    class SideEffectAction
    {
    public:
        SideEffectAction(SideEffectAction const&) = delete;
        SideEffectAction& operator=(SideEffectAction const&) = delete;
 
        ~SideEffectAction() = default;
 
        [[nodiscard]]
        explicit constexpr SideEffectAction(Action&& action) noexcept(std::is_nothrow_move_constructible_v<Action>)
            : m_Action{std::move(action)}
        {
        }
 
        [[nodiscard]]
        SideEffectAction(SideEffectAction&&) = default;
        SideEffectAction& operator=(SideEffectAction&&) = default;
 
        static constexpr bool is_satisfied() noexcept
        {
            return true;
        }
 
        template <typename Return, typename... Args>
        [[nodiscard]]
        static MatchResult matches(call::Info<Return, Args...> const& /*call*/) noexcept
        {
            return MatchSuccess{};
        }
 
        template <typename Return, typename... Args>
            requires std::invocable<Action&, call::Info<Return, Args...> const&>
        constexpr void consume(call::Info<Return, Args...> const& info)
            noexcept(std::is_nothrow_invocable_v<Action&, call::Info<Return, Args...> const&>)
        {
            std::invoke(m_Action, info);
        }
 
    private:
        Action m_Action;
    };
}
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp::then
{

    template <std::size_t index, typename Action>
    [[nodiscard]]
    constexpr auto apply_arg(Action&& action)
        noexcept(std::is_nothrow_constructible_v<std::remove_cvref_t<Action>, Action>)
    {
        using arg_selector_t = expectation::policies::detail::args_selector_fn<
            std::add_lvalue_reference_t,
            std::index_sequence<index>>;
        using apply_strategy_t = expectation::policies::detail::arg_list_forward_apply_fn;
 
        return expectation::policies::SideEffectAction{
            std::bind_front(
                expectation::policies::detail::apply_args_fn{arg_selector_t{}, apply_strategy_t{}},
                std::forward<Action>(action))};
    }

    template <std::size_t index, std::size_t... additionalIndices, typename Action>
    [[nodiscard]]
    constexpr auto apply_args(Action&& action)
        noexcept(std::is_nothrow_constructible_v<std::remove_cvref_t<Action>, Action>)
    {
        using arg_selector_t = expectation::policies::detail::args_selector_fn<
            std::add_lvalue_reference_t,
            std::index_sequence<index, additionalIndices...>>;
        using apply_strategy_t = expectation::policies::detail::arg_list_forward_apply_fn;
 
        return expectation::policies::SideEffectAction{
            std::bind_front(
                expectation::policies::detail::apply_args_fn{arg_selector_t{}, apply_strategy_t{}},
                std::forward<Action>(action))};
    }

    template <typename Action>
    [[nodiscard]]
    constexpr auto apply_all(Action&& action)
        noexcept(std::is_nothrow_constructible_v<std::remove_cvref_t<Action>, Action>)
    {
        using arg_selector_t = expectation::policies::detail::all_args_selector_fn<std::add_lvalue_reference_t>;
        using apply_strategy_t = expectation::policies::detail::arg_list_forward_apply_fn;
 
        return expectation::policies::SideEffectAction{
            std::bind_front(
                expectation::policies::detail::apply_args_fn{arg_selector_t{}, apply_strategy_t{}},
                std::forward<Action>(action))};
    }

    template <std::invocable Action>
    [[nodiscard]]
    constexpr auto invoke(Action&& action)
        noexcept(std::is_nothrow_constructible_v<std::remove_cvref_t<Action>, Action>)
    {
        return expectation::policies::SideEffectAction{
            [fn = std::forward<Action>(action)]([[maybe_unused]] auto const& call) mutable noexcept(
                std::is_nothrow_invocable_v<Action&>) {
                std::invoke(fn);
            }};
    }

}
 
#endif