NameTypes.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Misc/AssertionMacros.h"
#include "HAL/UnrealMemory.h"
#include "Templates/UnrealTypeTraits.h"
#include "Templates/UnrealTemplate.h"
#include "Containers/UnrealString.h"
#include "HAL/CriticalSection.h"
#include "Containers/StringConv.h"
#include "Containers/StringFwd.h"
#include "UObject/UnrealNames.h"
#include "Templates/Atomic.h"
#include "Serialization/MemoryLayout.h"
#include "Misc/IntrusiveUnsetOptionalState.h"
#include "Misc/StringBuilder.h"
#include "Misc/UEOps.h"
#include "Trace/Trace.h"
 
/*----------------------------------------------------------------------------
    Definitions.
----------------------------------------------------------------------------*/
 
#ifndef WITH_CASE_PRESERVING_NAME
    #define WITH_CASE_PRESERVING_NAME WITH_EDITORONLY_DATA
#endif
 
// Should the number part of the fname be stored in the name table or in the FName instance?
// Storing it in the name table may save memory overall but new number suffixes will cause the name table to grow like unique strings do.
#ifndef UE_FNAME_OUTLINE_NUMBER
    #define UE_FNAME_OUTLINE_NUMBER 0
#endif // UE_FNAME_OUTLINE_NUMBER
 
// Allows overriding the alignment of FNameEntry. This decreases the granularity of memory allocation for FNames and 
// therefore allows more data to be stored as FNames with the potential of increased waste.
// See the details of FNameEntryId encoding.
// Setting this to a nonzero value less than the natural alignment of FNameEntry will cause a compiler error.
#ifndef UE_FNAME_ENTRY_ALIGNMENT
    #if WITH_EDITOR
        #define UE_FNAME_ENTRY_ALIGNMENT 8
    #else
        #define UE_FNAME_ENTRY_ALIGNMENT 0
    #endif
#endif // UE_FNAME_ENTRY_ALIGNMENT
 
class FText;
 
enum {NAME_SIZE = 1024};
 
struct FMinimalName;
struct FScriptName;
struct FNumberedEntry;
class FName;
 
// Generic constructor/initializer struct to make Clang keep type debug info needed for debug visualizers
struct FClangKeepDebugInfo {};
 
struct FNameEntryId
{
    constexpr static bool bHasIntrusiveUnsetOptionalState = true;
    using IntrusiveUnsetOptionalStateType = FNameEntryId;
    
    // Default initialize to be equal to NAME_None
    constexpr FNameEntryId() : Value(0) {}
    constexpr FNameEntryId(ENoInit) {}
    constexpr explicit FNameEntryId(FIntrusiveUnsetOptionalState) : Value(~0u) {}
 
    constexpr bool IsNone() const
    {
        return Value == 0;
    }
 
    CORE_API int32 CompareLexical(FNameEntryId Rhs) const;
    bool LexicalLess(FNameEntryId Rhs) const { return CompareLexical(Rhs) < 0; }
 
    CORE_API int32 CompareLexicalSensitive(FNameEntryId Rhs) const;
    bool LexicalSensitiveLess(FNameEntryId Rhs) const { return CompareLexicalSensitive(Rhs) < 0; }
 
    int32 CompareFast(FNameEntryId Rhs) const { return Value - Rhs.Value; };
    bool FastLess(FNameEntryId Rhs) const { return CompareFast(Rhs) < 0; }
 
    bool UEOpLessThan(FNameEntryId Rhs) const { return Value < Rhs.Value; }
 
    bool UEOpEquals(FNameEntryId Rhs) const { return Value == Rhs.Value; }
    
    bool UEOpEquals(FIntrusiveUnsetOptionalState) const
    {
        return Value == ~0u;
    }
 
    // Returns true if this FNameEntryId is not equivalent to NAME_None
    constexpr explicit operator bool() const { return Value != 0; }
 
    constexpr uint32 ToUnstableInt() const { return Value; }
 
    static FNameEntryId FromUnstableInt(uint32 UnstableInt)
    {
        FNameEntryId Id;
        Id.Value = UnstableInt;
        return Id;
    }
 
    FORCEINLINE static FNameEntryId FromEName(EName Ename)
    {
        return Ename == NAME_None ? FNameEntryId() : FromValidEName(Ename);
    }
 
    inline bool UEOpEquals(EName Ename) const
    {
        return Ename == NAME_None ? Value == 0 : Value == FromValidENamePostInit(Ename).Value;
    }
 
private:
    uint32 Value;
 
    CORE_API static FNameEntryId FromValidEName(EName Ename);
    CORE_API static FNameEntryId FromValidENamePostInit(EName Ename);
 
public:
    friend CORE_API uint32 GetTypeHash(FNameEntryId Id);
 
    CORE_API friend FArchive& operator<<(FArchive& Ar, FNameEntryId& InId);
};
 
typedef FNameEntryId NAME_INDEX;
 
#define checkName checkSlow
 
#define NAME_NO_NUMBER_INTERNAL 0
 
#define NAME_INTERNAL_TO_EXTERNAL(x) (x - 1)
#define NAME_EXTERNAL_TO_INTERNAL(x) (x + 1)
 
#define NAME_NO_NUMBER NAME_INTERNAL_TO_EXTERNAL(NAME_NO_NUMBER_INTERNAL)
 
 
#define SUBOBJECT_DELIMITER_ANSI        ":"
#define SUBOBJECT_DELIMITER             TEXT(SUBOBJECT_DELIMITER_ANSI)
 
#define SUBOBJECT_DELIMITER_CHAR_ANSI   ':'
#define SUBOBJECT_DELIMITER_CHAR        TEXT(SUBOBJECT_DELIMITER_CHAR_ANSI)
 
#define INVALID_NAME_CHARACTERS         TEXT("\"' ,\n\r\t")
 
#define INVALID_OBJECTNAME_CHARACTERS   TEXT("\"' ,/.:|&!~\n\r\t@#(){}[]=;^%$`")
 
#define INVALID_OBJECTPATH_CHARACTERS   TEXT("\"' ,|&!~\n\r\t@#(){}[]=;^%$`")
 
#define INVALID_LONGPACKAGE_CHARACTERS  TEXT("\\:*?\"<>|' ,.&!~\n\r\t@#")
 
#define VALID_SAVEDDIRSUFFIX_CHARACTERS TEXT("_0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz")
 
#define NAMED_PAK_CHUNK_DELIMITER_CHAR  TEXT('-')
 
enum class ENameCase : uint8
{
    CaseSensitive,
    IgnoreCase,
};
 
enum ELinkerNameTableConstructor    {ENAME_LinkerConstructor};
 
enum EFindName
{
    FNAME_Find,
 
    FNAME_Add
};
 
namespace UE::Core::Private
{
 
template <typename CharType>
static constexpr uint32 ParseNumberFromName(const CharType* Name, int32& InOutLen)
{
    int32 Digits = 0;
    for (const CharType* It = Name + InOutLen - 1; It >= Name && *It >= '0' && *It <= '9'; --It)
    {
        ++Digits;
    }
 
    const CharType* FirstDigit = Name + InOutLen - Digits;
    constexpr int32 MaxDigitsInt32 = 10;
    if (Digits && Digits < InOutLen && FirstDigit[-1] == '_' && Digits <= MaxDigitsInt32 && (Digits == 1 || *FirstDigit != '0'))
    {
        int64 Number = 0;
        for (int32 Index = 0; Index < Digits; ++Index)
        {
            Number = 10 * Number + (FirstDigit[Index] - '0');
        }
        if (Number < MAX_int32)
        {
            InOutLen -= 1 + Digits;
            return static_cast<uint32>(NAME_EXTERNAL_TO_INTERNAL(Number));
        }
    }
 
    return NAME_NO_NUMBER_INTERNAL;
}
 
} // UE::Core::Private
 
