UObjectIterator.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    UObjectIterator.h: High level iterators for uobject
=============================================================================*/
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/GarbageCollectionGlobals.h"
#include "UObject/UObjectHash.h"
#include "UObject/UObjectArray.h"
#include "UObject/ObjectVisibility.h"
#include "UObject/Object.h"
#include "UObject/Class.h"
 
class FRawObjectIterator : public FUObjectArray::TIterator
{
public:
    FRawObjectIterator(bool bOnlyGCedObjects = false) :
        FUObjectArray::TIterator( GUObjectArray, bOnlyGCedObjects )
    {
    }
    UE_FORCEINLINE_HINT FUObjectItem* operator*() const
    {
        // casting UObjectBase to UObject for clients
        return GetObject();
    }
    UE_FORCEINLINE_HINT FUObjectItem* operator->() const
    {
        return GetObject();
    }
};
 
 
 
enum class EObjectIteratorThreadSafetyOptions : uint8
{
    None = 0,
    ThreadSafe = 1, // Use only with function local iterators. Persistent iterators may prevent (hang) UObject creation on worker threads otherwise.
    ThreadSafeAdvance = 2 // Can be used for global iterators but locks the global UObjectArray each time the iterator advances to the next object (can be slow but does not result in deadlocks).
};
 
inline EInternalObjectFlags GetObjectIteratorDefaultInternalExclusionFlags(EInternalObjectFlags InternalExclusionFlags)
{
    return InternalExclusionFlags | EInternalObjectFlags::Unreachable | EInternalObjectFlags::AutoRTFMConstructionAborted | EInternalObjectFlags::PendingConstruction | UE::GetAsyncLoadingInternalFlagsExclusion()
#if UE_WITH_REMOTE_OBJECT_HANDLE
        | EInternalObjectFlags::Remote
#endif
        ;
}
 
template <EObjectIteratorThreadSafetyOptions IteratorThreadSafety>
class TObjectIteratorBase : public FUObjectArray::TIterator
{
protected:
 
    inline bool AdvanceIterator()
    {
        bool bResult = false;
        if (IteratorThreadSafety != EObjectIteratorThreadSafetyOptions::ThreadSafeAdvance)
        {
            bResult = Advance();
        }
        else
        {
            GetIteratedArray().LockInternalArray();
            bResult = Advance();
            GetIteratedArray().UnlockInternalArray();
        }
        return bResult;
    }
 
public:
 
    explicit TObjectIteratorBase(UClass* InClass = UObject::StaticClass(), bool bOnlyGCedObjects = false, EObjectFlags AdditionalExclusionFlags = RF_NoFlags, EInternalObjectFlags InInternalExclusionFlags = EInternalObjectFlags::None)
        : FUObjectArray::TIterator(GUObjectArray, bOnlyGCedObjects)
        , Class(InClass)
        , ExclusionFlags(AdditionalExclusionFlags)
        , InternalExclusionFlags(GetObjectIteratorDefaultInternalExclusionFlags(InInternalExclusionFlags))
    {
        check(Class);
 
        if (IteratorThreadSafety == EObjectIteratorThreadSafetyOptions::ThreadSafe)
        {
            GetIteratedArray().LockInternalArray();
        }
 
        do
        {
            UObject* Object = **this;
            if (!(Object->HasAnyFlags(ExclusionFlags) || Object->HasAnyInternalFlags(InternalExclusionFlags) || (Class != UObject::StaticClass() && !Object->IsA(Class))))
            {
                break;
            }
        } while (AdvanceIterator());
    }
 
    TObjectIteratorBase(FUObjectArray::TIterator::EEndTagType, const TObjectIteratorBase& Begin)
        : FUObjectArray::TIterator(FUObjectArray::TIterator::EndTag, Begin)
        , Class(Begin.Class)
        , ExclusionFlags(Begin.ExclusionFlags)
        , InternalExclusionFlags(Begin.InternalExclusionFlags)
    {
        if (IteratorThreadSafety == EObjectIteratorThreadSafetyOptions::ThreadSafe)
        {
            GetIteratedArray().LockInternalArray();
        }
    }
 
