ArchiveReplaceObjectRef.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreMinimal.h"
#include "Serialization/ArchiveUObject.h"
#include "UObject/Object.h"
#include "UObject/SoftObjectPath.h"
 
class FArchiveReplaceObjectRefBase : public FArchiveUObject
{
public:
 
    int64 GetCount() const { return Count; }
 
    const UObject* GetSearchObject() const { return SearchObject; }
 
    COREUOBJECT_API const TMap<UObject*, TArray<FProperty*>>& GetReplacedReferences() const;
 
    virtual FString GetArchiveName() const { return TEXT("ReplaceObjectRef"); }
    
protected:
 
    template <typename ContainerType, typename ElementToObjectType>
    bool ShouldSkipReplacementCheckForObjectPtr(FObjectPtr& Obj, const ContainerType& ReplacementContainer, const ElementToObjectType& ElementToObject)
    {
        if (Obj.IsResolved())
        {
            return false;
        }
 
        if (!CanIgnoreUnresolvedImports.IsSet())
        {
            bool bCanIgnoreUnresolvedImportsLocal = ReplacementContainer.Num() == 0;
            if (!bCanIgnoreUnresolvedImportsLocal)
            {
                bCanIgnoreUnresolvedImportsLocal = true; // Will be set to false if any of the criteria in the loop below are met.
                for (const auto& ReplacementElem : ReplacementContainer)
                {
                    if (const UObject* ReplacementObject = ElementToObject(ReplacementElem))
                    {
                        if (ReplacementObject->GetOutermost() != GetTransientPackage())
                        {
                            bCanIgnoreUnresolvedImportsLocal = false;
                            break;
                        }
                    }
                }
            }
            CanIgnoreUnresolvedImports = bCanIgnoreUnresolvedImportsLocal;
        }
 
        if (CanIgnoreUnresolvedImports.GetValue())
        {
            return true;
        }
 
        if (UClass* ReferenceClass = Obj.GetClass())
        {
            bool bReferenceTypeIsRelatedToReplacementType = false;
            for (const auto& ReplacementElem : ReplacementContainer)
            {
                if (const UObject* ReplacementObject = ElementToObject(ReplacementElem))
                {
                    if (ReplacementObject->IsA(ReferenceClass) || Obj.IsA(ReplacementObject->GetClass()))
                    {
                        bReferenceTypeIsRelatedToReplacementType = true;
                        break;
                    }
                }
            }
            if (!bReferenceTypeIsRelatedToReplacementType)
            {
                return true;
            }
        }
 
        return false;
    }
 
    COREUOBJECT_API virtual void SerializeObject(UObject* ObjectToSerialize);
 
    UObject* SearchObject = nullptr;
 
    UObject* SerializingObject = nullptr;
 
    int32 Count = 0;
 
    TSet<UObject*> SerializedObjects;
 
    TArray<UObject*> PendingSerializationObjects;
 
    TMap<UObject*, TArray<FProperty*>> ReplacedReferences;
 
    bool bTrackReplacedReferences = false;
 
    bool bNullPrivateReferences = false;
 
    TOptional<bool> CanIgnoreUnresolvedImports;
};
 
enum class EArchiveReplaceObjectFlags
{
    None                      = 0,
 
    // References to non-public objects not contained within the SearchObject should be set to null
    NullPrivateRefs            = 1 << 0,
 
    // Do not replace Outer pointers on Objects.
    IgnoreOuterRef             = 1 << 1,
 
    // Do not replace the ObjectArchetype reference on Objects.
    IgnoreArchetypeRef         = 1 << 2,
 
    // Prevent the constructor from starting the process. Allows child classes to do initialization stuff in their constructor.
    DelayStart                 = 1 << 3,
 
    // Replace the ClassGeneratedBy reference in UClass
    IncludeClassGeneratedByRef = 1 << 4,
 
    // Populate the map of referencing objects to referencing properties
    TrackReplacedReferences    = 1 << 5
};
ENUM_CLASS_FLAGS(EArchiveReplaceObjectFlags)
 
/*----------------------------------------------------------------------------
    FArchiveReplaceObjectRef.
----------------------------------------------------------------------------*/
template< class T >
class FArchiveReplaceObjectRef : public FArchiveReplaceObjectRefBase
{
public:
    FArchiveReplaceObjectRef(UObject* InSearchObject, const TMap<T*, T*>& InReplacementMap, EArchiveReplaceObjectFlags Flags = EArchiveReplaceObjectFlags::None)
        : ReplacementMap(InReplacementMap)
    {
        bTrackReplacedReferences = !!(Flags & EArchiveReplaceObjectFlags::TrackReplacedReferences);
 
        SearchObject = InSearchObject;
        Count = 0;
        bNullPrivateReferences = !!(Flags & EArchiveReplaceObjectFlags::NullPrivateRefs);
 
        ArIsObjectReferenceCollector = true;
        ArIsModifyingWeakAndStrongReferences = true;        // Also replace weak references too!
        ArIgnoreArchetypeRef = !!(Flags & EArchiveReplaceObjectFlags::IgnoreArchetypeRef);
        ArIgnoreOuterRef = !!(Flags & EArchiveReplaceObjectFlags::IgnoreOuterRef);
        ArIgnoreClassGeneratedByRef = !(Flags & EArchiveReplaceObjectFlags::IncludeClassGeneratedByRef);
 
        if (!(Flags & EArchiveReplaceObjectFlags::DelayStart))
        {
            SerializeSearchObject();
        }
    }
 