/*----------------------------------------------------------------------------
    FNameEntry.
----------------------------------------------------------------------------*/
 
struct FNameEntryHeader
{
    uint16 bIsWide : 1;
#if WITH_CASE_PRESERVING_NAME
    uint16 Len : 15;
#else
    static constexpr inline uint32 ProbeHashBits = 5;
    uint16 LowercaseProbeHash : ProbeHashBits;
    uint16 Len : 10;
#endif
};
 
struct alignas(UE_FNAME_ENTRY_ALIGNMENT) FNameEntry
{
private:
#if WITH_CASE_PRESERVING_NAME
    FNameEntryId ComparisonId;
#endif
    FNameEntryHeader Header;
 
    // Unaligned to reduce alignment waste for non-numbered entries
    struct FNumberedData
    {
#if UE_FNAME_OUTLINE_NUMBER 
#if WITH_CASE_PRESERVING_NAME // ComparisonId is 4B-aligned, 4B-align Id/Number by 2B pad after 2B Header
        uint8 Pad[sizeof(Header) % alignof(decltype(ComparisonId))]; 
#endif                      
        uint8 Id[sizeof(FNameEntryId)];
        uint8 Number[sizeof(uint32)];
#endif // UE_FNAME_OUTLINE_NUMBER   
    };
 
    union
    {
        ANSICHAR            AnsiName[NAME_SIZE];
        WIDECHAR            WideName[NAME_SIZE];
        uint8               NameData[0];
        FNumberedData       NumberedName;
    };
 
 
    FNameEntry(FClangKeepDebugInfo);
    FNameEntry(const FNameEntry&) = delete;
    FNameEntry(FNameEntry&&) = delete;
    FNameEntry& operator=(const FNameEntry&) = delete;
    FNameEntry& operator=(FNameEntry&&) = delete;
 
public:
    FORCEINLINE bool IsWide() const                             { return Header.bIsWide; }
    FORCEINLINE int32 GetNameLength() const                     { return Header.Len; }
    CORE_API int32 GetNameLengthUtf8() const;
#if UE_FNAME_OUTLINE_NUMBER
    FORCEINLINE bool IsNumbered() const                         { return Header.Len == 0; }
#else
    FORCEINLINE bool IsNumbered() const                         { return false; }
#endif
 
    CORE_API void GetUnterminatedName(TCHAR* OutName, uint32 OutSize) const;
 
    CORE_API void GetName(TCHAR(&OutName)[NAME_SIZE]) const;
 
    CORE_API void GetAnsiName(ANSICHAR(&OutName)[NAME_SIZE]) const;
 
    CORE_API void GetWideName(WIDECHAR(&OutName)[NAME_SIZE]) const;
 
    CORE_API FString GetPlainNameString() const;
 
    CORE_API FUtf8String GetPlainNameUtf8String() const;
 
    CORE_API void AppendNameToString(FWideString& OutString) const;
    CORE_API void AppendNameToString(FUtf8String& OutString) const;
 
    CORE_API void AppendNameToString(FWideStringBuilderBase& OutString) const;
    CORE_API void AppendNameToString(FUtf8StringBuilderBase& OutString) const;
 
    CORE_API void AppendAnsiNameToString(FAnsiStringBuilderBase& OutString) const;
 
    CORE_API void AppendNameToPathString(FString& OutString) const;
 
    CORE_API void DebugDump(FOutputDevice& Out) const;
 
    CORE_API int32 GetSizeInBytes() const;
 
    CORE_API void Write(FArchive& Ar) const;
 
    static constexpr int32 GetDataOffset() { return offsetof(FNameEntry, NameData); }
    struct CORE_API FNameStringView MakeView(union FNameBuffer& OptionalDecodeBuffer) const;
private:
    friend class FName;
    friend struct FNameHelper;
    friend class FNameEntryAllocator;
    friend class FNamePoolShardBase;
    friend class FNamePool;
    void CopyUnterminatedName(ANSICHAR* OutName, uint32 Len) const;
    void CopyUnterminatedName(WIDECHAR* OutName, uint32 Len) const;
    void CopyAndConvertUnterminatedName(TCHAR* OutName, uint32 Len) const;
    const ANSICHAR* GetUnterminatedName(ANSICHAR(&OptionalDecodeBuffer)[NAME_SIZE]) const;
    const WIDECHAR* GetUnterminatedName(WIDECHAR(&OptionalDecodeBuffer)[NAME_SIZE]) const;
 
#if UE_FNAME_OUTLINE_NUMBER
    // @pre IsNumbered()
    FORCEINLINE const FNumberedEntry& GetNumberedName() const   { return reinterpret_cast<const FNumberedEntry&>(NumberedName.Id[0]); }
    uint32 GetNumber() const;
#endif // UE_FNAME_OUTLINE_NUMBER
};
 
struct FNameEntrySerialized
{
    bool bIsWide = false;
 
    union
    {
        ANSICHAR    AnsiName[NAME_SIZE];
        WIDECHAR    WideName[NAME_SIZE];
    };
 
    // These are not used anymore but recalculated on save to maintain serialization format
    uint16 NonCasePreservingHash = 0;
    uint16 CasePreservingHash = 0;
 
    FNameEntrySerialized(const FNameEntry& NameEntry);
    FNameEntrySerialized(enum ELinkerNameTableConstructor) {}
 
    ANSICHAR const* GetAnsiName() const
    {
        check(!bIsWide);
        return AnsiName;
    }
 
    WIDECHAR const* GetWideName() const
    {
        check(bIsWide);
        return WideName;
    }
 
    CORE_API FString GetPlainNameString() const;    
 
    friend CORE_API FArchive& operator<<(FArchive& Ar, FNameEntrySerialized& E);
    friend FArchive& operator<<(FArchive& Ar, FNameEntrySerialized* E)
    {
        return Ar << *E;
    }
};
 
struct FMinimalName
{
    friend FName;
 
    FMinimalName() {}
    
    FMinimalName(EName N)
        : Index(FNameEntryId::FromEName(N))
    {
    }
 
    FORCEINLINE explicit FMinimalName(const FName& Name);
    FORCEINLINE bool IsNone() const;
    FORCEINLINE bool UEOpLessThan(FMinimalName Rhs) const;
    
private:
    FNameEntryId    Index;
#if !UE_FNAME_OUTLINE_NUMBER
    int32           Number = NAME_NO_NUMBER_INTERNAL;
#endif // UE_FNAME_OUTLINE_NUMBE
 
public:
#if UE_FNAME_OUTLINE_NUMBER
    FORCEINLINE bool UEOpEquals(FMinimalName Rhs) const
    {
        return Index == Rhs.Index;
    }
    friend FORCEINLINE uint32 GetTypeHash(FMinimalName Name)
    {
        return GetTypeHash(Name.Index);
    }
#else
    FORCEINLINE bool UEOpEquals(FMinimalName Rhs) const
    {
        return Index == Rhs.Index && Number == Rhs.Number;
    }
    friend FORCEINLINE uint32 GetTypeHash(FMinimalName Name)
    {
        return GetTypeHash(Name.Index) + Name.Number;
    }
#endif
};
 
struct FScriptName
{
    friend FName;
 
    FScriptName() {}
    
    FScriptName(EName Ename)
        : ComparisonIndex(FNameEntryId::FromEName(Ename))
        , DisplayIndex(ComparisonIndex)
    {
    }
 
    FORCEINLINE explicit FScriptName(const FName& Name);
    FORCEINLINE bool IsNone() const;
    inline bool UEOpEquals(EName Name) const { return UEOpEquals(FScriptName(Name)); }
 
    CORE_API FString ToString() const;
    CORE_API FUtf8String ToUtf8String() const;
 
