CoreRedirects.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
/*=============================================================================
    CoreRedirects.h: Object/Class/Field redirects read from ini files or registered at startup
=============================================================================*/
 
#pragma once
 
#include "Containers/Array.h"
#include "Containers/ArrayView.h"
#include "Containers/Map.h"
#include "Containers/SparseArray.h"
#include "Containers/UnrealString.h"
#include "CoreMinimal.h"
#include "CoreTypes.h"
#include "Misc/TransactionallySafeRWLock.h"
#include "Misc/EnumClassFlags.h"
#include "Templates/SharedPointer.h"
#include "UObject/NameTypes.h"
#include "UObject/UnrealNames.h"
 
// TODO: Internal headers should not be included
#include "Runtime/CoreUObject/Internal/UObject/CoreRedirects/PM-k.h"
 
class FBlake3;
class IPakFile;
class UClass;
struct FSoftObjectPath;
struct FTopLevelAssetPath;
struct FCoreRedirectsContext;
struct FScopeCoreRedirectsReadLockedContext;
struct FScopeCoreRedirectsWriteLockedContext;
namespace UE::CoreRedirects::Private { struct FCoreRedirectObjectUtf8Name; }
 
DECLARE_LOG_CATEGORY_EXTERN(LogCoreRedirects, Log, All);
 
enum class ECoreRedirectFlags : uint32
{
    None = 0,
 
    // Core type of the Thing being redirected, multiple can be set.  A Query will only find Redirects that have at least one of the same Type bits set.
    Type_Object =               0x00000001, // UObject
    Type_Class =                0x00000002, // UClass
    Type_Struct =               0x00000004, // UStruct
    Type_Enum =                 0x00000008, // UEnum
    Type_Function =             0x00000010, // UFunction
    Type_Property =             0x00000020, // FProperty
    Type_Package =              0x00000040, // UPackage
    Type_Asset =                0x00000080, // Redirects derived from UObjectRedirectors. Implicitly included with other search types
    Type_AllMask =              0x0000FFFF, // Bit mask of all possible Types
 
    // Category flags.  A Query will only match Redirects that have the same value for every category bit.
    Category_InstanceOnly =     0x00010000, // Only redirect instances of this type, not the type itself
    Category_Removed =          0x00020000, // This type was explicitly removed, new name isn't valid
    Category_AllMask =          0x00FF0000, // Bit mask of all possible Categories
 
    // Option flags.  Does not behave as a bit-match between Queries and Redirects.  Each one specifies a custom rule for how FCoreRedirects handles the Redirect.
    Option_MatchPrefix =        0x01000000, // Does a prefix string match
    Option_MatchSuffix =        0x02000000, // Does a suffix string match
    Option_MatchSubstring =     Option_MatchPrefix | Option_MatchSuffix, // Does a slow substring match
    Option_MatchWildcardMask =  Option_MatchSubstring, // Bit mask of all possible wildcards
 
    Option_MissingLoad =        0x04000000, // An automatically-created redirect that was created in response to a missing Thing during load. Redirect will be removed if and when the Thing is loaded.
    Option_AllMask =            0xFF000000, // Bit mask of all possible Options
};
ENUM_CLASS_FLAGS(ECoreRedirectFlags);
 
enum class ECoreRedirectMatchFlags
{
    None = 0,
    AllowPartialMatch = (1 << 0),
    DisallowPartialLHSMatch = (1<<1)
};
ENUM_CLASS_FLAGS(ECoreRedirectMatchFlags);
 
struct FCoreRedirectObjectName
{
    FName ObjectName;
 
    FName OuterName;
 
    FName PackageName;
 
    FCoreRedirectObjectName() = default;
 
    FCoreRedirectObjectName(FName InObjectName, FName InOuterName, FName InPackageName)
        : ObjectName(InObjectName), OuterName(InOuterName), PackageName(InPackageName)
    {
 
    }
 
    COREUOBJECT_API FCoreRedirectObjectName(const FTopLevelAssetPath& TopLevelAssetPath);
 
    COREUOBJECT_API FCoreRedirectObjectName(const FSoftObjectPath& SoftObjectPath);
 
    COREUOBJECT_API FCoreRedirectObjectName(const FString& InString);
 
    COREUOBJECT_API FCoreRedirectObjectName(const class UObject* Object);
 
    COREUOBJECT_API FString ToString() const;
 
    COREUOBJECT_API void Reset();
 
    bool operator==(const FCoreRedirectObjectName& Other) const
    {
        return ObjectName == Other.ObjectName && OuterName == Other.OuterName && PackageName == Other.PackageName;
    }
 
    bool operator!=(const FCoreRedirectObjectName& Other) const
    {
        return !(*this == Other);
    }
 
