TextKey.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "Templates/TypeHash.h"
#include "Containers/StringConv.h"
#include "Containers/StringView.h"
#include "Containers/UnrealString.h"
#include "Serialization/StructuredArchive.h"
 
#ifndef UE_TEXTKEY_STORE_EMBEDDED_HASH
    #define UE_TEXTKEY_STORE_EMBEDDED_HASH (0)
#endif
 
namespace TextKeyUtil
{
    CORE_API uint32 HashString(const FTCHARToUTF16& InStr);
    UE_FORCEINLINE_HINT uint32 HashString(const FTCHARToUTF16& InStr, const uint32 InBaseHash)
    {
        return HashCombine(HashString(InStr), InBaseHash);
    }
 
    inline uint32 HashString(const TCHAR* InStr)
    {
        FTCHARToUTF16 UTF16String(InStr);
        return HashString(UTF16String);
    }
    inline uint32 HashString(const TCHAR* InStr, const uint32 InBaseHash)
    {
        FTCHARToUTF16 UTF16String(InStr);
        return HashString(UTF16String, InBaseHash);
    }
 
    inline uint32 HashString(const TCHAR* InStr, const int32 InStrLen)
    {
        FTCHARToUTF16 UTF16String(InStr, InStrLen);
        return HashString(UTF16String);
    }
    inline uint32 HashString(const TCHAR* InStr, const int32 InStrLen, const uint32 InBaseHash)
    {
        FTCHARToUTF16 UTF16String(InStr, InStrLen);
        return HashString(UTF16String, InBaseHash);
    }
 
    UE_FORCEINLINE_HINT uint32 HashString(const FString& InStr)
    {
        return HashString(*InStr, InStr.Len());
    }
    UE_FORCEINLINE_HINT uint32 HashString(const FString& InStr, const uint32 InBaseHash)
    {
        return HashString(*InStr, InStr.Len(), InBaseHash);
    }
 
    UE_FORCEINLINE_HINT uint32 HashString(FStringView InStr)
    {
        return HashString(InStr.GetData(), InStr.Len());
    }
    UE_FORCEINLINE_HINT uint32 HashString(FStringView InStr, const uint32 InBaseHash)
    {
        return HashString(InStr.GetData(), InStr.Len(), InBaseHash);
    }
}
 
class FTextKey
{
public:
    FTextKey() = default;
    CORE_API FTextKey(FStringView InStr);
    CORE_API FTextKey(const TCHAR* InStr);
    CORE_API FTextKey(const FString& InStr);
 
    UE_DEPRECATED(5.5, "GetChars is deprecated as FTextKey may now store its internal data as UTF-8. Use ToString/AppendString instead.")
    CORE_API const TCHAR* GetChars() const;
 
    CORE_API FString ToString() const;
    CORE_API void ToString(FString& Out) const;
    CORE_API void ToString(FStringBuilderBase& Out) const;
    CORE_API void AppendString(FString& Out) const;
    CORE_API void AppendString(FStringBuilderBase& Out) const;
 
    friend UE_FORCEINLINE_HINT bool operator==(const FTextKey& A, const FTextKey& B)
    {
        return A.Index == B.Index;
    }
 
    friend UE_FORCEINLINE_HINT bool operator!=(const FTextKey& A, const FTextKey& B)
    {
        return A.Index != B.Index;
    }
 
    friend CORE_API uint32 GetTypeHash(const FTextKey& A);
 
    CORE_API void SerializeAsString(FArchive& Ar);
 
    CORE_API void SerializeWithHash(FArchive& Ar);
 
    CORE_API void SerializeDiscardHash(FArchive& Ar);
 
    CORE_API void SerializeAsString(FStructuredArchiveSlot Slot);
 
    CORE_API void SerializeWithHash(FStructuredArchiveSlot Slot);
 
    CORE_API void SerializeDiscardHash(FStructuredArchiveSlot Slot);
 
    UE_FORCEINLINE_HINT bool IsEmpty() const
    {
        return Index == INDEX_NONE;
    }
 
    inline void Reset()
    {
        Index = INDEX_NONE;
#if UE_TEXTKEY_STORE_EMBEDDED_HASH
        StrHash = 0;
#endif
    }
 
    static CORE_API void CompactDataStructures();
 
    static CORE_API void TearDown();
 
private:
    int32 Index = INDEX_NONE;
 
#if UE_TEXTKEY_STORE_EMBEDDED_HASH
    uint32 StrHash = 0;
#endif
 
    friend class FTextKeyState;
};
 
class FTextId
{
public:
    FTextId() = default;
 
    FTextId(const FTextKey& InNamespace, const FTextKey& InKey)
        : Namespace(InNamespace)
        , Key(InKey)
    {
    }
 
    UE_FORCEINLINE_HINT FTextKey GetNamespace() const
    {
        return Namespace;
    }
 
    UE_FORCEINLINE_HINT FTextKey GetKey() const
    {
        return Key;
    }
 
    friend UE_FORCEINLINE_HINT bool operator==(const FTextId& A, const FTextId& B)
    {
        return A.Namespace == B.Namespace && A.Key == B.Key;
    }
 
    friend UE_FORCEINLINE_HINT bool operator!=(const FTextId& A, const FTextId& B)
    {
        return A.Namespace != B.Namespace || A.Key != B.Key;
    }
 
    friend UE_FORCEINLINE_HINT uint32 GetTypeHash(const FTextId& A)
    {
        return HashCombine(GetTypeHash(A.Namespace), GetTypeHash(A.Key));
    }
 
    void SerializeAsString(FArchive& Ar)
    {
        Namespace.SerializeAsString(Ar);
        Key.SerializeAsString(Ar);
    }
 
    void SerializeWithHash(FArchive& Ar)
    {
        Namespace.SerializeWithHash(Ar);
        Key.SerializeWithHash(Ar);
    }
 
    void SerializeDiscardHash(FArchive& Ar)
    {
        Namespace.SerializeDiscardHash(Ar);
        Key.SerializeDiscardHash(Ar);
    }
 
    void SerializeAsString(FStructuredArchiveSlot Slot)
    {
        FStructuredArchiveRecord Record = Slot.EnterRecord();
 
        Namespace.SerializeAsString(Record.EnterField(TEXT("Namespace")));
        Key.SerializeAsString(Record.EnterField(TEXT("Key")));
    }
 
    void SerializeWithHash(FStructuredArchiveSlot Slot)
    {
        FStructuredArchiveRecord Record = Slot.EnterRecord();
 
        Namespace.SerializeWithHash(Record.EnterField(TEXT("Namespace")));
        Key.SerializeWithHash(Record.EnterField(TEXT("Key")));
    }
 
    void SerializeDiscardHash(FStructuredArchiveSlot Slot)
    {
        FStructuredArchiveRecord Record = Slot.EnterRecord();
 
        Namespace.SerializeDiscardHash(Record.EnterField(TEXT("Namespace")));
        Key.SerializeDiscardHash(Record.EnterField(TEXT("Key")));
    }
 
    UE_FORCEINLINE_HINT bool IsEmpty() const
    {
        return Namespace.IsEmpty() && Key.IsEmpty();
    }
 
    inline void Reset()
    {
        Namespace.Reset();
        Key.Reset();
    }
 
private:
    FTextKey Namespace;
    FTextKey Key;
};