    // The internal structure of FScriptName is private in order to handle UE_FNAME_OUTLINE_NUMBER
private: 
    FNameEntryId    ComparisonIndex;
    FNameEntryId    DisplayIndex;
#if UE_FNAME_OUTLINE_NUMBER
    uint32          Dummy = 0; // Dummy to keep the size the same regardless of build configuration, but change the name so trying to use Number is a compile error
#else // UE_FNAME_OUTLINE_NUMBER
    uint32          Number = NAME_NO_NUMBER_INTERNAL;
#endif // UE_FNAME_OUTLINE_NUMBER
 
public:
#if UE_FNAME_OUTLINE_NUMBER
    FORCEINLINE bool UEOpEquals(FScriptName Rhs) const
    {
        return ComparisonIndex == Rhs.ComparisonIndex;
    }
    friend FORCEINLINE uint32 GetTypeHash(FScriptName Name)
    {
        return GetTypeHash(Name.ComparisonIndex);
    }
#else
    FORCEINLINE bool UEOpEquals(FScriptName Rhs) const
    {
        return ComparisonIndex == Rhs.ComparisonIndex && Number == Rhs.Number;
    }
    friend FORCEINLINE uint32 GetTypeHash(FScriptName Name)
    {
        return GetTypeHash(Name.ComparisonIndex) + Name.Number;
    }
#endif
};
 
struct FMemoryImageName;
 
namespace Freeze
{
    CORE_API void ApplyMemoryImageNamePatch(void* NameDst, const FMemoryImageName& Name, const FPlatformTypeLayoutParameters& LayoutParams);
    CORE_API void IntrinsicWriteMemoryImage(FMemoryImageWriter& Writer, const FMemoryImageName& Object, const FTypeLayoutDesc&);
    CORE_API uint32 IntrinsicUnfrozenCopy(const FMemoryUnfreezeContent& Context, const FMemoryImageName& Object, void* OutDst);
}
 
struct FMemoryImageName
{
    friend FName;
 
    friend CORE_API void Freeze::ApplyMemoryImageNamePatch(void* NameDst, const FMemoryImageName& Name, const FPlatformTypeLayoutParameters& LayoutParams);
    friend CORE_API void Freeze::IntrinsicWriteMemoryImage(FMemoryImageWriter& Writer, const FMemoryImageName& Object, const FTypeLayoutDesc&);
    friend CORE_API uint32 Freeze::IntrinsicUnfrozenCopy(const FMemoryUnfreezeContent& Context, const FMemoryImageName& Object, void* OutDst);
 
    FMemoryImageName();
    FMemoryImageName(EName Name);
    FORCEINLINE FMemoryImageName(const FName& Name);
 
    inline bool UEOpEquals(EName Name) const { return UEOpEquals(FMemoryImageName(Name)); }
 
    FORCEINLINE bool IsNone() const;
    CORE_API FString ToString() const;
 
    // The internal structure of FMemoryImageName is private in order to handle UE_FNAME_OUTLINE_NUMBER
private:
    FNameEntryId    ComparisonIndex;
#if UE_FNAME_OUTLINE_NUMBER
    uint32          Dummy = 0; // Dummy to keep the size the same regardless of build configuration, but change the name so trying to use Number is a compile error
#else // UE_FNAME_OUTLINE_NUMBER
    uint32          Number = NAME_NO_NUMBER_INTERNAL;
#endif // UE_FNAME_OUTLINE_NUMBER
#if WITH_CASE_PRESERVING_NAME
    FNameEntryId    DisplayIndex;
#endif
 
public:
#if UE_FNAME_OUTLINE_NUMBER
    FORCEINLINE bool UEOpEquals(FMemoryImageName Rhs) const
    {
        return ComparisonIndex == Rhs.ComparisonIndex;
    }
    friend FORCEINLINE uint32 GetTypeHash(FMemoryImageName Name)
    {
        return GetTypeHash(Name.ComparisonIndex);
    }
#else
    FORCEINLINE bool UEOpEquals(FMemoryImageName Rhs) const
    {
        return ComparisonIndex == Rhs.ComparisonIndex && Number == Rhs.Number;
    }
    friend FORCEINLINE uint32 GetTypeHash(FMemoryImageName Name)
    {
        return GetTypeHash(Name.ComparisonIndex) + Name.Number;
    }
#endif
};
 
class FName
{
public:
    constexpr static bool bHasIntrusiveUnsetOptionalState = true;
    using IntrusiveUnsetOptionalStateType = FName;
 
#if UE_FNAME_OUTLINE_NUMBER
    [[nodiscard]] CORE_API FNameEntryId GetComparisonIndex() const;
    [[nodiscard]] CORE_API FNameEntryId GetDisplayIndex() const;
#else // UE_FNAME_OUTLINE_NUMBER
    [[nodiscard]] FORCEINLINE FNameEntryId GetComparisonIndex() const
    {
        checkName(IsWithinBounds(ComparisonIndex));
        return ComparisonIndex;
    }
 
    [[nodiscard]] FORCEINLINE FNameEntryId GetDisplayIndex() const
    {
        const FNameEntryId Index = GetDisplayIndexFast();
        checkName(IsWithinBounds(Index));
        return Index;
    }
#endif //UE_FNAME_OUTLINE_NUMBER
 
#if UE_FNAME_OUTLINE_NUMBER
    [[nodiscard]] CORE_API int32 GetNumber() const;
    CORE_API void SetNumber(const int32 NewNumber);
#else //UE_FNAME_OUTLINE_NUMBER
    [[nodiscard]] FORCEINLINE int32 GetNumber() const
    {
        return Number;
    }
 
    FORCEINLINE void SetNumber(const int32 NewNumber)
    {
        Number = NewNumber;
    }
#endif //UE_FNAME_OUTLINE_NUMBER
    
    [[nodiscard]] CORE_API FString GetPlainNameString() const;
 
    CORE_API uint32 GetPlainNameString(TCHAR(&OutName)[NAME_SIZE]) const;
 
    CORE_API void GetPlainANSIString(ANSICHAR(&AnsiName)[NAME_SIZE]) const;
 
    CORE_API void GetPlainWIDEString(WIDECHAR(&WideName)[NAME_SIZE]) const;
 
    [[nodiscard]] CORE_API const FNameEntry* GetComparisonNameEntry() const;
    [[nodiscard]] CORE_API const FNameEntry* GetDisplayNameEntry() const;
 
    [[nodiscard]] CORE_API FString ToString() const;
 
    [[nodiscard]] CORE_API FUtf8String ToUtf8String() const;
 
    CORE_API void ToString(FWideString& Out) const;
    CORE_API void ToString(FUtf8String& Out) const;
 
    CORE_API void ToString(FWideStringBuilderBase& Out) const;
    CORE_API void ToString(FUtf8StringBuilderBase& Out) const;
 
    [[nodiscard]] CORE_API uint32 GetStringLength() const;
 
    static constexpr inline uint32 StringBufferSize = NAME_SIZE + 1 + 10; // NAME_SIZE includes null-terminator
 
private:
    CORE_API uint32 ToStringInternal(TCHAR* Out, uint32 OutSize) const;
 
public:
    UE_DEPRECATED(5.6, 
        "FName::ToString(TCHAR* Out, uint32 OutSize) is dangerous and can lead to buffer overflow if the provided "
        "buffer is smaller than FName::StringBufferSize, even if the OutSize parameter indicates the buffer is "
        "smaller than this value. Use the templated ToString() or ToStringTruncate() functions to format the name "
        "string into a pre-allocated array, or use the allocating ToString() functions that return an FString.")
    uint32 ToString(TCHAR* Out, uint32 OutSize) const
    {
        return ToStringInternal(Out, StringBufferSize);
    }
 
