UObjectAnnotation.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    UObjectAnnotation.h: Unreal object annotation template
=============================================================================*/
 
#pragma once
 
#include "AutoRTFM.h"
#include "UObject/UObjectArray.h"
#include "UObject/UObjectBaseUtility.h"
#include "Misc/ScopeExit.h"
#include "Misc/ScopeLock.h"
#include "Misc/ScopeRWLock.h"
#include "Misc/TransactionallySafeCriticalSection.h"
#include "Misc/TransactionallySafeRWLock.h"
 
template<typename TAnnotation, bool bAutoRemove>
class FUObjectAnnotationSparse : public FUObjectArray::FUObjectDeleteListener
{
public:
 
    virtual void NotifyUObjectDeleted(const UObjectBase *Object, int32 Index) override
    {
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
        if (!bAutoRemove)
        {
            UE::TRWScopeLock AnnotationMapLock(AnnotationMapCritical, SLT_ReadOnly);
            // in this case we are only verifying that the external assurances of removal are met
            check(!AnnotationMap.Find(Object));
        }
        else
#endif
        {
            RemoveAnnotation(Object);
        }
    }
 
    virtual void OnUObjectArrayShutdown() override
    {
        RemoveAllAnnotations();
        GUObjectArray.RemoveUObjectDeleteListener(this);
    }
 
    FUObjectAnnotationSparse()
    {
        // default constructor is required to be default annotation
        check(AnnotationCacheValue.IsDefault());
    }
 
    virtual ~FUObjectAnnotationSparse()
    {
#if UE_AUTORTFM
        if (bRegisteredAutoRTFMHandlers)
        {
            AutoRTFM::EContextStatus Status = AutoRTFM::Close([this]
            {
                AutoRTFM::PopOnCommitHandler(this);
            });
            checkSlow(Status == AutoRTFM::EContextStatus::OnTrack);
        }
#endif
        RemoveAllAnnotations();
    }
 
private:
    template<typename T>
    void AddAnnotationInternal(const UObjectBase* Object, T&& Annotation)
    {
        check(Object);
        bool bProcessRegistration = false;
        TAnnotation LocalAnnotation = Forward<T>(Annotation);
        if (LocalAnnotation.IsDefault())
        {
            RemoveAnnotation(Object); // adding the default annotation is the same as removing an annotation
        }
        else
        {
            UE::TRWScopeLock AnnotationMapLock(AnnotationMapCritical, SLT_Write);
            const bool bWasEmpty = (AnnotationMap.Num() == 0);
 
            AnnotationMap.Add(Object, LocalAnnotation);
            SetAnnotationCacheKeyAndValue(Object, MoveTemp(LocalAnnotation));
 
            if (bWasEmpty)
            {
                // we are adding the first one, so if we are auto removing or verifying removal, register now
#if (UE_BUILD_SHIPPING || UE_BUILD_TEST)
                if (bAutoRemove)
#endif
                {
                    bProcessRegistration = true;
                }
            }
        }
 
        if (bProcessRegistration)
        {
            ProcessRegistration();
        }
    }
 
    void ProcessRegistration()
    {
        // Always take the UObjectDeleteListeners mutex first to preserve lock order in all case
        // and avoid deadlock. This is important because we need to follow this lock flow :
        // ConditionalFinishDestroy -> RemoveObjectFromDeleteListeners (UObjectDeleteListenersCritical) -> NotifyUObjectDeleted -> RemoveAnnotation (AnnotationMapCritical)
        GUObjectArray.LockUObjectDeleteListeners();
        ON_SCOPE_EXIT
        {
            GUObjectArray.UnlockUObjectDeleteListeners();
        };
 
        UE::TWriteScopeLock AnnotationMapLock(AnnotationMapCritical);
        if (AnnotationMap.Num() == 0)
        {
            if (bRegistered)
            {
                GUObjectArray.RemoveUObjectDeleteListener(this);
                bRegistered = false;
            }
        }
        else
        {
            if (!bRegistered)
            {
                GUObjectArray.AddUObjectDeleteListener(this);
                bRegistered = true;
            }
        }
    }
public:
    void AddAnnotation(const UObjectBase* Object, TAnnotation&& Annotation)
    {
        AddAnnotationInternal(Object, MoveTemp(Annotation));
    }
 
