objectptr.h

/* 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 https://mozilla.org/MPL/2.0/. */
 
#pragma once
 
// External Includes
#include <utility/dllexport.h>
#include <unordered_set>
#include <rtti/object.h>
#include <cassert>
#include <mutex>
 
#ifdef NAP_ENABLE_PYTHON
    #include <pybind11/cast.h>
#endif
 
namespace nap
{
    namespace rtti
    {
        class NAPAPI ObjectPtrBase
        {
            RTTI_ENABLE()
        public:
            virtual ~ObjectPtrBase() = default;
            
            rttr::type getWrappedType() const               { return mPtr->get_type();   }
 
        private:
            ObjectPtrBase() = default;
        
            ObjectPtrBase(rtti::Object* ptr) :
                mPtr(ptr)                                   { }
 
            rtti::Object* get()                             { return mPtr; }
 
            const rtti::Object* get() const                 { return mPtr; }
 
        private:
            void set(rtti::Object* ptr)                             
            {
                if (mPtr != nullptr)
                    mPtr->decrementObjectPtrRefCount();
 
                mPtr = ptr;
 
                if (mPtr != nullptr)
                    mPtr->incrementObjectPtrRefCount();
            }
        private:
            template<class T> friend class ObjectPtr;
            friend class ObjectPtrManager;
            rtti::Object* mPtr = nullptr;
        };
 
 
        class NAPAPI ObjectPtrManager
        {
        public:
            typedef std::unordered_set<ObjectPtrBase*> ObjectPtrSet;
 
            static ObjectPtrManager& get();
 
            template<class OBJECTSBYIDMAP>
            void patchPointers(OBJECTSBYIDMAP& newTargetObjects);
        
            void resetPointers(const rtti::Object& targetObject)
            {
                for (ObjectPtrBase* ptr : mObjectPointers)
                {
                    if (ptr->get() == &targetObject)
                        ptr->set(nullptr);
                }
            }
 
        private:
            template<class T> friend class ObjectPtr;
 
            void add(ObjectPtrBase& ptr)                        { mObjectPointers.insert(&ptr); }
 
            void remove(ObjectPtrBase& ptr)                     { mObjectPointers.erase(&ptr); }
 
            ObjectPtrSet mObjectPointers;                   
        };
 
        template<typename T>
        class ObjectPtr : public ObjectPtrBase
        {
            RTTI_ENABLE(ObjectPtrBase)
 
        public:
            // Default constructor
            ObjectPtr() = default;
 
            // Dtor
            virtual ~ObjectPtr() override;
            
            // Regular ptr Ctor
            ObjectPtr(T* ptr);
 
            // Copy ctor
            ObjectPtr(const ObjectPtr<T>& other)                    { assign(other); }
 
            // Move ctor
            ObjectPtr(ObjectPtr<T>&& other)                         { move(other); }
 
            // Assignment operator
            ObjectPtr<T>& operator=(const ObjectPtr<T>& other)      { assign(other); return *this; }
 
            // Move assignment operator
            ObjectPtr<T>& operator=(ObjectPtr<T>&& other)           { move(other); return *this; }
 
            // Raw object pointer
            T* get() const                                          { return static_cast<T*>(mPtr); }
 
            // Raw object pointer
            T* get()                                                { return static_cast<T*>(mPtr); }
 
 
            // Regular ctor taking different type
            template<typename OTHER>
            ObjectPtr(const ObjectPtr<OTHER>& other)                { assign(other); }
 
            // Regular move ctor taking different type
            template<typename OTHER>
            ObjectPtr(ObjectPtr<OTHER>&& other)                     { move(other); }
 
            // Assignment operator taking different type
            template<typename OTHER>
            ObjectPtr<T>& operator=(const ObjectPtr<OTHER>& other)  { assign(other); return *this; }
 
            // Move assignment operator taking different type
            template<typename OTHER>
            ObjectPtr<T>& operator=(ObjectPtr<OTHER>&& other)       { move(other); return *this; }
 
 
            const T& operator*() const                              { assert(mPtr != nullptr); return *static_cast<T*>(mPtr); }
 
            T& operator*()                                          { assert(mPtr != nullptr); return *static_cast<T*>(mPtr); }
 
            T* operator->() const                                   { assert(mPtr != nullptr); return static_cast<T*>(mPtr); }
 
            T* operator->()                                         { assert(mPtr != nullptr); return static_cast<T*>(mPtr); }
 
            bool operator==(const ObjectPtr<T>& other) const        { return mPtr == other.mPtr; }
 
            template<typename OTHER>
            bool operator==(const ObjectPtr<OTHER>& other) const    { return mPtr == other.mPtr; }
 
            template<typename OTHER>
            bool operator==(const OTHER* ptr) const                 { return mPtr == ptr; }
 