    COREUOBJECT_API int Compare(const FCoreRedirectObjectName& Other) const;
 
    enum class EMatchFlags
    {
        None = 0,
        DisallowPartialLHSMatch = (1 << 0),
        AllowPartialRHSMatch = (1 << 1),
        CheckSubString = (1 << 2),
        CheckPrefix = (1 << 3),
        CheckSuffix = (1 << 4),
    };
    COREUOBJECT_API bool Matches(const FCoreRedirectObjectName& Other, EMatchFlags MatchFlags = EMatchFlags::None) const;
 
    COREUOBJECT_API int32 MatchScore(const FCoreRedirectObjectName& Other, ECoreRedirectFlags RedirectFlags, ECoreRedirectMatchFlags MatchFlags) const;
 
    COREUOBJECT_API void UnionFieldsInline(const FCoreRedirectObjectName& Other);
 
    FName GetSearchKey(ECoreRedirectFlags Type) const;
 
    bool IsValid() const
    {
        return ObjectName != NAME_None || PackageName != NAME_None;
    }
 
    friend uint32 GetTypeHash(const FCoreRedirectObjectName& RedirectName)
    {
        return HashCombine(GetTypeHash(RedirectName.ObjectName), HashCombine(GetTypeHash(RedirectName.OuterName), GetTypeHash(RedirectName.PackageName)));
    }
 
    COREUOBJECT_API bool HasValidCharacters(ECoreRedirectFlags Type) const;
 
    COREUOBJECT_API void AppendHash(FBlake3& Hasher) const;
 
    static COREUOBJECT_API bool ExpandNames(const FStringView FullString, FName& OutName, FName& OutOuter, FName& OutPackage);
 
    static COREUOBJECT_API FString CombineNames(FName NewName, FName NewOuter, FName NewPackage);
 
    static COREUOBJECT_API FCoreRedirectObjectName
        AppendObjectName(const FCoreRedirectObjectName& Parent, FName ObjectName);
    static COREUOBJECT_API FCoreRedirectObjectName GetParent(const FCoreRedirectObjectName& Child);
};
ENUM_CLASS_FLAGS(FCoreRedirectObjectName::EMatchFlags);
 
struct FCoreRedirect
{
    ECoreRedirectFlags RedirectFlags;
 
    FCoreRedirectObjectName OldName;
 
    FCoreRedirectObjectName NewName;
 
    FCoreRedirectObjectName OverrideClassName;
 
    TMap<FString, FString> ValueChanges;
 
    FCoreRedirect(ECoreRedirectFlags InRedirectFlags, FString InOldName, FString InNewName)
        : RedirectFlags(InRedirectFlags), OldName(InOldName), NewName(InNewName)
    {
        NormalizeNewName();
    }
    
    FCoreRedirect(ECoreRedirectFlags InRedirectFlags, const FCoreRedirectObjectName& InOldName, const FCoreRedirectObjectName& InNewName)
        : RedirectFlags(InRedirectFlags), OldName(InOldName), NewName(InNewName)
    {
        NormalizeNewName();
    }
 
    COREUOBJECT_API void NormalizeNewName();
 
    COREUOBJECT_API const TCHAR* ParseValueChanges(const TCHAR* Buffer);
 
    COREUOBJECT_API bool Matches(ECoreRedirectFlags InFlags, const FCoreRedirectObjectName& InName,
        ECoreRedirectMatchFlags MatchFlags = ECoreRedirectMatchFlags::None) const;
    COREUOBJECT_API bool Matches(const FCoreRedirectObjectName& InName,
        ECoreRedirectMatchFlags MatchFlags = ECoreRedirectMatchFlags::None) const;
 
    COREUOBJECT_API bool HasValueChanges() const;
 
    COREUOBJECT_API bool IsSubstringMatch() const;
 
    COREUOBJECT_API FCoreRedirectObjectName RedirectName(const FCoreRedirectObjectName& OldObjectName) const;
 
    COREUOBJECT_API bool IdenticalMatchRules(const FCoreRedirect& Other) const;
 
    FName GetSearchKey() const
    {
        return OldName.GetSearchKey(RedirectFlags);
    }
 
    COREUOBJECT_API void AppendHash(FBlake3& Hasher) const;
    COREUOBJECT_API int Compare(const FCoreRedirect& Other) const;
 
private:
    friend struct FCoreRedirects;
    friend class FRedirectionSummary;
 
    /* Returns the updated name after redirection. If bIsKnownToMatch is true, OldObjectName must have 
    been validated previously to be acceptable for redirection */
    FCoreRedirectObjectName RedirectName(const FCoreRedirectObjectName& OldObjectName, bool bIsKnownToMatch) const;
 
