ObjectWatcher.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_OBJECT_WATCHER_HPP
#define MIMICPP_OBJECT_WATCHER_HPP
 
#pragma once
 
#include "mimic++/Fwd.hpp"
#include "mimic++/Mock.hpp"
#include "mimic++/printing/TypePrinter.hpp"
#include "mimic++/utilities/Concepts.hpp"
 
#ifndef MIMICPP_DETAIL_IS_MODULE
    #include <algorithm>
    #include <concepts>
    #include <cstddef>
    #include <memory>
    #include <stdexcept>
    #include <type_traits>
    #include <utility>
#endif
 
namespace mimicpp::detail
{
    template <typename Base>
    [[nodiscard]]
    static StringT generate_lifetime_watcher_mock_name()
    {
        StringStreamT out{};
        out << "LifetimeWatcher for " << print_type<Base>();
        return std::move(out).str();
    }
 
    template <typename Base>
    [[nodiscard]]
    static StringT generate_relocation_watcher_mock_name()
    {
        StringStreamT out{};
        out << "RelocationWatcher for " << print_type<Base>();
        return std::move(out).str();
    }
}
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp
{
 
    template <typename Base>
    struct for_base_tag
    {
        using type = Base;
    };
 
    template <typename Base>
    constexpr for_base_tag<Base> for_base_v{};

    class LifetimeWatcher
    {
        // omits the following entries:
        // - ~LifetimeWatcher
        // - ~CombinedWatchers
        // - ~BasicWatched
        // - ~Watched
        static constexpr std::size_t stacktraceSkip = 4u;
 
    public:
        ~LifetimeWatcher() noexcept(false)
        {
            if (const std::unique_ptr destruction = std::exchange(
                    m_DestructionMock,
                    nullptr))
            {
                (*destruction)();
            }
        }

        [[nodiscard]]
        LifetimeWatcher() = default;
 
        template <typename Base>
        [[nodiscard]] explicit LifetimeWatcher([[maybe_unused]] const for_base_tag<Base>)
            : LifetimeWatcher{
                  MockSettings{
                               .name = detail::generate_lifetime_watcher_mock_name<Base>(),
                               .stacktraceSkip = stacktraceSkip}
        }
        {
        }

        [[nodiscard]]
        LifetimeWatcher(const LifetimeWatcher& other)
            : LifetimeWatcher{other.m_MockSettings}
        {
        }

        LifetimeWatcher& operator=(const LifetimeWatcher& other)
        {
            // let's make this a two-step.
            // First destroy the previous instance, which may already report a violation.
            // If we would already have the new instance created, this would lead also to
            // a violation report, which actually might break everything.
            {
                LifetimeWatcher temp{std::move(*this)};
            }
 
            *this = LifetimeWatcher{other.m_MockSettings};
 
            return *this;
        }

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

        LifetimeWatcher& operator=(LifetimeWatcher&&) = default;

        [[nodiscard]]
        auto expect_destruct()
        {
            if (std::exchange(m_HasDestructExpectation, true))
            {
                throw std::logic_error{
                    "LifetimeWatcher: A destruct expectation can not be created more than once for a single instance."};
            }
 
            return m_DestructionMock->expect_call()
               and expect::once(); // prevent further times specifications
        }
 
    private:
        bool m_HasDestructExpectation{};
        MockSettings m_MockSettings{};
        std::unique_ptr<Mock<void()>> m_DestructionMock{
            std::make_unique<Mock<void()>>(m_MockSettings)};
 
        [[nodiscard]]
        explicit LifetimeWatcher(MockSettings settings)
            : m_MockSettings{std::move(settings)}
        {
        }
    };

    class RelocationWatcher
    {
        // omits the following entries:
        // - RelocationWatcher::handle_move
        // - RelocationWatcher move ctor/assignment
        // - CombinedWatchers move ctor/assignment
        // - BasicWatched move ctor/assignment
        // - Watched move ctor/assignment
        static constexpr std::size_t stacktraceSkip = 5u;
 
    public:
        ~RelocationWatcher() = default;

        [[nodiscard]]
        RelocationWatcher() = default;
 
        template <typename Base>
        [[nodiscard]] explicit RelocationWatcher([[maybe_unused]] const for_base_tag<Base>)
            : RelocationWatcher{
                  MockSettings{
                               .name = detail::generate_relocation_watcher_mock_name<Base>(),
                               .stacktraceSkip = stacktraceSkip}
        }
        {
        }

        [[nodiscard]]
        RelocationWatcher(const RelocationWatcher& other)
            : RelocationWatcher{other.m_MockSettings}
        {
        }

        RelocationWatcher& operator=(const RelocationWatcher& other)
        {
            m_MockSettings = other.m_MockSettings;
 
            // explicitly circumvent default construct and assign, because otherwise that would
            // involve the move-assignment.
            m_RelocationMock = Mock<void()>{m_MockSettings};
 
            return *this;
        }

        [[nodiscard]]
        RelocationWatcher(RelocationWatcher&& other) noexcept(false)
        {
            handle_move(std::move(other));
        }

        RelocationWatcher& operator=(RelocationWatcher&& other) noexcept(false)
        {
            handle_move(std::move(other));
 
            return *this;
        }

        [[nodiscard]]
        auto expect_relocate()
        {
            return m_RelocationMock.expect_call();
        }
 
    private:
        MockSettings m_MockSettings{};
        Mock<void()> m_RelocationMock{m_MockSettings};
 
        [[nodiscard]]
        explicit RelocationWatcher(MockSettings settings)
            : m_MockSettings{std::move(settings)}
        {
        }
 
        void handle_move(RelocationWatcher&& other)
        {
            other.m_RelocationMock();
 
            std::ranges::swap(m_MockSettings, other.m_MockSettings);
            // do not swap here, because we want the target mock to be destroyed NOW
            m_RelocationMock = std::move(other).m_RelocationMock;
        }
    };
 
    template <typename T, typename Base>
    concept object_watcher_for = std::is_constructible_v<T, for_base_tag<Base>>
                              && std::is_copy_constructible_v<T>
                              && std::is_copy_assignable_v<T>
                              && std::is_move_constructible_v<T>
                              && std::is_move_assignable_v<T>
                              && std::is_destructible_v<T>;
}
 