    TObjectIteratorBase(const TObjectIteratorBase& Other)
        : FUObjectArray::TIterator(Other)
        , Class(Other.Class)
        , ExclusionFlags(Other.ExclusionFlags)
        , InternalExclusionFlags(Other.InternalExclusionFlags)
    {
        if (IteratorThreadSafety == EObjectIteratorThreadSafetyOptions::ThreadSafe)
        {
            GetIteratedArray().LockInternalArray();
        }
    }
 
    ~TObjectIteratorBase()
    {
        if (IteratorThreadSafety == EObjectIteratorThreadSafetyOptions::ThreadSafe)
        {
            GetIteratedArray().UnlockInternalArray();
        }
    }
 
    void operator++()
    {
        //@warning: behavior is partially mirrored in UnObjGC.cpp. Make sure to adapt code there as well if you make changes below.
        // verify that the async loading exclusion flag still matches (i.e. we didn't start/stop async loading within the scope of the iterator)
        checkSlow(IsInAsyncLoadingThread() || int32(InternalExclusionFlags & EInternalObjectFlags_AsyncLoading));
 
        while (AdvanceIterator())
        {
            UObject* Object = **this;
            if (!(Object->HasAnyFlags(ExclusionFlags) || (Class != UObject::StaticClass() && !Object->IsA(Class)) || Object->HasAnyInternalFlags(InternalExclusionFlags)))
            {
                break;
            }
        }
    }
    inline UObject* operator*() const
    {
        // casting UObjectBase to UObject for clients
        FUObjectItem* ObjectItem = GetObject();
        return (UObject*)(ObjectItem ? ObjectItem->GetObject() : nullptr);
    }
    inline UObject* operator->() const
    {
        FUObjectItem* ObjectItem = GetObject();
        return (UObject*)(ObjectItem ? ObjectItem->GetObject() : nullptr);
    }
private:
    UClass* Class;
protected:
    EObjectFlags ExclusionFlags;
    EInternalObjectFlags InternalExclusionFlags;
};
 
typedef TObjectIteratorBase<EObjectIteratorThreadSafetyOptions::None> FUnsafeObjectIterator;
 
UE_DEPRECATED(4.27, "FObjectIterator is not thread safe, use FThreadSafeObjectIterator or FPresistentThreadSafeObjectIterator instead.")
typedef FUnsafeObjectIterator FObjectIterator;
 
 
typedef TObjectIteratorBase<EObjectIteratorThreadSafetyOptions::ThreadSafe> FThreadSafeObjectIterator;
 
typedef TObjectIteratorBase<EObjectIteratorThreadSafetyOptions::ThreadSafeAdvance> FPersistentThreadSafeObjectIterator;
 
template< class T > class TObjectIterator
{
public:
    enum EEndTagType
    {
        EndTag
    };
 
    explicit TObjectIterator(EObjectFlags AdditionalExclusionFlags = RF_ClassDefaultObject, bool bIncludeDerivedClasses = true, EInternalObjectFlags InInternalExclusionFlags = EInternalObjectFlags::None)
        : Index(-1)
    {
        GetObjectsOfClass(T::StaticClass(), ObjectArray, bIncludeDerivedClasses, AdditionalExclusionFlags, GetObjectIteratorDefaultInternalExclusionFlags(InInternalExclusionFlags));
        Advance();
    }
 
    TObjectIterator(EEndTagType, const TObjectIterator& Begin)
        : Index(Begin.ObjectArray.Num())
    {
    }
 
    UE_FORCEINLINE_HINT void operator++()
    {
        Advance();
    }
 
    UE_FORCEINLINE_HINT explicit operator bool() const
    { 
        return ObjectArray.IsValidIndex(Index); 
    }
    UE_FORCEINLINE_HINT bool operator !() const 
    {
        return !(bool)*this;
    }
 
    FUNCTION_NON_NULL_RETURN_START
        UE_FORCEINLINE_HINT T* operator* () const
    FUNCTION_NON_NULL_RETURN_END
    {
        return (T*)GetObject();
    }
    FUNCTION_NON_NULL_RETURN_START
        UE_FORCEINLINE_HINT T* operator-> () const
    FUNCTION_NON_NULL_RETURN_END
    {
        return (T*)GetObject();
    }
 
    UE_FORCEINLINE_HINT bool operator==(const TObjectIterator& Rhs) const { return Index == Rhs.Index; }
    UE_FORCEINLINE_HINT bool operator!=(const TObjectIterator& Rhs) const { return Index != Rhs.Index; }
 
protected:
    UE_FORCEINLINE_HINT UObject* GetObject() const 
    { 
        return ObjectArray[Index];
    }
    
    inline bool Advance()
    {
        //@todo UE check this for LHS on Index on consoles
        while(++Index < ObjectArray.Num())
        {
            if (GetObject())
            {
                return true;
            }
        }
        return false;
    }
 
protected:
    TArray<UObject*> ObjectArray;
    int32 Index;
};
 