    template <uint32 N>
    uint32 ToString(TCHAR (&Out)[N]) const
    {
        UE_STATIC_DEPRECATE(5.6, N < StringBufferSize,
            "FName::ToString(TCHAR (&Out)[N]) requires a buffer of size of at least FName::StringBufferSize. "
            "Use ToStringTruncate() if a smaller buffer is required and it is safe for the returned string to be truncated.");
 
        return ToStringInternal(Out, N);
    }
 
    uint32 ToStringTruncate(TCHAR* Out, uint32 OutSize) const
    {
        return ToStringInternal(Out, OutSize);
    }
 
    template <uint32 N>
    uint32 ToStringTruncate(TCHAR (&Out)[N]) const
    {
        static_assert(N > 0, "Out buffer must have at least one element.");
        return ToStringTruncate(Out, N);
    }
 
    CORE_API void AppendString(FWideString& Out) const;
    CORE_API void AppendString(FUtf8String& Out) const;
 
    CORE_API void AppendString(FWideStringBuilderBase& Out) const;
    CORE_API void AppendString(FUtf8StringBuilderBase& Out) const;
 
    CORE_API bool TryAppendAnsiString(FAnsiStringBuilderBase& Out) const;
 
    [[nodiscard]] FORCEINLINE bool IsEqual(const FName& Other, const ENameCase CompareMethod = ENameCase::IgnoreCase, const bool bCompareNumber = true) const;
 
    [[nodiscard]] FORCEINLINE bool UEOpEquals(FName Other) const
    {
        return ToUnstableInt() == Other.ToUnstableInt();
    }
 
    [[nodiscard]] inline bool UEOpEquals(FIntrusiveUnsetOptionalState I) const
    {
        return ComparisonIndex == I;
    }
 
    [[nodiscard]] FORCEINLINE bool FastLess(const FName& Other) const
    {
        return CompareIndexes(Other) < 0;
    }
 
    [[nodiscard]] FORCEINLINE bool LexicalLess(const FName& Other) const
    {
        return Compare(Other) < 0;
    }
 
    [[nodiscard]] FORCEINLINE bool IsNone() const
    {
#if PLATFORM_64BITS && !WITH_CASE_PRESERVING_NAME
        return ToUnstableInt() == 0;
#else
        return ComparisonIndex.IsNone() && GetNumber() == NAME_NO_NUMBER_INTERNAL;
#endif
    }
 
    [[nodiscard]] bool IsValid() const { return IsWithinBounds(ComparisonIndex); }
 
    [[nodiscard]] bool IsValidIndexFast() const { return IsValid(); }
 
 
    CORE_API static bool IsValidXName( const FName InName, const FString& InInvalidChars, FText* OutReason = nullptr, const FText* InErrorCtx = nullptr );
    CORE_API static bool IsValidXName( const TCHAR* InName, const FString& InInvalidChars, FText* OutReason = nullptr, const FText* InErrorCtx = nullptr );
    CORE_API static bool IsValidXName( const FString& InName, const FString& InInvalidChars, FText* OutReason = nullptr, const FText* InErrorCtx = nullptr );
    CORE_API static bool IsValidXName( const FStringView& InName, const FString& InInvalidChars, FText* OutReason = nullptr, const FText* InErrorCtx = nullptr );
 
    bool IsValidXName( const FString& InInvalidChars, FText* OutReason = nullptr, const FText* InErrorCtx = nullptr ) const
    {
        return IsValidXName(*this, InInvalidChars, OutReason, InErrorCtx);
    }
    CORE_API bool IsValidXName() const;
 
    bool IsValidXName( FText& OutReason, const FString& InInvalidChars ) const
    {
        return IsValidXName(*this, InInvalidChars, &OutReason);
    }
    CORE_API bool IsValidXName( FText& OutReason ) const;
 
    CORE_API bool IsValidObjectName( FText& OutReason ) const;
 
    CORE_API bool IsValidGroupName( FText& OutReason, bool bIsGroupName=false ) const;
 
    [[nodiscard]] CORE_API static FString SanitizeWhitespace(const FString& FNameString);
    
    [[nodiscard]] CORE_API int32 Compare( const FName& Other ) const;
 
    [[nodiscard]] FORCEINLINE int32 CompareIndexes(const FName& Other) const
    {
        if (int32 ComparisonDiff = ComparisonIndex.CompareFast(Other.ComparisonIndex))
        {
            return ComparisonDiff;
        }
 
#if UE_FNAME_OUTLINE_NUMBER
        return 0;  // If comparison indices are the same we are the same
#else //UE_FNAME_OUTLINE_NUMBER
        return GetNumber() - Other.GetNumber();
#endif //UE_FNAME_OUTLINE_NUMBER
    }
 
    FORCEINLINE FName(EName Ename) : FName(Ename, NAME_NO_NUMBER_INTERNAL) {}
 
    FORCEINLINE FName(EName Ename, int32 InNumber)
        : FName(CreateNumberedNameIfNecessary(FNameEntryId::FromEName(Ename), InNumber))
    {
    }
 
 
    FORCEINLINE FName(FName Other, int32 InNumber)
        : FName(CreateNumberedNameIfNecessary(Other.GetComparisonIndex(), Other.GetDisplayIndex(), InNumber))
    {
    }
 
    FORCEINLINE FName(FNameEntryId InComparisonIndex, FNameEntryId InDisplayIndex, int32 InNumber)
        : FName(CreateNumberedNameIfNecessary(InComparisonIndex, InDisplayIndex, InNumber))
    {
    }
 
#if WITH_CASE_PRESERVING_NAME
    [[nodiscard]] CORE_API static FNameEntryId GetComparisonIdFromDisplayId(FNameEntryId DisplayId);
#else
    [[nodiscard]] static FNameEntryId GetComparisonIdFromDisplayId(FNameEntryId DisplayId) { return DisplayId; }
#endif
 
    [[nodiscard]] static FName CreateFromDisplayId(FNameEntryId DisplayId, int32 Number)
    {
#if UE_FNAME_OUTLINE_NUMBER
        checkSlow(ResolveEntry(DisplayId)->IsNumbered() == false); // This id should be unnumbered i.e. returned from GetDisplayIndex on an FName.
#endif
        return FName(GetComparisonIdFromDisplayId(DisplayId), DisplayId, Number);
    }
 
#if UE_FNAME_OUTLINE_NUMBER
    CORE_API static FName FindNumberedName(FNameEntryId DisplayId, int32 Number);
#endif //UE_FNAME_OUTLINE_NUMBER
 
    FORCEINLINE constexpr FName()
#if !UE_FNAME_OUTLINE_NUMBER
        : Number(NAME_NO_NUMBER_INTERNAL)
#endif 
    {
    }
 
    explicit constexpr FName(ENoInit)
        : ComparisonIndex(NoInit)
#if WITH_CASE_PRESERVING_NAME
        , DisplayIndex(NoInit)
#endif
    {}
 
    explicit FName(FIntrusiveUnsetOptionalState I)
        : ComparisonIndex(I)
#if !UE_FNAME_OUTLINE_NUMBER
        , Number(NAME_NO_NUMBER_INTERNAL)
#endif
#if WITH_CASE_PRESERVING_NAME
        , DisplayIndex(I)
#endif
    {
    }
 
    FORCEINLINE explicit FName(FMinimalName InName);
    FORCEINLINE explicit FName(FScriptName InName);
    FORCEINLINE FName(FMemoryImageName InName);
 
    CORE_API FName(const WIDECHAR* Name);
    CORE_API FName(const ANSICHAR* Name);
    CORE_API FName(const UTF8CHAR* Name);
 
    CORE_API FName(const WIDECHAR* Name, EFindName FindType);
    CORE_API FName(const ANSICHAR* Name, EFindName FindType);
    CORE_API FName(const UTF8CHAR* Name, EFindName FindType);
 
