RedirectCollector.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    RedirectCollector:  Editor-only global object that handles resolving redirectors and handling string asset cooking rules
=============================================================================*/
 
#pragma once
 
#include "Async/UniqueLock.h"
#include "Containers/Map.h"
#include "Containers/Set.h"
#include "Containers/SparseArray.h"
#include "CoreMinimal.h"
#include "HAL/CriticalSection.h"
#include "HAL/Platform.h"
#include "Misc/ScopeLock.h"
#include "Misc/TVariant.h"
#include "Templates/Function.h"
#include "Templates/TypeHash.h"
#include "Templates/UniquePtr.h"
#include "UObject/NameTypes.h"
#include "UObject/SoftObjectPath.h"
#include "UObject/UnrealNames.h"
 
class FArchive;
 
#if WITH_EDITOR
 
enum class ESoftObjectPathCollectType : uint8;
 
class FRedirectCollector
{
private:
    
    struct FSoftObjectPathProperty
    {
        FSoftObjectPathProperty(FSoftObjectPath InObjectPath, FName InProperty, bool bInReferencedByEditorOnlyProperty)
            : ObjectPath(MoveTemp(InObjectPath))
            , PropertyName(InProperty)
            , bReferencedByEditorOnlyProperty(bInReferencedByEditorOnlyProperty)
        {}
 
         bool operator==(const FSoftObjectPathProperty& Other) const
         {
            return ObjectPath == Other.ObjectPath &&
                PropertyName == Other.PropertyName &&
                bReferencedByEditorOnlyProperty == Other.bReferencedByEditorOnlyProperty;
         }
 
        friend inline uint32 GetTypeHash(const FSoftObjectPathProperty& Key)
        {
            uint32 Hash = 0;
            Hash = HashCombine(Hash, GetTypeHash(Key.ObjectPath));
            Hash = HashCombine(Hash, GetTypeHash(Key.PropertyName));
            Hash = HashCombine(Hash, (uint32)Key.bReferencedByEditorOnlyProperty);
            return Hash;
        }
 
        const FSoftObjectPath& GetObjectPath() const
        {
            return ObjectPath;
        }
 
        const FName& GetPropertyName() const
        {
            return PropertyName;
        }
 
        bool GetReferencedByEditorOnlyProperty() const
        {
            return bReferencedByEditorOnlyProperty;
        }
 
    private:
        FSoftObjectPath ObjectPath;
        FName PropertyName;
        bool bReferencedByEditorOnlyProperty;
    };
 
public:
 
    COREUOBJECT_API void OnSoftObjectPathLoaded(const struct FSoftObjectPath& InPath, FArchive* InArchive);
 
    COREUOBJECT_API void CollectSavedSoftPackageReferences(FName ReferencingPackage, const TSet<FName>& PackageNames, bool bEditorOnlyReferences);
 
    COREUOBJECT_API void ResolveAllSoftObjectPaths(FName FilterPackage = NAME_None);
 
    COREUOBJECT_API void ProcessSoftObjectPathPackageList(FName FilterPackage, bool bGetEditorOnly, TSet<FName>& OutReferencedPackages);
 
    COREUOBJECT_API void AddAssetPathRedirection(const FSoftObjectPath& OriginalPath, const FSoftObjectPath& RedirectedPath);
 
    COREUOBJECT_API void RemoveAssetPathRedirection(const FSoftObjectPath& OriginalPath);
 
    COREUOBJECT_API FSoftObjectPath GetAssetPathRedirection(const FSoftObjectPath& OriginalPath) const;
 
    bool HasAnySoftObjectPathsToResolve() const
    {
        return SoftObjectPathMap.Num() > 0;
    }
 
    COREUOBJECT_API bool RemoveAndCopySoftObjectPathExclusions(FName PackageName, TSet<FName>& OutExcludedReferences);
 
    COREUOBJECT_API void OnStartupPackageLoadComplete();
 
    UE_DEPRECATED(5.6, "Use EnumerateRedirectsUnderLock instead.")
    COREUOBJECT_API const TMap<FSoftObjectPath, FSoftObjectPath>&
    GetObjectPathRedirectionMapUnderLock(const UE::TDynamicUniqueLock<FCriticalSection>& Lock) const;
 
    struct FRedirectionData
    {
    public:
        const FSoftObjectPath& GetSource() const;
        const FSoftObjectPath& GetFirstTarget() const;
        const FSoftObjectPath& GetFinalTarget() const;
 
    private:
        const FSoftObjectPath& Source;
        const FSoftObjectPath& FirstTarget;
        const FSoftObjectPath& FinalTarget;
        FRedirectionData(const FSoftObjectPath& InSource, const FSoftObjectPath& InFirstTarget,
            const FSoftObjectPath& InFinalTarget);
        friend FRedirectCollector;
    };
    COREUOBJECT_API void EnumerateRedirectsUnderLock(TFunctionRef<void(FRedirectionData&)>) const;
 
    COREUOBJECT_API void GetAllSourcePathsForTargetPath(const FSoftObjectPath& TargetPath, TArray<FSoftObjectPath>& OutSourcePaths) const;
 
    UE_DEPRECATED(5.6, "Use EnumerateRedirectsUnderLock instead.")
    UE::TDynamicUniqueLock<FCriticalSection> AcquireLock() const
    {
        return UE::TDynamicUniqueLock<FCriticalSection>(CriticalSection);
    }
 
private:
    
    void AddObjectPathRedirectionInternal(const FSoftObjectPath& Source, const FSoftObjectPath& Destination);
 
    bool TryRemoveObjectPathRedirectionInternal(const FSoftObjectPath& Source);
 