    void AddAnnotation(const UObjectBase* Object, const TAnnotation& Annotation)
    {
        AddAnnotationInternal(Object, Annotation);
    }
    TAnnotation GetAndRemoveAnnotation(const UObjectBase *Object)
    {       
        check(Object);
        bool bProcessRegistration = false;
 
        TAnnotation Result;
        {
            SetAnnotationCacheKeyAndValue(Object, TAnnotation());
 
            UE::TRWScopeLock AnnotationMapLock(AnnotationMapCritical, SLT_Write);
            const bool bHadElements = (AnnotationMap.Num() > 0);
            AnnotationMap.RemoveAndCopyValue(Object, Result);
            const bool bIsNowEmpty = (AnnotationMap.Num() == 0);
 
            if (bHadElements && bIsNowEmpty)
            {
                // we are removing the last one, so if we are auto removing or verifying removal, unregister now
#if (UE_BUILD_SHIPPING || UE_BUILD_TEST)
                if (bAutoRemove)
#endif
                {
                    bProcessRegistration = true;
                }
            }
        }
 
        if (bProcessRegistration)
        {
            ProcessRegistration();
        }
        return Result;
    }
    void RemoveAnnotation(const UObjectBase *Object)
    {
        check(Object);
        bool bProcessRegistration = false;
 
        {
            SetAnnotationCacheKeyAndValue(Object, TAnnotation());
 
            UE::TRWScopeLock AnnotationMapLock(AnnotationMapCritical, SLT_Write);
            const bool bHadElements = (AnnotationMap.Num() > 0);
            AnnotationMap.Remove(Object);
            const bool bIsNowEmpty = (AnnotationMap.Num() == 0);
 
            if (bHadElements && bIsNowEmpty)
            {
                // we are removing the last one, so if we are auto removing or verifying removal, unregister now
#if (UE_BUILD_SHIPPING || UE_BUILD_TEST)
                if (bAutoRemove)
#endif
                {
                    bProcessRegistration = true;
                }
            }
        }
 
        if (bProcessRegistration)
        {
            ProcessRegistration();
        }
    }
    void RemoveAllAnnotations()
    {
        bool bProcessRegistration = false;
 
        {
            SetAnnotationCacheKeyAndValue(nullptr, TAnnotation());
            const bool bHadElements = (AnnotationMap.Num() > 0);
            UE::TRWScopeLock AnnotationMapLock(AnnotationMapCritical, SLT_Write);
            AnnotationMap.Empty();
 
            if (bHadElements)
            {
                // we are removing the last one, so if we are auto removing or verifying removal, unregister now
#if (UE_BUILD_SHIPPING || UE_BUILD_TEST)
                if (bAutoRemove)
#endif
                {
                    bProcessRegistration = true;
                }
            }
        }
 
        if (bProcessRegistration)
        {
            ProcessRegistration();
        }
    }
 
    inline TAnnotation GetAnnotation(const UObjectBase *Object)
    {
        check(Object);
 
        
        // If we are within a transaction, we don't touch the annotation cache, as it can be altered from the open.
        // Look up the annotation directly from the map.
        if (AutoRTFM::IsTransactional())
        {
            UE::TRWScopeLock AnnotationMapLock(AnnotationMapCritical, SLT_ReadOnly);
            TAnnotation* Entry = AnnotationMap.Find(Object);
            return Entry ? *Entry : TAnnotation();
        }
 
        {
            // Check cache
            UE::TRWScopeLock AnnotationCacheLock(AnnotationCacheCritical, SLT_ReadOnly);
            if (Object == AnnotationCacheKey)
            {
                return AnnotationCacheValue;
            }
        }
        
        // Update the cache if it isn't a match.
        UE::TRWScopeLock AnnotationMapLock(AnnotationMapCritical, SLT_ReadOnly);
        TAnnotation* Entry = AnnotationMap.Find(Object);
        SetAnnotationCacheKeyAndValue(Object, Entry ? *Entry : TAnnotation());
 
        return Entry ? *Entry : TAnnotation();
    }
 
    const TMap<const UObjectBase *,TAnnotation>& GetAnnotationMap() const
    {
        return AnnotationMap;
    }
 
    void Reserve(int32 ExpectedNumElements)
    {
        UE::TRWScopeLock AnnotationMapLock(AnnotationMapCritical, SLT_Write);
        AnnotationMap.Empty(ExpectedNumElements);
    }
 
    virtual SIZE_T GetAllocatedSize() const override
    {
        UE::TRWScopeLock AnnotationMapLock(AnnotationMapCritical, SLT_ReadOnly);
        return AnnotationMap.GetAllocatedSize();
    }
 
private:
    // Sets the AnnotationCacheKey and AnnotationCacheValue if called outside of
    // an AutoRTFM transaction.
    // This is a no-op in a transaction to avoid writes to the same memory locations 
    // from open and closed code. If a transaction is committed or aborted, we reset
    // the cache to avoid reading back a stale value.
    void SetAnnotationCacheKeyAndValue(const UObjectBase* Key, const TAnnotation& Value)
    {
        if (AutoRTFM::IsTransactional())
        {
            MaybeRegisterAutoRTFMHandlers();
        }
        else
        {
            UE::TRWScopeLock AnnotationCacheLock(AnnotationCacheCritical, SLT_Write);
            AnnotationCacheKey = Key;
            AnnotationCacheValue = Value;
        }
    }
 