    CORE_API FName(int32 Len, const WIDECHAR* Name, EFindName FindType=FNAME_Add);
    CORE_API FName(int32 Len, const ANSICHAR* Name, EFindName FindType=FNAME_Add);
    CORE_API FName(int32 Len, const UTF8CHAR* Name, EFindName FindType=FNAME_Add);
 
    inline explicit FName(TStringView<ANSICHAR> View, EFindName FindType = FNAME_Add)
        : FName(NoInit)
    {
        *this = FName(View.Len(), View.GetData(), FindType);
    }
    inline explicit FName(TStringView<WIDECHAR> View, EFindName FindType = FNAME_Add)
        : FName(NoInit)
    {
        *this = FName(View.Len(), View.GetData(), FindType);
    }
    inline explicit FName(TStringView<UTF8CHAR> View, EFindName FindType = FNAME_Add)
        : FName(NoInit)
    {
        *this = FName(View.Len(), View.GetData(), FindType);
    }
 
 
    CORE_API FName(const WIDECHAR* Name, int32 Number);
    CORE_API FName(const ANSICHAR* Name, int32 Number);
    CORE_API FName(const UTF8CHAR* Name, int32 Number);
    CORE_API FName(int32 Len, const WIDECHAR* Name, int32 Number);
    CORE_API FName(int32 Len, const ANSICHAR* Name, int32 Number);
    CORE_API FName(int32 Len, const UTF8CHAR* Name, int32 Number);
 
    inline FName(TStringView<ANSICHAR> View, int32 InNumber)
        : FName(NoInit)
    {
        *this = FName(View.Len(), View.GetData(), InNumber);
    }
    inline FName(TStringView<WIDECHAR> View, int32 InNumber)
        : FName(NoInit)
    {
        *this = FName(View.Len(), View.GetData(), InNumber);
    }
    inline FName(TStringView<UTF8CHAR> View, int32 InNumber)
        : FName(NoInit)
    {
        *this = FName(View.Len(), View.GetData(), InNumber);
    }
 
    CORE_API FName(const TCHAR* Name, int32 InNumber, bool bSplitName);
 
    CORE_API FName(const FNameEntrySerialized& LoadedEntry);
 
    CORE_API static void DisplayHash( class FOutputDevice& Ar );
    [[nodiscard]] CORE_API static FString SafeString(FNameEntryId InDisplayIndex, int32 InstanceNumber = NAME_NO_NUMBER_INTERNAL);
 
    CORE_API static void Reserve(uint32 NumBytes, uint32 NumNames);
 
    [[nodiscard]] CORE_API static int64 GetNameEntryMemorySize();
 
    [[nodiscard]] CORE_API static int64 GetNameEntryMemoryEstimatedAvailable();
 
    [[nodiscard]] CORE_API static int64 GetNameTableMemorySize();
 
    [[nodiscard]] CORE_API static int32 GetNumAnsiNames();
 
    [[nodiscard]] CORE_API static int32 GetNumWideNames();
 
#if UE_FNAME_OUTLINE_NUMBER
    [[nodiscard]] CORE_API static int32 GetNumNumberedNames();
#endif
 
    [[nodiscard]] CORE_API static TArray<const FNameEntry*> DebugDump();
 
    [[nodiscard]] CORE_API static FNameEntry const* GetEntry(EName Ename);
    [[nodiscard]] CORE_API static FNameEntry const* GetEntry(FNameEntryId Id);
 
#if UE_TRACE_ENABLED
    [[nodiscard]] CORE_API static UE::Trace::FEventRef32 TraceName(const FName& Name);
    CORE_API static void TraceNamesOnConnection();
#endif
 
 
    CORE_API static void AutoTest();
    
    [[nodiscard]] CORE_API static FString NameToDisplayString( const FString& InDisplayName, const bool bIsBool );
 
    CORE_API static void AddNameToDisplayStringExemption(const FString& InExemption);
    CORE_API static void RemoveNameToDisplayStringExemption(const FString& InExemption);
 
    [[nodiscard]] CORE_API const EName* ToEName() const;
 
    CORE_API static void TearDown();
 
#if UE_FNAME_OUTLINE_NUMBER
    [[nodiscard]] FORCEINLINE uint64 ToUnstableInt() const
    {
        return ComparisonIndex.ToUnstableInt();
    }
#else
    [[nodiscard]] FORCEINLINE uint64 ToUnstableInt() const
    {
        static_assert(STRUCT_OFFSET(FName, ComparisonIndex) == 0);
        static_assert(STRUCT_OFFSET(FName, Number) == 4);
        static_assert((STRUCT_OFFSET(FName, Number) + sizeof(Number)) == sizeof(uint64));
 
        uint64 Out = 0;
        FMemory::Memcpy(&Out, this, sizeof(uint64));
        return Out;
    }
#endif
 
private:
    FNameEntryId    ComparisonIndex;
#if !UE_FNAME_OUTLINE_NUMBER
    uint32          Number;
#endif// ! //UE_FNAME_OUTLINE_NUMBER
#if WITH_CASE_PRESERVING_NAME
    FNameEntryId    DisplayIndex;
#endif // WITH_CASE_PRESERVING_NAME
 
    friend const TCHAR* DebugFName(int32);
    friend const TCHAR* DebugFName(int32, int32);
    friend const TCHAR* DebugFName(FName&);
 
    friend struct FNameHelper;
    friend FScriptName NameToScriptName(FName InName);
    friend FMinimalName NameToMinimalName(FName InName);
    friend FMinimalName::FMinimalName(const FName& Name);
    friend FScriptName::FScriptName(const FName& Name);
    friend FMemoryImageName::FMemoryImageName(const FName& Name);
 
    template <typename StringBufferType>
    FORCEINLINE void AppendStringInternal(StringBufferType& Out) const;
 
    FORCEINLINE FNameEntryId GetDisplayIndexFast() const
    {
#if WITH_CASE_PRESERVING_NAME
        return DisplayIndex;
#else
        return ComparisonIndex;
#endif
    }
 
    // Accessor for unmodified comparison index when UE_FNAME_OUTLINE_NUMBER is set
    [[nodiscard]] FORCEINLINE FNameEntryId GetComparisonIndexInternal() const
    {
        return ComparisonIndex;
    }
 
    // Accessor for unmodified display index when UE_FNAME_OUTLINE_NUMBER is set
    [[nodiscard]] FORCEINLINE FNameEntryId GetDisplayIndexInternal() const
    {
#if WITH_CASE_PRESERVING_NAME
        return DisplayIndex;
#else // WITH_CASE_PRESERVING_NAME
        return ComparisonIndex;
#endif // WITH_CASE_PRESERVING_NAME
    }
 
    // Resolve the entry directly referred to by LookupId
    [[nodiscard]] CORE_API static const FNameEntry* ResolveEntry(FNameEntryId LookupId);
    // Recursively resolve through the entry referred to by LookupId to reach the allocated string entry, in the case of UE_FNAME_OUTLINE_NUMBER=1
    [[nodiscard]] static const FNameEntry* ResolveEntryRecursive(FNameEntryId LookupId);
 
    [[nodiscard]] CORE_API static bool IsWithinBounds(FNameEntryId Id);
 
    // These FNameEntryIds are passed in from user code so they must be non-numbered if Number != NAME_NO_NUMBER_INTERNAL
#if UE_FNAME_OUTLINE_NUMBER
    [[nodiscard]] CORE_API static FName CreateNumberedName(FNameEntryId ComparisonId, FNameEntryId DisplayId, int32 Number);
#endif
 
    [[nodiscard]] FORCEINLINE static FName CreateNumberedNameIfNecessary(FNameEntryId ComparisonId, FNameEntryId DisplayId, int32 Number)
    {
#if UE_FNAME_OUTLINE_NUMBER
        if (Number != NAME_NO_NUMBER_INTERNAL)
        {
            // We need to store a new entry in the name table
            return CreateNumberedName(ComparisonId, DisplayId, Number);
        }
        // Otherwise we can just set the index members
#endif
        FName Out;
        Out.ComparisonIndex = ComparisonId;
#if WITH_CASE_PRESERVING_NAME
        Out.DisplayIndex = DisplayId;
#endif
#if !UE_FNAME_OUTLINE_NUMBER
        Out.Number = Number;
#endif
        return Out;
    }
 