    const FSoftObjectPath& TraverseToFinalTarget(const FSoftObjectPath* FirstTarget) const;
 
    typedef TSet<FSoftObjectPathProperty> FSoftObjectPathPropertySet;
    typedef TMap<FName, FSoftObjectPathPropertySet> FSoftObjectPathMap;
 
    bool ShouldTrackPackageReferenceTypes();
 
    FSoftObjectPathMap SoftObjectPathMap;
    TMap<FName, TMap<FName, ESoftObjectPathCollectType>> PackageReferenceTypes;
 
    struct FChainedRedirectionData
    {
        FSoftObjectPath FirstTarget;
        FSoftObjectPath FinalTarget;
    };
    struct FSimpleOrChainedRedirect
    {
    public:
        FSimpleOrChainedRedirect();
        FSimpleOrChainedRedirect(FSoftObjectPath InSimpleTarget);
        FSimpleOrChainedRedirect(FSoftObjectPath InFirstTarget, FSoftObjectPath InFinalTarget);
        static FSimpleOrChainedRedirect ConstructSimpleOrChained(FSoftObjectPath InFirstTarget,
            FSoftObjectPath InFinalTarget);
 
        const FSoftObjectPath& GetFirstTarget() const;
        const FSoftObjectPath& GetFinalTarget() const;
        bool IsSimpleRedirect() const;
        bool IsChainedRedirect() const;
 
    private:
        TVariant<FSoftObjectPath, TUniquePtr<FChainedRedirectionData>> Data;
    };
    TMap<FSoftObjectPath, FSimpleOrChainedRedirect> ObjectPathRedirectionMap;
 
    typedef TArray<FSoftObjectPath, TInlineAllocator<1>> ObjectPathSourcesArray;
    TMap<FSoftObjectPath, TArray<FSoftObjectPath, TInlineAllocator<1>>> ObjectPathRedirectionReverseMap;
 
    mutable FCriticalSection CriticalSection;
 
    enum class ETrackingReferenceTypesState : uint8
    {
        Uninitialized,
        Disabled,
        Enabled,
    };
    ETrackingReferenceTypesState TrackingReferenceTypesState;
 
    friend class FRedirectCollectorReverseLookupTest;
};
 
// global redirect collector callback structure
COREUOBJECT_API extern FRedirectCollector GRedirectCollector;
 
 
// Inline implementations
 
 
inline FRedirectCollector::FSimpleOrChainedRedirect::FSimpleOrChainedRedirect()
    : Data(TInPlaceType<FSoftObjectPath>(), FSoftObjectPath())
{
}
 
inline FRedirectCollector::FSimpleOrChainedRedirect::FSimpleOrChainedRedirect(
    FSoftObjectPath InSimpleTarget)
    : Data(TInPlaceType<FSoftObjectPath>(), MoveTemp(InSimpleTarget))
{
}
 
inline FRedirectCollector::FSimpleOrChainedRedirect::FSimpleOrChainedRedirect(
    FSoftObjectPath InFirstTarget, FSoftObjectPath InFinalTarget)
    : Data(TInPlaceType<TUniquePtr<FChainedRedirectionData>>(),
        new FChainedRedirectionData{ MoveTemp(InFirstTarget), MoveTemp(InFinalTarget) })
{
}
 
inline FRedirectCollector::FSimpleOrChainedRedirect
FRedirectCollector::FSimpleOrChainedRedirect::ConstructSimpleOrChained(
    FSoftObjectPath InFirstTarget, FSoftObjectPath InFinalTarget)
{
    return InFirstTarget == InFinalTarget
        ? FSimpleOrChainedRedirect(MoveTemp(InFirstTarget))
        : FSimpleOrChainedRedirect(MoveTemp(InFirstTarget), MoveTemp(InFinalTarget));
}
 
inline const FSoftObjectPath& FRedirectCollector::FSimpleOrChainedRedirect::GetFirstTarget() const
{
    return IsSimpleRedirect()
        ? Data.Get<FSoftObjectPath>()
        : Data.Get<TUniquePtr<FChainedRedirectionData>>()->FirstTarget;
}
 
inline const FSoftObjectPath& FRedirectCollector::FSimpleOrChainedRedirect::GetFinalTarget() const
{
    return IsSimpleRedirect()
        ? Data.Get<FSoftObjectPath>()
        : Data.Get<TUniquePtr<FChainedRedirectionData>>()->FinalTarget;
}
 
inline bool FRedirectCollector::FSimpleOrChainedRedirect::IsSimpleRedirect() const
{
    return Data.IsType<FSoftObjectPath>();
}
 
inline bool FRedirectCollector::FSimpleOrChainedRedirect::IsChainedRedirect() const
{
    return Data.IsType<TUniquePtr<FChainedRedirectionData>>();
}
 
inline const FSoftObjectPath& FRedirectCollector::FRedirectionData::GetSource() const
{
    return Source;
}
 
inline const FSoftObjectPath& FRedirectCollector::FRedirectionData::GetFirstTarget() const
{
    return FirstTarget;
}
 
inline const FSoftObjectPath& FRedirectCollector::FRedirectionData::GetFinalTarget() const
{
    return FinalTarget;
}
 
inline FRedirectCollector::FRedirectionData::FRedirectionData(const FSoftObjectPath& InSource,
    const FSoftObjectPath& InFirstTarget, const FSoftObjectPath& InFinalTarget)
    : Source(InSource), FirstTarget(InFirstTarget), FinalTarget(InFinalTarget)
{
}
 
#endif // WITH_EDITOR