    void SetAnnotationCacheKeyAndValue(const UObjectBase* Key, TAnnotation&& Value)
    {
        if (AutoRTFM::IsTransactional())
        {
            MaybeRegisterAutoRTFMHandlers();
        }
        else
        {
            UE::TRWScopeLock AnnotationCacheLock(AnnotationCacheCritical, SLT_Write);
            AnnotationCacheKey = Key;
            AnnotationCacheValue = MoveTemp(Value);
        }
    }
 
    void MaybeRegisterAutoRTFMHandlers()
    {
#if UE_AUTORTFM
        if (!bRegisteredAutoRTFMHandlers)
        {
            checkSlow(AutoRTFM::IsTransactional());  // Precondition: our caller should have checked this
 
            AutoRTFM::EContextStatus Status = AutoRTFM::Close([this]
            {
                bRegisteredAutoRTFMHandlers = true;
 
                // We avoid touching the cache key and value within a transaction, so after a transaction completes,
                // the cache value may be outdated. To avoid stale data, we null out the cache key at the end of a
                // transaction. It will be automatically repopulated the next time GetAnnotation is called.
                AutoRTFM::PushOnCommitHandler(this, [this] 
                { 
                    AnnotationCacheKey = nullptr; 
                    bRegisteredAutoRTFMHandlers = false;
                });
            });
 
            checkSlow(Status == AutoRTFM::EContextStatus::OnTrack);
        }
#endif
    }
 
protected:
    mutable FTransactionallySafeRWLock AnnotationMapCritical;
    mutable FTransactionallySafeRWLock AnnotationCacheCritical;
 
    TMap<const UObjectBase *, TAnnotation> AnnotationMap;
 
    const UObjectBase* AnnotationCacheKey = nullptr;
 
    TAnnotation AnnotationCacheValue;
 
    bool bRegistered = false;
 
#if UE_AUTORTFM
    bool bRegisteredAutoRTFMHandlers = false;
#endif
};
 
 
template<typename TAnnotation, bool bAutoRemove>
class FUObjectAnnotationSparseSearchable : public FUObjectAnnotationSparse<TAnnotation, bAutoRemove>
{
    typedef FUObjectAnnotationSparse<TAnnotation, bAutoRemove> Super;
public:
    virtual void NotifyUObjectDeleted(const UObjectBase *Object, int32 Index) override
    {
        RemoveAnnotation(Object);
    }
 
    virtual void OnUObjectArrayShutdown() override
    {
        RemoveAllAnnotations();
        GUObjectArray.RemoveUObjectDeleteListener(this);
    }
 
    virtual ~FUObjectAnnotationSparseSearchable()
    {
        RemoveAllAnnotations();
    }
 
    UObject* Find(const TAnnotation& Annotation)
    {
        UE::TScopeLock InverseAnnotationMapLock(InverseAnnotationMapCritical);
        checkSlow(!Annotation.IsDefault()); // it is not legal to search for the default annotation
        return (UObject*)InverseAnnotationMap.FindRef(Annotation);
    }
 
private:
    template<typename T> 
    void AddAnnotationInternal(const UObjectBase* Object, T&& Annotation)
    {
        UE::TScopeLock InverseAnnotationMapLock(InverseAnnotationMapCritical);
        if (Annotation.IsDefault())
        {
            RemoveAnnotation(Object); // adding the default annotation is the same as removing an annotation
        }
        else
        {
            TAnnotation ExistingAnnotation = this->GetAnnotation(Object);
            int32 NumExistingRemoved = InverseAnnotationMap.Remove(ExistingAnnotation);
            checkSlow(NumExistingRemoved == 0);
 
            Super::AddAnnotation(Object, Annotation);
            // should not exist in the mapping; we require uniqueness
            int32 NumRemoved = InverseAnnotationMap.Remove(Annotation);
            checkSlow(NumRemoved == 0);
            InverseAnnotationMap.Add(Forward<T>(Annotation), Object);
        }
    }
 
 
public:
 
    void AddAnnotation(const UObjectBase* Object, const TAnnotation& Annotation)
    {
        AddAnnotationInternal(Object, Annotation);
    }
 
    void AddAnnotation(const UObjectBase* Object, TAnnotation&& Annotation)
    {
        AddAnnotationInternal(Object, MoveTemp(Annotation));
    }
 
    void RemoveAnnotation(const UObjectBase *Object)
    {
        UE::TScopeLock InverseAnnotationMapLock(InverseAnnotationMapCritical);
        TAnnotation Annotation = this->GetAndRemoveAnnotation(Object);
        if (Annotation.IsDefault())
        {
            // should not exist in the mapping
            checkSlow(!InverseAnnotationMap.Find(Annotation));
        }
        else
        {
            int32 NumRemoved = InverseAnnotationMap.Remove(Annotation);
            checkSlow(NumRemoved == 1);
        }
    }
    void RemoveAllAnnotations()
    {
        UE::TScopeLock InverseAnnotationMapLock(InverseAnnotationMapCritical);
        Super::RemoveAllAnnotations();
        InverseAnnotationMap.Empty();
    }
 
