SharedPointer.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Misc/IntrusiveUnsetOptionalState.h"
#include "Templates/PointerIsConvertibleFromTo.h"
#include "Misc/AssertionMacros.h"
#include "HAL/UnrealMemory.h"
#include "Containers/Array.h"
#include "Containers/Map.h"
#include "CoreGlobals.h"
#include "Misc/UEOps.h"
 
 
// SharedPointerInternals.h contains the implementation of reference counting structures we need
#include "Templates/SharedPointerInternals.h" // IWYU pragma: export
 
 
template< class CastToType, class CastFromType, ESPMode Mode >
[[nodiscard]] UE_FORCEINLINE_HINT TSharedRef< CastToType, Mode > StaticCastSharedRef( TSharedRef< CastFromType, Mode > const& InSharedRef )
{
    return TSharedRef< CastToType, Mode >( InSharedRef, SharedPointerInternals::FStaticCastTag() );
}
 
 
namespace UE::Core::Private
{
    // Needed to work around an Android compiler bug - we need to construct a TSharedRef
    // from MakeShared without making MakeShared a friend in order to access the private constructor.
    template <typename ObjectType, ESPMode Mode>
    UE_FORCEINLINE_HINT TSharedRef<ObjectType, Mode> MakeSharedRef(ObjectType* InObject, SharedPointerInternals::TReferenceControllerBase<Mode>* InSharedReferenceCount)
    {
        return TSharedRef<ObjectType, Mode>(InObject, InSharedReferenceCount);
    }
}
 
 
// NOTE: TSharedRef is an Unreal extension to standard smart pointer feature set
template< class ObjectType, ESPMode InMode >
class TSharedRef
{
public:
    static_assert(!std::is_void_v<ObjectType>, "TSharedRef<void> is not supported - use TSharedPtr instead");
 
    using ElementType = ObjectType;
    static constexpr ESPMode Mode = InMode;
 
    // NOTE: TSharedRef has no default constructor as it does not support empty references.  You must
    //       initialize your TSharedRef to a valid object at construction time.
 
    template <
        typename OtherType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline explicit TSharedRef( OtherType* InObject )
        : Object( InObject )
        , SharedReferenceCount( SharedPointerInternals::NewDefaultReferenceController< Mode >( InObject ) )
    {
        Init(InObject);
    }
 
    template <
        typename OtherType,
        typename DeleterType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TSharedRef( OtherType* InObject, DeleterType&& InDeleter )
        : Object( InObject )
        , SharedReferenceCount( SharedPointerInternals::NewCustomReferenceController< Mode >( InObject, Forward< DeleterType >( InDeleter ) ) )
    {
        Init(InObject);
    }
 
    TSharedRef()
        : Object(new ObjectType())
        , SharedReferenceCount(SharedPointerInternals::NewDefaultReferenceController<Mode>(Object))
    {
        EnsureRetrievingVTablePtrDuringCtor(TEXT("TSharedRef()"));
        Init(Object);
    }
 
    // NOTE: The following is an Unreal extension to standard shared_ptr behavior
    template <
        typename OtherType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TSharedRef( SharedPointerInternals::TRawPtrProxy< OtherType > const& InRawPtrProxy )
        : Object( InRawPtrProxy.Object )
        , SharedReferenceCount( SharedPointerInternals::NewDefaultReferenceController< Mode >( InRawPtrProxy.Object ) )
    {
        // If the following assert goes off, it means a TSharedRef was initialized from a nullptr object pointer.
        // Shared references must never be nullptr, so either pass a valid object or consider using TSharedPtr instead.
        check( InRawPtrProxy.Object != nullptr );
 
        // If the object happens to be derived from TSharedFromThis, the following method
        // will prime the object with a weak pointer to itself.
        SharedPointerInternals::EnableSharedFromThis( this, InRawPtrProxy.Object );
    }
 
    // NOTE: The following is an Unreal extension to standard shared_ptr behavior
    template <
        typename OtherType,
        typename DeleterType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TSharedRef( SharedPointerInternals::TRawPtrProxyWithDeleter< OtherType, DeleterType > const& InRawPtrProxy )
        : Object( InRawPtrProxy.Object )
        , SharedReferenceCount( SharedPointerInternals::NewCustomReferenceController< Mode >( InRawPtrProxy.Object, InRawPtrProxy.Deleter ) )
    {
        // If the following assert goes off, it means a TSharedRef was initialized from a nullptr object pointer.
        // Shared references must never be nullptr, so either pass a valid object or consider using TSharedPtr instead.
        check( InRawPtrProxy.Object != nullptr );
 
        // If the object happens to be derived from TSharedFromThis, the following method
        // will prime the object with a weak pointer to itself.
        SharedPointerInternals::EnableSharedFromThis( this, InRawPtrProxy.Object );
    }
 
    // NOTE: The following is an Unreal extension to standard shared_ptr behavior
    template <
        typename OtherType,
        typename DeleterType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TSharedRef( SharedPointerInternals::TRawPtrProxyWithDeleter< OtherType, DeleterType >&& InRawPtrProxy )
        : Object( InRawPtrProxy.Object )
        , SharedReferenceCount( SharedPointerInternals::NewCustomReferenceController< Mode >( InRawPtrProxy.Object, MoveTemp( InRawPtrProxy.Deleter ) ) )
    {
        // If the following assert goes off, it means a TSharedRef was initialized from a nullptr object pointer.
        // Shared references must never be nullptr, so either pass a valid object or consider using TSharedPtr instead.
        check( InRawPtrProxy.Object != nullptr );
 
        // If the object happens to be derived from TSharedFromThis, the following method
        // will prime the object with a weak pointer to itself.
        SharedPointerInternals::EnableSharedFromThis( this, InRawPtrProxy.Object );
    }
 
    template <
        typename OtherType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TSharedRef( TSharedRef< OtherType, Mode > const& InSharedRef )
        : Object( InSharedRef.Object )
        , SharedReferenceCount( InSharedRef.SharedReferenceCount )
    {
    }
 
    template <typename OtherType>
    inline TSharedRef( TSharedRef< OtherType, Mode > const& InSharedRef, SharedPointerInternals::FStaticCastTag )
        : Object( static_cast< ObjectType* >( InSharedRef.Object ) )
        , SharedReferenceCount( InSharedRef.SharedReferenceCount )
    {
    }
 
    template <typename OtherType>
    inline TSharedRef( TSharedRef< OtherType, Mode > const& InSharedRef, SharedPointerInternals::FConstCastTag )
        : Object( const_cast< ObjectType* >( InSharedRef.Object ) )
        , SharedReferenceCount( InSharedRef.SharedReferenceCount )
    {
    }
 