    bool IsWildcardMatch() const
    {
        return EnumHasAnyFlags(RedirectFlags, ECoreRedirectFlags::Option_MatchWildcardMask);
    }
 
    bool IsPrefixMatch() const
    {
        return EnumHasAllFlags(RedirectFlags, ECoreRedirectFlags::Option_MatchPrefix);
    }
 
    bool IsSuffixMatch() const
    {
        return EnumHasAllFlags(RedirectFlags, ECoreRedirectFlags::Option_MatchSuffix);
    }
};
 
struct FCoreRedirects
{
    static COREUOBJECT_API void Initialize();
 
    static COREUOBJECT_API FCoreRedirectObjectName GetRedirectedName(ECoreRedirectFlags Type,
        const FCoreRedirectObjectName& OldObjectName, ECoreRedirectMatchFlags MatchFlags = ECoreRedirectMatchFlags::None);
 
    static COREUOBJECT_API const TMap<FString, FString>* GetValueRedirects(ECoreRedirectFlags Type,
        const FCoreRedirectObjectName& OldObjectName, ECoreRedirectMatchFlags MatchFlags = ECoreRedirectMatchFlags::None);
 
    static COREUOBJECT_API bool RedirectNameAndValues(ECoreRedirectFlags Type, const FCoreRedirectObjectName& OldObjectName,
        FCoreRedirectObjectName& NewObjectName, const FCoreRedirect** FoundValueRedirect,
        ECoreRedirectMatchFlags MatchFlags = ECoreRedirectMatchFlags::None);
 
    static COREUOBJECT_API bool IsKnownMissing(ECoreRedirectFlags Type, const FCoreRedirectObjectName& ObjectName);
 
    static COREUOBJECT_API bool AddKnownMissing(ECoreRedirectFlags Type, const FCoreRedirectObjectName& ObjectName, ECoreRedirectFlags Channel = ECoreRedirectFlags::Option_MissingLoad);
 
    static COREUOBJECT_API bool RemoveKnownMissing(ECoreRedirectFlags Type, const FCoreRedirectObjectName& ObjectName, ECoreRedirectFlags Channel = ECoreRedirectFlags::Option_MissingLoad);
 
    static COREUOBJECT_API void ClearKnownMissing(ECoreRedirectFlags Type, ECoreRedirectFlags Channel = ECoreRedirectFlags::Option_MissingLoad);
 
    static COREUOBJECT_API bool FindPreviousNames(ECoreRedirectFlags Type, const FCoreRedirectObjectName& NewObjectName, TArray<FCoreRedirectObjectName>& PreviousNames);
 
    static COREUOBJECT_API bool GetMatchingRedirects(ECoreRedirectFlags Type, const FCoreRedirectObjectName& OldObjectName,
        TArray<const FCoreRedirect*>& FoundRedirects, ECoreRedirectMatchFlags MatchFlags = ECoreRedirectMatchFlags::None);
 
    static COREUOBJECT_API bool ReadRedirectsFromIni(const FString& IniName);
 
    static COREUOBJECT_API bool AddRedirectList(TArrayView<const FCoreRedirect> Redirects, const FString& SourceString);
 
    static COREUOBJECT_API bool RemoveRedirectList(TArrayView<const FCoreRedirect> Redirects, const FString& SourceString);
 
    static COREUOBJECT_API bool IsInitialized();
 
    static COREUOBJECT_API bool IsInDebugMode();
 
    static COREUOBJECT_API void ValidateRedirectList(TArrayView<const FCoreRedirect> Redirects, const FString& SourceString);
 
    static COREUOBJECT_API void ValidateAllRedirects();
 
    static COREUOBJECT_API bool ValidateAssetRedirects();
 
    static COREUOBJECT_API const TMap<FName, ECoreRedirectFlags>& GetConfigKeyMap();
 
    static COREUOBJECT_API ECoreRedirectFlags GetFlagsForTypeName(FName PackageName, FName TypeName);
 
    static COREUOBJECT_API ECoreRedirectFlags GetFlagsForTypeClass(UClass *TypeClass);
 
#if WITH_EDITOR
    UE_DEPRECATED(5.6, "Use GetHashOfRedirectsAffectingPackages(const TConstArrayView<FName> PackageNames, TArray<FBlake3Hash>& Hashes) instead.")
    static COREUOBJECT_API void AppendHashOfRedirectsAffectingPackages(FBlake3& Hasher, TConstArrayView<FName> PackageNames);
 
    static COREUOBJECT_API void GetHashOfRedirectsAffectingPackages(const TConstArrayView<FName>& PackageNames, TArray<FBlake3Hash>& Hashes);
 