    virtual SIZE_T GetAllocatedSize() const override
    {
        return InverseAnnotationMap.GetAllocatedSize() + Super::GetAllocatedSize();
    }
private:
 
    TMap<TAnnotation, const UObjectBase *> InverseAnnotationMap;
    FTransactionallySafeCriticalSection InverseAnnotationMapCritical;
};
 
 
struct FBoolAnnotation
{
    FBoolAnnotation() :
        Mark(false)
    {
    }
    FBoolAnnotation(bool InMark) :
        Mark(InMark)
    {
    }
    UE_FORCEINLINE_HINT bool IsDefault()
    {
        return !Mark;
    }
 
    bool                Mark; 
 
};
 
template <> struct TIsPODType<FBoolAnnotation> { enum { Value = true }; };
 
 
class FUObjectAnnotationSparseBool : private FUObjectAnnotationSparse<FBoolAnnotation,true>
{
public:
    UE_FORCEINLINE_HINT void Set(const UObjectBase *Object)
    {
        this->AddAnnotation(Object,FBoolAnnotation(true));
    }
    UE_FORCEINLINE_HINT void Clear(const UObjectBase *Object)
    {
        this->RemoveAnnotation(Object);
    }
 
    UE_FORCEINLINE_HINT void ClearAll()
    {
        this->RemoveAllAnnotations();
    }
 
    UE_FORCEINLINE_HINT bool Get(const UObjectBase *Object)
    {
        return this->GetAnnotation(Object).Mark;
    }
 
    UE_FORCEINLINE_HINT void Reserve(int32 ExpectedNumElements)
    {
        FUObjectAnnotationSparse<FBoolAnnotation,true>::Reserve(ExpectedNumElements);
    }
 
    UE_FORCEINLINE_HINT int32 Num() const
    {
        return this->GetAnnotationMap().Num();
    }
};
 
template<typename TAnnotation, bool bAutoRemove, int32 NumAnnotationsPerChunk = 64 * 1024>
class FUObjectAnnotationChunked : public FUObjectArray::FUObjectDeleteListener
{
    struct TAnnotationChunk
    {
        int32 Num;
        TAnnotation* Items;
 
        TAnnotationChunk()
            : Num(0)
            , Items(nullptr)
        {}
    };
 
 
    TArray<TAnnotationChunk> Chunks;
    int32 NumAnnotations;
    int32 MaxAnnotations;
    uint32 CurrentAllocatedMemory;
    uint32 MaxAllocatedMemory;
 
    FTransactionallySafeRWLock AnnotationArrayCritical;
 
    void ExpandChunksToIndex(int32 Index) TSAN_SAFE
    {
        check(Index >= 0);
        int32 ChunkIndex = Index / NumAnnotationsPerChunk;
        if (ChunkIndex >= Chunks.Num())
        {
            Chunks.AddZeroed(ChunkIndex + 1 - Chunks.Num());
        }
        check(ChunkIndex < Chunks.Num());
        MaxAnnotations = Chunks.Num() * NumAnnotationsPerChunk;
    }
 
    TAnnotation& AllocateAnnotation(int32 Index) TSAN_SAFE
    {
        ExpandChunksToIndex(Index);
 
        const int32 ChunkIndex = Index / NumAnnotationsPerChunk;
        const int32 WithinChunkIndex = Index % NumAnnotationsPerChunk;
 
        TAnnotationChunk& Chunk = Chunks[ChunkIndex];
        if (!Chunk.Items)
        {
            Chunk.Items = new TAnnotation[NumAnnotationsPerChunk];
            CurrentAllocatedMemory += NumAnnotationsPerChunk * sizeof(TAnnotation);
            MaxAllocatedMemory = FMath::Max(CurrentAllocatedMemory, MaxAllocatedMemory);
        }
        if (Chunk.Items[WithinChunkIndex].IsDefault())
        {
            Chunk.Num++;
            check(Chunk.Num <= NumAnnotationsPerChunk);
            NumAnnotations++;
        }
 
        return Chunk.Items[WithinChunkIndex];
    }
 
    void FreeAnnotation(int32 Index) TSAN_SAFE
    {
        const int32 ChunkIndex = Index / NumAnnotationsPerChunk;
        const int32 WithinChunkIndex = Index % NumAnnotationsPerChunk;
 
        if (ChunkIndex >= Chunks.Num())
        {
            return;
        }
 
        TAnnotationChunk& Chunk = Chunks[ChunkIndex];
        if (!Chunk.Items)
        {
            return;
        }
 
        if (Chunk.Items[WithinChunkIndex].IsDefault())
        {
            return;
        }
 
        Chunk.Items[WithinChunkIndex] = TAnnotation();
        Chunk.Num--;
        check(Chunk.Num >= 0);
        if (Chunk.Num == 0)
        {
            delete[] Chunk.Items;
            Chunk.Items = nullptr;
            const uint32 ChunkMemory = NumAnnotationsPerChunk * sizeof(TAnnotation);
            check(CurrentAllocatedMemory >= ChunkMemory);
            CurrentAllocatedMemory -= ChunkMemory;
        }
        NumAnnotations--;
        check(NumAnnotations >= 0);
    }
 
