safeptr.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
 
// Std includes
#include <set>
#include <functional>
#include <atomic>
 
// Nap includes
#include <utility/dllexport.h>
#include <readerwriterqueue.h>
 
namespace nap
{
 
    namespace audio
    {
        // Forward declarations
        class DeletionQueue;
 
        template<typename T>
        class SafeOwner;
 
        template<typename T>
        class SafePtr;
 
        class NAPAPI SafeOwnerBase
        {
            friend class DeletionQueue;
 
        protected:
            class Data
            {
            public:
                virtual ~Data() = default;
            };
 
        public:
            virtual ~SafeOwnerBase() = default;
 
        protected:
            void assign(SafeOwnerBase& source);
 
        private:
            // These methods are internally used by assign() and will be overwritted by SafeOwner<T> to support polymorphism.
            virtual void* getData() = 0;
 
            virtual void setData(void* data) = 0;
 
            virtual DeletionQueue* getDeletionQueue() = 0;
 
            virtual void setDeletionQueue(DeletionQueue* queue) = 0;
 
            virtual void enqueueForDeletion() = 0;
        };
 
 
        class NAPAPI DeletionQueue final
        {
            friend class SafeOwnerBase;
 
        public:
            DeletionQueue() = default;
 
            ~DeletionQueue();
 
            void enqueue(std::unique_ptr<SafeOwnerBase::Data> ownerData)
            {
                mQueue.enqueue(std::move(ownerData));
            }
 
            void clear();
 
        private:
            moodycamel::ReaderWriterQueue<std::unique_ptr<SafeOwnerBase::Data>> mQueue; // Lockfree queue that holds SafeOwner::Data objects to be deleted because the enclosing SafeOwner went out of scope.
        };
 
 
        template<typename T>
        class SafeOwner final : public SafeOwnerBase
        {
            friend class DeletionQueue;
 
            friend class SafePtr<T>;
 
        private:
            class Data : public SafeOwnerBase::Data
            {
            public:
                Data(T* ptr)
                {
                    mObject = std::unique_ptr<T>(ptr);
                    mSharedSafePtr = std::make_shared<Data*>(this);
                }
 
                ~Data() override
                {
                    *mSharedSafePtr = nullptr;
                }
 
            public:
                std::unique_ptr<T> mObject = nullptr; 
                std::shared_ptr<Data*> mSharedSafePtr = nullptr; 
                std::atomic<bool> mEnqueuedForDeletion = { false }; 
            };
 
        public:
            SafeOwner() = default;
 
            SafeOwner(DeletionQueue& deletionQueue, T* ptr)
            {
                mDeletionQueue = &deletionQueue;
                mData = std::make_unique<Data>(ptr);
            }
 
            ~SafeOwner()
            {
                enqueueForDeletion();
            }
 
            // Copy constructor with nullptr
            SafeOwner(const std::nullptr_t) { }
 
            // Assignment operator with nullptr
            SafeOwner& operator=(const std::nullptr_t)
            {
                enqueueForDeletion();
                return *this;
            }
 
            // Copy and move are not allowed because the SafeOwner (just like unique_ptr) holds ownership
            SafeOwner(const SafeOwner& other) = delete;
            SafeOwner& operator=(const SafeOwner& other) = delete;
 
            // Move ctor is fine, as unique_ptr's can be moved
            SafeOwner(SafeOwner<T>&& other) { assign(other); }
 
            // Move assignment operator
            SafeOwner<T>& operator=(SafeOwner<T>&& other)
            {
                assign(other);
                return *this;
            }
 
            // Move constructor with different type
            template<typename OTHER>
            SafeOwner(SafeOwner<OTHER>&& other) { assign(other); }
 
            // Move assignment operator with different type
            template<typename OTHER>
            SafeOwner<T>& operator=(SafeOwner<OTHER>&& other)
            {
                assign(other);
                return *this;
            }
 
            const T& operator*() const
            {
                assert(mData != nullptr);
                return *static_cast<T*>(mData->mObject.get());
            }
 
            T& operator*()
            {
                assert(mData != nullptr);
                return *static_cast<T*>(mData->mObject.get());
            }
 
            T* operator->() const
            {
                assert(mData != nullptr);
                return static_cast<T*>(mData->mObject.get());
            }
 
            T* operator->()
            {
                assert(mData != nullptr);
                return static_cast<T*>(mData->mObject.get());
            }
 
            template<typename OTHER>
            bool operator==(const OTHER* ptr) const
            {
 
                return ptr ? mData->mObject.get() == ptr : mData == nullptr;
            }
 
            template<typename OTHER>
            bool operator!=(const OTHER* ptr) const
            {
                return ptr ? mData->mObject.get() != ptr : mData != nullptr;
            }
 
            bool operator==(const std::nullptr_t) const
            {
                return mData == nullptr;
            }
 
            bool operator!=(const std::nullptr_t) const
            {
                return mData != nullptr;
            }
 
            SafePtr<T> get()
            {
                auto safePtr = SafePtr<T>(*this);
                return std::move(safePtr);
            }
 
            SafePtr<T> get() const
            {
                auto safePtr = SafePtr<T>(*this);
                return std::move(safePtr);
            }
 
            T* getRaw() { return mData->mObject.get(); }
 
