SharedPtrTypes.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2024 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
#pragma once
 
#include <memory>
#include <functional>
#include <optional>
#include <type_traits>
 
class AObject;
 
#ifdef AUI_SHARED_PTR_FIND_INSTANCES
#include <AUI/api.h>
#include <AUI/Util/APimpl.h>
#include <map>
#include <set>
#include <mutex>
#include <AUI/Reflect/AClass.h>
 
class API_AUI_CORE AStacktrace;
 
namespace aui::impl::shared_ptr {
    struct InstancesDict {
        std::recursive_mutex sync;
        std::map<void*, std::set<void*>> map;
    };
 
    API_AUI_CORE InstancesDict& instances() noexcept;
    API_AUI_CORE void printAllInstancesOf(void* ptrToSharedPtr) noexcept;
}
 
#endif
 
template<typename T>
class _;

template<typename T>
struct _weak: public std::weak_ptr<T> {
private:
    using super = std::weak_ptr<T>;
 
public:
    using super::weak_ptr;
 
    _weak(const _weak<T>& v) noexcept: std::weak_ptr<T>(v) {}
    _weak(_weak<T>&& v) noexcept: std::weak_ptr<T>(std::move(v)) {}
    _weak(const std::weak_ptr<T>& v): std::weak_ptr<T>(v) {}
    _weak(std::weak_ptr<T>&& v) noexcept: std::weak_ptr<T>(std::move(v)) {}
 
    _<T> lock() const noexcept {
        return static_cast<_<T>>(super::lock());
    }
 
    _weak& operator=(const std::weak_ptr<T>& v) noexcept {
        super::weak_ptr::operator=(v);
        return *this;
    }
 
    _weak& operator=(std::weak_ptr<T>&& v) noexcept {
        super::weak_ptr::operator=(std::move(v));
        return *this;
    }
 
    _weak& operator=(const _weak<T>& v) noexcept {
        super::weak_ptr::operator=(v);
        return *this;
    }
 
    _weak& operator=(_weak<T>&& v) noexcept {
        super::weak_ptr::operator=(std::move(v));
        return *this;
    }
 
    _weak& operator=(const std::shared_ptr<T>& v) noexcept {
        super::weak_ptr::operator=(v);
        return *this;
    }
 
    _weak& operator=(std::shared_ptr<T>&& v) noexcept {
        super::weak_ptr::operator=(std::move(v));
        return *this;
    }
 
    _weak& operator=(const _<T>& v) noexcept {
        super::weak_ptr::operator=(v);
        return *this;
    }
 
    _weak& operator=(_<T>&& v) noexcept {
        super::weak_ptr::operator=(std::move(v));
        return *this;
    }
};
 
template<typename T, typename Deleter = std::default_delete<T>>
using _unique = std::unique_ptr<T, Deleter>;
 
 
namespace aui {
 
    struct ptr {
        template<typename T, typename Deleter = std::default_delete<T>>
        static _unique<T, Deleter> make_unique_with_deleter(T* ptr, Deleter deleter = Deleter{}) {
            return { ptr, std::move(deleter) };
        }

        template<typename T>
        static _<T> manage(T* raw);

        template<typename T, typename Deleter>
        static _<T> manage(T* raw, Deleter deleter);

        template<typename T>
        static _unique<T> unique(T* raw);

        template<typename T>
        static _<T> fake(T* raw);
    };
}
 

template<typename T>
class _ : public std::shared_ptr<T>
{
    friend struct aui::ptr;
private:
    using super = std::shared_ptr<T>;
 
    _(T* raw, std::nullopt_t): std::shared_ptr<T>(raw) {
 
    }
 
#ifdef AUI_SHARED_PTR_FIND_INSTANCES
    friend API_AUI_CORE void aui::impl::shared_ptr::printAllInstancesOf(void* ptrToSharedPtr) noexcept;
    struct InstanceDescriber;
 
    static AStacktrace makeStacktrace();
 
    struct InstanceDescriber {
        aui::fast_pimpl<AStacktrace, sizeof(std::vector<int>) + 8, alignof(std::vector<int>)> stacktrace;
        _<T>* self;
        T* pointingTo;
 
        InstanceDescriber(_<T>* self): stacktrace(_<T>::makeStacktrace()), self(self), pointingTo(self->get()) {
            if (pointingTo == nullptr) return;
            std::unique_lock lock(aui::impl::shared_ptr::instances().sync);
            aui::impl::shared_ptr::instances().map[pointingTo].insert(self);
            //std::printf("[AUI_SHARED_PTR_FIND_INSTANCES] %s << %p\n", AClass<T>::name().toStdString().c_str(), pointingTo);
        }
 
        InstanceDescriber(const InstanceDescriber&) = delete;
        InstanceDescriber(InstanceDescriber&&) = delete;
 
        ~InstanceDescriber() {
            if (pointingTo == nullptr) return;
            auto& inst = aui::impl::shared_ptr::instances();
            std::unique_lock lock(inst.sync);
            if (auto mapIt = inst.map.find(pointingTo); mapIt != inst.map.end()) {
                auto setIt = mapIt->second.find(self);
                AUI_ASSERT(setIt != mapIt->second.end());
                mapIt->second.erase(setIt);
                if (mapIt->second.empty()) {
                    //inst.map.erase(it);
                }
            }
            //std::printf("[AUI_SHARED_PTR_FIND_INSTANCES] %s >> %p\n", AClass<T>::name().toStdString().c_str(), pointingTo);
        }
    } mInstanceDescriber = this;
 
#endif
 
public:
    using stored_t = T;
 
 
#ifdef AUI_SHARED_PTR_FIND_INSTANCES
    void printAllInstances() {
        aui::impl::shared_ptr::printAllInstancesOf(this);
    }
    void printAllInstances() const {
        const_cast<_<T>&>(*this).printAllInstances();
    }
#endif
 
