SharedPointer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "uLang/Common/Common.h"
#include "uLang/Common/Containers/Function.h"
#include "uLang/Common/Memory/Allocator.h"
#include "uLang/Common/Templates/Conditionals.h"
#include "uLang/Common/Templates/References.h"
 
#define UE_API ULANGCORE_API
 
namespace uLang
{
 
template<class ObjectType, bool AllowNull, class AllocatorType, typename... AllocatorArgsType> class TSPtrG;
template<class ObjectType, bool AllowNull, class AllocatorType, typename... AllocatorArgsType> class TSPtrArrayG;
template<class ObjectType, bool AllowNull, class KeyType, class AllocatorType, typename... AllocatorArgsType> class TSPtrSetG;
 
class CSharedMix
{
public:
 
    CSharedMix() : _RefCount(0) {}
    UE_API virtual ~CSharedMix();
 
    CSharedMix(const CSharedMix & Other) = delete; // Do not copy
    CSharedMix & operator=(const CSharedMix & Other) = delete; // Do not assign
 
    uint32_t GetRefCount() const { return _RefCount; }
 
protected:
    template<class ObjectType>
    static TSPtrG<ObjectType, false, CHeapRawAllocator> SharedThis(ObjectType* This)
    {
        return TSPtrG<ObjectType, false, CHeapRawAllocator>(This, CHeapRawAllocator());
    }
 
    template<class ObjectType>
    static TSPtrG<const ObjectType, false, CHeapRawAllocator> SharedThis(const ObjectType* This)
    {
        return TSPtrG<const ObjectType, false, CHeapRawAllocator>(This, CHeapRawAllocator());
    }
 
private:
 
    template<class ObjectType, bool AllowNull, class AllocatorType, typename... AllocatorArgsType> friend class TSPtrG;
    template<class ObjectType, bool AllowNull, class AllocatorType, typename... AllocatorArgsType> friend class TSPtrArrayG;
    template<class ObjectType, bool AllowNull, class KeyType, class AllocatorType, typename... AllocatorArgsType> friend class TSPtrSetG;
 
 
 
    void    Reference() const { ++_RefCount; }
    bool    Dereference() const;
 
    mutable uint32_t _RefCount;
 
};
 
template<class ObjectType, bool AllowNull, class AllocatorType, typename... AllocatorArgsType>
class TSPtrG
{
public:
 
    // Construction
 
    ULANG_FORCEINLINE TSPtrG(NullPtrType NullPtr = nullptr) : _Object(nullptr), _Allocator(DefaultInit), _ReleaseFunc(nullptr) { static_assert(AllowNull, "Cannot default construct a shared reference, as it is not allowed to be null."); }
    ULANG_FORCEINLINE TSPtrG(const TSPtrG & Other) : _Object(Other._Object), _Allocator(Other._Allocator) { EnableRelease(); if (Other._Object) { Other._Object->Reference(); } }
    template<class OtherObjectType, bool OtherAllowNull, typename = typename TEnableIf<TPointerIsConvertibleFromTo<OtherObjectType, ObjectType>::Value && (AllowNull || !OtherAllowNull)>::Type>
    ULANG_FORCEINLINE TSPtrG(const TSPtrG<OtherObjectType, OtherAllowNull, AllocatorType, AllocatorArgsType...> & Other) : _Object(Other._Object), _Allocator(Other._Allocator) { EnableRelease(); if (Other._Object) { Other._Object->Reference(); } }
    ULANG_FORCEINLINE TSPtrG(TSPtrG && Other) : _Object(Other._Object), _Allocator(Other._Allocator) { EnableRelease(); Other._Object = nullptr; } // Note: We null here even when OtherAllowNull==false since 99% likely will be destructed immediately after anyway
    template<class OtherObjectType, bool OtherAllowNull, typename = typename TEnableIf<TPointerIsConvertibleFromTo<OtherObjectType, ObjectType>::Value && (AllowNull || !OtherAllowNull)>::Type>
    ULANG_FORCEINLINE TSPtrG(TSPtrG<OtherObjectType, OtherAllowNull, AllocatorType, AllocatorArgsType...> && Other) : _Object(Other._Object), _Allocator(Other._Allocator) { EnableRelease(); Other._Object = nullptr; } // Note: We null here even when OtherAllowNull==false since 99% likely will be destructed immediately after anyway 
    ULANG_FORCEINLINE ~TSPtrG() { if (_Object) Release(); }
 
