Fwd.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_FWD_HPP
#define MIMICPP_FWD_HPP
 
#pragma once
 
#include "mimic++/config/Config.hpp"
 
#ifndef MIMICPP_DETAIL_IS_MODULE
    #include <string>
    #include <string_view>
#endif
 
namespace mimicpp::call
{
    template <typename Return, typename... Args>
    class Info;
}
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp
{
    enum class Constness
    {
        non_const = 0b01,
        as_const = 0b10,
        any = non_const | as_const
    };
 
    enum class ValueCategory
    {
        lvalue = 0b01,
        rvalue = 0b10,
        any = lvalue | rvalue
    };

    template <typename Signature>
    struct signature_add_noexcept;

    template <typename Signature>
    using signature_add_noexcept_t = typename signature_add_noexcept<Signature>::type;

    template <typename Signature>
    struct signature_remove_noexcept;

    template <typename Signature>
    using signature_remove_noexcept_t = typename signature_remove_noexcept<Signature>::type;

    template <typename Signature>
    struct signature_is_noexcept;

    template <typename Signature>
    inline constexpr bool signature_is_noexcept_v = signature_is_noexcept<Signature>::value;

    template <typename Signature>
    struct signature_call_convention;

    template <typename Signature>
    using signature_call_convention_t = typename signature_call_convention<Signature>::type;

    template <typename Signature>
    struct signature_remove_call_convention;

    template <typename Signature>
    using signature_remove_call_convention_t = typename signature_remove_call_convention<Signature>::type;

    template <typename Signature>
    struct signature_remove_ref_qualifier;

    template <typename Signature>
    using signature_remove_ref_qualifier_t = typename signature_remove_ref_qualifier<Signature>::type;

    template <typename Signature>
    struct signature_add_const_qualifier;

    template <typename Signature>
    using signature_add_const_qualifier_t = typename signature_add_const_qualifier<Signature>::type;

    template <typename Signature>
    struct signature_add_lvalue_ref_qualifier;

    template <typename Signature>
    using signature_add_lvalue_ref_qualifier_t = typename signature_add_lvalue_ref_qualifier<Signature>::type;

    template <typename Signature>
    struct signature_add_rvalue_ref_qualifier;

    template <typename Signature>
    using signature_add_rvalue_ref_qualifier_t = typename signature_add_rvalue_ref_qualifier<Signature>::type;

    template <typename Signature>
    struct signature_remove_const_qualifier;

    template <typename Signature>
    using signature_remove_const_qualifier_t = typename signature_remove_const_qualifier<Signature>::type;

    template <typename Signature>
    struct signature_decay;

    template <typename Signature>
    using signature_decay_t = typename signature_decay<Signature>::type;

    template <typename Signature>
    struct signature_return_type;

    template <typename Signature>
    using signature_return_type_t = typename signature_return_type<Signature>::type;

    template <typename Signature>
    struct signature_const_qualification;

    template <typename Signature>
    inline constexpr Constness signature_const_qualification_v = signature_const_qualification<Signature>::value;

    template <typename Signature>
    struct signature_ref_qualification;

    template <typename Signature>
    inline constexpr ValueCategory signature_ref_qualification_v = signature_ref_qualification<Signature>::value;

    template <std::size_t index, typename Signature>
    struct signature_param_type;

    template <std::size_t index, typename Signature>
    using signature_param_type_t = typename signature_param_type<index, Signature>::type;

    template <typename Signature>
    struct signature_param_list;

    template <typename Signature>
    using signature_param_list_t = typename signature_param_list<Signature>::type;

    template <typename Signature>
    struct signature_arity;

    template <typename Signature>
    inline constexpr std::size_t signature_arity_v{signature_arity<Signature>::value};

    template <typename Signature, typename T>
    struct signature_prepend_param;

    template <typename Signature, typename T>
    using signature_prepend_param_t = typename signature_prepend_param<Signature, T>::type;

    template <typename First, typename Second>
    struct is_overloadable_with;

    template <typename First, typename Second>
    inline constexpr bool is_overloadable_with_v = is_overloadable_with<First, Second>::value;

    template <typename First, typename... Others>
    struct is_overload_set;

    template <typename First, typename... Others>
    inline constexpr bool is_overload_set_v = is_overload_set<First, Others...>::value;

    template <typename Tag>
    struct call_convention_traits;

    template <std::size_t byteCount>
    struct uint_with_size;

    template <std::size_t byteCount>
    using uint_with_size_t = typename uint_with_size<byteCount>::type;
 
    template <typename T>
    struct is_character;
 
    template <typename T>
    struct string_traits;
 
    using CharT = char;
    using CharTraitsT = std::char_traits<CharT>;
    using StringT = std::basic_string<CharT, CharTraitsT>;
    using StringViewT = std::basic_string_view<CharT, CharTraitsT>;
 
    template <typename FirstSignature, typename... OtherSignatures>
        requires is_overload_set_v<FirstSignature, OtherSignatures...>
    class Mock;
}
 
namespace mimicpp::sequence
{
    enum Tag : std::ptrdiff_t
    {
    };
 
    enum class Id : int
    {
    };
 
    struct rating
    {
        int priority{};
        Tag tag{};
 
        [[nodiscard]]
        friend bool operator==(rating const&, rating const&) = default;
    };
 
    namespace detail
    {
        template <typename Id, auto priorityStrategy>
            requires std::is_enum_v<Id>
                  && std::signed_integral<std::underlying_type_t<Id>>
                  && std::convertible_to<
                         std::invoke_result_t<decltype(priorityStrategy), Id, int>,
                         int>
        class BasicSequence;
 
        template <typename Id, auto priorityStrategy>
        class BasicSequenceInterface;
    }
}
 
namespace mimicpp::detail
{
    template <
        typename Derived,
        typename Signature,
        Constness constQualifier = signature_const_qualification_v<Signature>,
        ValueCategory refQualifier = signature_ref_qualification_v<Signature>,
        typename ParamList = signature_param_list_t<Signature>>
    class DefaultCallInterface;
}
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp::util
{
    namespace stacktrace
    {
        class NullBackend;
 
        struct find_backend;
 
        template <typename Backend>
        struct backend_traits;
    }
 
    class Stacktrace;
    class SourceLocation;
}
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp::expectation
{
    class Collector;
    class Expectation;
    class Registry;
    class Owner;
}
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp
{
    using ScopedExpectation = expectation::Owner;

    using ScopedExpectations = expectation::Collector;
}
 
#endif