    using std::shared_ptr<T>::shared_ptr;
 
    _(const std::shared_ptr<T>& v): std::shared_ptr<T>(v) {}
    _(std::shared_ptr<T>&& v) noexcept: std::shared_ptr<T>(std::move(v)) {}
    _(const _& v): std::shared_ptr<T>(v) {}
    _(_&& v) noexcept: std::shared_ptr<T>(std::move(v)) {}
    _(const std::weak_ptr<T>& v): std::shared_ptr<T>(v) {}
    _(const _weak<T>& v): std::shared_ptr<T>(v) {}
 
    _& operator=(const _& rhs) noexcept {
        std::shared_ptr<T>::operator=(rhs);
        return *this;
    }
 
    _& operator=(_&& rhs) noexcept {
        std::shared_ptr<T>::operator=(std::forward<_>(rhs));
        return *this;
    }

    _(T* v) = delete;

    [[nodiscard]]
    _weak<T> weak() const {
        return _weak<T>(*this);
    }
 
    template<typename SignalField, typename Object, typename Function>
    inline _<T>& connect(SignalField signalField, Object object, Function&& function);
 
    template<typename SignalField, typename Function>
    inline _<T>& connect(SignalField signalField, Function&& function);
 
 
    template <typename Functor>
    inline _<T>& operator^(Functor&& functor) {
        functor(*this);
        return *this;
    }
    // forward ranged-for loops
    auto begin() const {
        return super::operator->()->begin();
    }
    auto end() const {
        return super::operator->()->end();
    }
    auto begin() {
        return super::operator->()->begin();
    }
    auto end() {
        return super::operator->()->end();
    }
 
    // operators
 
    template<typename Arg>
    const _<T>& operator<<(Arg&& value) const {
        (*super::get()) << std::forward<Arg>(value);
        return *this;
    }
 
    template<typename Arg>
    _<T>& operator<<(Arg&& value) {
        (*super::get()) << std::forward<Arg>(value);
        return *this;
    }
 
    template<typename... Arg>
    auto operator()(Arg&&... value) const requires std::is_invocable_v<T, Arg...> {
        return (*super::get())(std::forward<Arg>(value)...);
    }
 
    template<typename Arg>
    const _<T>& operator+(Arg&& value) const {
        (*super::get()) + std::forward<Arg>(value);
        return *this;
    }
 
    template<typename Arg>
    _<T>& operator+(Arg&& value) {
        (*super::get()) + std::forward<Arg>(value);
        return *this;
    }
 
    template<typename Arg>
    const _<T>& operator*(Arg&& value) {
        (*super::get()) * std::forward<Arg>(value);
        return *this;
    }
 
    [[nodiscard]]
    std::add_lvalue_reference_t<T> operator*() const noexcept {
        return super::operator*();
    }
 
    template<typename Arg>
    const _<T>& operator-(Arg&& value) const {
        (*super::get()) - std::forward<Arg>(value);
        return *this;
    }
 
    template<typename Arg>
    _<T>& operator-(Arg&& value) {
        (*super::get()) - std::forward<Arg>(value);
        return *this;
    }
    template<typename Arg>
    _<T>& operator>>(Arg&& value) {
        (*super::get()) >> std::forward<Arg>(value);
        return *this;
    }
 
    template<typename...Args>
    _<T>& operator()(const Args&... value) {
        (*super::get())(value...);
        return *this;
    }
    template<typename...Args>
    auto operator()(Args&&... value) {
        return (*super::get())(std::forward<Args>(value)...);
    }
};
 
 
namespace aui {
    template<typename T>
    _<T> ptr::manage(T* raw) {
        return _<T>(raw, std::nullopt);
    }
 
    template<typename T>
    _<T> ptr::fake(T* raw) {
        return _<T>(std::shared_ptr<void>{}, raw);
    }
 
    template<typename T, typename Deleter>
    _<T> ptr::manage(T* raw, Deleter deleter) {
        return _<T>(raw, deleter);
    }
    template<typename T>
    _unique<T> ptr::unique(T* raw) {
        return _unique<T>(raw);
    }
}
 
template<typename TO, typename FROM>
inline TO* _cast(const _unique<FROM>& object)
{
    return dynamic_cast<TO*>(object.get());
}
 
template<typename TO, typename FROM>
inline _<TO> _cast(const _<FROM>& object)
{
    return std::dynamic_pointer_cast<TO, FROM>(object);
}
 
template<typename TO, typename FROM>
inline _<TO> _cast(_<FROM>&& object)
{
    return std::dynamic_pointer_cast<TO, FROM>(std::move(object));
}
 
template<typename TO, typename FROM>
inline _<TO> _cast(const std::shared_ptr<FROM>& object)
{
    return std::dynamic_pointer_cast<TO, FROM>(object);
}
 
 
template<typename TO, typename FROM>
inline _<TO> _cast(std::shared_ptr<FROM>&& object)
{
    return std::dynamic_pointer_cast<TO, FROM>(std::move(object));
}
 
 

#define AUI_NULLSAFE(s) if(decltype(auto) _tmp = (s))_tmp