    [[nodiscard]] FORCEINLINE static FName CreateNumberedNameIfNecessary(FNameEntryId ComparisonId, int32 Number)
    {
        return CreateNumberedNameIfNecessary(ComparisonId, ComparisonId, Number);
    }
    
    
    [[nodiscard]] static bool Equals(FName A, FName B) = delete;
    [[nodiscard]] CORE_API static bool Equals(FName A, FAnsiStringView B);
    [[nodiscard]] CORE_API static bool Equals(FName A, FWideStringView B);
    [[nodiscard]] CORE_API static bool Equals(FName A, const ANSICHAR* B);
    [[nodiscard]] CORE_API static bool Equals(FName A, const WIDECHAR* B);
 
    [[nodiscard]] FORCEINLINE static bool Equals(FName A, EName B)
    {
        // With UE_FNAME_OUTLINE_NUMBER 1, FName == FName(EName) is
        // faster than extracting index and number for direct EName comparison.
        // return A.GetComparisonIndex() == B && A.GetNumber() == NAME_NO_NUMBER_INTERNAL;
        return A == FName(B);
    }
 
#if UE_FNAME_OUTLINE_NUMBER
    [[nodiscard]] FORCEINLINE static bool Equals(FName A, FMinimalName B)
    {
        return A.GetComparisonIndexInternal() == B.Index;
    }
    [[nodiscard]] FORCEINLINE static bool Equals(FName A, FScriptName B)
    {
        return A.GetComparisonIndexInternal() == B.ComparisonIndex;
    }
    [[nodiscard]] FORCEINLINE static bool Equals(FName A, FMemoryImageName B)
    {
        return A.GetComparisonIndexInternal() == B.ComparisonIndex;
    }
    [[nodiscard]] friend FORCEINLINE uint32 GetTypeHash(FName Name)
    {
        return GetTypeHash(Name.GetComparisonIndexInternal());
    }
#else
    [[nodiscard]] FORCEINLINE static bool Equals(FName A, FMinimalName B)
    {
        return A.GetComparisonIndex() == B.Index && A.GetNumber() == B.Number;
    }
    [[nodiscard]] FORCEINLINE static bool Equals(FName A, FScriptName B)
    {
        return A.GetComparisonIndex() == B.ComparisonIndex && A.GetNumber() == B.Number;
    }
    [[nodiscard]] FORCEINLINE static bool Equals(FName A, FMemoryImageName B)
    {
        return A.GetComparisonIndex() == B.ComparisonIndex && A.GetNumber() == B.Number;
    }
    [[nodiscard]] friend FORCEINLINE uint32 GetTypeHash(FName Name)
    {
        return GetTypeHash(Name.GetComparisonIndex()) + Name.GetNumber();
    }
#endif
 
public:
    template <typename T>
    [[nodiscard]] FORCEINLINE auto UEOpEquals(T Rhs) const -> decltype(FName::Equals(*this, Rhs))
    {
        return FName::Equals(*this, Rhs);
    }
};
 
template<> struct TIsZeroConstructType<class FName> { enum { Value = true }; };
Expose_TNameOf(FName)
 
namespace Freeze
{
    // These structures mirror the layout of FMemoryImageName depending on the value of WITH_CASE_PRESERVING_NAME
    // for use in memory image writing/unfreezing
    template<bool bCasePreserving>
    struct TMemoryImageNameLayout;
 
    template<>
    struct TMemoryImageNameLayout<false>
    {
        FNameEntryId    ComparisonIndex;
        uint32          NumberOrDummy = 0;
    };
 
    template<>
    struct TMemoryImageNameLayout<true> : public TMemoryImageNameLayout<false>
    {
        FNameEntryId    DisplayIndex;
    };
 
    CORE_API void ApplyMemoryImageNamePatch(void* NameDst, const FMemoryImageName& Name, const FPlatformTypeLayoutParameters& LayoutParams);
 
    CORE_API uint32 IntrinsicAppendHash(const FMemoryImageName* DummyObject, const FTypeLayoutDesc& TypeDesc, const FPlatformTypeLayoutParameters& LayoutParams, FSHA1& Hasher);
    CORE_API void IntrinsicWriteMemoryImage(FMemoryImageWriter& Writer, const FMemoryImageName& Object, const FTypeLayoutDesc&);
    CORE_API uint32 IntrinsicUnfrozenCopy(const FMemoryUnfreezeContent& Context, const FMemoryImageName& Object, void* OutDst);
    CORE_API void IntrinsicWriteMemoryImage(FMemoryImageWriter& Writer, const FScriptName& Object, const FTypeLayoutDesc&);
}
 
FORCEINLINE FMemoryImageName::FMemoryImageName()
{
    // The structure must match the layout of Freeze::TMemoryImageNameLayout for the matching value of WITH_CASE_PRESERVING_NAME
    static_assert(sizeof(FMemoryImageName) == sizeof(Freeze::TMemoryImageNameLayout<WITH_CASE_PRESERVING_NAME>));
    static_assert(STRUCT_OFFSET(FMemoryImageName, ComparisonIndex) == STRUCT_OFFSET(Freeze::TMemoryImageNameLayout<WITH_CASE_PRESERVING_NAME>, ComparisonIndex));
#if UE_FNAME_OUTLINE_NUMBER
    static_assert(STRUCT_OFFSET(FMemoryImageName, Dummy) == STRUCT_OFFSET(Freeze::TMemoryImageNameLayout<WITH_CASE_PRESERVING_NAME>, NumberOrDummy));
#else
    static_assert(STRUCT_OFFSET(FMemoryImageName, Number) == STRUCT_OFFSET(Freeze::TMemoryImageNameLayout<WITH_CASE_PRESERVING_NAME>, NumberOrDummy));
#endif
#if WITH_CASE_PRESERVING_NAME
    static_assert(STRUCT_OFFSET(FMemoryImageName, DisplayIndex) == STRUCT_OFFSET(Freeze::TMemoryImageNameLayout<WITH_CASE_PRESERVING_NAME>, DisplayIndex));
#endif
 
}
 
FORCEINLINE FMemoryImageName::FMemoryImageName(EName Name)
    : FMemoryImageName(FName(Name))
{
}
 
DECLARE_INTRINSIC_TYPE_LAYOUT(FMemoryImageName);
DECLARE_INTRINSIC_TYPE_LAYOUT(FScriptName);
 
#if UE_FNAME_OUTLINE_NUMBER
 
FORCEINLINE FName::FName(FMinimalName InName)
    : ComparisonIndex(InName.Index)
#if WITH_CASE_PRESERVING_NAME
    , DisplayIndex(InName.Index)
#endif
{
}
 
FORCEINLINE FName::FName(FScriptName InName)
    : ComparisonIndex(InName.ComparisonIndex)
#if WITH_CASE_PRESERVING_NAME
    , DisplayIndex(InName.DisplayIndex)
#endif
{
 
}
 
FORCEINLINE FName::FName(FMemoryImageName InName)
    : ComparisonIndex(InName.ComparisonIndex)
#if WITH_CASE_PRESERVING_NAME
    , DisplayIndex(InName.DisplayIndex)
#endif
{
}
 
FORCEINLINE FMinimalName::FMinimalName(const FName& Name)
    : Index(Name.GetComparisonIndexInternal())
{
}
 
FORCEINLINE FScriptName::FScriptName(const FName& Name)
    : ComparisonIndex(Name.GetComparisonIndexInternal())