    void FreeAllAnnotations() TSAN_SAFE
    {
        for (TAnnotationChunk& Chunk : Chunks)
        {
            delete[] Chunk.Items;
        }
        Chunks.Empty();
        NumAnnotations = 0;
        MaxAnnotations = 0;
        CurrentAllocatedMemory = 0;
        MaxAllocatedMemory = 0;
    }
 
    template<typename T>
    void AddAnnotationInternal(int32 Index, T&& Annotation)
    {
        check(Index >= 0);
        if (Annotation.IsDefault())
        {
            FreeAnnotation(Index); // adding the default annotation is the same as removing an annotation
        }
        else
        {
            if (NumAnnotations == 0 && Chunks.Num() == 0)
            {
                // we are adding the first one, so if we are auto removing or verifying removal, register now
#if (UE_BUILD_SHIPPING || UE_BUILD_TEST)
                if (bAutoRemove)
#endif
                {
                    GUObjectArray.AddUObjectDeleteListener(this);
                }
            }
 
            TAnnotation& NewAnnotation = AllocateAnnotation(Index);
            NewAnnotation = Forward<T>(Annotation);
        }
    }
 
public:
 
    FUObjectAnnotationChunked() TSAN_SAFE
        : NumAnnotations(0)
        , MaxAnnotations(0)
        , CurrentAllocatedMemory(0)
        , MaxAllocatedMemory(0)
    {
    }
 
    virtual ~FUObjectAnnotationChunked()
    {
        RemoveAllAnnotations();
    }
 
public:
 
    void AddAnnotation(const UObjectBase *Object, const TAnnotation& Annotation)
    {
        check(Object);
        AddAnnotation(GUObjectArray.ObjectToIndex(Object), Annotation);
    }
 
    void AddAnnotation(const UObjectBase* Object, TAnnotation&& Annotation)
    {
        check(Object);
        AddAnnotation(GUObjectArray.ObjectToIndex(Object), MoveTemp(Annotation));
    }
 
    void AddAnnotation(int32 Index, const TAnnotation& Annotation)
    {
        UE::TWriteScopeLock AnnotationArrayLock(AnnotationArrayCritical);
        AddAnnotationInternal(Index, Annotation);
    }
 
    void AddAnnotation(int32 Index, TAnnotation&& Annotation)
    {
        UE::TWriteScopeLock AnnotationArrayLock(AnnotationArrayCritical);
        AddAnnotationInternal(Index, MoveTemp(Annotation));
    }
 
    TAnnotation& AddOrGetAnnotation(const UObjectBase *Object, TFunctionRef<TAnnotation()> NewAnnotationFn)
    {
        check(Object);
        return AddOrGetAnnotation(GUObjectArray.ObjectToIndex(Object), NewAnnotationFn);
    }
    TAnnotation& AddOrGetAnnotation(int32 Index, TFunctionRef<TAnnotation()> NewAnnotationFn)
    {       
        UE::TWriteScopeLock AnnotationArrayLock(AnnotationArrayCritical);
        
        if (NumAnnotations == 0 && Chunks.Num() == 0)
        {
            // we are adding the first one, so if we are auto removing or verifying removal, register now
#if (UE_BUILD_SHIPPING || UE_BUILD_TEST)
            if (bAutoRemove)
#endif
            {
                GUObjectArray.AddUObjectDeleteListener(this);
            }
        }
 
        ExpandChunksToIndex(Index);
 
        const int32 ChunkIndex = Index / NumAnnotationsPerChunk;
        const int32 WithinChunkIndex = Index % NumAnnotationsPerChunk;
 
        TAnnotationChunk& Chunk = Chunks[ChunkIndex];
        if (!Chunk.Items)
        {
            Chunk.Items = new TAnnotation[NumAnnotationsPerChunk];
            CurrentAllocatedMemory += NumAnnotationsPerChunk * sizeof(TAnnotation);
            MaxAllocatedMemory = FMath::Max(CurrentAllocatedMemory, MaxAllocatedMemory);
        }
        if (Chunk.Items[WithinChunkIndex].IsDefault())
        {
            Chunk.Num++;
            check(Chunk.Num <= NumAnnotationsPerChunk);
            NumAnnotations++;
            Chunk.Items[WithinChunkIndex] = NewAnnotationFn();
            check(!Chunk.Items[WithinChunkIndex].IsDefault());
        }
        return Chunk.Items[WithinChunkIndex];
    }
 
    void RemoveAnnotation(const UObjectBase *Object)
    {
        check(Object);
        RemoveAnnotation(GUObjectArray.ObjectToIndex(Object));
    }
    void RemoveAnnotation(int32 Index)
    {
        UE::TWriteScopeLock AnnotationArrayLock(AnnotationArrayCritical);
        FreeAnnotation(Index);
    }
 
