SideEffectPolicies.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_POLICIES_SIDE_EFFECT_POLICIES_HPP
#define MIMICPP_POLICIES_SIDE_EFFECT_POLICIES_HPP
 
#pragma once
 
#include "mimic++/Fwd.hpp"
#include "mimic++/policies/ArgumentList.hpp"
 
#include <concepts>
#include <functional>
#include <type_traits>
#include <utility>
 
namespace mimicpp::expectation_policies
{
    template <typename Action>
    class SideEffectAction
    {
    public:
        ~SideEffectAction() = default;
 
        [[nodiscard]]
        explicit constexpr SideEffectAction(
            Action&& action) noexcept(std::is_nothrow_move_constructible_v<Action>)
            : m_Action{std::move(action)}
        {
        }
 
        SideEffectAction(const SideEffectAction&) = delete;
        SideEffectAction& operator=(const SideEffectAction&) = delete;
 
        [[nodiscard]]
        SideEffectAction(SideEffectAction&&) = default;
        SideEffectAction& operator=(SideEffectAction&&) = default;
 
        static constexpr bool is_satisfied() noexcept
        {
            return true;
        }
 
        template <typename Return, typename... Args>
        [[nodiscard]]
        static constexpr bool matches(const call::Info<Return, Args...>&) noexcept
        {
            return true;
        }
 
        [[nodiscard]]
        static std::nullopt_t describe() noexcept
        {
            return std::nullopt;
        }
 
        template <typename Return, typename... Args>
            requires std::invocable<Action&, const call::Info<Return, Args...>&>
        constexpr void consume(const call::Info<Return, Args...>& info)
            noexcept(std::is_nothrow_invocable_v<Action&, const call::Info<Return, Args...>&>)
        {
            std::invoke(m_Action, info);
        }
 
    private:
        Action m_Action;
    };
}
 
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 = detail::args_selector_fn<
            std::add_lvalue_reference_t,
            std::index_sequence<index>>;
        using apply_strategy_t = detail::arg_list_forward_apply_fn;
 
        return expectation_policies::SideEffectAction{
            std::bind_front(
                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 = detail::args_selector_fn<
            std::add_lvalue_reference_t,
            std::index_sequence<index, additionalIndices...>>;
        using apply_strategy_t = detail::arg_list_forward_apply_fn;
 
        return expectation_policies::SideEffectAction{
            std::bind_front(
                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 = detail::all_args_selector_fn<std::add_lvalue_reference_t>;
        using apply_strategy_t = detail::arg_list_forward_apply_fn;
 
        return expectation_policies::SideEffectAction{
            std::bind_front(
                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]] const auto& call) mutable noexcept(
                std::is_nothrow_invocable_v<Action&>) {
                std::invoke(fn);
            }};
    }

}
 
#endif