    UE_DEPRECATED(5.0, "Use version that supplies flags via enum.")
    FArchiveReplaceObjectRef
    (
        UObject* InSearchObject,
        const TMap<T*,T*>& inReplacementMap,
        bool bNullPrivateRefs,
        bool bIgnoreOuterRef,
        bool bIgnoreArchetypeRef,
        bool bDelayStart = false,
        bool bIgnoreClassGeneratedByRef = true
    )
    : FArchiveReplaceObjectRef(InSearchObject, inReplacementMap,
          (bNullPrivateRefs ? EArchiveReplaceObjectFlags::NullPrivateRefs : EArchiveReplaceObjectFlags::None)
        | (bIgnoreOuterRef ? EArchiveReplaceObjectFlags::IgnoreOuterRef : EArchiveReplaceObjectFlags::None)
        | (bIgnoreArchetypeRef ? EArchiveReplaceObjectFlags::IgnoreArchetypeRef : EArchiveReplaceObjectFlags::None)
        | (bDelayStart ? EArchiveReplaceObjectFlags::DelayStart : EArchiveReplaceObjectFlags::None)
        | (!bIgnoreClassGeneratedByRef ? EArchiveReplaceObjectFlags::IncludeClassGeneratedByRef : EArchiveReplaceObjectFlags::None))
    {
    }
 
    void SerializeSearchObject()
    {
        ReplacedReferences.Reset();
 
        if (SearchObject != NULL && !SerializedObjects.Find(SearchObject)
        &&  (ReplacementMap.Num() > 0 || bNullPrivateReferences))
        {
            // start the initial serialization
            SerializedObjects.Add(SearchObject);
            SerializingObject = SearchObject;
            SerializeObject(SearchObject);
            for (int32 Iter = 0; Iter < PendingSerializationObjects.Num(); Iter++)
            {
                SerializingObject = PendingSerializationObjects[Iter];
                SerializeObject(SerializingObject);
            }
            PendingSerializationObjects.Reset();
        }
    }
 
    virtual FArchive& operator<<( UObject*& Obj ) override
    {
        if (Obj != NULL)
        {
            // If these match, replace the reference
            if (T* const* ReplaceWith = (T* const*)((const TMap<UObject*, UObject*>*)&ReplacementMap)->Find(Obj))
            {
                Obj = *ReplaceWith;
                if (bTrackReplacedReferences)
                {
                    ReplacedReferences.FindOrAdd(SerializingObject).AddUnique(GetSerializedProperty());
                }
                Count++;
            }
            // A->IsIn(A) returns false, but we don't want to NULL that reference out, so extra check here.
            else if ( Obj == SearchObject || Obj->IsIn(SearchObject) )
            {
#if 0
                // DEBUG: Log when we are using the A->IsIn(A) path here.
                if(Obj == SearchObject)
                {
                    FString ObjName = Obj->GetPathName();
                    UE_LOG(LogSerialization, Log,  TEXT("FArchiveReplaceObjectRef: Obj == SearchObject : '%s'"), *ObjName );
                }
#endif
                bool bAlreadyAdded = false;
                SerializedObjects.Add(Obj, &bAlreadyAdded);
                if (!bAlreadyAdded)
                {
                    // No recursion
                    PendingSerializationObjects.Add(Obj);
                }
            }
            else if ( bNullPrivateReferences && !Obj->HasAnyFlags(RF_Public) )
            {
                Obj = NULL;
            }
        }
        return *this;
    }
 
    FArchive& operator<<( FObjectPtr& Obj )
    {
        if (ShouldSkipReplacementCheckForObjectPtr(Obj, ReplacementMap, [] (const TPair<T*, T*>& ReplacementPair) -> const UObject*
            {
                return ReplacementPair.Key;
            }))
        {
            return *this;
        }
 
        // Allow object references to go through the normal code path of resolving and running the raw pointer code path
        return FArchiveReplaceObjectRefBase::operator<<(Obj);
    }
 
    virtual FArchive& operator<<(FSoftObjectPath& Value) override 
    {
        if (UObject* Obj = Value.ResolveObject())
        {
            *this << Obj;
            Value = Obj;
        }
        else
        {
            FArchiveReplaceObjectRefBase::operator<<(Value);
        }
        return *this;
    }
 
protected:
    const TMap<T*,T*>& ReplacementMap;
    
};