Owner.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_OWNER_HPP
#define MIMICPP_EXPECTATION_OWNER_HPP
 
#pragma once
 
#include "mimic++/Fwd.hpp"
#include "mimic++/config/Config.hpp"
#include "mimic++/expectation/Expectation.hpp"
#include "mimic++/expectation/Registry.hpp"
 
#ifndef MIMICPP_DETAIL_IS_MODULE
    #include <concepts>
    #include <utility>
#endif
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp::expectation
{
    namespace detail
    {
        template <typename T>
        concept finalizable = requires(util::SourceLocation loc) {
            { std::declval<T&&>().finalize(loc) } -> std::convertible_to<Owner>;
        };
    }

    class Owner
    {
    public:
        Owner(Owner const&) = delete;

        Owner& operator=(Owner const&) = delete;

        ~Owner() noexcept(false)
        {
            if (m_Registry)
            {
                m_Registry->remove(m_Expectation);
            }
        }

        [[nodiscard]]
        explicit Owner(Registry::Ptr registry, Expectation expectation)
            : m_Registry{std::move(registry)},
              m_Expectation{std::move(expectation)}
        {
        }

        template <detail::finalizable T>
        [[nodiscard]]
        explicit(false) constexpr Owner(T&& object, util::SourceLocation loc = {})
            : Owner{std::forward<T>(object).finalize(std::move(loc))}
        {
        }

        [[nodiscard]]
        Owner(Owner&&) = default;

        Owner& operator=(Owner&&) = default;

        [[nodiscard]]
        bool is_satisfied() const
        {
            return m_Expectation.is_satisfied();
        }

        [[nodiscard]]
        bool is_applicable() const
        {
            return m_Expectation.is_applicable();
        }

        [[nodiscard]]
        util::SourceLocation const& from() const noexcept
        {
            return m_Expectation.from();
        }

        [[nodiscard]]
        StringT const& mock_name() const noexcept
        {
            return m_Expectation.mock_name();
        }
 
    private:
        Registry::Ptr m_Registry;
        Expectation m_Expectation;
    };
}
 
#endif