database_ptr.h

#pragma once
 
#include "sound_bakery/core/database/database_object.h"
#include "sound_bakery/pch.h"
 
namespace sbk::core
{
    class database_object;
 
    std::weak_ptr<database_object> SB_API findObject(sbk_id id);
    bool SB_API objectIdIsChildOfParent(sbk_id childToCheck, sbk_id parent);
    sbk_id SB_API getParentIdFromId(sbk_id id);
 
    template <typename TObject>
    class database_ptr
    {
    public:
        using TThisType       = database_ptr<TObject>;
        using TIdentifierType = sbk_id;
        using TObjectPtr      = TObject*;
        using TObjectRef      = TObject&;
        using TObjectWeak     = std::weak_ptr<database_object>;
        using TObjectShared   = std::shared_ptr<TObject>;
        using TPtrType        = std::weak_ptr<database_object>;
 
        static_assert(!std::is_pointer<TObject>::value);
 
    public:
        database_ptr() : m_objectID(), m_objectPtr(), m_null(true) {}
 
        database_ptr(const TThisType& other) = default;
        database_ptr(TThisType&& other)      = default;
 
        database_ptr(sbk_id id) : m_objectID(id), m_objectPtr(), m_null(true) {}
 
        database_ptr(const TObjectShared& object)
            : m_objectID(object ? static_cast<TIdentifierType>(*object) : 0),
              m_objectPtr(object),
              m_null(object.use_count() == 0)
        {
        }
 
        database_ptr(const TObjectPtr& object)
            : m_objectID(object ? static_cast<TIdentifierType>(*object) : 0), m_objectPtr(findObject(id())), m_null(object == nullptr)
        {
        }
 
        database_ptr(std::nullptr_t) : m_objectID(), m_objectPtr(), m_null(true) {}
 
        ~database_ptr() = default;
 
    public:
        sbk_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=(TObjectShared object)
        {
            if (raw() != object.get())
            {
                reset(object.get());
            }
            return *this;
        }
 
        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:
        sbk_id m_objectID;
        mutable TPtrType m_objectPtr = TPtrType();
        mutable bool m_null;
    };
 
    template <typename T1, typename T2>
    bool operator==(const database_ptr<T1>& lhs, const database_ptr<T2>& rhs)
    {
        return lhs.id() == rhs.id();
    }
 
    template <typename T>
    bool operator==(const database_ptr<T>& lhs, const T* rhs)
    {
        return lhs.raw() == rhs;
    }
 
    template <typename T1, typename T2>
    bool operator<(const database_ptr<T1>& lhs, const database_ptr<T2>& rhs)
    {
        return lhs.id() < rhs.id();
    }
 
    template <typename TObject>
    class child_ptr final : public database_ptr<TObject>
    {
    public:
        using TThisType = child_ptr<TObject>;
 
    public:
        child_ptr() = default;
 