    template<typename... CtorArgsType>
    ULANG_FORCEINLINE TSPtrG& SetNew(CtorArgsType&&... CtorArgs) { EnableRelease(); if (_Object) { Release(); } ObjectType * Object = new(_Allocator) ObjectType(uLang::ForwardArg<CtorArgsType>(CtorArgs)...); ULANG_ASSERT(Object); Object->Reference(); _Object = Object; return *this; }
    template<typename... CtorArgsType>
    ULANG_FORCEINLINE static TSPtrG New(AllocatorArgsType&&... AllocatorArgs, CtorArgsType&&... CtorArgs) { AllocatorType Allocator(AllocatorArgs...); ObjectType* Object = new(Allocator) ObjectType(uLang::ForwardArg<CtorArgsType>(CtorArgs)...); ULANG_ASSERT(Object); return TSPtrG(Object, uLang::Move(Allocator)); }
 
    // Assignment
 
    ULANG_FORCEINLINE TSPtrG & operator=(NullPtrType) { static_assert(AllowNull, "Cannot assign null to shared reference, as it is not allowed to be null."); if (_Object) { Release(); } _Object = nullptr; return *this; }
    ULANG_FORCEINLINE TSPtrG & operator=(const TSPtrG & Other) { return AssignCopy(Other); }
    template<class OtherObjectType, bool OtherAllowNull, typename = typename TEnableIf<TPointerIsConvertibleFromTo<OtherObjectType, ObjectType>::Value && (AllowNull || !OtherAllowNull)>::Type>
    ULANG_FORCEINLINE TSPtrG & operator=(const TSPtrG<OtherObjectType, OtherAllowNull, AllocatorType, AllocatorArgsType...> & Other) { return AssignCopy(Other); }
    ULANG_FORCEINLINE TSPtrG & operator=(TSPtrG && Other) { return AssignMove(ForwardArg<TSPtrG>(Other)); }
    template<class OtherObjectType, bool OtherAllowNull, typename = typename TEnableIf<TPointerIsConvertibleFromTo<OtherObjectType, ObjectType>::Value>::Type>
    ULANG_FORCEINLINE TSPtrG & operator=(TSPtrG<OtherObjectType, OtherAllowNull, AllocatorType, AllocatorArgsType...> && Other) { return AssignMove(uLang::ForwardArg<TSPtrG<OtherObjectType, OtherAllowNull, AllocatorType, AllocatorArgsType...>>(Other)); }
 
    // Conversion methods
 
    ULANG_FORCEINLINE operator ObjectType*() const { return _Object; }
    ULANG_FORCEINLINE ObjectType &          operator*() const { ULANG_ASSERT(_Object); return *_Object; }
    ULANG_FORCEINLINE ObjectType *          operator->() const { ULANG_ASSERT(AllowNull || _Object); return _Object; }
    ULANG_FORCEINLINE ObjectType *          Get() const { ULANG_ASSERT(AllowNull || _Object); return _Object; }
    ULANG_FORCEINLINE const AllocatorType & GetAllocator() const { return _Allocator; }
    ULANG_FORCEINLINE void                  Reset() { if (_Object) { Release(); _Object = nullptr; } }
 
    ULANG_FORCEINLINE TSPtrG<ObjectType, false, AllocatorType, AllocatorArgsType...>& AsRef()&
    {
        static_assert(AllowNull, "Unnecessary conversion!");
        ULANG_ASSERTF(_Object, "Converting null pointer to reference!");
        return *reinterpret_cast<TSPtrG<ObjectType, false, AllocatorType, AllocatorArgsType...> *>(this);
    }
    ULANG_FORCEINLINE TSPtrG<ObjectType, false, AllocatorType, AllocatorArgsType...> AsRef()&&
    {
        static_assert(AllowNull, "Unnecessary conversion!");
        ULANG_ASSERTF(_Object, "Converting null pointer to reference!");
        return *reinterpret_cast<TSPtrG<ObjectType, false, AllocatorType, AllocatorArgsType...> *>(this);
    }
    ULANG_FORCEINLINE const TSPtrG<ObjectType, false, AllocatorType, AllocatorArgsType...>& AsRef() const&
    {
        static_assert(AllowNull, "Unnecessary conversion!");
        ULANG_ASSERTF(_Object, "Converting null pointer to reference!");
        return *reinterpret_cast<const TSPtrG<ObjectType, false, AllocatorType, AllocatorArgsType...> *>(this);
    }
 
