FindReferencersArchive.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "Algo/BinarySearch.h"
#include "Algo/Sort.h"
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/Map.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "HAL/PlatformCrt.h"
#include "HAL/PlatformMath.h"
#include "Misc/AssertionMacros.h"
#include "Serialization/ArchiveUObject.h"
 
class FArchive;
class UObject;
 
/*----------------------------------------------------------------------------
    FFindReferencersArchive.
----------------------------------------------------------------------------*/
class FFindReferencersArchive : public FArchiveUObject
{
public:
    COREUOBJECT_API FFindReferencersArchive(class UObject* PotentialReferencer, TArrayView<class UObject*> InTargetObjects, bool bFindAlsoWeakReferences = false);
 
    COREUOBJECT_API int32 GetReferenceCount( class UObject* TargetObject, TArray<class FProperty*>* out_ReferencingProperties=NULL ) const;
 
    COREUOBJECT_API int32 GetReferenceCounts( TMap<class UObject*, int32>& out_ReferenceCounts ) const;
 
    COREUOBJECT_API int32 AppendReferenceCounts( TMap<class UObject*, int32>& out_ReferenceCounts ) const;
 
    COREUOBJECT_API int32 GetReferenceCounts( TMap<class UObject*, int32>& out_ReferenceCounts, TMultiMap<class UObject*,class FProperty*>& out_ReferencingProperties ) const;
 
    virtual FString GetArchiveName() const { return TEXT("FFindReferencersArchive"); }
 
    COREUOBJECT_API void ResetPotentialReferencer(UObject* InPotentialReferencer);
 
protected:
    // Container specifically optimized for the operations we're doing here.
    //   - Reduce allocations while adding.
    //   - Reduce cache misses while searching.
    //   - Fast to reset its values as they're all contiguous in memory.
    //   - Reduce iteration count to initialized values only when searching for values > 0 by stopping at ValueNum().
    class FTargetObjectContainer
    {
    public:
        // Functions used to prepare the container until it is frozen
 
        void Reserve(int32 Num)
        {
            CheckUnfrozen();
 
            TargetObjects.Reserve(Num);
        }
 
        void AddObject(UObject* Object)
        {
            CheckUnfrozen();
 
            TargetObjects.Add(Object);
        }
 
        void Freeze()
        {
            CheckUnfrozen();
 
            bFrozen = true;
            Algo::Sort(TargetObjects);
            ResetRefCounts();
        }
 
        // Functions to use once the container has been frozen
 
        // This will initialize and return the refcount associated with the object if it exists
        int32* GetRefCountPtr(UObject* Object)
        {
            CheckFrozen();
 
            int32 ExistingIndex = Algo::BinarySearch(TargetObjects, Object);
            if (ExistingIndex == INDEX_NONE)
            {
                return nullptr;
            }
 
            if (ExistingIndex >= RefCounts.Num())
            {
                RefCounts.SetNumZeroed(ExistingIndex+1, EAllowShrinking::No);
            }
 
            return &RefCounts[ExistingIndex];
        }
 
        // This won't initialize the refcount associated with the object even if it exists
        const int32* TryGetRefCountPtr(UObject* Object) const
        {
            CheckFrozen();
 
            int32 ExistingIndex = Algo::BinarySearch(TargetObjects, Object);
            if (ExistingIndex == INDEX_NONE)
            {
                return nullptr;
            }
 
            return (ExistingIndex < RefCounts.Num()) ? &RefCounts[ExistingIndex] : nullptr;
        }
 
        void ResetRefCounts()
        {
            RefCounts.Empty(TargetObjects.Num());
        }
 
        int32 RefCountNum() const
        {
            return RefCounts.Num();
        }
 
        UObject* GetObject(int32 Index) const
        {
            return TargetObjects[Index];
        }
 
        // This should not be queried past RefCountNum(), otherwise you're doing useless work.
        int32 GetRefCount(int32 Index) const
        {
            return RefCounts[Index];
        }
 
    private:
        UE_FORCEINLINE_HINT void CheckFrozen() const
        {
            checkf(bFrozen, TEXT("Container has not been frozen and cannot be searched yet"));
        }
 
        UE_FORCEINLINE_HINT void CheckUnfrozen() const
        {
            checkf(!bFrozen, TEXT("Container has been frozen and cannot be modified anymore"));
        }
 
        bool              bFrozen = false;
        TArray<UObject*>  TargetObjects;
        TArray<int32>     RefCounts;
    };
 
    FTargetObjectContainer TargetObjects;
 
    TMultiMap<class UObject*,class FProperty*> ReferenceMap;
 
    class UObject* PotentialReferencer;
 
private:
 
    COREUOBJECT_API FArchive& operator<<( class UObject*& Obj );
};