            T* getRaw() const { return mData->mObject.get(); }
 
        protected:
            // Inherited from SafeOwnerBase for polymorphism support
            void* getData() override { return mData.release(); }
 
            void setData(void* data) override { mData = std::unique_ptr<Data>(static_cast<Data*>(data)); }
 
            DeletionQueue* getDeletionQueue() override { return mDeletionQueue; }
 
            void setDeletionQueue(DeletionQueue* queue) override { mDeletionQueue = queue; }
 
        private:
            void enqueueForDeletion() override
            {
                if (mData != nullptr) {
                    assert(mDeletionQueue != nullptr);
                    mData->mEnqueuedForDeletion = true;
                    mDeletionQueue->enqueue(std::move(mData));
                    mDeletionQueue = nullptr;
                    mData = nullptr;
                }
            }
 
            std::unique_ptr<Data> mData = nullptr; 
            DeletionQueue* mDeletionQueue = nullptr; 
        };
 
 
        class NAPAPI SafePtrBase
        {
        public:
            virtual ~SafePtrBase() = default;
 
        protected:
            void assign(const SafePtrBase& other)
            {
                setOwnerData(other.getOwnerData());
            }
 
        private:
            // These methods are internally used by assign() in order to support polymorphism.
            virtual void* getOwnerData() const = 0;
 
            virtual void setOwnerData(void* ownerData) = 0;
        };
 
 
        template<typename T>
        class SafePtr final : public SafePtrBase
        {
            friend class SafeOwner<T>;
 
            friend class DeletionQueue;
 
        public:
            SafePtr() = default;
 
            SafePtr(SafeOwner<T>& owner)
            {
                mOwnerData = owner.mData->mSharedSafePtr;
            }
 
            ~SafePtr()
            {
            }
 
            // Copy ctor
            SafePtr(const SafePtr<T>& other)
            {
                assign(other);
            }
 
            // Assignment operator
            SafePtr& operator=(const SafePtr<T>& other)
            {
                assign(other);
                return *this;
            }
 
            // Copy ctor with different type
            template<typename OTHER>
            SafePtr(const SafePtr<OTHER>& other)
            {
                assign(other);
            }
 
            // Assignment operator with different type
            template<typename OTHER>
            SafePtr& operator=(const SafePtr<OTHER>& other)
            {
                assign(other);
                return *this;
            }
 
            // Copy ctor with nullptr
            SafePtr(const std::nullptr_t)
            {}
 
            // Assignment operator with nullptr
            SafePtr& operator=(const std::nullptr_t)
            {
                mOwnerData = nullptr;
                return *this;
            }
 
            // Move ctor
            SafePtr(SafePtr<T>&& other)
            {
                assign(other);
            }
 
            // Move assignment operator
            SafePtr<T>& operator=(SafePtr<T>&& other)
            {
                assign(other);
                return *this;
            }
 
            // Move ctor with different type
            template<typename OTHER>
            SafePtr(SafePtr<OTHER>&& other)
            {
                assign(other);
            }
 
            // Move assignment operator with different type
            template<typename OTHER>
            SafePtr<T>& operator=(SafePtr<OTHER>&& other)
            {
                assign(other);
                return *this;
            }
 
            const T& operator*() const
            {
                assert(isValid());
                return *static_cast<T*>((*mOwnerData)->mObject.get());
            }
 
            T& operator*()
            {
                assert(isValid());
                return *static_cast<T*>((*mOwnerData)->mObject.get());
            }
 
            T* operator->() const
            {
                assert(isValid());
                return static_cast<T*>((*mOwnerData)->mObject.get());
            }
 
            T* operator->()
            {
                assert(isValid());
                return static_cast<T*>((*mOwnerData)->mObject.get());
            }
 
            template<typename OTHER>
            bool operator==(const OTHER* ptr) const
            {
                return ptr ? isValid() && (*mOwnerData)->mObject.get() == ptr : !isValid();
            }
 
            template<typename OTHER>
            bool operator!=(const OTHER* ptr) const
            {
                return ptr ? isValid() && (*mOwnerData)->mObject.get() != ptr : !isValid();
            }
 
            bool operator==(const std::nullptr_t) const
            {
                return !isValid() || (*mOwnerData)->mEnqueuedForDeletion == true;
            }
 
            bool operator!=(const std::nullptr_t) const
            {
                return isValid() && (*mOwnerData)->mEnqueuedForDeletion == false;
            }
 
            T* get() const
            {
                assert(isValid());
                return static_cast<T*>((*mOwnerData)->mObject.get());
            }
 
            T* get()
            {
                assert(isValid());
                return static_cast<T*>((*mOwnerData)->mObject.get());
            }
 
        private:
            void* getOwnerData() const override
            { return *mOwnerData; }
 
            void setOwnerData(void* ownerData) override
            {
                if (ownerData == nullptr)
                    mOwnerData = nullptr;
                else
                    // Update the target data
                    mOwnerData = static_cast<typename SafeOwner<T>::Data*>(ownerData)->mSharedSafePtr;
            }
 
            bool isValid() const
            {
                return (mOwnerData != nullptr) && (*mOwnerData != nullptr);
            }
 
            std::shared_ptr<typename SafeOwner<T>::Data*> mOwnerData = nullptr; 
        };
 
 
    }
 
}