group_ptr.hpp

// Copyright Take Vos 2022.
// 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)
 
#pragma once
 
#include "assert.hpp"
#include "type_traits.hpp"
#include "concepts.hpp"
#include "cast.hpp"
#include "unfair_mutex.hpp"
#include <memory>
#include <vector>
#include <functional>
#include <tuple>
 
namespace hi::inline v1 {
 
template<typename>
class group_ptr;
 
template<typename T, typename... Proto>
class enable_group_ptr;
 
template<typename T, typename... Args>
class enable_group_ptr<T, void(Args...)> {
public:
#ifndef NDEBUG
    ~enable_group_ptr()
    {
        hi_assert(_enable_group_ptr_owners.empty());
    }
#endif
 
    void notify_group_ptr(Args const&...args) const noexcept
    {
        hilet owners_copy = [&] {
            hilet lock = std::scoped_lock(_enable_group_ptr_mutex);
            return _enable_group_ptr_owners;
        }();
 
        for (auto owner : owners_copy) {
            hi_assert_not_null(owner);
            if (owner->_notify) {
                owner->_notify(args...);
            }
        }
    }
 
private:
    using _enable_group_ptr_notify_proto = void(Args...);
 
    std::vector<group_ptr<T> *> _enable_group_ptr_owners;
    mutable unfair_mutex _enable_group_ptr_mutex;
 
    [[nodiscard]] bool _enable_group_ptr_holds_invariant() const noexcept
    {
        hi_axiom(_enable_group_ptr_mutex.is_locked());
 
        for (auto owner : _enable_group_ptr_owners) {
            if (owner == nullptr or owner->_ptr == nullptr or owner->_ptr.get() != this or
                owner->_ptr.use_count() < _enable_group_ptr_owners.size()) {
                return false;
            }
        }
        return true;
    }
 
    void _enable_group_ptr_add_owner(group_ptr<T> *owner) noexcept
    {
        hilet lock = std::scoped_lock(_enable_group_ptr_mutex);
 
        _enable_group_ptr_owners.push_back(owner);
        hi_axiom(_enable_group_ptr_holds_invariant());
    }
 
    void _enable_group_ptr_remove_owner(group_ptr<T> *owner) noexcept
    {
        hilet lock = std::scoped_lock(_enable_group_ptr_mutex);
 
        hilet num_removed = std::erase(_enable_group_ptr_owners, owner);
        hi_assert(num_removed == 1);
        hi_axiom(_enable_group_ptr_holds_invariant());
    }
 
    void _enable_group_ptr_reseat(std::shared_ptr<enable_group_ptr> const& replacement) noexcept
    {
        hilet lock = std::scoped_lock(_enable_group_ptr_mutex);
 
        hi_assert_not_null(replacement);
        hi_assert_not_null(replacement.get());
 
        while (not _enable_group_ptr_owners.empty()) {
            auto *owner = _enable_group_ptr_owners.back();
            _enable_group_ptr_owners.pop_back();
            owner->_ptr = replacement;
            owner->_ptr->_enable_group_ptr_add_owner(owner);
        }
        hi_axiom(_enable_group_ptr_holds_invariant());
    }
 
    friend class group_ptr<T>;
};
 
template<typename T>
class enable_group_ptr<T> : public enable_group_ptr<T, void()> {
};
 
template<typename T>
class group_ptr {
public:
    using notify_proto = T::_enable_group_ptr_notify_proto;
    using element_type = T;
 
    virtual ~group_ptr()
    {
        if (_ptr) {
            _ptr->_enable_group_ptr_remove_owner(this);
        }
    }
 
    group_ptr(group_ptr const& other) noexcept : _ptr(other._ptr)
    {
        if (_ptr) {
            _ptr->_enable_group_ptr_add_owner(this);
        }
    }
 
    group_ptr& operator=(group_ptr const& other) noexcept
    {
        if (_ptr == other._ptr) {
            return *this;
 
        } else if (_ptr and other._ptr) {
            // Make copy because reseat() will overwrite _ptr.
            auto tmp = _ptr;
            tmp->_enable_group_ptr_reseat(other._ptr);
            return *this;
 
        } else if (_ptr) {
            _ptr->_enable_group_ptr_remove_owner(this);
            _ptr = nullptr;
            return *this;
 
        } else {
            _ptr = other._ptr;
            _ptr->_enable_group_ptr_add_owner(this);
            return *this;
        }
    }
 
    group_ptr(group_ptr&& other) noexcept : _ptr(std::move(other._ptr))
    {
        if (_ptr) {
            _ptr->_enable_group_ptr_remove_owner(&other);
            _ptr->_enable_group_ptr_add_owner(this);
        }
    }
 
    group_ptr& operator=(group_ptr&& other) noexcept
    {
        hi_return_on_self_assignment(other);
 
        if (_ptr == other._ptr) {
            other._ptr->_enable_group_ptr_remove_owner(&other);
            other._ptr = nullptr;
            return *this;
 
        } else if (_ptr and other._ptr) {
            other._ptr->_enable_group_ptr_remove_owner(&other);
            // Make copy because reseat() will overwrite _ptr.
            auto tmp = _ptr;
            tmp->_enable_group_ptr_reseat(std::exchange(other._ptr, nullptr));
            return *this;
 
        } else if (_ptr) {
            _ptr->_enable_group_ptr_remove_owner(this);
            _ptr = nullptr;
            return *this;
 
        } else {
            other._ptr->_enable_group_ptr_remove_owner(&other);
            _ptr = std::exchange(other._ptr, nullptr);
            _ptr->_enable_group_ptr_add_owner(this);
            return *this;
        }
    }
 
    constexpr group_ptr() noexcept = default;
 
    constexpr group_ptr(std::nullptr_t) noexcept {}
 
    void reset() noexcept
    {
        if (_ptr) {
            _ptr->_enable_group_ptr_remove_owner(this);
            _ptr = nullptr;
        }
    }
 
    template<forward_of<std::shared_ptr<enable_group_ptr<T, notify_proto>>> Ptr>
    group_ptr(Ptr&& ptr) noexcept : _ptr(std::forward<Ptr>(ptr))
    {
        if (_ptr) {
            _ptr->_enable_group_ptr_add_owner(this);
        }
    }
 
    template<forward_of<std::shared_ptr<enable_group_ptr<T, notify_proto>>> Ptr>
    group_ptr& operator=(Ptr&& ptr) noexcept
    {
        return *this = group_ptr{std::forward<Ptr>(ptr)};
    }
 
    [[nodiscard]] T *get() const noexcept
    {
        return static_cast<T *>(_ptr.get());
    }
 
    [[nodiscard]] T *operator->() const noexcept
    {
        return get();
    }
 
    [[nodiscard]] T& operator*() const noexcept
    {
        return *get();
    }
 
    explicit operator bool() const noexcept
    {
        return to_bool(_ptr);
    }
 
    void subscribe(forward_of<notify_proto> auto&& func) noexcept
    {
        _notify = hi_forward(func);
    }
 
    void unsubscribe() noexcept
    {
        _notify = {};
    }
 
private:
    std::shared_ptr<enable_group_ptr<T, notify_proto>> _ptr = {};
    std::function<notify_proto> _notify = {};
 
    friend class enable_group_ptr<T, notify_proto>;
};
 
template<typename Context, typename Expected>
struct is_forward_of<Context, group_ptr<Expected>> :
    std::conditional_t<std::is_convertible_v<Context, group_ptr<Expected>>, std::true_type, std::false_type> {
};
 
} // namespace hi::inline v1