    inline TAnnotation GetAnnotation(const UObjectBase *Object)
    {
        check(Object);
        return GetAnnotation(GUObjectArray.ObjectToIndex(Object));
    }
 
    inline TAnnotation GetAnnotation(int32 Index)
    {
        check(Index >= 0);
 
        TAnnotation Result = TAnnotation();
 
        UE_AUTORTFM_OPEN
        {
            UE::TReadScopeLock AnnotationArrayLock(AnnotationArrayCritical);
 
            const int32 ChunkIndex = Index / NumAnnotationsPerChunk;
            if (ChunkIndex < Chunks.Num())
            {
                const int32 WithinChunkIndex = Index % NumAnnotationsPerChunk;
 
                TAnnotationChunk& Chunk = Chunks[ChunkIndex];
                if (Chunk.Items != nullptr)
                {
                    Result = Chunk.Items[WithinChunkIndex];
                }
            }
        };
 
        return Result;
    }
 
    UE_FORCEINLINE_HINT int32 GetAnnotationCount() const
    {
        return NumAnnotations;
    }
 
    UE_FORCEINLINE_HINT int32 GetMaxAnnotations() const TSAN_SAFE
    {
        return MaxAnnotations;
    }
 
    UE_DEPRECATED(5.3, "Use GetMaxAnnotations instead")
    UE_FORCEINLINE_HINT int32 GetMaxAnnottations() const TSAN_SAFE
    {
        return MaxAnnotations;
    }
 
    UE_FORCEINLINE_HINT bool IsValidIndex(int32 Index) const
    {
        return Index >= 0 && Index < MaxAnnotations;
    }
 
    void RemoveAllAnnotations()
    {
        bool bHadAnnotations = (NumAnnotations > 0);    
        UE::TWriteScopeLock AnnotationArrayLock(AnnotationArrayCritical);
        FreeAllAnnotations();
        if (bHadAnnotations)
        {
            // we are removing the last one, so if we are auto removing or verifying removal, unregister now
#if (UE_BUILD_SHIPPING || UE_BUILD_TEST)
            if (bAutoRemove)
#endif
            {
                GUObjectArray.RemoveUObjectDeleteListener(this);
            }
        }
    }
 
    void TrimAnnotations()
    {
        UE::TWriteScopeLock AnnotationArrayLock(AnnotationArrayCritical);
        for (TAnnotationChunk& Chunk : Chunks)
        {
            if (Chunk.Num == 0 && Chunk.Items)
            {
                delete[] Chunk.Items;
                Chunk.Items = nullptr;
                const uint32 ChunkMemory = NumAnnotationsPerChunk * sizeof(TAnnotationChunk);
                check(CurrentAllocatedMemory >= ChunkMemory);
                CurrentAllocatedMemory -= ChunkMemory;
            }
        }
    }
 
    virtual SIZE_T GetAllocatedSize() const override
    {
        SIZE_T AllocatedSize = Chunks.GetAllocatedSize();
        for (const TAnnotationChunk& Chunk : Chunks)
        {
            if (Chunk.Items)
            {
                AllocatedSize += NumAnnotationsPerChunk * sizeof(TAnnotation);
            }
        }
        return AllocatedSize;
    }
 
    uint32 GetMaxAllocatedSize() const
    {
        return Chunks.GetAllocatedSize() + MaxAllocatedMemory;
    }
 
    virtual void NotifyUObjectDeleted(const UObjectBase *Object, int32 Index)
    {
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
        if (!bAutoRemove)
        {
            // in this case we are only verifying that the external assurances of removal are met
            check(Index >= MaxAnnotations || GetAnnotation(Index).IsDefault());
        }
        else
#endif
        {
            RemoveAnnotation(Index);
        }
    }
 
    virtual void OnUObjectArrayShutdown() override
    {
        RemoveAllAnnotations();
        GUObjectArray.RemoveUObjectDeleteListener(this);
    }
};
 
template<typename TAnnotation, bool bAutoRemove>
class FUObjectAnnotationDense : public FUObjectArray::FUObjectDeleteListener
{
public:
 
    virtual void NotifyUObjectDeleted(const UObjectBase *Object, int32 Index)
    {
#if !(UE_BUILD_SHIPPING || UE_BUILD_TEST)
        if (!bAutoRemove)
        {
            // in this case we are only verifying that the external assurances of removal are met
            check(Index >= AnnotationArray.Num() || AnnotationArray[Index].IsDefault());
        }
        else
#endif
        {
            RemoveAnnotation(Index);
        }
    }
 
    virtual void OnUObjectArrayShutdown() override
    {
        RemoveAllAnnotations();
        GUObjectArray.RemoveUObjectDeleteListener(this);
    }
 
    virtual ~FUObjectAnnotationDense()
    {
        RemoveAllAnnotations();
    }
 