    template <typename OtherType>
    inline TSharedRef( TSharedRef< OtherType, Mode > const& OtherSharedRef, ObjectType* InObject )
        : Object( InObject )
        , SharedReferenceCount( OtherSharedRef.SharedReferenceCount )
    {
        // If the following assert goes off, it means a TSharedRef was initialized from a nullptr object pointer.
        // Shared references must never be nullptr, so either pass a valid object or consider using TSharedPtr instead.
        check( InObject != nullptr );
    }
 
    inline TSharedRef( TSharedRef const& InSharedRef )
        : Object( InSharedRef.Object )
        , SharedReferenceCount( InSharedRef.SharedReferenceCount )
    { }
 
    inline TSharedRef( TSharedRef&& InSharedRef )
        : Object( InSharedRef.Object )
        , SharedReferenceCount( InSharedRef.SharedReferenceCount )
    {
        // We're intentionally not moving here, because we don't want to leave InSharedRef in a
        // null state, because that breaks the class invariant.  But we provide a move constructor
        // anyway in case the compiler complains that we have a move assign but no move construct.
    }
 
    inline TSharedRef& operator=( TSharedRef const& InSharedRef )
    {
        TSharedRef Temp = InSharedRef;
        ::Swap(Temp, *this);
        return *this;
    }
 
    inline TSharedRef& operator=( TSharedRef&& InSharedRef )
    {
        ::Swap(*this, InSharedRef);
        return *this;
    }
 
    // NOTE: The following is an Unreal extension to standard shared_ptr behavior
    template <
        typename OtherType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TSharedRef& operator=( SharedPointerInternals::TRawPtrProxy< OtherType > const& InRawPtrProxy )
    {
        // If the following assert goes off, it means a TSharedRef was initialized from a nullptr object pointer.
        // Shared references must never be nullptr, so either pass a valid object or consider using TSharedPtr instead.
        check( InRawPtrProxy.Object != nullptr );
 
        *this = TSharedRef< ObjectType, Mode >( InRawPtrProxy );
        return *this;
    }
 
    // NOTE: The following is an Unreal extension to standard shared_ptr behavior
    template <
        typename OtherType,
        typename DeleterType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TSharedRef& operator=( SharedPointerInternals::TRawPtrProxyWithDeleter< OtherType, DeleterType > const& InRawPtrProxy )
    {
        // If the following assert goes off, it means a TSharedRef was initialized from a nullptr object pointer.
        // Shared references must never be nullptr, so either pass a valid object or consider using TSharedPtr instead.
        check( InRawPtrProxy.Object != nullptr );
 
        *this = TSharedRef< ObjectType, Mode >( InRawPtrProxy );
        return *this;
    }
 