        child_ptr(const TThisType& other) : database_ptr<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);
            }
        }
 
        child_ptr(TThisType&& other) = default;
        ~child_ptr()                 = default;
 
        child_ptr(const database_object& owner) : database_ptr<TObject>(), m_ownerID(owner.get_database_id()) {}
 
        child_ptr(sbk_id id) : database_ptr<TObject>(id), m_ownerID(getParentIdFromId(id)) {}
 
        TThisType& operator=(typename database_ptr<TObject>::TIdentifierType id)
        {
            setID(id);
 
            return *this;
        }
 
        TThisType& operator=(typename database_ptr<TObject>::TObjectPtr object)
        {
            reset(object);
 
            return *this;
        }
 
        TThisType& operator=(const TThisType& other)
        {
            if (database_ptr<TObject>::id() != other.id())
            {
                if (m_ownerID == 0 && database_ptr<TObject>::m_objectID != 0)
                {
                    m_ownerID = getParentIdFromId(database_ptr<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)
                {
                    database_ptr<TObject>::m_objectID  = other.id();
                    database_ptr<TObject>::m_objectPtr = other.weak();
                    database_ptr<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))
                    {
                        database_ptr<TObject>::m_objectID  = other.id();
                        database_ptr<TObject>::m_objectPtr = other.weak();
                        database_ptr<TObject>::m_null      = other.null();
                    }
                }
                // else: don't allow changing owner IDs once they're set
            }
 
            return *this;
        }
 
        void setID(typename database_ptr<TObject>::TIdentifierType id = 0)
        {
            // Fill our get_parent ID if we didn't have it already
            if (m_ownerID == 0 && database_ptr<TObject>::m_objectID != 0)
            {
                m_ownerID = getParentIdFromId(database_ptr<TObject>::m_objectID);
            }
 
            if (id == 0)
            {
                database_ptr<TObject>::m_objectID = 0;
                database_ptr<TObject>::m_objectPtr.reset();
                database_ptr<TObject>::m_null = true;
            }
            else
            {
                if (m_ownerID == 0 || objectIdIsChildOfParent(id, m_ownerID))
                {
                    database_ptr<TObject>::m_objectID = id;
                    database_ptr<TObject>::m_objectPtr.reset();
                    database_ptr<TObject>::m_null = true;
                }
            }
        }
 
        void reset(typename database_ptr<TObject>::TObjectPtr object = nullptr)
        {
            // Fill our get_parent ID if we didn't have it already
            if (m_ownerID == 0 && database_ptr<TObject>::m_objectID != 0)
            {
                m_ownerID = getParentIdFromId(database_ptr<TObject>::m_objectID);
            }
 
            // Reset pointed to values but retain the owner ID
            if (object == nullptr)
            {
                database_ptr<TObject>::m_objectID = 0;
                database_ptr<TObject>::m_objectPtr.reset();
                database_ptr<TObject>::m_null = true;
            }
            // Point to new object if it's a child of our owner
            else
            {
                sbk_id newObjectID = static_cast<typename database_ptr<TObject>::TIdentifierType>(*object);
 
                if (m_ownerID == 0 || objectIdIsChildOfParent(newObjectID, m_ownerID))
                {
                    database_ptr<TObject>::m_objectID = newObjectID;
                    database_ptr<TObject>::m_objectPtr.reset();
                    database_ptr<TObject>::m_null = true;
                }
            }
        }
 
    private:
        typename database_ptr<TObject>::TIdentifierType m_ownerID = 0;
    };
}  // namespace sbk::core
 
namespace std
{
    template <typename T>
    struct hash<sbk::core::database_ptr<T>>
    {
        size_t operator()(const sbk::core::database_ptr<T>& k) const { return hash<sbk_id>{}(k.id()); }
    };
 
    template <typename T>
    struct hash<sbk::core::child_ptr<T>>
    {
        size_t operator()(const sbk::core::child_ptr<T>& k) const { return hash<sbk_id>{}(k.id()); }
    };
}  // namespace std
 
#include <rttr/wrapper_mapper.h>
 
namespace rttr
{
    template <typename T>
    struct wrapper_mapper<sbk::core::child_ptr<T>>
    {
        using wrapped_type = decltype(sbk::core::child_ptr<T>(0).id());
        using type         = sbk::core::child_ptr<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 sbk::core::child_ptr<T2> convert(const type& source, bool& ok)
        {
            sbk::core::child_ptr<T2> convertedLazyPtr(source.id());
 
            ok = source.hasId() == convertedLazyPtr.hasId();
 
            return convertedLazyPtr;
        }
    };
 
    template <typename T>
    struct wrapper_mapper<sbk::core::database_ptr<T>>
    {
        using wrapped_type = decltype(sbk::core::database_ptr<T>().id());
        using type         = sbk::core::database_ptr<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 sbk::core::database_ptr<T2> convert(const type& source, bool& ok)
        {
            sbk::core::database_ptr<T2> convertedLazyPtr(source.id());
 
            ok = source.hasId() == convertedLazyPtr.hasId();
 
            return convertedLazyPtr;
        }
    };
 
}  // namespace rttr