    static COREUOBJECT_API void AppendHashOfGlobalRedirects(FBlake3& Hasher);
 
    static COREUOBJECT_API void RecordAddedObjectRedirector(const FSoftObjectPath& Source, const FSoftObjectPath& Dest);
    static COREUOBJECT_API void RecordRemovedObjectRedirector(const FSoftObjectPath& Source, const FSoftObjectPath& Dest);
#endif
 
    static COREUOBJECT_API bool RunTests();
 
    static COREUOBJECT_API void AddAssetRedirects(const TMap<FSoftObjectPath, FSoftObjectPath>& InRedirects);
 
    static COREUOBJECT_API void RemoveAllAssetRedirects();
     
private:
 
    COREUOBJECT_API FCoreRedirects();
 
    static COREUOBJECT_API bool AddRedirectListUnderWriteLock(TArrayView<const FCoreRedirect> Redirects, 
        const FString& SourceString, FScopeCoreRedirectsWriteLockedContext& LockedContext);
 
    static COREUOBJECT_API bool AddSingleRedirectUnderWriteLock(const FCoreRedirect& NewRedirect, 
        const FString& SourceString, FScopeCoreRedirectsWriteLockedContext& LockedContext);
 
    static COREUOBJECT_API bool RemoveSingleRedirectUnderWriteLock(const FCoreRedirect& OldRedirect, 
        const FString& SourceString, FScopeCoreRedirectsWriteLockedContext& LockedContext);
 
    static COREUOBJECT_API void RegisterNativeRedirectsUnderWriteLock(FScopeCoreRedirectsWriteLockedContext& LockedContext);
 
    static COREUOBJECT_API bool GetMatchingRedirectsUnderReadLock(ECoreRedirectFlags Type, 
        const FCoreRedirectObjectName& OldObjectName, TArray<const FCoreRedirect*>& FoundRedirects, ECoreRedirectMatchFlags MatchFlags, 
        FScopeCoreRedirectsReadLockedContext& LockedContext);
 
    static COREUOBJECT_API bool RedirectNameAndValuesUnderReadLock(ECoreRedirectFlags Type, const FCoreRedirectObjectName& OldObjectName,
        FCoreRedirectObjectName& NewObjectName, const FCoreRedirect** FoundValueRedirect,
        ECoreRedirectMatchFlags MatchFlags, FScopeCoreRedirectsReadLockedContext& LockedContext);
 
    static COREUOBJECT_API bool ValidateAssetRedirectsUnderReadLock(FScopeCoreRedirectsReadLockedContext& LockedContext);
 
    struct FWildcardData
    {
        void Add(const FCoreRedirect& Redirect);
 
        void Rebuild();
        bool Matches(ECoreRedirectFlags InFlags, const FCoreRedirectObjectName& InName, ECoreRedirectMatchFlags InMatchFlags, TArray<const FCoreRedirect*>& OutFoundRedirects) const;
 
        TArray<FCoreRedirect> Substrings;
        TArray<FCoreRedirect> Prefixes;
        TArray<FCoreRedirect> Suffixes;
    private:
        bool MatchSubstringApproximate(const UE::CoreRedirects::Private::FCoreRedirectObjectUtf8Name& RedirectName) const;
        void AddPredictionWords(const FCoreRedirect& Redirect);
 
        FPredictMatch8 PredictMatch;
    };
 
    struct FRedirectNameMap
    {
        TMap<FName, TArray<FCoreRedirect>> RedirectMap;
        TSharedPtr<FWildcardData> Wildcards;
    };
 
    struct FRedirectTypeMap
    {
    public:
        FRedirectTypeMap() = default;
        FRedirectTypeMap(const FRedirectTypeMap& Other);
        FRedirectTypeMap& operator=(const FRedirectTypeMap& Other);
        FRedirectNameMap& FindOrAdd(ECoreRedirectFlags Key);
        FRedirectNameMap* Find(ECoreRedirectFlags Key);
        void Empty();
 
        TArray<TPair<ECoreRedirectFlags, FRedirectNameMap>>::RangedForIteratorType begin() { return FastIterable.begin(); }
        TArray<TPair<ECoreRedirectFlags, FRedirectNameMap>>::RangedForIteratorType end() { return FastIterable.end(); }
 
        FRedirectTypeMap(const FRedirectTypeMap&& Other) = delete;
        FRedirectTypeMap& operator=(const FRedirectTypeMap&& Other) = delete;
    private:
        TMap<ECoreRedirectFlags, FRedirectNameMap*> Map;
        TArray<TPair<ECoreRedirectFlags, FRedirectNameMap>> FastIterable;
    };
 
    friend struct FCoreRedirectsContext;
};