ObjectPtr.h

// Copyright (C) Entropy Software LLC - All Rights Reserved
 
#pragma once
 
namespace SmartEngine
{
 
class IObject;
 
#pragma pack(push, 1)
 
template <typename T> class ObjectPtr
{
public:
    ObjectPtr() {}
 
    ObjectPtr(const ObjectPtr<T>& ptr)
    {
        _ptr = ptr._ptr;
        AddRef();
    }
 
    ObjectPtr(T* ptr)
    {
        _ptr = ptr;
        if (_ptr)
        {
            _ptr->AddRef();
        }
    }
 
    ~ObjectPtr() { Release(); }
 
    void Clear() { Release(); }
 
    ObjectPtr<T>& operator=(ObjectPtr<T>&& ptr)
    {
        Release();
        _ptr = ptr._ptr;
        ptr._ptr = nullptr;
        return *this;
    }
 
    ObjectPtr<T>& operator=(IObject* ptr)
    {
        T* tmp = _ptr;
 
        if (ptr)
        {
            _ptr = static_cast<T*>(ptr->QueryInterface(T::GetClassId()));
            if (_ptr)
            {
                _ptr->AddRef();
            }
        }
        else
        {
            _ptr = nullptr;
        }
 
        if (tmp)
        {
            tmp->Release();
        }
 
        return *this;
    }
 
    ObjectPtr<T>& operator=(const ObjectPtr<T>& ptr)
    {
        T* tmp = _ptr;
 
        _ptr = ptr._ptr;
        AddRef();
 
        if (tmp)
        {
            tmp->Release();
        }
 
        return *this;
    }
 
    T* operator->() const { return _ptr; }
 
    T* Get() const { return _ptr; }
 
    T*& Get() { return _ptr; }
 
    void Attach(IObject* ptr)
    {
        Release();
        if (ptr)
        {
            _ptr = static_cast<T*>(ptr->QueryInterface(T::GetClassId()));
        }
        else
        {
            _ptr = nullptr;
        }
    }
 
    T* Detach()
    {
        T* tmp = _ptr;
        _ptr = nullptr;
        return tmp;
    }
 
    operator T*() const { return _ptr; }
 
    template <typename D> 
    bool IsA()
    {
        if (!_ptr)
        {
            return false;
        }
        return (_ptr->QueryInterface(D::GetClassId()) != nullptr);
    }
 
private:
    void Release()
    {
        if (_ptr)
        {
            _ptr->Release();
            _ptr = nullptr;
        }
    }
 
    void AddRef()
    {
        if (_ptr)
        {
            _ptr->AddRef();
        }
    }
 
    T* _ptr = nullptr;
};
 
#pragma pack(pop)
 
template <typename T> bool operator==(const ObjectPtr<T>& ptr, const T* p) { return ptr.Get() == p; }
template <typename T> bool operator==(const ObjectPtr<T>& ptr, T* p) { return ptr.Get() == p; }
 
template <typename D> ObjectPtr<D> DynamicCast(IObject* p)
{
    ObjectPtr<D> ptr;
    ptr = p;
    return ptr;
}
 
template <typename D> ObjectPtr<D> DynamicCast(const IObject* p)
{
    ObjectPtr<D> ptr;
    ptr = const_cast<IObject*>(p);
    return ptr;
}
 
template <typename D> ObjectPtr<D> DynamicCastAttach(IObject* p)
{
    ObjectPtr<D> ptr;
    ptr.Attach(p);
    return ptr;
}
 
template <typename D> ObjectPtr<D> IsA(IObject* p)
{
    if (!p)
    {
        return false;
    }
 
    return (p->QueryInterface(D::GetClassId()) != nullptr);
}
 
} // namespace SmartEngine