database_ptr.h

#pragma once
 
#include "sound_bakery/core/database/database_object.h"
#include "sound_bakery/pch.h"
 
namespace SB::Core
{
    class DatabaseObject;
 
    std::weak_ptr<DatabaseObject> SB_API findObject(SB_ID id);
    bool SB_API objectIdIsChildOfParent(SB_ID childToCheck, SB_ID parent);
    SB_ID SB_API getParentIdFromId(SB_ID id);
 
    template <typename TObject>
    class DatabasePtr
    {
    public:
        using TThisType       = DatabasePtr<TObject>;
        using TIdentifierType = SB_ID;
        using TObjectPtr      = TObject*;
        using TObjectRef      = TObject&;
        using TObjectWeak     = std::weak_ptr<DatabaseObject>;
        using TObjectShared   = std::shared_ptr<TObject>;
        using TPtrType        = std::weak_ptr<DatabaseObject>;
 
        static_assert(!std::is_pointer<TObject>::value);
 
    public:
        DatabasePtr() : m_objectID(), m_objectPtr(), m_null(true) {}
 
        DatabasePtr(const TThisType& other) = default;
        DatabasePtr(TThisType&& other)      = default;
 
        DatabasePtr(SB_ID id) : m_objectID(id), m_objectPtr(), m_null(true) {}
 
        DatabasePtr(const TObjectPtr& object)
            : m_objectID(static_cast<TIdentifierType>(*object)), m_objectPtr(findObject(id())), m_null(false)
        {
        }
 
        DatabasePtr(std::nullptr_t) : m_objectID(), m_objectPtr(), m_null(true) {}
 
        ~DatabasePtr() = default;
 
    public:
        SB_ID id() const noexcept { return m_objectID; }
 
        TObjectShared shared() const noexcept
        {
            lookup();
 
            if (m_objectPtr.expired())
            {
                return std::shared_ptr<TObject>();
            }
            else
            {
                return std::static_pointer_cast<TObject>(m_objectPtr.lock());
            }
        }
 
        TObjectWeak weak() const noexcept { return m_objectPtr; }
 
        TObjectPtr raw() const noexcept { return shared().get(); }
 
        TObjectPtr lookupRaw() const noexcept
        {
            lookup();
            return raw();
        }
 
        bool hasId() const { return m_objectID != TIdentifierType(); }
 
        bool null() const { return m_null || m_objectPtr.expired(); }
 
        bool pending() const { return hasId() && null(); }
 
        bool stale() const { return !m_null && m_objectPtr.expired(); }
 
        bool valid() const { return hasId() && !null(); }
 
    public:
        bool lookup() const
        {
            if (pending())
            {
                m_objectPtr = findObject(id());
                m_null      = m_objectPtr.expired();
            }
            return valid();
        }
 
        void reset(TObjectPtr object = nullptr)
        {
            m_objectID = object ? static_cast<TIdentifierType>(*object) : TIdentifierType();
            m_objectPtr.reset();
            m_null = true;
 
            lookup();
        }
 
    public:
        TThisType& operator=(TObjectPtr object)
        {
            if (raw() != object)
            {
                reset(object);
            }
            return *this;
        }
 
        TThisType& operator=(const TThisType& other)
        {
            if (id() != other.id())
            {
                m_objectID  = other.id();
                m_objectPtr = other.weak();
                m_null      = other.null();
            }
 
            return *this;
        }
 
        TThisType& operator=(const TThisType&& other)
        {
            if (id() != other.id())
            {
                m_objectID  = other.id();
                m_objectPtr = other.weak();
                m_null      = other.null();
            }
 
            return *this;
        }
 
        operator bool() const { return valid(); }
 
        bool operator!() const { return !valid(); }
 
        TObjectPtr operator->() const { return raw(); }
 
    protected:
        SB_ID m_objectID;
        mutable TPtrType m_objectPtr = TPtrType();
        mutable bool m_null;
    };
 
    template <typename T1, typename T2>
    bool operator==(const DatabasePtr<T1>& lhs, const DatabasePtr<T2>& rhs)
    {
        return lhs.id() == rhs.id();
    }
 
    template <typename T>
    bool operator==(const DatabasePtr<T>& lhs, const T* rhs)
    {
        return lhs.raw() == rhs;
    }
 
    template <typename T1, typename T2>
    bool operator<(const DatabasePtr<T1>& lhs, const DatabasePtr<T2>& rhs)
    {
        return lhs.id() < rhs.id();
    }
 
    template <typename TObject>
    class ChildPtr final : public DatabasePtr<TObject>
    {
    public:
        using TThisType = ChildPtr<TObject>;
 
    public:
        ChildPtr() = default;
 
        ChildPtr(const TThisType& other) : DatabasePtr<TObject>(other), m_ownerID(other.m_ownerID)
        {
            // If we don't have an owner, try finding it now
            // We can't do any other checks because we were empty before this copy
            // Because we can't do checks, we're just hoping the passed in object is valid
            if (m_ownerID == 0)
            {
                m_ownerID = getParentIdFromId(other.m_objectID);
            }
        }
 
        ChildPtr(TThisType&& other) = default;
        ~ChildPtr()                 = default;
 
        ChildPtr(const DatabaseObject& owner) : DatabasePtr<TObject>(), m_ownerID(owner.getDatabaseID()) {}
 
        ChildPtr(SB_ID id) : DatabasePtr<TObject>(id), m_ownerID(getParentIdFromId(id)) {}
 
        TThisType& operator=(typename DatabasePtr<TObject>::TIdentifierType id)
        {
            setID(id);
 
            return *this;
        }
 