    template<class OtherObjectType, typename = typename TEnableIf<TPointerIsStaticCastableFromTo<OtherObjectType, ObjectType>::Value>::Type>
    ULANG_FORCEINLINE TSPtrG<OtherObjectType, AllowNull, AllocatorType, AllocatorArgsType...>& As() { return *reinterpret_cast<TSPtrG<OtherObjectType, AllowNull, AllocatorType, AllocatorArgsType...> *>(this); }
    template<class OtherObjectType, typename = typename TEnableIf<TPointerIsStaticCastableFromTo<OtherObjectType, ObjectType>::Value>::Type>
    ULANG_FORCEINLINE const TSPtrG<OtherObjectType, AllowNull, AllocatorType, AllocatorArgsType...>& As() const { return *reinterpret_cast<const TSPtrG<OtherObjectType, AllowNull, AllocatorType, AllocatorArgsType...> *>(this); }
 
    // Comparison operators
 
    ULANG_FORCEINLINE bool operator==(NullPtrType)  const { return _Object == nullptr; }
    ULANG_FORCEINLINE bool operator!=(NullPtrType)  const { return _Object != nullptr; }
    ULANG_FORCEINLINE bool operator==(const TSPtrG & Other)  const { return _Object == Other._Object; }
    template<class OtherObjectType, bool OtherAllowNull>
    ULANG_FORCEINLINE bool operator==(const TSPtrG<OtherObjectType, OtherAllowNull, AllocatorType, AllocatorArgsType...> & Other)  const { return _Object == Other._Object; }
    template<class OtherObjectType, bool OtherAllowNull>
    ULANG_FORCEINLINE bool operator==(OtherObjectType * Object) const { return _Object == Object; }
    ULANG_FORCEINLINE bool operator!=(const TSPtrG & Other)  const { return _Object != Other._Object; }
    template<class OtherObjectType, bool OtherAllowNull>
    ULANG_FORCEINLINE bool operator!=(const TSPtrG<OtherObjectType, OtherAllowNull, AllocatorType, AllocatorArgsType...> & Other)  const { return _Object != Other._Object; }
    template<class OtherObjectType, bool OtherAllowNull>
    ULANG_FORCEINLINE bool operator!=(OtherObjectType * Object) const { return _Object != Object; }
    ULANG_FORCEINLINE bool operator< (const TSPtrG & Other)  const { return _Object < Other._Object; }
    template<class OtherObjectType, bool OtherAllowNull>
    ULANG_FORCEINLINE bool operator< (const TSPtrG<OtherObjectType, OtherAllowNull, AllocatorType, AllocatorArgsType...> & Other)  const { return _Object < Other._Object; }
    template<class OtherObjectType, bool OtherAllowNull>
    ULANG_FORCEINLINE bool operator< (OtherObjectType * Object) const { return _Object < Object; }
    ULANG_FORCEINLINE bool operator> (const TSPtrG & Other)  const { return _Object > Other._Object; }
    template<class OtherObjectType, bool OtherAllowNull>
    ULANG_FORCEINLINE bool operator> (const TSPtrG<OtherObjectType, OtherAllowNull, AllocatorType, AllocatorArgsType...> & Other)  const { return _Object > Other._Object; }
    template<class OtherObjectType, bool OtherAllowNull>
    ULANG_FORCEINLINE bool operator> (OtherObjectType * Object) const { return _Object > Object; }
 
    // Validation methods
 
    ULANG_FORCEINLINE operator bool() { return (_Object != nullptr); }
    ULANG_FORCEINLINE operator bool() const { return (_Object != nullptr); }
    ULANG_FORCEINLINE bool operator!() const { return (_Object == nullptr); }
    ULANG_FORCEINLINE bool IsValid() const { return (_Object != nullptr); }
 
