FinalizerPolicies.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_FINALIZER_POLICIES_HPP
#define MIMICPP_POLICIES_FINALIZER_POLICIES_HPP
 
#pragma once
 
#include "mimic++/Fwd.hpp"
#include "mimic++/Utility.hpp"
#include "mimic++/policies/ArgumentList.hpp"
 
#include <concepts>
#include <functional>
#include <type_traits>
#include <utility>
 
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)}
        {
        }
        explicit constexpr ReturnsResultOf(Action&& action) {…}
 
        template <typename Return, typename... Args>
            requires std::invocable<Action&, const call::Info<Return, Args...>&>
                  && explicitly_convertible_to<
                         std::invoke_result_t<Action&, const call::Info<Return, Args...>&>,
                         Return>
        [[nodiscard]]
        constexpr Return finalize_call([[maybe_unused]] const call::Info<Return, Args...>& call)
            noexcept(
                std::is_nothrow_invocable_v<Action&, const call::Info<Return, Args...>&>
                && nothrow_explicitly_convertible_to<std::invoke_result_t<Action&, const call::Info<Return, Args...>&>, Return>)
        {
            return static_cast<Return>(
                std::invoke(m_Action, call));
        }
        constexpr Return finalize_call([[maybe_unused]] const call::Info<Return, Args...>& call) {…}
 
    private:
        Action m_Action;
    };
    class ReturnsResultOf {…};
 
    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)}
        {
        }
        explicit constexpr Throws(Exception exception) noexcept(std::is_nothrow_move_constructible_v<Exception>) {…}
 
        template <typename Return, typename... Args>
        constexpr Return finalize_call(
            [[maybe_unused]] const call::Info<Return, Args...>& call)
        {
            throw m_Exception; // NOLINT(hicpp-exception-baseclass)
        }
        constexpr Return finalize_call( {…}
 
    private:
        Exception m_Exception;
    };
    class Throws {…};
}
 
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]] const auto& call) mutable noexcept(
                std::is_nothrow_invocable_v<decltype(fun)>) -> decltype(auto) {
                return std::invoke(fn);
            }};
    }
    constexpr auto returns_result_of(Fun&& fun) {…}

    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]] const auto& call) mutable noexcept -> auto& {
                return static_cast<std::unwrap_reference_t<decltype(v)>&>(v);
            }};
    }
    constexpr auto returns(T&& value) {…}

    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 = detail::args_selector_fn<
            std::add_lvalue_reference_t,
            std::index_sequence<index, otherIndices...>>;
        using apply_strategy_t = detail::arg_list_forward_apply_fn;
 
        return expectation_policies::ReturnsResultOf{
            std::bind_front(
                detail::apply_args_fn{
                    arg_selector_t{},
                    apply_strategy_t{}},
                std::forward<Action>(action))};
    }
    constexpr auto returns_apply_result_of(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 = detail::all_args_selector_fn<std::add_lvalue_reference_t>;
        using apply_strategy_t = detail::arg_list_forward_apply_fn;
 
        return expectation_policies::ReturnsResultOf{
            std::bind_front(
                detail::apply_args_fn{
                    arg_selector_t{},
                    apply_strategy_t{}},
                std::forward<Action>(action))};
    }
    constexpr auto returns_apply_all_result_of(Action&& action) {…}

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

    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)};
    }
    constexpr expectation_policies::Throws<std::remove_cvref_t<T>> throws(T&& exception) {…}

}
namespace mimicpp::finally {…}
 
#endif