    void AddAnnotation(const UObjectBase* Object, const TAnnotation& Annotation)
    {
        check(Object);
        AddAnnotation(GUObjectArray.ObjectToIndex(Object), Annotation);
    }
 
    void AddAnnotation(const UObjectBase* Object, TAnnotation&& Annotation)
    {
        check(Object);
        AddAnnotation(GUObjectArray.ObjectToIndex(Object), MoveTemp(Annotation));
    }
 
    void AddAnnotation(int32 Index, const TAnnotation& Annotation)
    {
        bool bProcessRegistration = false;
        {
            UE::TRWScopeLock AnnotationArrayLock(AnnotationArrayCritical, SLT_Write);
            bProcessRegistration = AddAnnotationInternal(Index, Annotation);
        }
 
        if (bProcessRegistration)
        {
            ProcessRegistration();
        }
    }
 
    void AddAnnotation(int32 Index, TAnnotation&& Annotation)
    {   
        bool bProcessRegistration = false;
        {
            UE::TRWScopeLock AnnotationArrayLock(AnnotationArrayCritical, SLT_Write);
            bProcessRegistration = AddAnnotationInternal(Index, MoveTemp(Annotation));
        }
 
        if (bProcessRegistration)
        {
            ProcessRegistration();
        }
    }
 
 
private:
    void ProcessRegistration()
    {
        // Always take the UObjectDeleteListeners mutex first to preserve lock order in all case
        // and avoid deadlock. This is important because we need to follow this lock flow :
        // ConditionalFinishDestroy -> RemoveObjectFromDeleteListeners (UObjectDeleteListenersCritical) -> NotifyUObjectDeleted -> RemoveAnnotation (AnnotationMapCritical)
        GUObjectArray.LockUObjectDeleteListeners();
        ON_SCOPE_EXIT
        {
            GUObjectArray.UnlockUObjectDeleteListeners();
        };
 
        UE::TWriteScopeLock AnnotationMapLock(AnnotationArrayCritical);
        if (AnnotationArray.Num() == 0)
        {
            if (bRegistered)
            {
                GUObjectArray.RemoveUObjectDeleteListener(this);
                bRegistered = false;
            }
        }
        else
        {
            if (!bRegistered)
            {
                GUObjectArray.AddUObjectDeleteListener(this);
                bRegistered = true;
            }
        }
    }
 
    template<typename T>
    [[nodiscard]] bool AddAnnotationInternal(int32 Index, T&& Annotation)
    {
        bool bProcessRegistration = false;
 
        check(Index >= 0);
        if (Annotation.IsDefault())
        {
            RemoveAnnotationInternal(Index); // adding the default annotation is the same as removing an annotation
        }
        else
        {
            if (AnnotationArray.Num() == 0)
            {
                // we are adding the first one, so if we are auto removing or verifying removal, register now
#if (UE_BUILD_SHIPPING || UE_BUILD_TEST)
                if (bAutoRemove)
#endif
                {
                    bProcessRegistration = true;
                }
            }
            if (Index >= AnnotationArray.Num())
            {
                int32 AddNum = 1 + Index - AnnotationArray.Num();
                int32 Start = AnnotationArray.AddUninitialized(AddNum);
                while (AddNum--) 
                {
                    new (AnnotationArray.GetData() + Start++) TAnnotation();
                }
            }
            AnnotationArray[Index] = Forward<T>(Annotation);
        }
 
        return bProcessRegistration;
    }
 
public:
    void RemoveAnnotation(const UObjectBase *Object)
    {
        check(Object);
        RemoveAnnotation(GUObjectArray.ObjectToIndex(Object));
    }
    void RemoveAnnotation(int32 Index)
    {
        UE::TRWScopeLock AnnotationArrayLock(AnnotationArrayCritical, SLT_Write);
        RemoveAnnotationInternal(Index);
    }
 
private:
    void RemoveAnnotationInternal(int32 Index)
    {
        check(Index >= 0);
        if (Index <  AnnotationArray.Num())
        {
            AnnotationArray[Index] = TAnnotation();
        }
    }
 
public:
    void RemoveAllAnnotations()
    {
        bool bProcessRegistration = false;
        {
            UE::TRWScopeLock AnnotationArrayLock(AnnotationArrayCritical, SLT_Write);
            bool bHadElements = (AnnotationArray.Num() > 0);
            AnnotationArray.Empty();
            if (bHadElements)
            {
                // we are removing the last one, so if we are auto removing or verifying removal, unregister now
#if (UE_BUILD_SHIPPING || UE_BUILD_TEST)
                if (bAutoRemove)
#endif
                {
                    bProcessRegistration = true;
                }
            }
        }
 
        ProcessRegistration();
    }
 