#if WITH_CASE_PRESERVING_NAME
    , DisplayIndex(Name.GetDisplayIndexInternal())
#endif
{
}
 
FORCEINLINE FMemoryImageName::FMemoryImageName(const FName& Name)
    : ComparisonIndex(Name.GetComparisonIndexInternal())
#if WITH_CASE_PRESERVING_NAME
    , DisplayIndex(Name.GetDisplayIndexInternal())
#endif
{
}
 
FORCEINLINE bool FMinimalName::IsNone() const
{
    return Index.IsNone();
}
 
FORCEINLINE bool FMinimalName::UEOpLessThan(FMinimalName Rhs) const
{
    return Index < Rhs.Index;
}
 
FORCEINLINE bool FScriptName::IsNone() const
{
    return ComparisonIndex.IsNone();
}
 
FORCEINLINE bool FMemoryImageName::IsNone() const
{
    return ComparisonIndex.IsNone();
}
 
FORCEINLINE bool FName::IsEqual(const FName& Rhs, const ENameCase CompareMethod /*= ENameCase::IgnoreCase*/, const bool bCompareNumber /*= true*/) const
{
    return bCompareNumber ?
        (CompareMethod == ENameCase::IgnoreCase ? GetComparisonIndexInternal() == Rhs.GetComparisonIndexInternal() : GetDisplayIndexInternal() == Rhs.GetDisplayIndexInternal()) :  // Unresolved indices include the number, are stored in instances
        (CompareMethod == ENameCase::IgnoreCase ? GetComparisonIndex() == Rhs.GetComparisonIndex() : GetDisplayIndex() == Rhs.GetDisplayIndex()); // Resolved indices, have to hit the name table
}
 
#else // UE_FNAME_OUTLINE_NUMBER
 
FORCEINLINE FName::FName(FMinimalName InName)
    : ComparisonIndex(InName.Index)
    , Number(InName.Number)
#if WITH_CASE_PRESERVING_NAME
    , DisplayIndex(InName.Index)
#endif
{
}
 
FORCEINLINE FName::FName(FScriptName InName)
    : ComparisonIndex(InName.ComparisonIndex)
    , Number(InName.Number)
#if WITH_CASE_PRESERVING_NAME
    , DisplayIndex(InName.DisplayIndex)
#endif
{
}
 
FORCEINLINE FName::FName(FMemoryImageName InName)
    : ComparisonIndex(InName.ComparisonIndex)
    , Number(InName.Number)
#if WITH_CASE_PRESERVING_NAME
    , DisplayIndex(InName.DisplayIndex)
#endif
{
}
 
FORCEINLINE FMinimalName::FMinimalName(const FName& Name)
    : Index(Name.GetComparisonIndexInternal())
    , Number(Name.GetNumber())
{
}
 
FORCEINLINE FScriptName::FScriptName(const FName& Name)
    : ComparisonIndex(Name.GetComparisonIndexInternal())
#if WITH_CASE_PRESERVING_NAME
    , DisplayIndex(Name.GetDisplayIndexInternal())
#endif
    , Number(Name.GetNumber())
{
}
 
FORCEINLINE FMemoryImageName::FMemoryImageName(const FName& Name)
    : ComparisonIndex(Name.GetComparisonIndex())
    , Number(Name.GetNumber())
#if WITH_CASE_PRESERVING_NAME
    , DisplayIndex(Name.GetDisplayIndex())
#endif
{
}
 
FORCEINLINE bool FMinimalName::IsNone() const
{
    return Index.IsNone() && Number == NAME_NO_NUMBER_INTERNAL;
}
 
FORCEINLINE bool FMinimalName::UEOpLessThan(FMinimalName Rhs) const
{
    return Index == Rhs.Index ? Number < Rhs.Number : Index < Rhs.Index;
}
 
FORCEINLINE bool FScriptName::IsNone() const
{
    return ComparisonIndex.IsNone() && Number == NAME_NO_NUMBER_INTERNAL;
}
 
FORCEINLINE bool FMemoryImageName::IsNone() const
{
    return ComparisonIndex.IsNone() && Number == NAME_NO_NUMBER_INTERNAL;
}
 
 
FORCEINLINE bool FName::IsEqual(const FName& Rhs, const ENameCase CompareMethod /*= ENameCase::IgnoreCase*/, const bool bCompareNumber /*= true*/) const
{
    return ((CompareMethod == ENameCase::IgnoreCase) ? GetComparisonIndex() == Rhs.GetComparisonIndex() : GetDisplayIndexFast() == Rhs.GetDisplayIndexFast())
        && (!bCompareNumber || GetNumber() == Rhs.GetNumber());
}
#endif // UE_FNAME_OUTLINE_NUMBER
 
FORCEINLINE FName MinimalNameToName(FMinimalName InName)
{
    return FName(InName);
}
 
FORCEINLINE FName ScriptNameToName(FScriptName InName)
{
    return FName(InName);
}
 
FORCEINLINE FMinimalName NameToMinimalName(FName InName)
{
    return FMinimalName(InName);
}
 
FORCEINLINE FScriptName NameToScriptName(FName InName)
{
    return FScriptName(InName);
}
 
CORE_API FString LexToString(const FName& Name);
 
FORCEINLINE void LexFromString(FName& Name, const TCHAR* Str)
{
    Name = FName(Str);
}
 
inline FWideStringBuilderBase& operator<<(FWideStringBuilderBase& Builder, const FName& Name)
{
    Name.AppendString(Builder);
    return Builder;
}
 
inline FUtf8StringBuilderBase& operator<<(FUtf8StringBuilderBase& Builder, const FName& Name)
{
    Name.AppendString(Builder);
    return Builder;
}
 
CORE_API FWideStringBuilderBase& operator<<(FWideStringBuilderBase& Builder, FNameEntryId Id);
CORE_API FUtf8StringBuilderBase& operator<<(FUtf8StringBuilderBase& Builder, FNameEntryId Id);
 
template <> struct TIsPODType<FName> { enum { Value = true }; };
 
struct FNameFastLess
{
    FORCEINLINE bool operator()(const FName& A, const FName& B) const
    {
        return A.CompareIndexes(B) < 0;
    }
 
    FORCEINLINE bool operator()(FNameEntryId A, FNameEntryId B) const
    {
        return A.FastLess(B);
    }
};
 
struct FNameLexicalLess
{
    FORCEINLINE bool operator()(const FName& A, const FName& B) const
    {
        return A.Compare(B) < 0;
    }
 
    FORCEINLINE bool operator()(FNameEntryId A, FNameEntryId B) const
    {
        return A.LexicalLess(B);
    }
};
 
struct FNameDebugVisualizer
{
    CORE_API FNameDebugVisualizer(FClangKeepDebugInfo);
    CORE_API uint8** GetBlocks();
private:
    static constexpr uint32 EntryStride = alignof(FNameEntry);
    static constexpr uint32 OffsetBits = 16;
    static constexpr uint32 BlockBits = 13;
    static constexpr uint32 OffsetMask = (1 << OffsetBits) - 1;
    static constexpr uint32 UnusedMask = UINT32_MAX << BlockBits << OffsetBits;
    static constexpr uint32 MaxLength = NAME_SIZE;
};
 
class FLazyName
{
    // NOTE: Numeric values are used for comparison in UEOpEquals.
    enum class ELiteralType : uint8
    {
        None = 0,
        AnsiLiteral = 1,
        Utf8Literal = 2,
        WideLiteral = 3,
    };
 
public:
    constexpr FLazyName() = default;
 
    template <int N>
    constexpr FLazyName(const ANSICHAR (&Literal)[N])
        : Either{.AnsiLiteral = Literal}
        , Number(ParseNumber(Literal, N - 1))
        , LiteralType(ELiteralType::AnsiLiteral)
    {
    }
 
