ObjectWatcher.hpp

Go to the documentation of this file.

// //          Copyright Dominic (DNKpp) Koepke 2024 - 2024.
// // 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++/Mock.hpp"
 
#include <stdexcept>
#include <utility>
 
namespace mimicpp
{
    class LifetimeWatcher
    {
    public:
        ~LifetimeWatcher() noexcept(false)
        {
            if (const auto destruction = std::exchange(
                    m_DestructionMock,
                    nullptr))
            {
                (*destruction)();
            }
        }
 
        [[nodiscard]]
        LifetimeWatcher() = default;
 
        [[nodiscard]]
        LifetimeWatcher([[maybe_unused]] const LifetimeWatcher& other)
            : LifetimeWatcher{}
        {
        }
 
        LifetimeWatcher& operator=([[maybe_unused]] 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{};
 
            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{};
        std::unique_ptr<Mock<void()>> m_DestructionMock{
            std::make_unique<Mock<void()>>()};
    };
 
    class RelocationWatcher
    {
    public:
        ~RelocationWatcher() = default;
 
        [[nodiscard]]
        RelocationWatcher() = default;
 
        [[nodiscard]]
        RelocationWatcher([[maybe_unused]] const RelocationWatcher& other)
            : RelocationWatcher{}
        {
        }
 
        RelocationWatcher& operator=([[maybe_unused]] const RelocationWatcher& other)
        {
            // explicitly circumvent default construct and assign, because that would
            // involve the move-assignment.
            m_RelocationMock = Mock<void()>{};
 
            return *this;
        }
 
        [[nodiscard]]
        RelocationWatcher(RelocationWatcher&& other) noexcept(false)
        {
            *this = std::move(other);
        }
 
        RelocationWatcher& operator=(RelocationWatcher&& other) noexcept(false)
        {
            other.m_RelocationMock();
            m_RelocationMock = std::move(other).m_RelocationMock;
 
            return *this;
        }
 
        [[nodiscard]]
        auto expect_relocate()
        {
            return m_RelocationMock.expect_call();
        }
 
    private:
        Mock<void()> m_RelocationMock{};
    };
 
    template <typename T>
    concept object_watcher = std::is_default_constructible_v<T>
                          && 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 detail
    {
        template <typename Base, typename... Watchers>
        class CombinedWatchers
            : public Watchers...
        {
        public:
            ~CombinedWatchers() noexcept(std::is_nothrow_destructible_v<Base>) = default;
 
            CombinedWatchers() = default;
 
            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 <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;
        };
    }
 
    template <typename Base, object_watcher... 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