ArchiveScriptReferenceCollector.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "UObject/Field.h"
#include "UObject/Object.h"
#include "UObject/ObjectPtr.h"
#include "UObject/UObjectGlobals.h"
#include "Serialization/ArchiveUObject.h"
 
class FPropertyReferenceCollector : public FReferenceCollector
{
    UObject* ExcludeOwner;
    TArray<UObject*>& UniqueReferences;
public:
    FPropertyReferenceCollector(UObject* InExcludeOwner, TArray<UObject*>& InUniqueReferences)
        : ExcludeOwner(InExcludeOwner)
        , UniqueReferences(InUniqueReferences)
    {
    }
 
    virtual bool IsIgnoringArchetypeRef() const override { return false; }
    virtual bool IsIgnoringTransient() const override { return false; }
    virtual void HandleObjectReference(UObject*& InObject, const UObject* InReferencingObject, const FProperty* InReferencingProperty) override
    {
        // Skip nulls and the owner object
        if (InObject != nullptr && InObject != ExcludeOwner)
        {
            // Don't collect objects that will never be GC'd anyway
            if (!InObject->HasAnyInternalFlags(EInternalObjectFlags::Native) && !GUObjectArray.IsDisregardForGC(InObject) && !UniqueReferences.Contains(InObject))
            {
                UniqueReferences.Add(InObject);
            }
        }
    }
};
 
/*******************************************************************************
 * FArchiveScriptReferenceCollector
 ******************************************************************************/
 
class FArchiveScriptReferenceCollector : public FArchiveUObject
{
public:
    explicit FArchiveScriptReferenceCollector(TArray<UObject*>& InObjectArray, UObject* InExcludeOwner = nullptr)
        : ObjectArray(InObjectArray)
        , ExcludeOwner(InExcludeOwner)
    {
        ArIsObjectReferenceCollector = true;
        this->SetIsPersistent(false);
        ArIgnoreArchetypeRef = false;
    }
protected:
    virtual FArchive& operator<<(UObject*& Object) override
    {
        // Avoid duplicate entries.
        if (Object != nullptr && Object != ExcludeOwner && !ObjectArray.Contains(Object))
        {
            check(Object->IsValidLowLevel());
            ObjectArray.Add(Object);
        }
        return *this;
    }
 
    virtual FArchive& operator<<(FObjectPtr& Object) override
    {
        if (Object.IsResolved())
        {
            UObject* Obj = Object.Get();
            FArchive& Ar = *this << Obj;
            return Ar;
        }
        return *this;
    }
 
    virtual FArchive& operator<<(FField*& Field) override
    {
        if (Field != nullptr)
        {
            // It's faster to collect references via AddReferencedObjects than serialization
            FPropertyReferenceCollector Collector(ExcludeOwner, ObjectArray);
            Field->AddReferencedObjects(Collector);
        }
        return *this;
    }
 
    TArray<UObject*>&       ObjectArray;
    UObject*                ExcludeOwner;
};