template<> class TObjectIterator<UObject> : public FThreadSafeObjectIterator
{
public:
 
    explicit TObjectIterator(EObjectFlags AdditionalExclusionFlags = RF_ClassDefaultObject, bool bIncludeDerivedClasses = true, EInternalObjectFlags InInternalExclusionFlags = EInternalObjectFlags::None)
        : FThreadSafeObjectIterator(UObject::StaticClass(), false, AdditionalExclusionFlags, GetObjectIteratorDefaultInternalExclusionFlags(InInternalExclusionFlags))
    {
    }
 
    explicit TObjectIterator(bool bOnlyGCedObjects) :
        FThreadSafeObjectIterator(UObject::StaticClass(), bOnlyGCedObjects, RF_ClassDefaultObject)
    {
    }
 
    TObjectIterator(TObjectIteratorBase::EEndTagType, const TObjectIterator& Begin) :
        FThreadSafeObjectIterator(FUObjectArray::TIterator::EndTag, Begin)
    {
    }
 
    void operator++()
    {
        // verify that the async loading exclusion flag still matches (i.e. we didn't start/stop async loading within the scope of the iterator)
        checkSlow(IsInAsyncLoadingThread() || int32(InternalExclusionFlags & EInternalObjectFlags_AsyncLoading));
        while (AdvanceIterator())
        {
            if (!(*this)->HasAnyFlags(ExclusionFlags) && !(*this)->HasAnyInternalFlags(InternalExclusionFlags))
            {
                break;
            }
        }
    }
};
 
template <typename T>
struct TObjectRange
{
    TObjectRange(EObjectFlags AdditionalExclusionFlags = RF_ClassDefaultObject, bool bIncludeDerivedClasses = true, EInternalObjectFlags InInternalExclusionFlags = EInternalObjectFlags::None)
    : Begin(AdditionalExclusionFlags, bIncludeDerivedClasses, InInternalExclusionFlags)
    {
    }
 
    friend TObjectIterator<T> begin(const TObjectRange& Range) { return Range.Begin; }
    friend TObjectIterator<T> end  (const TObjectRange& Range) { return TObjectIterator<T>(TObjectIterator<T>::EndTag, Range.Begin); }
 
    TObjectIterator<T> Begin;
};
 
template <>
struct TObjectRange<UObject>
{
    explicit TObjectRange(EObjectFlags AdditionalExclusionFlags = RF_ClassDefaultObject, bool bIncludeDerivedClasses = true, EInternalObjectFlags InInternalExclusionFlags = EInternalObjectFlags::None)
    : Begin(AdditionalExclusionFlags, bIncludeDerivedClasses, InInternalExclusionFlags)
    {
    }
 
    explicit TObjectRange(bool bOnlyGCedObjects)
        : Begin(bOnlyGCedObjects)
    {
    }
 
    friend TObjectIterator<UObject> begin(const TObjectRange& Range) { return Range.Begin; }
    friend TObjectIterator<UObject> end  (const TObjectRange& Range) { return TObjectIterator<UObject>(TObjectIterator<UObject>::EndTag, Range.Begin); }
 
    TObjectIterator<UObject> Begin;
};