namespace mimicpp::detail
{
    template <typename Base, typename... Watchers>
    class CombinedWatchers
        : public Watchers...
    {
    public:
        ~CombinedWatchers() noexcept(std::is_nothrow_destructible_v<Base>) = default;
 
        CombinedWatchers()
            : Watchers{for_base_v<Base>}...
        {
        }
 
        CombinedWatchers(const CombinedWatchers&) = default;
        CombinedWatchers& operator=(const CombinedWatchers&) = default;
 
        CombinedWatchers(CombinedWatchers&& other) noexcept(std::is_nothrow_move_constructible_v<Base>) = default;
        CombinedWatchers& operator=(CombinedWatchers&& other) noexcept(std::is_nothrow_move_assignable_v<Base>) = default;
    };
 
    template <typename Base, typename... Watchers>
    class BasicWatched
        : public CombinedWatchers<Base, Watchers...>,
          public Base
    {
    public:
        ~BasicWatched() = default;
 
        using Base::Base;
 
        BasicWatched(const BasicWatched&) = default;
        BasicWatched& operator=(const BasicWatched&) = default;
        BasicWatched(BasicWatched&&) = default;
        BasicWatched& operator=(BasicWatched&&) = default;
    };
 
    template <util::satisfies<std::has_virtual_destructor> Base, typename... Watchers>
    class BasicWatched<Base, Watchers...>
        : public CombinedWatchers<Base, Watchers...>,
          public Base
    {
    public:
        ~BasicWatched() override = default;
 
        using Base::Base;
 
        BasicWatched(const BasicWatched&) = default;
        BasicWatched& operator=(const BasicWatched&) = default;
        BasicWatched(BasicWatched&&) = default;
        BasicWatched& operator=(BasicWatched&&) = default;
    };
}
 
MIMICPP_DETAIL_MODULE_EXPORT namespace mimicpp
{
    template <typename Base, object_watcher_for<Base>... Watchers>
        requires std::same_as<Base, std::remove_cvref_t<Base>>
    class Watched
        : public detail::BasicWatched<Base, Watchers...>
    {
        using SuperT = detail::BasicWatched<Base, Watchers...>;
 
    public:
        ~Watched() = default;
 
        using SuperT::SuperT;
 
        Watched(const Watched&) = default;
        Watched& operator=(const Watched&) = default;
        Watched(Watched&&) = default;
        Watched& operator=(Watched&&) = default;
    };

}
 
#endif