            bool operator==(std::nullptr_t) const                   { return mPtr == nullptr; }
 
            bool operator!=(const ObjectPtr<T>& other) const        { return mPtr != other.mPtr; }
 
            template<typename OTHER>
            bool operator!=(const ObjectPtr<OTHER>& other) const    { return mPtr != other.mPtr; }
 
            template<typename OTHER>
            bool operator!=(const OTHER* ptr) const                 { return mPtr != ptr; }
 
            bool operator!=(std::nullptr_t) const                   { return mPtr != nullptr; }
 
            bool operator<(const ObjectPtr<T>& other) const         { return mPtr < other.mPtr; }
 
            bool operator>(const ObjectPtr<T>& other) const         { return mPtr > other.mPtr; }
 
            bool operator<=(const ObjectPtr<T>& other) const        { return mPtr <= other.mPtr; }
 
            bool operator>=(const ObjectPtr<T>& other) const        { return mPtr >= other.mPtr; }
 
        private:
            template<typename OTHER>
            void move(ObjectPtr<OTHER>& other);
 
            template<typename OTHER>
            void assign(const ObjectPtr<OTHER>& other);
        };
 
 
        // Template Definitions
 
        template<class OBJECTSBYIDMAP>
        void ObjectPtrManager::patchPointers(OBJECTSBYIDMAP& newTargetObjects)
        {
            for (ObjectPtrBase* ptr : mObjectPointers)
            {
                rtti::Object* target = ptr->get();
                if (target == nullptr)
                    continue;
 
                std::string& target_id = target->mID;
                typename OBJECTSBYIDMAP::iterator new_target = newTargetObjects.find(target_id);
                if (new_target != newTargetObjects.end())
                    ptr->set(&*(new_target->second));
            }
        }
 
 
        template<typename T>
        ObjectPtr<T>::~ObjectPtr()
        {
            if (mPtr != nullptr)
            {
                mPtr->decrementObjectPtrRefCount();
            }
            ObjectPtrManager::get().remove(*this);
        }
 
        template<typename T>
        nap::rtti::ObjectPtr<T>::ObjectPtr(T* ptr) : ObjectPtrBase(ptr)
        {
            if (mPtr != nullptr)
            {
                ObjectPtrManager::get().add(*this);
                mPtr->incrementObjectPtrRefCount();
            }
        }
 
        template<typename T>
        template<typename OTHER>
        void nap::rtti::ObjectPtr<T>::move(ObjectPtr<OTHER>& other)
        {
            assign(other);
            if (other.mPtr != nullptr)
            {
                other.mPtr->decrementObjectPtrRefCount();
                other.mPtr = nullptr;
            }
        }
 
        template<typename T>
        template<typename OTHER>
        void nap::rtti::ObjectPtr<T>::assign(const ObjectPtr<OTHER>& other)
        {
            if (mPtr == nullptr && other.mPtr != nullptr)
                ObjectPtrManager::get().add(*this);
 
            if (other.mPtr != mPtr)
            {
                if (mPtr != nullptr)
                    mPtr->decrementObjectPtrRefCount();
 
                mPtr = static_cast<T*>(other.get());
 
                if (mPtr != nullptr)
                    mPtr->incrementObjectPtrRefCount();
            }
 
            if (mPtr == nullptr)
                ObjectPtrManager::get().remove(*this);
        }
 
    }
}
 
 
namespace rttr
{
    template<typename T>
    struct wrapper_mapper<nap::rtti::ObjectPtr<T>>
    {
        using wrapped_type = T*;
        using type = nap::rtti::ObjectPtr<T>;
        inline static wrapped_type get(const type& obj)         { return obj.get(); }
        inline static type create(const wrapped_type& value)    { return nap::rtti::ObjectPtr<T>(value); }      
    };
}
 
 
#ifdef NAP_ENABLE_PYTHON
namespace pybind11
{
    namespace detail
    {
        template <typename type>
        struct always_construct_holder<nap::rtti::ObjectPtr<type>> : always_construct_holder<void, true>
        {
        };
 
        template <typename type> class type_caster<nap::rtti::ObjectPtr<type>> : public copyable_holder_caster<type, nap::rtti::ObjectPtr<type>>
        {
        public:
            static handle cast(const nap::rtti::ObjectPtr<type>& src, return_value_policy, handle)
            {
                const auto *ptr = src.get();
 
                auto st = copyable_holder_caster<type, nap::rtti::ObjectPtr<type>>::src_and_type(ptr);
 
                return type_caster_generic::cast(
                    st.first, return_value_policy::reference, {}, st.second,
                    nullptr, nullptr, nullptr);
            }
        };
    }
}
#endif // NAP_ENABLE_PYTHON