    template <int N>
    constexpr FLazyName(const UTF8CHAR (&Literal)[N])
        : Either{.Utf8Literal = Literal}
        , Number(ParseNumber(Literal, N - 1))
        , LiteralType(ELiteralType::Utf8Literal)
    {
    }
 
    template <int N>
    constexpr FLazyName(const WIDECHAR (&Literal)[N])
        : Either{.WideLiteral = Literal}
        , Number(ParseNumber(Literal, N - 1))
        , LiteralType(ELiteralType::WideLiteral)
    {
    }
 
    explicit FLazyName(FName Name)
        : Either{.PackedName = FLiteralOrName::PackName(Name.GetComparisonIndex(), Name.GetDisplayIndex())}
        , Number(Name.GetNumber())
        , LiteralType(ELiteralType::None)
    {
    }
    
    UE_REWRITE operator FName() const
    {
        return Resolve();
    }
 
    CORE_API FName Resolve() const;
 
    CORE_API FString ToString() const;
    CORE_API FUtf8String ToUtf8String() const;
 
private:
    union FLiteralOrName
    {
        // NOTE: This uses the high bit for the flag. This may be an issue in the future if the high byte
        // of an address starts being used for features like hardware ASan.
        static constexpr uint64 IsNameFlag = uint64(1) << (sizeof(uint64) * 8 - 1);
        static constexpr uint32 DisplayIdShift = 32;
 
        const ANSICHAR* AnsiLiteral;
        const UTF8CHAR* Utf8Literal;
        const WIDECHAR* WideLiteral;
        mutable uint64 PackedName = 0;
 
        static constexpr uint64 PackName(FNameEntryId ComparisonId, FNameEntryId DisplayId)
        {
            // FNameEntryId fits in 31 bits -> (DisplayId & IsNameFlag) != 0 -> IsName() == true.
            return IsNameFlag | ComparisonId.ToUnstableInt() |
                (WITH_CASE_PRESERVING_NAME ? (uint64(DisplayId.ToUnstableInt()) << DisplayIdShift) : 0);
        }
 
        constexpr bool IsName() const
        {
            return !!(PackedName & IsNameFlag);
        }
 
        inline FNameEntryId GetComparisonId() const
        {
            return FNameEntryId::FromUnstableInt(static_cast<uint32>(PackedName));
        }
 
        inline FNameEntryId GetDisplayId() const
        {
#if WITH_CASE_PRESERVING_NAME
            return FNameEntryId::FromUnstableInt(static_cast<uint32>((PackedName & ~IsNameFlag) >> DisplayIdShift));
#else
            return GetComparisonId();
#endif
        }
    };
 
    FLiteralOrName Either;
    uint32 Number = NAME_NO_NUMBER_INTERNAL;
    ELiteralType LiteralType = ELiteralType::None;
 
    // Parse the number at compile time when possible to avoid runtime initialization overhead.
    // Number must be stored upon construction to allow Resolve() to convert a literal
    // to a name without synchronization. If Number had to be written at the same time
    // it would require synchronization.
    template <typename CharType>
    UE_REWRITE static constexpr uint32 ParseNumber(const CharType* Literal, int32 Len)
    {
        UE_IF_CONSTEVAL
        {
            return UE::Core::Private::ParseNumberFromName(Literal, Len);
        }
        else
        {
            return CallParseNumber(Literal, Len);
        }
    }
 
    template <typename CharType>
    CORE_API static uint32 CallParseNumber(const CharType* Literal, int32 Len);
 
public:
    bool UEOpEquals(FName Rhs) const
    {
        // If !Rhs.IsNone(), we have started creating FNames
        // and might as well resolve and cache Lhs
        if (Either.IsName() || !Rhs.IsNone())
        {
            return Rhs == Resolve();
        }
        else if (LiteralType == ELiteralType::AnsiLiteral)
        {
            return Rhs == Either.AnsiLiteral;
        }
        else if (LiteralType == ELiteralType::Utf8Literal)
        {
            return Rhs == Either.Utf8Literal;
        }
        else
        {
            return Rhs == Either.WideLiteral;
        }
    }
 
    CORE_API bool UEOpEquals(const FLazyName& Rhs) const;
 
    friend FORCEINLINE uint32 GetTypeHash(FLazyName Name)
    {
        return GetTypeHash(Name.Resolve());
    }
};
 
// Ordering operators for FName are deliberately disabled as there is no correct default.
// Users should use the following to select the desired behavior:
//
// Lexicographical comparison:
// - Expression: NameA.LexicalLess(NameB)
// - Predicate: FNameLexicalLess
//
// Fast comparison:
// - Expression: NameA.FastLess(NameB)
// - Predicate: FNameFastLess
bool operator<(FName, FName) = delete;
bool operator>(FName, FName) = delete;
bool operator<=(FName, FName) = delete;
bool operator>=(FName, FName) = delete;
 
class FDisplayNameEntryId
{
public:
    FDisplayNameEntryId() : FDisplayNameEntryId(FName()) {}
    explicit FDisplayNameEntryId(FName Name) : FDisplayNameEntryId(Name.GetDisplayIndex(), Name.GetComparisonIndex()) {}
    FORCEINLINE FName ToName(uint32 Number) const { return FName(GetComparisonId(), GetDisplayId(), Number); }
 
private:
#if WITH_CASE_PRESERVING_NAME
    static constexpr uint32 DifferentIdsFlag = 1u << 31;
    static constexpr uint32 DisplayIdMask = ~DifferentIdsFlag;
 
    uint32 Value = 0;
 
    FDisplayNameEntryId(FNameEntryId Id, FNameEntryId CmpId) : Value(Id.ToUnstableInt() | (Id != CmpId) * DifferentIdsFlag) {}
    FORCEINLINE bool SameIds() const { return (Value & DifferentIdsFlag) == 0; }
    FORCEINLINE FNameEntryId GetDisplayId() const { return FNameEntryId::FromUnstableInt(Value & DisplayIdMask); }
    FORCEINLINE FNameEntryId GetComparisonId() const { return SameIds() ? GetDisplayId() : FName::GetComparisonIdFromDisplayId(GetDisplayId()); }
public:
    bool UEOpEquals(FDisplayNameEntryId Rhs) const { return Value == Rhs.Value; }
#else
    FNameEntryId Id;
 
    FDisplayNameEntryId(FNameEntryId InId, FNameEntryId) : Id(InId) {}
    FORCEINLINE FNameEntryId GetDisplayId() const { return Id; }
    FORCEINLINE FNameEntryId GetComparisonId() const { return Id; }
public:
    bool UEOpEquals(FDisplayNameEntryId Rhs) const { return Id == Rhs.Id; }
#endif
    bool UEOpEquals(FNameEntryId Rhs) const { return GetDisplayId() == Rhs; }
    [[nodiscard]] friend uint32 GetTypeHash(FDisplayNameEntryId InId) { return GetTypeHash(InId.GetDisplayId()); }
 
public: // Internal functions for batch serialization code - intentionally lacking CORE_API
    static FDisplayNameEntryId FromComparisonId(FNameEntryId ComparisonId);
    FNameEntryId ToDisplayId() const;
    void SetLoadedComparisonId(FNameEntryId ComparisonId); // Called first
#if WITH_CASE_PRESERVING_NAME
    void SetLoadedDifferentDisplayId(FNameEntryId DisplayId); // Called second if display id differs
    FNameEntryId GetLoadedComparisonId() const; // Get the already loaded comparison id
#endif
};
 
class FNameBuilder : public TStringBuilder<FName::StringBufferSize>
{
public:
    FNameBuilder() = default;
 
    inline explicit FNameBuilder(const FName InName)
    {
        InName.AppendString(*this);
    }
};
 
template <> struct TIsContiguousContainer<FNameBuilder> { static constexpr inline bool Value = true; };
 
class FBlake3;
CORE_API void AppendHash(FBlake3& Builder, FName In);