COMPointer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Misc/AssertionMacros.h"
#include <Unknwn.h>
 
#ifdef TEXT_PASTE
    #undef TEXT
    #define TEXT(x) TEXT_PASTE(x)
#endif
 
 
template<typename T>
class TComPtr
{
public:
 
    typedef T PointerType;
 
public:
 
    TComPtr()
        :   RawPointer(NULL)
    { }
 
    TComPtr(PointerType* const Object)
        : RawPointer(Object)
    {
        if (RawPointer)
        {
            RawPointer->AddRef();
        }
    }
 
    TComPtr(const TComPtr<PointerType>& Other)
        : RawPointer(Other.RawPointer)
    {
        if (RawPointer)
        {
            RawPointer->AddRef();
        }
    }
 
    TComPtr(TComPtr<PointerType>&& Other)
        : RawPointer(Other.RawPointer)
    {   
        Other.RawPointer = NULL;
    }   
 
    TComPtr<PointerType>& operator=(PointerType* const Object) 
    {
        if (RawPointer != Object)
        {
            if (Object)
            {
                Object->AddRef();
            }
 
            if (RawPointer)
            {
                RawPointer->Release();
            }
 
            RawPointer = Object;
        }
 
        return *this;
    }
 
    TComPtr<PointerType>& operator=(const TComPtr<PointerType>& Other) 
    {
        if (RawPointer != Other.RawPointer)
        {
            if (Other.RawPointer)
            {
                Other->AddRef();
            }
 
            if (RawPointer)
            {
                RawPointer->Release();
            }
 
            RawPointer = Other.RawPointer;
        }
 
        return *this;
    }
 
    TComPtr<PointerType>& operator=(TComPtr<PointerType>&& Other) 
    {           
        if (RawPointer != Other.RawPointer)
        {
            if (RawPointer)
            {
                RawPointer->Release();
            }
 
            RawPointer = Other.RawPointer;
            Other.RawPointer = NULL;
        }
 
        return *this;
    }
 
    ~TComPtr() 
    {
        if (RawPointer)
        {
            RawPointer->Release();
        }
    }
 
public:
 
    UE_FORCEINLINE_HINT PointerType** operator&()
    {
        return &(RawPointer);
    }
 
    inline PointerType* operator->() const 
    {
        check(RawPointer != NULL);
        return RawPointer;
    }
 
    UE_FORCEINLINE_HINT bool operator==(PointerType* const Object) const
    {
        return RawPointer == Object;
    }
 
    UE_FORCEINLINE_HINT bool operator!=(PointerType* const Object) const
    {
        return RawPointer != Object;
    }
 
    UE_FORCEINLINE_HINT operator PointerType*() const
    {
        return RawPointer;
    }
 
public:
 
    void Attach(PointerType* Object)
    {
        if (RawPointer)
        {
            RawPointer->Release();
        }
 
        RawPointer = Object;
    }
 
    void Detach()
    {
        RawPointer = NULL;
    }
 
    HRESULT FromQueryInterface(REFIID Riid, IUnknown* Unknown)
    {
        if (RawPointer)
        {
            RawPointer->Release();
            RawPointer = NULL;
        }
 
        return Unknown->QueryInterface(Riid, reinterpret_cast<void**>(&(RawPointer)));
    }
 
    UE_FORCEINLINE_HINT PointerType* Get() const
    {
        return RawPointer;
    }
 
    UE_FORCEINLINE_HINT const bool IsValid() const
    {
        return (RawPointer != NULL);
    }
 
    void Reset()
    {
        if (RawPointer)
        {
            RawPointer->Release();
            RawPointer = NULL;
        }
    }
 
private:
 
    PointerType* RawPointer;
 
    friend UE_FORCEINLINE_HINT uint32 GetTypeHash(const TComPtr<T>& InObjectPtr)
    {
        return GetTypeHash(InObjectPtr.RawPointer);
    }
};