FinalizerPolicies.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_FINALIZER_POLICIES_HPP
#define MIMICPP_EXPECTATION_POLICIES_FINALIZER_POLICIES_HPP
 
#pragma once
 
#include "mimic++/Fwd.hpp"
#include "mimic++/config/Config.hpp"
#include "mimic++/expectation/policies/ArgumentList.hpp"
#include "mimic++/utilities/Concepts.hpp"
#include "mimic++/utilities/UnwrapRef.hpp"
 
#ifndef MIMICPP_DETAIL_IS_MODULE
    #include <concepts>
    #include <functional>
    #include <type_traits>
    #include <utility>
#endif
 
namespace mimicpp::expectation::policies
{
    template <typename Action>
        requires std::same_as<Action, std::remove_cvref_t<Action>>
              && std::is_move_constructible_v<Action>
    class ReturnsResultOf
    {
    public:
        [[nodiscard]]
        explicit constexpr ReturnsResultOf(Action&& action)
            noexcept(std::is_nothrow_move_constructible_v<Action>)
            : m_Action{std::move(action)}
        {
        }
 
        template <typename Return, typename... Args>
            requires std::invocable<Action&, call::Info<Return, Args...> const&>
                  && util::explicitly_convertible_to<
                         std::invoke_result_t<Action&, call::Info<Return, Args...> const&>,
                         Return>
        [[nodiscard]]
        constexpr Return finalize_call([[maybe_unused]] call::Info<Return, Args...> const& call)
            noexcept(
                std::is_nothrow_invocable_v<Action&, call::Info<Return, Args...> const&>
                && util::nothrow_explicitly_convertible_to<std::invoke_result_t<Action&, call::Info<Return, Args...> const&>, Return>)
        {
            return static_cast<Return>(
                std::invoke(m_Action, call));
        }
 
    private:
        Action m_Action;
    };
 
    template <typename Exception>
        requires(!std::is_reference_v<Exception>)
             && std::copyable<Exception>
    class Throws
    {
    public:
        [[nodiscard]]
        explicit constexpr Throws(Exception exception) noexcept(std::is_nothrow_move_constructible_v<Exception>)
            : m_Exception{std::move(exception)}
        {
        }
 
        template <typename Return, typename... Args>
        constexpr Return finalize_call(call::Info<Return, Args...> const& /*call*/)
        {
            throw m_Exception; // NOLINT(hicpp-exception-baseclass)
        }
 
    private:
        Exception m_Exception;
    };
}
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp::finally
{

    template <typename Fun>
        requires std::invocable<std::remove_cvref_t<Fun>&>
              && (!std::is_void_v<std::invoke_result_t<std::remove_cvref_t<Fun>&>>)
    [[nodiscard]]
    constexpr auto returns_result_of(Fun&& fun)
        noexcept(std::is_nothrow_constructible_v<std::remove_cvref_t<Fun>, Fun>)
    {
        return expectation::policies::ReturnsResultOf{
            [fn = std::forward<Fun>(fun)]([[maybe_unused]] auto const& call) mutable noexcept(
                std::is_nothrow_invocable_v<decltype(fun)>) -> decltype(auto) {
                return std::invoke(fn);
            }};
    }

    template <typename T>
        requires std::copyable<std::remove_cvref_t<T>>
    [[nodiscard]]
    constexpr auto returns(T&& value)
        noexcept(std::is_nothrow_constructible_v<std::remove_cvref_t<T>, T>)
    {
        return expectation::policies::ReturnsResultOf{
            [v = std::forward<T>(value)]([[maybe_unused]] auto const& call) mutable noexcept -> auto& {
                return util::unwrap_ref(v);
            }};
    }

    template <std::size_t index, std::size_t... otherIndices, typename Action>
    [[nodiscard]]
    constexpr auto returns_apply_result_of(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, otherIndices...>>;
        using apply_strategy_t = expectation::policies::detail::arg_list_forward_apply_fn;
 
        return expectation::policies::ReturnsResultOf{
            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 returns_apply_all_result_of(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::ReturnsResultOf{
            std::bind_front(
                expectation::policies::detail::apply_args_fn{arg_selector_t{}, apply_strategy_t{}},
                std::forward<Action>(action))};
    }

    template <std::size_t index>
    [[nodiscard]]
    consteval auto returns_arg() noexcept
    {
        using arg_selector_t = expectation::policies::detail::args_selector_fn<
            std::add_rvalue_reference_t,
            std::index_sequence<index>>;
        using apply_strategy_t = expectation::policies::detail::arg_list_forward_apply_fn;
 
        return expectation::policies::ReturnsResultOf{
            std::bind_front(
                expectation::policies::detail::apply_args_fn{arg_selector_t{}, apply_strategy_t{}},
                std::identity{})};
    }

    template <typename T>
        requires std::copyable<std::remove_cvref_t<T>>
    [[nodiscard]]
    constexpr expectation::policies::Throws<std::remove_cvref_t<T>> throws(
        T && exception) noexcept(std::is_nothrow_constructible_v<std::remove_cvref_t<T>, T>)
    {
        return expectation::policies::Throws<std::remove_cvref_t<T>>{
            std::forward<T>(exception)};
    }

}
 
#endif