    // NOTE: The following is an Unreal extension to standard shared_ptr behavior
    template <
        typename OtherType,
        typename DeleterType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TSharedRef& operator=( SharedPointerInternals::TRawPtrProxyWithDeleter< OtherType, DeleterType >&& InRawPtrProxy )
    {
        // If the following assert goes off, it means a TSharedRef was initialized from a nullptr object pointer.
        // Shared references must never be nullptr, so either pass a valid object or consider using TSharedPtr instead.
        check( InRawPtrProxy.Object != nullptr );
 
        *this = TSharedRef< ObjectType, Mode >( MoveTemp( InRawPtrProxy ) );
        return *this;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT TSharedPtr<ObjectType, Mode> ToSharedPtr() const
    {
        return TSharedPtr<ObjectType, Mode>(*this);
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT TWeakPtr<ObjectType, Mode> ToWeakPtr() const
    {
        return TWeakPtr<ObjectType, Mode>(*this);
    }
 
    [[nodiscard]] inline ObjectType& Get() const
    {
        // Should never be nullptr as TSharedRef is never nullable
        checkSlow( IsValid() );
        return *Object;
    }
 
    [[nodiscard]] inline ObjectType& operator*() const
    {
        // Should never be nullptr as TSharedRef is never nullable
        checkSlow( IsValid() );
        return *Object;
    }
 
    [[nodiscard]] inline ObjectType* operator->() const
    {
        // Should never be nullptr as TSharedRef is never nullable
        checkSlow( IsValid() );
        return Object;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT int32 GetSharedReferenceCount() const
    {
        return SharedReferenceCount.GetSharedReferenceCount();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsUnique() const
    {
        return SharedReferenceCount.IsUnique();
    }
 
    // Start - intrusive TOptional<TSharedRef> state //
    constexpr static bool bHasIntrusiveUnsetOptionalState = true;
    using IntrusiveUnsetOptionalStateType = TSharedRef;
 
    explicit TSharedRef(FIntrusiveUnsetOptionalState)
        : Object(nullptr)
    {
    }
    bool UEOpEquals(FIntrusiveUnsetOptionalState) const
    {
        return !IsValid();
    }
    // End - intrusive TOptional<TSharedRef> state //
 
    template <typename OtherType>
    [[nodiscard]] bool UEOpEquals(const TSharedRef<OtherType, Mode>& Rhs) const
    {
        return this->Object == &Rhs.Get();
    }
 
    template <typename OtherType>
    [[nodiscard]] bool UEOpEquals(const TSharedPtr<OtherType, Mode>& Rhs) const
    {
        // This comparison against null is maintained as existing behavior, but isn't consistent with TWeakPtr comparison.
        OtherType* RhsPtr = Rhs.Get();
        return RhsPtr && RhsPtr == this->Object;
    }
 
    template <typename OtherType>
    [[nodiscard]] bool UEOpEquals(const TWeakPtr<OtherType, Mode>& Rhs) const
    {
        return this->Object == Rhs.Pin().Get();
    }
 
    template <typename OtherType>
    [[nodiscard]] bool UEOpLessThan(const TSharedRef<OtherType, Mode>& Rhs) const
    {
        return this->Object < &Rhs.Get();
    }
 
private:
    template<class OtherType>
    void Init(OtherType* InObject)
    {
        // If the following assert goes off, it means a TSharedRef was initialized from a nullptr object pointer.
        // Shared references must never be nullptr, so either pass a valid object or consider using TSharedPtr instead.
        check(InObject != nullptr);
 
        // If the object happens to be derived from TSharedFromThis, the following method
        // will prime the object with a weak pointer to itself.
        SharedPointerInternals::EnableSharedFromThis(this, InObject);
    }
 
    template <
        typename OtherType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline explicit TSharedRef( TSharedPtr< OtherType, Mode > const& InSharedPtr )
        : Object( InSharedPtr.Object )
        , SharedReferenceCount( InSharedPtr.SharedReferenceCount )
    {
        // If this assert goes off, it means a shared reference was created from a shared pointer that was nullptr.
        // Shared references are never allowed to be null.  Consider using TSharedPtr instead.
        check( IsValid() );
    }
 
    template <
        typename OtherType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline explicit TSharedRef( TSharedPtr< OtherType, Mode >&& InSharedPtr )
        : Object( InSharedPtr.Object )
        , SharedReferenceCount( MoveTemp(InSharedPtr.SharedReferenceCount) )
    {
        InSharedPtr.Object = nullptr;
 
        // If this assert goes off, it means a shared reference was created from a shared pointer that was nullptr.
        // Shared references are never allowed to be null.  Consider using TSharedPtr instead.
        check( IsValid() );
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsValid() const
    {
        return Object != nullptr;
    }
 
    // We declare ourselves as a friend (templated using OtherType) so we can access members as needed
    template< class OtherType, ESPMode OtherMode > friend class TSharedRef;
 
    // Declare other smart pointer types as friends as needed
    template< class OtherType, ESPMode OtherMode > friend class TSharedPtr;
    template< class OtherType, ESPMode OtherMode > friend class TWeakPtr;
 
private:
 
    ObjectType* Object;
 
    SharedPointerInternals::FSharedReferencer< Mode > SharedReferenceCount;
 
    // VC emits an erroneous warning here - there is no inline specifier!
    #ifdef _MSC_VER
        #pragma warning(push)
        #pragma warning(disable : 4396) // warning: the inline specifier cannot be used when a friend declaration refers to a specialization of a function template
    #endif
 
    friend TSharedRef UE::Core::Private::MakeSharedRef<ObjectType, Mode>(ObjectType* InObject, SharedPointerInternals::TReferenceControllerBase<Mode>* InSharedReferenceCount);
 
    #ifdef _MSC_VER
        #pragma warning(pop)
    #endif
 
    inline explicit TSharedRef(ObjectType* InObject, SharedPointerInternals::TReferenceControllerBase<Mode>* InSharedReferenceCount)
        : Object(InObject)
        , SharedReferenceCount(InSharedReferenceCount)
    {
        Init(InObject);
    }
};
 
template <typename T>                       constexpr bool TIsTSharedRef_V                                                = false;
template <class ObjectType, ESPMode InMode> constexpr bool TIsTSharedRef_V<               TSharedRef<ObjectType, InMode>> = true;
template <class ObjectType, ESPMode InMode> constexpr bool TIsTSharedRef_V<const          TSharedRef<ObjectType, InMode>> = true;
template <class ObjectType, ESPMode InMode> constexpr bool TIsTSharedRef_V<      volatile TSharedRef<ObjectType, InMode>> = true;
template <class ObjectType, ESPMode InMode> constexpr bool TIsTSharedRef_V<const volatile TSharedRef<ObjectType, InMode>> = true;
 
template <class ObjectType, ESPMode Mode>
struct TCallTraits<TSharedRef<ObjectType, Mode>> : public TCallTraitsBase<TSharedRef<ObjectType, Mode>>
{
    using ConstPointerType = TSharedRef<const ObjectType, Mode>;
};
 
 
template< class ObjectType, ESPMode InMode >
class TSharedPtr
{
public:
    using ElementType = ObjectType;
    static constexpr ESPMode Mode = InMode;
 
    // NOTE: FNullTag parameter is an Unreal extension to standard shared_ptr behavior
    inline TSharedPtr( SharedPointerInternals::FNullTag* = nullptr )
        : Object( nullptr )
        , SharedReferenceCount()
    {
    }
 
    template <
        typename OtherType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline explicit TSharedPtr( OtherType* InObject )
        : Object( InObject )
        , SharedReferenceCount( SharedPointerInternals::NewDefaultReferenceController< Mode >( InObject ) )
    {
        // If the object happens to be derived from TSharedFromThis, the following method
        // will prime the object with a weak pointer to itself.
        SharedPointerInternals::EnableSharedFromThis( this, InObject );
    }
 
    template <
        typename OtherType,
        typename DeleterType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TSharedPtr( OtherType* InObject, DeleterType&& InDeleter )
        : Object( InObject )
        , SharedReferenceCount( SharedPointerInternals::NewCustomReferenceController< Mode >( InObject, Forward< DeleterType >( InDeleter ) ) )
    {
        // If the object happens to be derived from TSharedFromThis, the following method
        // will prime the object with a weak pointer to itself.
        SharedPointerInternals::EnableSharedFromThis( this, InObject );
    }
 
    // NOTE: The following is an Unreal extension to standard shared_ptr behavior
    template <
        typename OtherType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TSharedPtr( SharedPointerInternals::TRawPtrProxy< OtherType > const& InRawPtrProxy )
        : Object( InRawPtrProxy.Object )
        , SharedReferenceCount( SharedPointerInternals::NewDefaultReferenceController< Mode >( InRawPtrProxy.Object ) )
    {
        // If the object happens to be derived from TSharedFromThis, the following method
        // will prime the object with a weak pointer to itself.
        SharedPointerInternals::EnableSharedFromThis( this, InRawPtrProxy.Object );
    }
 
    // NOTE: The following is an Unreal extension to standard shared_ptr behavior
    template <
        typename OtherType,
        typename DeleterType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TSharedPtr( SharedPointerInternals::TRawPtrProxyWithDeleter< OtherType, DeleterType > const& InRawPtrProxy )
        : Object( InRawPtrProxy.Object )
        , SharedReferenceCount( SharedPointerInternals::NewCustomReferenceController< Mode >( InRawPtrProxy.Object, InRawPtrProxy.Deleter ) )
    {
        // If the object happens to be derived from TSharedFromThis, the following method
        // will prime the object with a weak pointer to itself.
        SharedPointerInternals::EnableSharedFromThis( this, InRawPtrProxy.Object );
    }
 
    // NOTE: The following is an Unreal extension to standard shared_ptr behavior
    template <
        typename OtherType,
        typename DeleterType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TSharedPtr( SharedPointerInternals::TRawPtrProxyWithDeleter< OtherType, DeleterType >&& InRawPtrProxy )
        : Object( InRawPtrProxy.Object )
        , SharedReferenceCount( SharedPointerInternals::NewCustomReferenceController< Mode >( InRawPtrProxy.Object, MoveTemp( InRawPtrProxy.Deleter ) ) )
    {
        // If the object happens to be derived from TSharedFromThis, the following method
        // will prime the object with a weak pointer to itself.
        SharedPointerInternals::EnableSharedFromThis( this, InRawPtrProxy.Object );
    }
 
    template <
        typename OtherType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TSharedPtr( TSharedPtr< OtherType, Mode > const& InSharedPtr )
        : Object( InSharedPtr.Object )
        , SharedReferenceCount( InSharedPtr.SharedReferenceCount )
    {
    }
 
    inline TSharedPtr( TSharedPtr const& InSharedPtr )
        : Object( InSharedPtr.Object )
        , SharedReferenceCount( InSharedPtr.SharedReferenceCount )
    {
    }
 
    inline TSharedPtr( TSharedPtr&& InSharedPtr )
        : Object( InSharedPtr.Object )
        , SharedReferenceCount( MoveTemp(InSharedPtr.SharedReferenceCount) )
    {
        InSharedPtr.Object = nullptr;
    }
 
    // NOTE: The following is an Unreal extension to standard shared_ptr behavior
    template <
        typename OtherType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TSharedPtr( TSharedRef< OtherType, Mode > const& InSharedRef )
        : Object( InSharedRef.Object )
        , SharedReferenceCount( InSharedRef.SharedReferenceCount )
    {
        // There is no rvalue overload of this constructor, because 'stealing' the pointer from a
        // TSharedRef would leave it as null, which would invalidate its invariant.
    }
 
    template <typename OtherType>
    inline TSharedPtr( TSharedPtr< OtherType, Mode > const& InSharedPtr, SharedPointerInternals::FStaticCastTag )
        : Object( static_cast< ObjectType* >( InSharedPtr.Object ) )
        , SharedReferenceCount( InSharedPtr.SharedReferenceCount )
    {
    }
    
    template <typename OtherType>
    inline TSharedPtr( TSharedPtr< OtherType, Mode > const& InSharedPtr, SharedPointerInternals::FConstCastTag )
        : Object( const_cast< ObjectType* >( InSharedPtr.Object ) )
        , SharedReferenceCount( InSharedPtr.SharedReferenceCount )
    {
    }
 
    template <typename OtherType>
    inline TSharedPtr( TSharedPtr< OtherType, Mode > const& OtherSharedPtr, ObjectType* InObject )
        : Object( InObject )
        , SharedReferenceCount( OtherSharedPtr.SharedReferenceCount )
    {
    }
 
    template <typename OtherType>
    inline TSharedPtr( TSharedPtr< OtherType, Mode >&& OtherSharedPtr, ObjectType* InObject )
        : Object( InObject )
        , SharedReferenceCount( MoveTemp(OtherSharedPtr.SharedReferenceCount) )
    {
        OtherSharedPtr.Object = nullptr;
    }
 
    template <typename OtherType>
    inline TSharedPtr( TSharedRef< OtherType, Mode > const& OtherSharedRef, ObjectType* InObject )
        : Object( InObject )
        , SharedReferenceCount( OtherSharedRef.SharedReferenceCount )
    {
    }
 
    // NOTE: The following is an Unreal extension to standard shared_ptr behavior
    inline TSharedPtr& operator=( SharedPointerInternals::FNullTag* )
    {
        Reset();
        return *this;
    }
 
    inline TSharedPtr& operator=( TSharedPtr const& InSharedPtr )
    {
        TSharedPtr Temp = InSharedPtr;
        ::Swap(Temp, *this);
        return *this;
    }
 
    // Disable false positive buffer overrun warning during pgo linking step
    PGO_LINK_DISABLE_WARNINGS
    inline TSharedPtr& operator=( TSharedPtr&& InSharedPtr )
    {
        if (this != &InSharedPtr)
        {
            Object = InSharedPtr.Object;
            InSharedPtr.Object = nullptr;
            SharedReferenceCount = MoveTemp(InSharedPtr.SharedReferenceCount);
        }
        return *this;
    }
    PGO_LINK_ENABLE_WARNINGS
 
    // NOTE: The following is an Unreal extension to standard shared_ptr behavior
    template <
        typename OtherType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TSharedPtr& operator=( SharedPointerInternals::TRawPtrProxy< OtherType > const& InRawPtrProxy )
    {
        *this = TSharedPtr< ObjectType, Mode >( InRawPtrProxy );
        return *this;
    }
 
    // NOTE: The following is an Unreal extension to standard shared_ptr behavior
    template <
        typename OtherType,
        typename DeleterType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TSharedPtr& operator=( SharedPointerInternals::TRawPtrProxyWithDeleter< OtherType, DeleterType > const& InRawPtrProxy )
    {
        *this = TSharedPtr< ObjectType, Mode >( InRawPtrProxy );
        return *this;
    }
 
    // NOTE: The following is an Unreal extension to standard shared_ptr behavior
    template <
        typename OtherType,
        typename DeleterType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TSharedPtr& operator=( SharedPointerInternals::TRawPtrProxyWithDeleter< OtherType, DeleterType >&& InRawPtrProxy )
    {
        *this = TSharedPtr< ObjectType, Mode >( MoveTemp( InRawPtrProxy ) );
        return *this;
    }
 
    // NOTE: The following is an Unreal extension to standard shared_ptr behavior
    [[nodiscard]] inline TSharedRef< ObjectType, Mode > ToSharedRef() const&
    {
        // If this assert goes off, it means a shared reference was created from a shared pointer that was nullptr.
        // Shared references are never allowed to be null.  Consider using TSharedPtr instead.
        check( IsValid() );
        return TSharedRef< ObjectType, Mode >( *this );
    }
 
     // NOTE: The following is an Unreal extension to standard shared_ptr behavior
    [[nodiscard]] inline TSharedRef< ObjectType, Mode > ToSharedRef() &&
    {
        // If this assert goes off, it means a shared reference was created from a shared pointer that was nullptr.
        // Shared references are never allowed to be null.  Consider using TSharedPtr instead.
        check( IsValid() );
        return TSharedRef< ObjectType, Mode >( MoveTemp( *this ) );
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT TWeakPtr<ObjectType, Mode> ToWeakPtr() const
    {
        return TWeakPtr<ObjectType, Mode>(*this);
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT ObjectType* Get() const
    {
        return Object;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT explicit operator bool() const
    {
        return Object != nullptr;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT const bool IsValid() const
    {
        return Object != nullptr;
    }
 
    template <
        typename DummyObjectType = ObjectType
        UE_REQUIRES(UE_REQUIRES_EXPR(*(DummyObjectType*)nullptr)) // this construct means that operator* is only considered for overload resolution if T is dereferenceable
    >
    [[nodiscard]] inline DummyObjectType& operator*() const
    {
        check( IsValid() );
        return *Object;
    }
 
    [[nodiscard]] inline ObjectType* operator->() const
    {
        check( IsValid() );
        return Object;
    }
 
    UE_FORCEINLINE_HINT void Reset()
    {
        *this = TSharedPtr< ObjectType, Mode >();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT int32 GetSharedReferenceCount() const
    {
        return SharedReferenceCount.GetSharedReferenceCount();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsUnique() const
    {
        return SharedReferenceCount.IsUnique();
    }
 
    // Start - intrusive TOptional<TSharedPtr> state //
    constexpr static bool bHasIntrusiveUnsetOptionalState = true;
    using IntrusiveUnsetOptionalStateType = TSharedPtr;
 
    explicit TSharedPtr(FIntrusiveUnsetOptionalState)
        : Object((ObjectType*)-1)
    {
    }
    bool UEOpEquals(FIntrusiveUnsetOptionalState) const
    {
        return Object == (ObjectType*)-1;
    }
    // End - intrusive TOptional<TSharedPtr> state //
 
    template <typename OtherType>
    [[nodiscard]] inline bool UEOpEquals(const TSharedPtr<OtherType, Mode>& Rhs) const
    {
        return this->Object == Rhs.Get();
    }
 
    template <typename OtherType>
    [[nodiscard]] UE_REWRITE bool UEOpEquals(const TWeakPtr<OtherType, Mode>& Rhs) const
    {
        return this->Object == Rhs.Pin().Get();
    }
 
    [[nodiscard]] UE_REWRITE bool UEOpEquals(TYPE_OF_NULLPTR) const
    {
        return !this->Object;
    }
 
    template <typename OtherType>
    [[nodiscard]] inline bool UEOpLessThan(const TSharedPtr<OtherType, Mode>& Rhs) const
    {
        return this->Object < Rhs.Get();
    }
 
private:
    template <
        typename OtherType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline explicit TSharedPtr( TWeakPtr< OtherType, Mode > const& InWeakPtr )
        : Object( nullptr )
        , SharedReferenceCount( InWeakPtr.WeakReferenceCount )
    {
        // Check that the shared reference was created from the weak reference successfully.  We'll only
        // cache a pointer to the object if we have a valid shared reference.
        if( SharedReferenceCount.IsValid() )
        {
            Object = InWeakPtr.Object;
        }
    }
 
    template <
        typename OtherType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline explicit TSharedPtr(TWeakPtr< OtherType, Mode >&& InWeakPtr)
        : Object(nullptr)
        , SharedReferenceCount( MoveTemp( InWeakPtr.WeakReferenceCount ) )
    {
        // Check that the shared reference was created from the weak reference successfully.  We'll only
        // cache a pointer to the object if we have a valid shared reference.
        if (SharedReferenceCount.IsValid())
        {
            Object = InWeakPtr.Object;
            InWeakPtr.Object = nullptr;
        }
    }
 
    // We declare ourselves as a friend (templated using OtherType) so we can access members as needed
    template< class OtherType, ESPMode OtherMode > friend class TSharedPtr;
 
    // Declare other smart pointer types as friends as needed
    template< class OtherType, ESPMode OtherMode > friend class TSharedRef;
    template< class OtherType, ESPMode OtherMode > friend class TWeakPtr;
    template< class OtherType, ESPMode OtherMode > friend class TSharedFromThis;
 
private:
 
    ObjectType* Object;
 
    SharedPointerInternals::FSharedReferencer< Mode > SharedReferenceCount;
};
 
template <typename T>                       constexpr bool TIsTSharedPtr_V                                                = false;
template <class ObjectType, ESPMode InMode> constexpr bool TIsTSharedPtr_V<               TSharedPtr<ObjectType, InMode>> = true;
template <class ObjectType, ESPMode InMode> constexpr bool TIsTSharedPtr_V<const          TSharedPtr<ObjectType, InMode>> = true;
template <class ObjectType, ESPMode InMode> constexpr bool TIsTSharedPtr_V<      volatile TSharedPtr<ObjectType, InMode>> = true;
template <class ObjectType, ESPMode InMode> constexpr bool TIsTSharedPtr_V<const volatile TSharedPtr<ObjectType, InMode>> = true;
 
namespace Freeze
{
    template<class ObjectType, ESPMode Mode>
    void IntrinsicWriteMemoryImage(FMemoryImageWriter& Writer, const TSharedPtr<ObjectType, Mode>& Object, const FTypeLayoutDesc&)
    {
        // we never want to freeze pointers, so write an empty one
        Writer.WriteBytes(TSharedPtr<ObjectType, Mode>());
    }
}
 
DECLARE_TEMPLATE_INTRINSIC_TYPE_LAYOUT((template<class ObjectType, ESPMode Mode>), (TSharedPtr<ObjectType, Mode>));
 
template<class ObjectType, ESPMode Mode> struct TIsZeroConstructType<TSharedPtr<ObjectType, Mode>> { enum { Value = true }; };
 
template <class ObjectType, ESPMode Mode>
struct TCallTraits<TSharedPtr<ObjectType, Mode>> : public TCallTraitsBase<TSharedPtr<ObjectType, Mode>>
{
    using ConstPointerType = TSharedPtr<const ObjectType, Mode>;
};
 
 
template< class ObjectType, ESPMode InMode >
class TWeakPtr
{
public:
    using ElementType = ObjectType;
    static constexpr ESPMode Mode = InMode;
 
    // NOTE: FNullTag parameter is an Unreal extension to standard shared_ptr behavior
    inline TWeakPtr( SharedPointerInternals::FNullTag* = nullptr )
        : Object( nullptr )
        , WeakReferenceCount()
    {
    }
 
    // NOTE: The following is an Unreal extension to standard shared_ptr behavior
    template <
        typename OtherType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TWeakPtr( TSharedRef< OtherType, Mode > const& InSharedRef )
        : Object( InSharedRef.Object )
        , WeakReferenceCount( InSharedRef.SharedReferenceCount )
    {
    }
 
    template <
        typename OtherType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TWeakPtr( TSharedPtr< OtherType, Mode > const& InSharedPtr )
        : Object( InSharedPtr.Object )
        , WeakReferenceCount( InSharedPtr.SharedReferenceCount )
    {
    }
 
    template <typename OtherType>
    inline TWeakPtr(TWeakPtr< OtherType, Mode > const& InWeakPtr, SharedPointerInternals::FStaticCastTag)
        : Object(static_cast<ObjectType*>(InWeakPtr.Object))
        , WeakReferenceCount(InWeakPtr.WeakReferenceCount)
    {
    }
 
    template <typename OtherType>
    inline TWeakPtr(TWeakPtr< OtherType, Mode > const& InWeakPtr, SharedPointerInternals::FConstCastTag)
        : Object(const_cast<ObjectType*>(InWeakPtr.Object))
        , WeakReferenceCount(InWeakPtr.WeakReferenceCount)
    {
    }
 
    template <
        typename OtherType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TWeakPtr( TWeakPtr< OtherType, Mode > const& InWeakPtr )
        : Object( InWeakPtr.Object )
        , WeakReferenceCount( InWeakPtr.WeakReferenceCount )
    {
    }
 
    template <
        typename OtherType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TWeakPtr( TWeakPtr< OtherType, Mode >&& InWeakPtr )
        : Object( InWeakPtr.Object )
        , WeakReferenceCount( MoveTemp(InWeakPtr.WeakReferenceCount) )
    {
        InWeakPtr.Object = nullptr;
    }
 
    inline TWeakPtr( TWeakPtr const& InWeakPtr )
        : Object( InWeakPtr.Object )
        , WeakReferenceCount( InWeakPtr.WeakReferenceCount )
    {
    }
 
    inline TWeakPtr( TWeakPtr&& InWeakPtr )
        : Object( InWeakPtr.Object )
        , WeakReferenceCount( MoveTemp(InWeakPtr.WeakReferenceCount) )
    {
        InWeakPtr.Object = nullptr;
    }
 
    // NOTE: The following is an Unreal extension to standard shared_ptr behavior
    inline TWeakPtr& operator=( SharedPointerInternals::FNullTag* )
    {
        Reset();
        return *this;
    }
 
    inline TWeakPtr& operator=( TWeakPtr const& InWeakPtr )
    {
        TWeakPtr Temp = InWeakPtr;
        ::Swap(Temp, *this);
        return *this;
    }
 
    inline TWeakPtr& operator=( TWeakPtr&& InWeakPtr )
    {
        if (this != &InWeakPtr)
        {
            Object             = InWeakPtr.Object;
            InWeakPtr.Object   = nullptr;
            WeakReferenceCount = MoveTemp(InWeakPtr.WeakReferenceCount);
        }
        return *this;
    }
 
    template <
        typename OtherType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TWeakPtr& operator=( TWeakPtr<OtherType, Mode> const& InWeakPtr )
    {
        Object = InWeakPtr.Pin().Get();
        WeakReferenceCount = InWeakPtr.WeakReferenceCount;
        return *this;
    }
 
    template <
        typename OtherType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TWeakPtr& operator=( TWeakPtr<OtherType, Mode>&& InWeakPtr )
    {
        Object             = InWeakPtr.Object;
        InWeakPtr.Object   = nullptr;
        WeakReferenceCount = MoveTemp(InWeakPtr.WeakReferenceCount);
        return *this;
    }
 
    // NOTE: The following is an Unreal extension to standard shared_ptr behavior
    template <
        typename OtherType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TWeakPtr& operator=( TSharedRef< OtherType, Mode > const& InSharedRef )
    {
        Object = InSharedRef.Object;
        WeakReferenceCount = InSharedRef.SharedReferenceCount;
        return *this;
    }
 
    template <
        typename OtherType
        UE_REQUIRES(std::is_convertible_v<OtherType*, ObjectType*>)
    >
    inline TWeakPtr& operator=( TSharedPtr< OtherType, Mode > const& InSharedPtr )
    {
        Object = InSharedPtr.Object;
        WeakReferenceCount = InSharedPtr.SharedReferenceCount;
        return *this;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT TSharedPtr< ObjectType, Mode > Pin() const&
    {
        return TSharedPtr< ObjectType, Mode >( *this );
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT TSharedPtr< ObjectType, Mode > Pin() &&
    {
        return TSharedPtr< ObjectType, Mode >( MoveTemp( *this ) );
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsValid() const
    {
        return Object != nullptr && WeakReferenceCount.IsValid();
    }
 
    UE_FORCEINLINE_HINT void Reset()
    {
        *this = TWeakPtr< ObjectType, Mode >();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool HasSameObject( const void* InOtherPtr ) const
    {
        return Pin().Get() == InOtherPtr;
    }
 
    UE_FORCEINLINE_HINT uint32 GetWeakPtrTypeHash() const
    {
        return ::PointerHash( Object );
    }
 
    // Start - intrusive TOptional<TWeakPtr> state //
    constexpr static bool bHasIntrusiveUnsetOptionalState = true;
    using IntrusiveUnsetOptionalStateType = TWeakPtr;
 
    explicit TWeakPtr(FIntrusiveUnsetOptionalState)
        : Object((ObjectType*)-1)
    {
    }
    bool UEOpEquals(FIntrusiveUnsetOptionalState) const
    {
        return Object == (ObjectType*)-1;
    }
    // End - intrusive TOptional<TWeakPtr> state //
 
    template <typename OtherType>
    [[nodiscard]] inline bool UEOpEquals(const TWeakPtr<OtherType, Mode>& Rhs) const
    {
        return this->Pin().Get() == Rhs.Pin().Get();
    }
 
    [[nodiscard]] UE_REWRITE bool UEOpEquals(TYPE_OF_NULLPTR) const
    {
        return !this->IsValid();
    }
 
    template <typename OtherType>
    [[nodiscard]] inline bool UEOpLessThan(const TWeakPtr<OtherType, Mode>& Rhs) const
    {
        return this->Pin().Get() < Rhs.Pin().Get();
    }
 
private:
    // We declare ourselves as a friend (templated using OtherType) so we can access members as needed
    template< class OtherType, ESPMode OtherMode > friend class TWeakPtr;
 
    // Declare ourselves as a friend of TSharedPtr so we can access members as needed
    template< class OtherType, ESPMode OtherMode > friend class TSharedPtr;
 
private:
    ObjectType* Object;
 
    SharedPointerInternals::FWeakReferencer< Mode > WeakReferenceCount;
};
 
template <typename T>                       constexpr bool TIsTWeakPtr_V                                              = false;
template <class ObjectType, ESPMode InMode> constexpr bool TIsTWeakPtr_V<               TWeakPtr<ObjectType, InMode>> = true;
template <class ObjectType, ESPMode InMode> constexpr bool TIsTWeakPtr_V<const          TWeakPtr<ObjectType, InMode>> = true;
template <class ObjectType, ESPMode InMode> constexpr bool TIsTWeakPtr_V<      volatile TWeakPtr<ObjectType, InMode>> = true;
template <class ObjectType, ESPMode InMode> constexpr bool TIsTWeakPtr_V<const volatile TWeakPtr<ObjectType, InMode>> = true;
 
 
template<class T, ESPMode Mode> struct TIsWeakPointerType<TWeakPtr<T, Mode> > { enum { Value = true }; };
template<class T, ESPMode Mode> struct TIsZeroConstructType<TWeakPtr<T, Mode> > { enum { Value = true }; };
 
template <class ObjectType, ESPMode Mode>
struct TCallTraits<TWeakPtr<ObjectType, Mode>> : public TCallTraitsBase<TWeakPtr<ObjectType, Mode>>
{
    using ConstPointerType = TWeakPtr<const ObjectType, Mode>;
};
 
 
template< class ObjectType, ESPMode Mode >
class TSharedFromThis : private UE::Core::Private::FSharedFromThisBase
{
public:
 
    [[nodiscard]] TSharedRef< ObjectType, Mode > AsShared()
    {
        TSharedPtr< ObjectType, Mode > SharedThis( WeakThis.Pin() );
 
        //
        // If the following assert goes off, it means one of the following:
        //
        //     - You tried to request a shared reference before the object was ever assigned to one. (e.g. constructor)
        //     - You tried to request a shared reference while the object is being destroyed (destructor chain)
        //
        // To fix this, make sure you create at least one shared reference to your object instance before requested,
        // and also avoid calling this function from your object's destructor.
        //
        check( SharedThis.Get() == this );
 
        // Now that we've verified the shared pointer is valid, we'll convert it to a shared reference
        // and return it!
        return MoveTemp( SharedThis ).ToSharedRef();
    }
 
    [[nodiscard]] TSharedRef< ObjectType const, Mode > AsShared() const
    {
        TSharedPtr< ObjectType const, Mode > SharedThis( WeakThis );
 
        //
        // If the following assert goes off, it means one of the following:
        //
        //     - You tried to request a shared reference before the object was ever assigned to one. (e.g. constructor)
        //     - You tried to request a shared reference while the object is being destroyed (destructor chain)
        //
        // To fix this, make sure you create at least one shared reference to your object instance before requested,
        // and also avoid calling this function from your object's destructor.
        //
        check( SharedThis.Get() == this );
 
        // Now that we've verified the shared pointer is valid, we'll convert it to a shared reference
        // and return it!
        return MoveTemp( SharedThis ).ToSharedRef();
    }
 
    template< typename SubobjectType >
    [[nodiscard]] TSharedRef< SubobjectType, Mode > AsSharedSubobject( SubobjectType* SubobjectPtr ) const
    {
        return TSharedRef< SubobjectType, Mode >( AsShared(), SubobjectPtr );
    }
 
    [[nodiscard]] TWeakPtr< ObjectType, Mode > AsWeak()
    {
        TWeakPtr< ObjectType, Mode > Result = WeakThis;
 
        //
        // If the following assert goes off, it means one of the following:
        //
        //     - You tried to request a weak pointer before the object was ever assigned to a shared pointer. (e.g. constructor)
        //     - You tried to request a weak pointer while the object is being destroyed (destructor chain)
        //
        // To fix this, make sure you create at least one shared reference to your object instance before requested,
        // and also avoid calling this function from your object's destructor.
        //
        check( Result.Pin().Get() == this );
 
        // Now that we've verified the pointer is valid, we'll return it!
        return Result;
    }
    [[nodiscard]] TWeakPtr< ObjectType const, Mode > AsWeak() const
    {
        TWeakPtr< ObjectType const, Mode > Result = WeakThis;
 
        //
        // If the following assert goes off, it means one of the following:
        //
        //     - You tried to request a weak pointer before the object was ever assigned to a shared pointer. (e.g. constructor)
        //     - You tried to request a weak pointer while the object is being destroyed (destructor chain)
        //
        // To fix this, make sure you create at least one shared reference to your object instance before requested,
        // and also avoid calling this function from your object's destructor.
        //
        check( Result.Pin().Get() == this );
 
        // Now that we've verified the pointer is valid, we'll return it!
        return Result;
    }
 
    template <typename SubobjectType>
    [[nodiscard]] TWeakPtr< SubobjectType, Mode > AsWeakSubobject( SubobjectType* SubobjectPtr ) const
    {
        return AsSharedSubobject( SubobjectPtr ).ToWeakPtr();
    }
 
protected:
 
    template< class OtherType >
    [[nodiscard]] UE_FORCEINLINE_HINT static TSharedRef< OtherType, Mode > SharedThis( OtherType* ThisPtr )
    {
        return StaticCastSharedRef< OtherType >( ThisPtr->AsShared() );
    }
 
    template< class OtherType >
    [[nodiscard]] UE_FORCEINLINE_HINT static TSharedRef< OtherType const, Mode > SharedThis( const OtherType* ThisPtr )
    {
        return StaticCastSharedRef< OtherType const >( ThisPtr->AsShared() );
    }
 
public:     // @todo: Ideally this would be private, but template sharing problems prevent it
 
    template< class SharedPtrType, ESPMode SharedPtrMode, class OtherType >
    inline void UpdateWeakReferenceInternal( TSharedPtr< SharedPtrType, SharedPtrMode > const* InSharedPtr, OtherType* InObject ) const
    {
        static_assert(SharedPtrMode == Mode, "You cannot use a TSharedPtr of one mode with a type which inherits TSharedFromThis of another mode.");
 
        if( !WeakThis.IsValid() )
        {
            WeakThis = TSharedPtr< ObjectType, Mode >( *InSharedPtr, InObject );
        }
    }
 
    template< class SharedRefType, ESPMode SharedPtrMode, class OtherType >
    inline void UpdateWeakReferenceInternal( TSharedRef< SharedRefType, SharedPtrMode > const* InSharedRef, OtherType* InObject ) const
    {
        static_assert(SharedPtrMode == Mode, "You cannot use a TSharedPtr of one mode with a type which inherits TSharedFromThis of another mode.");
 
        if( !WeakThis.IsValid() )
        {
            WeakThis = TSharedRef< ObjectType, Mode >( *InSharedRef, InObject );
        }
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool DoesSharedInstanceExist() const
    {
        return WeakThis.IsValid();
    }
 
protected:
 
    TSharedFromThis()
    {
#ifndef UE_HEADER_UNITS
        // Cause a compile error if ObjectType is a UObject.
        int32 UObjectTestOverload(const volatile UObject*);
        int16 UObjectTestOverload(...);
        static_assert(sizeof(UObjectTestOverload((ObjectType*)nullptr)) == sizeof(int16), "TSharedFromThis is not supported on UObjects");
#endif
    }
 
    TSharedFromThis( TSharedFromThis const& ) { }
 
    UE_FORCEINLINE_HINT TSharedFromThis& operator=( TSharedFromThis const& )
    {
        return *this;
    }
 
    ~TSharedFromThis()
    {
    }
 
private:
 
    mutable TWeakPtr< ObjectType, Mode > WeakThis;  
};
 
 
template< class CastToType, class CastFromType, ESPMode Mode >
[[nodiscard]] UE_FORCEINLINE_HINT TSharedPtr< CastToType, Mode > StaticCastSharedPtr(TSharedPtr< CastFromType, Mode > const& InSharedPtr)
{
    return TSharedPtr< CastToType, Mode >(InSharedPtr, SharedPointerInternals::FStaticCastTag());
}
 
 
template< class CastToType, class CastFromType, ESPMode Mode >
[[nodiscard]] UE_FORCEINLINE_HINT TWeakPtr< CastToType, Mode > StaticCastWeakPtr(TWeakPtr< CastFromType, Mode > const& InWeakPtr)
{
    return TWeakPtr< CastToType, Mode >(InWeakPtr, SharedPointerInternals::FStaticCastTag());
}
 
 
template< class CastToType, class CastFromType, ESPMode Mode >
[[nodiscard]] UE_FORCEINLINE_HINT TSharedRef< CastToType, Mode > ConstCastSharedRef( TSharedRef< CastFromType, Mode > const& InSharedRef )
{
    return TSharedRef< CastToType, Mode >( InSharedRef, SharedPointerInternals::FConstCastTag() );
}
 
 
template< class CastToType, class CastFromType, ESPMode Mode >
[[nodiscard]] UE_FORCEINLINE_HINT TSharedPtr< CastToType, Mode > ConstCastSharedPtr( TSharedPtr< CastFromType, Mode > const& InSharedPtr )
{
    return TSharedPtr< CastToType, Mode >( InSharedPtr, SharedPointerInternals::FConstCastTag() );
}
 
 
template< class CastToType, class CastFromType, ESPMode Mode >
[[nodiscard]] UE_FORCEINLINE_HINT TWeakPtr< CastToType, Mode > ConstCastWeakPtr(TWeakPtr< CastFromType, Mode > const& InWeakPtr)
{
    return TWeakPtr< CastToType, Mode >(InWeakPtr, SharedPointerInternals::FConstCastTag());
}
 
 
// NOTE: The following is an Unreal extension to standard shared_ptr behavior
template< class ObjectType >
[[nodiscard]] inline SharedPointerInternals::TRawPtrProxy< ObjectType > MakeShareable( ObjectType* InObject )
{
    // If you get an 'ambiguous call' compile error in this function, it means you have multiple //
    // TSharedFromThis bases in your inheritance hierarchy.  This is not supported.              //
 
    if constexpr (IsDerivedFromSharedFromThis<ObjectType>())
    {
        // If this goes off, you should probably be using Ptr->AsShared() or Ptr->AsWeak() instead.
        checkf(!InObject || !InObject->DoesSharedInstanceExist(), TEXT("Trying to share an already-shared object"));
    }
 
    return SharedPointerInternals::TRawPtrProxy< ObjectType >( InObject );
}
 
 
// NOTE: The following is an Unreal extension to standard shared_ptr behavior
template< class ObjectType, class DeleterType >
[[nodiscard]] inline SharedPointerInternals::TRawPtrProxyWithDeleter< ObjectType, DeleterType > MakeShareable( ObjectType* InObject, DeleterType&& InDeleter )
{
    // If you get an 'ambiguous call' compile error in this function, it means you have multiple //
    // TSharedFromThis bases in your inheritance hierarchy.  This is not supported.              //
 
    if constexpr (IsDerivedFromSharedFromThis<ObjectType>())
    {
        // If this goes off, you should probably be using Ptr->AsShared() or Ptr->AsWeak() instead.
        checkf(!InObject || !InObject->DoesSharedInstanceExist(), TEXT("Trying to share an already-shared object"));
    }
 
    return SharedPointerInternals::TRawPtrProxyWithDeleter< ObjectType, DeleterType >( InObject, Forward< DeleterType >( InDeleter ) );
}
 
template <typename InObjectType, ESPMode InMode = ESPMode::ThreadSafe, typename... InArgTypes>
[[nodiscard]] inline TSharedRef<InObjectType, InMode> MakeShared(InArgTypes&&... Args)
{
    SharedPointerInternals::TIntrusiveReferenceController<InObjectType, InMode>* Controller = SharedPointerInternals::NewIntrusiveReferenceController<InMode, InObjectType>(Forward<InArgTypes>(Args)...);
    return UE::Core::Private::MakeSharedRef<InObjectType, InMode>(Controller->GetObjectPtr(), (SharedPointerInternals::TReferenceControllerBase<InMode>*)Controller);
}
 
 
template <class Type>
inline void CleanupPointerArray(TArray< TWeakPtr<Type> >& PointerArray)
{
    TArray< TWeakPtr<Type> > NewArray;
    for (int32 i = 0; i < PointerArray.Num(); ++i)
    {
        if (PointerArray[i].IsValid())
        {
            NewArray.Add(PointerArray[i]);
        }
    }
    PointerArray = NewArray;
}
 
 
template <class KeyType, class ValueType>
inline void CleanupPointerMap(TMap< TWeakPtr<KeyType>, ValueType >& PointerMap)
{
    TMap< TWeakPtr<KeyType>, ValueType > NewMap;
    for (typename TMap< TWeakPtr<KeyType>, ValueType >::TConstIterator Op(PointerMap); Op; ++Op)
    {
        const TWeakPtr<KeyType> WeakPointer = Op.Key();
        if (WeakPointer.IsValid())
        {
            NewMap.Add(WeakPointer, Op.Value());
        }
    }
    PointerMap = NewMap;
}
 
template <typename ObjectType, ESPMode Mode>
[[nodiscard]] uint32 GetTypeHash( const TSharedRef< ObjectType, Mode >& InSharedRef )
{
    return ::PointerHash( &InSharedRef.Get() );
}
 
template <typename ObjectType, ESPMode Mode>
[[nodiscard]] uint32 GetTypeHash( const TSharedPtr< ObjectType, Mode >& InSharedPtr )
{
    return ::PointerHash( InSharedPtr.Get() );
}
 
template <typename ObjectType, ESPMode Mode>
[[nodiscard]] uint32 GetTypeHash( const TWeakPtr< ObjectType, Mode >& InWeakPtr )
{
    return InWeakPtr.GetWeakPtrTypeHash();
}
 
// Shared pointer testing
#include "Templates/SharedPointerTesting.inl" // IWYU pragma: export