    // Needed to avoid ambiguous function resolution between
    // uLang and UnrealTemplate.h versions of Swap
    ULANG_FORCEINLINE friend void Swap(TSPtrG& A, TSPtrG& B) { uLang::Swap(A, B); }
 
    // Composability methods
    template <typename FuncType, typename... ArgTypes>
    ULANG_FORCEINLINE TSPtrG Map(FuncType&& Func, ArgTypes&&... Args) &&
    {
        TSPtrG Result{*this};
        Invoke(uLang::ForwardArg<FuncType>(Func), Result, uLang::ForwardArg<ArgTypes>(Args)...);
        return Result;
    }
 
protected:
 
    template<class OtherObjectType, bool OtherAllowNull, class OtherAllocatorType, typename... OtherAllocatorArgsType> friend class TSPtrG;
    template<class OtherObjectType, bool OtherAllowNull, class OtherAllocatorType, typename... OtherAllocatorArgsType> friend class TSPtrArrayG;
    template<class OtherObjectType, bool OtherAllowNull, class OtherKeyType, class OtherAllocatorType, typename... OtherAllocatorArgsType> friend class TSPtrSetG;
 
 
    // This is needed for CSharedMix to support SharedThis().
    // `return SharedThis(this)` is an equivalent of `return this` for Shared Pointers.
    friend class CSharedMix;
 
    ULANG_FORCEINLINE TSPtrG(ObjectType * Object, const AllocatorType & Allocator)
        : _Object(Object)
        , _Allocator(Allocator)
        , _ReleaseFunc(nullptr)
    {
        if (Object)
        {
            Object->Reference();
            EnableRelease();
        }
    }
 
    template<class OtherObjectType, bool OtherAllowNull>
    ULANG_FORCEINLINE TSPtrG & AssignCopy(const TSPtrG<OtherObjectType, OtherAllowNull, AllocatorType, AllocatorArgsType...> & Other)
    {
        if (_Object != Other._Object)
        {
            if (Other._Object)
            {
                Other._Object->Reference();
                EnableRelease();
            }
 
            if (_Object)
            {
                Release();
            }
 
            _Object = Other._Object;
            _Allocator = Other._Allocator;
        }
 
        return *this;
    }
 
    template<class OtherObjectType, bool OtherAllowNull>
    ULANG_FORCEINLINE TSPtrG & AssignMove(TSPtrG<OtherObjectType, OtherAllowNull, AllocatorType, AllocatorArgsType...> && Other)
    {
        EnableRelease();
 
        if (_Object)
        {
            Release();
        }
 
        _Object = Other._Object;
        _Allocator = Other._Allocator;
        Other._Object = nullptr;
 
        return *this;
    }
 
    ULANG_FORCEINLINE void EnableRelease()
    {
        _ReleaseFunc = [](ObjectType * Object, const AllocatorType & Allocator)
        {
            if (Object->Dereference())
            {
                // No references left: Delete the object
                Object->~ObjectType();
                Allocator.Deallocate(Object);
            }
        };
    }
 
    ULANG_FORCEINLINE void Release()
    {
        // Call the function set by EnableRelease() above
        (_ReleaseFunc)(_Object, _Allocator);
    }
 
    ObjectType * _Object;
 
    AllocatorType _Allocator;
 
    using ReleaseFuncType = void(*)(ObjectType *, const AllocatorType &);
    ReleaseFuncType _ReleaseFunc;
};
 
template<class ObjectType>
using TSPtr = TSPtrG<ObjectType, true, CHeapRawAllocator>;
 
template<class ObjectType>
using TSRef = TSPtrG<ObjectType, false, CHeapRawAllocator>;
 
template<class ObjectType>
using TSPtrA = TSPtrG<ObjectType, true, CInstancedRawAllocator, CAllocatorInstance *>;
 
template<class ObjectType>
using TSRefA = TSPtrG<ObjectType, false, CInstancedRawAllocator, CAllocatorInstance *>;
 
//=======================================================================================
// CSharedMix Inline Methods
//=======================================================================================
 
ULANG_FORCEINLINE bool CSharedMix::Dereference() const
{
    ULANG_ASSERTF(_RefCount > 0, "Tried to dereference an object that has no references!");
    return (--_RefCount == 0);
}
 
}
 
#undef UE_API