        TThisType& operator=(typename DatabasePtr<TObject>::TObjectPtr object)
        {
            reset(object);
 
            return *this;
        }
 
        TThisType& operator=(const TThisType& other)
        {
            if (DatabasePtr<TObject>::id() != other.id())
            {
                if (m_ownerID == 0 && DatabasePtr<TObject>::m_objectID != 0)
                {
                    m_ownerID = getParentIdFromId(DatabasePtr<TObject>::m_objectID);
                }
 
                // If we don't have an owner, we don't care about checking children
                // We can completely copy other
                if (m_ownerID == 0)
                {
                    DatabasePtr<TObject>::m_objectID  = other.id();
                    DatabasePtr<TObject>::m_objectPtr = other.weak();
                    DatabasePtr<TObject>::m_null      = other.null();
                    m_ownerID                         = other.m_ownerID;
                }
                // If owner isn't trying to be changed, we can just check children and update the pointed to ID
                else if (m_ownerID == other.m_ownerID || other.m_ownerID == 0)
                {
                    // Do child check
                    if (objectIdIsChildOfParent(other.m_objectID, m_ownerID))
                    {
                        DatabasePtr<TObject>::m_objectID  = other.id();
                        DatabasePtr<TObject>::m_objectPtr = other.weak();
                        DatabasePtr<TObject>::m_null      = other.null();
                    }
                }
                // else: don't allow changing owner IDs once they're set
            }
 
            return *this;
        }
 
        void setID(typename DatabasePtr<TObject>::TIdentifierType id = 0)
        {
            // Fill our parent ID if we didn't have it already
            if (m_ownerID == 0 && DatabasePtr<TObject>::m_objectID != 0)
            {
                m_ownerID = getParentIdFromId(DatabasePtr<TObject>::m_objectID);
            }
 
            if (id == 0)
            {
                DatabasePtr<TObject>::m_objectID = 0;
                DatabasePtr<TObject>::m_objectPtr.reset();
                DatabasePtr<TObject>::m_null = true;
            }
            else
            {
                if (m_ownerID == 0 || objectIdIsChildOfParent(id, m_ownerID))
                {
                    DatabasePtr<TObject>::m_objectID = id;
                    DatabasePtr<TObject>::m_objectPtr.reset();
                    DatabasePtr<TObject>::m_null = true;
                }
            }
        }
 
        void reset(typename DatabasePtr<TObject>::TObjectPtr object = nullptr)
        {
            // Fill our parent ID if we didn't have it already
            if (m_ownerID == 0 && DatabasePtr<TObject>::m_objectID != 0)
            {
                m_ownerID = getParentIdFromId(DatabasePtr<TObject>::m_objectID);
            }
 
            // Reset pointed to values but retain the owner ID
            if (object == nullptr)
            {
                DatabasePtr<TObject>::m_objectID = 0;
                DatabasePtr<TObject>::m_objectPtr.reset();
                DatabasePtr<TObject>::m_null = true;
            }
            // Point to new object if it's a child of our owner
            else
            {
                SB_ID newObjectID = static_cast<typename DatabasePtr<TObject>::TIdentifierType>(*object);
 
                if (m_ownerID == 0 || objectIdIsChildOfParent(newObjectID, m_ownerID))
                {
                    DatabasePtr<TObject>::m_objectID = newObjectID;
                    DatabasePtr<TObject>::m_objectPtr.reset();
                    DatabasePtr<TObject>::m_null = true;
                }
            }
        }
 
    private:
        typename DatabasePtr<TObject>::TIdentifierType m_ownerID = 0;
    };
}  // namespace SB::Core
 
namespace std
{
    template <typename T>
    struct hash<SB::Core::DatabasePtr<T>>
    {
        size_t operator()(const SB::Core::DatabasePtr<T>& k) const { return hash<SB_ID>{}(k.id()); }
    };
 
    template <typename T>
    struct hash<SB::Core::ChildPtr<T>>
    {
        size_t operator()(const SB::Core::ChildPtr<T>& k) const { return hash<SB_ID>{}(k.id()); }
    };
}  // namespace std
 
#include <rttr/wrapper_mapper.h>
 
namespace rttr
{
    template <typename T>
    struct wrapper_mapper<SB::Core::ChildPtr<T>>
    {
        using wrapped_type = decltype(SB::Core::ChildPtr<T>(0).id());
        using type         = SB::Core::ChildPtr<T>;
 
        inline static wrapped_type get(const type& obj) { return obj.id(); }
 
        inline static type create(const wrapped_type& t) { return type(t); }
 
        template <typename T2>
        inline static SB::Core::ChildPtr<T2> convert(const type& source, bool& ok)
        {
            SB::Core::ChildPtr<T2> convertedLazyPtr(source.id());
 
            ok = source.hasId() == convertedLazyPtr.hasId();
 
            return convertedLazyPtr;
        }
    };
 
    template <typename T>
    struct wrapper_mapper<SB::Core::DatabasePtr<T>>
    {
        using wrapped_type = decltype(SB::Core::DatabasePtr<T>().id());
        using type         = SB::Core::DatabasePtr<T>;
 
        inline static wrapped_type get(const type& obj) { return obj.id(); }
 
        inline static type create(const wrapped_type& t) { return type(t); }
 
        template <typename T2>
        inline static SB::Core::DatabasePtr<T2> convert(const type& source, bool& ok)
        {
            SB::Core::DatabasePtr<T2> convertedLazyPtr(source.id());
 
            ok = source.hasId() == convertedLazyPtr.hasId();
 
            return convertedLazyPtr;
        }
    };
 
}  // namespace rttr