    inline TAnnotation GetAnnotation(const UObjectBase *Object)
    {
        check(Object);
        int32 Index = GUObjectArray.ObjectToIndex(Object);
        // Since we are potentially dealing with a corrupt ptr validation is broken into two checks.
        // First to tell if something is wrong and the second to try to provide
        // more information to the user (however in a potentially unsafe way by reading the ptr).
        ensureAlwaysMsgf(Index >= 0, TEXT("Corrupt object with negative Index passed to GetAnnotation: Index == %d"), Index);
        checkf(Index >= 0, TEXT("Failed GetAnnotation for Object '%s'"), *static_cast<const UObjectBaseUtility*>(Object)->GetPathName());
        return GetAnnotation(Index);
    }
 
    inline TAnnotation GetAnnotation(int32 Index)
    {
        check(Index >= 0);
        UE::TRWScopeLock AnnotationArrayLock(AnnotationArrayCritical, SLT_ReadOnly);
        if (Index < AnnotationArray.Num())
        {
            return AnnotationArray[Index];
        }
        return TAnnotation();
    }
 
    inline TAnnotation& GetAnnotationRef(const UObjectBase *Object)
    {
        check(Object);
        return GetAnnotationRef(GUObjectArray.ObjectToIndex(Object));
    }
 
    inline TAnnotation& GetAnnotationRef(int32 Index)
    {
        bool bProcessRegistration = false;
        {
            UE::TRWScopeLock AnnotationArrayLock(AnnotationArrayCritical, SLT_Write);
            if (Index >= AnnotationArray.Num())
            {
                bProcessRegistration = AddAnnotationInternal(Index, TAnnotation());
            }
        }
 
        if (bProcessRegistration)
        {
            ProcessRegistration();
        }
        return AnnotationArray[Index];
    }
 
    virtual SIZE_T GetAllocatedSize() const override
    {
        return AnnotationArray.GetAllocatedSize();
    }
 
private:
 
    TArray<TAnnotation> AnnotationArray;
    FTransactionallySafeRWLock AnnotationArrayCritical;
 
    bool bRegistered = false;
};
 
class FUObjectAnnotationDenseBool : public FUObjectArray::FUObjectDeleteListener
{
    typedef uint32 TBitType;
    enum {BitsPerElement = sizeof(TBitType) * 8};
public:
 
    virtual void NotifyUObjectDeleted(const UObjectBase *Object, int32 Index)
    {
        RemoveAnnotation(Index);
    }
 
    virtual void OnUObjectArrayShutdown() override
    {
        RemoveAllAnnotations();
        GUObjectArray.RemoveUObjectDeleteListener(this);
    }
 
    virtual ~FUObjectAnnotationDenseBool()
    {
        RemoveAllAnnotations();
    }
 
    inline void Set(const UObjectBase *Object)
    {
        checkSlow(Object);
        int32 Index = GUObjectArray.ObjectToIndex(Object);
        checkSlow(Index >= 0);
        if (AnnotationArray.Num() == 0)
        {
            GUObjectArray.AddUObjectDeleteListener(this);
        }
        if (Index >= AnnotationArray.Num() * BitsPerElement)
        {
            int32 AddNum = 1 + Index - AnnotationArray.Num() * BitsPerElement;
            int32 AddElements = (AddNum +  BitsPerElement - 1) / BitsPerElement;
            checkSlow(AddElements);
            AnnotationArray.AddZeroed(AddElements);
            checkSlow(Index < AnnotationArray.Num() * BitsPerElement);
        }
        AnnotationArray[Index / BitsPerElement] |= TBitType(TBitType(1) << (Index % BitsPerElement));
    }
    inline void Clear(const UObjectBase *Object)
    {
        checkSlow(Object);
        int32 Index = GUObjectArray.ObjectToIndex(Object);
        RemoveAnnotation(Index);
    }
 
    UE_FORCEINLINE_HINT void ClearAll()
    {
        RemoveAllAnnotations();
    }
 
    inline bool Get(const UObjectBase *Object)
    {
        checkSlow(Object);
        int32 Index = GUObjectArray.ObjectToIndex(Object);
        checkSlow(Index >= 0);
        if (Index < AnnotationArray.Num() * BitsPerElement)
        {
            return !!(AnnotationArray[Index / BitsPerElement] & TBitType(TBitType(1) << (Index % BitsPerElement)));
        }
        return false;
    }
 
    virtual SIZE_T GetAllocatedSize() const override
    {
        return AnnotationArray.GetAllocatedSize();
    }
 
private:
    void RemoveAnnotation(int32 Index)
    {
        checkSlow(Index >= 0);
        if (Index <  AnnotationArray.Num() * BitsPerElement)
        {
            AnnotationArray[Index / BitsPerElement] &= ~TBitType(TBitType(1) << (Index % BitsPerElement));
        }
    }
    void RemoveAllAnnotations()
    {
        bool bHadElements = (AnnotationArray.Num() > 0);
        AnnotationArray.Empty();
        if (bHadElements)
        {
            GUObjectArray.RemoveUObjectDeleteListener(this);
        }
    }
 
    TArray<TBitType> AnnotationArray;
};