TextHistory.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "Async/TransactionallySafeMutex.h"
#include "Containers/Array.h"
#include "CoreTypes.h"
#include "HAL/CriticalSection.h"
#include "Internationalization/CulturePointer.h"
#include "Internationalization/ITextData.h"
#include "Internationalization/LocalizedTextSourceTypes.h"
#include "Internationalization/StringTableCoreFwd.h"
#include "Internationalization/Text.h"
#include "Internationalization/TextKey.h"
#include "Misc/DateTime.h"
#include "Misc/TransactionallySafeCriticalSection.h"
#include "Serialization/StructuredArchive.h"
#include "Templates/SharedPointerInternals.h"
#include "Templates/UnrealTemplate.h"
#include "UObject/NameTypes.h"
 
class ITextGenerator;
struct FDecimalNumberFormattingRules;
 
enum class ETextHistoryType : int8
{
    None = -1,
    Base = 0,
    NamedFormat,
    OrderedFormat,
    ArgumentFormat,
    AsNumber,
    AsPercent,
    AsCurrency,
    AsDate,
    AsTime,
    AsDateTime,
    Transform,
    StringTableEntry,
    TextGenerator,
 
    // Add new enum types at the end only! They are serialized by index.
};
 
#define OVERRIDE_TEXT_HISTORY_STRINGIFICATION                                                                                       \
    static  bool StaticShouldReadFromBuffer(const TCHAR* Buffer);                                                                   \
    virtual bool ShouldReadFromBuffer(const TCHAR* Buffer) const override { return StaticShouldReadFromBuffer(Buffer); }            \
    virtual const TCHAR* ReadFromBuffer(const TCHAR* Buffer, const TCHAR* TextNamespace, const TCHAR* PackageNamespace) override;   \
    virtual bool WriteToBuffer(FString& Buffer, const bool bStripPackageNamespace) const override;
 
namespace TextStringificationUtil
{
 
#define LOC_DEFINE_REGION
inline const auto& TextMarker = TEXT("TEXT");
inline const auto& InvTextMarker = TEXT("INVTEXT");
inline const auto& NsLocTextMarker = TEXT("NSLOCTEXT");
inline const auto& LocTextMarker = TEXT("LOCTEXT");
inline const auto& LocTableMarker = TEXT("LOCTABLE");
inline const auto& LocGenNumberMarker = TEXT("LOCGEN_NUMBER");
inline const auto& LocGenPercentMarker = TEXT("LOCGEN_PERCENT");
inline const auto& LocGenCurrencyMarker = TEXT("LOCGEN_CURRENCY");
inline const auto& LocGenDateMarker = TEXT("LOCGEN_DATE");
inline const auto& LocGenTimeMarker = TEXT("LOCGEN_TIME");
inline const auto& LocGenDateTimeMarker = TEXT("LOCGEN_DATETIME");
inline const auto& LocGenToLowerMarker = TEXT("LOCGEN_TOLOWER");
inline const auto& LocGenToUpperMarker = TEXT("LOCGEN_TOUPPER");
inline const auto& LocGenFormatOrderedMarker = TEXT("LOCGEN_FORMAT_ORDERED");
inline const auto& LocGenFormatNamedMarker = TEXT("LOCGEN_FORMAT_NAMED");
inline const auto& GroupedSuffix = TEXT("_GROUPED");
inline const auto& UngroupedSuffix = TEXT("_UNGROUPED");
inline const auto& CustomSuffix = TEXT("_CUSTOM");
inline const auto& UtcSuffix = TEXT("_UTC");
inline const auto& LocalSuffix = TEXT("_LOCAL");
#undef LOC_DEFINE_REGION
 
#define TEXT_STRINGIFICATION_FUNC_MODIFY_BUFFER_AND_VALIDATE(Func, ...)     \
    Buffer = Func(Buffer, ##__VA_ARGS__);                                   \
    if (!Buffer) { return nullptr; }
 
#define TEXT_STRINGIFICATION_PEEK_MARKER(T)                 TextStringificationUtil::PeekMarker(Buffer, T, UE_ARRAY_COUNT(T) - 1)
#define TEXT_STRINGIFICATION_PEEK_INSENSITIVE_MARKER(T)     TextStringificationUtil::PeekInsensitiveMarker(Buffer, T, UE_ARRAY_COUNT(T) - 1)
bool PeekMarker(const TCHAR* Buffer, const TCHAR* InMarker, const int32 InMarkerLen);
bool PeekInsensitiveMarker(const TCHAR* Buffer, const TCHAR* InMarker, const int32 InMarkerLen);
 
#define TEXT_STRINGIFICATION_SKIP_MARKER(T)                 TEXT_STRINGIFICATION_FUNC_MODIFY_BUFFER_AND_VALIDATE(TextStringificationUtil::SkipMarker, T, UE_ARRAY_COUNT(T) - 1)
#define TEXT_STRINGIFICATION_SKIP_INSENSITIVE_MARKER(T)     TEXT_STRINGIFICATION_FUNC_MODIFY_BUFFER_AND_VALIDATE(TextStringificationUtil::SkipInsensitiveMarker, T, UE_ARRAY_COUNT(T) - 1)
#define TEXT_STRINGIFICATION_SKIP_MARKER_LEN(T)             Buffer += (UE_ARRAY_COUNT(T) - 1)
const TCHAR* SkipMarker(const TCHAR* Buffer, const TCHAR* InMarker, const int32 InMarkerLen);
const TCHAR* SkipInsensitiveMarker(const TCHAR* Buffer, const TCHAR* InMarker, const int32 InMarkerLen);
 
#define TEXT_STRINGIFICATION_SKIP_WHITESPACE()              TEXT_STRINGIFICATION_FUNC_MODIFY_BUFFER_AND_VALIDATE(TextStringificationUtil::SkipWhitespace)
const TCHAR* SkipWhitespace(const TCHAR* Buffer);
 
#define TEXT_STRINGIFICATION_SKIP_WHITESPACE_TO_CHAR(C)     TEXT_STRINGIFICATION_FUNC_MODIFY_BUFFER_AND_VALIDATE(TextStringificationUtil::SkipWhitespaceToCharacter, TEXT(C))
const TCHAR* SkipWhitespaceToCharacter(const TCHAR* Buffer, const TCHAR InChar);
 
#define TEXT_STRINGIFICATION_SKIP_WHITESPACE_AND_CHAR(C)    TEXT_STRINGIFICATION_FUNC_MODIFY_BUFFER_AND_VALIDATE(TextStringificationUtil::SkipWhitespaceAndCharacter, TEXT(C))
const TCHAR* SkipWhitespaceAndCharacter(const TCHAR* Buffer, const TCHAR InChar);
 
#define TEXT_STRINGIFICATION_READ_NUMBER(V)                 TEXT_STRINGIFICATION_FUNC_MODIFY_BUFFER_AND_VALIDATE(TextStringificationUtil::ReadNumberFromBuffer, V)
const TCHAR* ReadNumberFromBuffer(const TCHAR* Buffer, FFormatArgumentValue& OutValue);
 
#define TEXT_STRINGIFICATION_READ_ALNUM(V)                  TEXT_STRINGIFICATION_FUNC_MODIFY_BUFFER_AND_VALIDATE(TextStringificationUtil::ReadAlnumFromBuffer, V)
const TCHAR* ReadAlnumFromBuffer(const TCHAR* Buffer, FString& OutValue);
 
#define TEXT_STRINGIFICATION_READ_QUOTED_STRING(V)          TEXT_STRINGIFICATION_FUNC_MODIFY_BUFFER_AND_VALIDATE(TextStringificationUtil::ReadQuotedStringFromBuffer, V)
const TCHAR* ReadQuotedStringFromBuffer(const TCHAR* Buffer, FString& OutStr);
 
#define TEXT_STRINGIFICATION_READ_SCOPED_ENUM(S, V)         TEXT_STRINGIFICATION_FUNC_MODIFY_BUFFER_AND_VALIDATE(TextStringificationUtil::ReadScopedEnumFromBuffer, S, V)
template <typename T>
const TCHAR* ReadScopedEnumFromBuffer(const TCHAR* Buffer, const FString& Scope, T& OutValue)
{
    if (PeekInsensitiveMarker(Buffer, *Scope, Scope.Len()))
    {
        // Parsing something of the form: EEnumName::...
        Buffer += Scope.Len();
 
        FString EnumValueString;
        Buffer = ReadAlnumFromBuffer(Buffer, EnumValueString);
 
        if (Buffer && LexTryParseString(OutValue, *EnumValueString))
        {
            return Buffer;
        }
    }
 
    return nullptr;
}
 
template <typename T>
void WriteScopedEnumToBuffer(FString& Buffer, const TCHAR* Scope, const T Value)
{
    Buffer += Scope;
    Buffer += LexToString(Value);
}
 
}   // namespace TextStringificationUtil
 
class FTextHistory : public ITextData, public TRefCountingMixin<FTextHistory>
{
public:
    FTextHistory() = default;
    virtual ~FTextHistory() = default;
 
    FTextHistory(const FTextHistory&) = delete;
    FTextHistory& operator=(FTextHistory&) = delete;
 
    //~ IRefCountedObject
    virtual FReturnedRefCountValue AddRef() const override final { return TRefCountingMixin<FTextHistory>::AddRef(); }
    virtual uint32 Release() const override final { return TRefCountingMixin<FTextHistory>::Release(); }
    virtual uint32 GetRefCount() const override final { return TRefCountingMixin<FTextHistory>::GetRefCount(); }
 
    //~ ITextData
    virtual const FString& GetSourceString() const override { return GetDisplayString(); }
    virtual FTextConstDisplayStringPtr GetLocalizedString() const override { return nullptr; }
    virtual uint16 GetGlobalHistoryRevision() const override final;
    virtual uint16 GetLocalHistoryRevision() const override final;
    virtual const FTextHistory& GetTextHistory() const override final { return *this; }
    virtual FTextHistory& GetMutableTextHistory() override final { return *this; }
 
    virtual ETextHistoryType GetType() const = 0;
 
    virtual FTextId GetTextId() const { return FTextId(); }
 
    virtual FString BuildInvariantDisplayString() const = 0;
 
    virtual bool IdenticalTo(const FTextHistory& Other, const ETextIdenticalModeFlags CompareModeFlags) const = 0;
 
    virtual void Serialize(FStructuredArchive::FRecord Record) = 0;
 
    static  bool StaticShouldReadFromBuffer(const TCHAR* Buffer) { return false; }
    virtual bool ShouldReadFromBuffer(const TCHAR* Buffer) const { return StaticShouldReadFromBuffer(Buffer); }
 
    virtual const TCHAR* ReadFromBuffer(const TCHAR* Buffer, const TCHAR* TextNamespace, const TCHAR* PackageNamespace) { return nullptr; }
 
    virtual bool WriteToBuffer(FString& Buffer, const bool bStripPackageNamespace) const { return false; }
 
    virtual void GetHistoricFormatData(const FText& InText, TArray<FHistoricTextFormatData>& OutHistoricFormatData) const {}
 
    virtual bool GetHistoricNumericData(const FText& InText, FHistoricTextNumericData& OutHistoricNumericData) const { return false; }
 
    void UpdateDisplayStringIfOutOfDate();
 
protected:
    virtual bool CanUpdateDisplayString() { return true; }
 
    virtual void UpdateDisplayString() = 0;
 
    void MarkDisplayStringOutOfDate();
 
    void MarkDisplayStringUpToDate();
 
private:
    uint16 GlobalRevision = 0;
    uint16 LocalRevision = 0;
    mutable UE::FTransactionallySafeMutex Mutex = UE::FTransactionallySafeMutex();
};
 
class FTextHistory_Base : public FTextHistory
{
public:
    FTextHistory_Base() = default;
    FTextHistory_Base(const FTextId& InTextId, FString&& InSourceString);
    FTextHistory_Base(const FTextId& InTextId, FString&& InSourceString, FTextConstDisplayStringPtr&& InLocalizedString);
 
    //~ Begin FTextHistory Interface
    OVERRIDE_TEXT_HISTORY_STRINGIFICATION;
    virtual ETextHistoryType GetType() const override { return ETextHistoryType::Base; }
    virtual FTextId GetTextId() const override final;
    virtual FTextConstDisplayStringPtr GetLocalizedString() const override;
    virtual const FString& GetSourceString() const override;
    virtual const FString& GetDisplayString() const override;
    virtual FString BuildInvariantDisplayString() const override;
    virtual bool IdenticalTo(const FTextHistory& Other, const ETextIdenticalModeFlags CompareModeFlags) const override;
    virtual void Serialize(FStructuredArchive::FRecord Record) override;
    virtual bool CanUpdateDisplayString() override;
    virtual void UpdateDisplayString() override;
    //~ End FTextHistory Interface
 
private:
    FTextId TextId;
    FString SourceString;
    FTextConstDisplayStringPtr LocalizedString;
};
 
class FTextHistory_Generated : public FTextHistory
{
public:
    FTextHistory_Generated() = default;
    explicit FTextHistory_Generated(FString&& InDisplayString);
 
    //~ Begin FTextHistory Interface
    virtual FTextId GetTextId() const override final { return FTextId(); }
    virtual const FString& GetDisplayString() const override;
    virtual void Serialize(FStructuredArchive::FRecord Record) override;
    virtual void UpdateDisplayString() override;
    //~ End FTextHistory Interface
 
protected:
    virtual FString BuildLocalizedDisplayString() const = 0;
 
    FString DisplayString;
};
 
class FTextHistory_NamedFormat : public FTextHistory_Generated
{
public:
    FTextHistory_NamedFormat() = default;
    FTextHistory_NamedFormat(FString&& InDisplayString, FTextFormat&& InSourceFmt, FFormatNamedArguments&& InArguments);
 
    //~ Begin FTextHistory Interface
    OVERRIDE_TEXT_HISTORY_STRINGIFICATION;
    virtual ETextHistoryType GetType() const override { return ETextHistoryType::NamedFormat; }
    virtual bool IdenticalTo(const FTextHistory& Other, const ETextIdenticalModeFlags CompareModeFlags) const override;
    virtual FString BuildLocalizedDisplayString() const override;
    virtual FString BuildInvariantDisplayString() const override;
    virtual void Serialize(FStructuredArchive::FRecord Record) override;
    virtual void GetHistoricFormatData(const FText& InText, TArray<FHistoricTextFormatData>& OutHistoricFormatData) const override;
    //~ End FTextHistory Interface
 
private:
    FTextFormat SourceFmt;
    FFormatNamedArguments Arguments;
};
 
class FTextHistory_OrderedFormat : public FTextHistory_Generated
{
public:
    FTextHistory_OrderedFormat() = default;
    FTextHistory_OrderedFormat(FString&& InDisplayString, FTextFormat&& InSourceFmt, FFormatOrderedArguments&& InArguments);
 
    //~ Begin FTextHistory Interface
    OVERRIDE_TEXT_HISTORY_STRINGIFICATION;
    virtual ETextHistoryType GetType() const override { return ETextHistoryType::OrderedFormat; }
    virtual bool IdenticalTo(const FTextHistory& Other, const ETextIdenticalModeFlags CompareModeFlags) const override;
    virtual FString BuildLocalizedDisplayString() const override;
    virtual FString BuildInvariantDisplayString() const override;
    virtual void Serialize(FStructuredArchive::FRecord Record) override;
    virtual void GetHistoricFormatData(const FText& InText, TArray<FHistoricTextFormatData>& OutHistoricFormatData) const override;
    //~ End FTextHistory Interface
 
private:
    FTextFormat SourceFmt;
    FFormatOrderedArguments Arguments;
};
 
class FTextHistory_ArgumentDataFormat : public FTextHistory_Generated
{
public:
    FTextHistory_ArgumentDataFormat() = default;
    FTextHistory_ArgumentDataFormat(FString&& InDisplayString, FTextFormat&& InSourceFmt, TArray<FFormatArgumentData>&& InArguments);
 
    //~ Begin FTextHistory Interface
    OVERRIDE_TEXT_HISTORY_STRINGIFICATION;
    virtual ETextHistoryType GetType() const override { return ETextHistoryType::ArgumentFormat; }
    virtual bool IdenticalTo(const FTextHistory& Other, const ETextIdenticalModeFlags CompareModeFlags) const override;
    virtual FString BuildLocalizedDisplayString() const override;
    virtual FString BuildInvariantDisplayString() const override;
    virtual void Serialize(FStructuredArchive::FRecord Record) override;
    virtual void GetHistoricFormatData(const FText& InText, TArray<FHistoricTextFormatData>& OutHistoricFormatData) const override;
    //~ End FTextHistory Interface
 
private:
    FTextFormat SourceFmt;
    TArray<FFormatArgumentData> Arguments;
};
 
class FTextHistory_FormatNumber : public FTextHistory_Generated
{
public:
    FTextHistory_FormatNumber() = default;
    FTextHistory_FormatNumber(FString&& InDisplayString, FFormatArgumentValue InSourceValue, const FNumberFormattingOptions* const InFormatOptions, FCulturePtr InTargetCulture);
 
    //~ Begin FTextHistory Interface
    virtual bool IdenticalTo(const FTextHistory& Other, const ETextIdenticalModeFlags CompareModeFlags) const override;
    virtual void Serialize(FStructuredArchive::FRecord Record) override;
    //~ End FTextHistory interface
 
protected:
    FString BuildNumericDisplayString(const FDecimalNumberFormattingRules& InFormattingRules, const int32 InValueMultiplier = 1) const;
 
    FFormatArgumentValue SourceValue;
    TOptional<FNumberFormattingOptions> FormatOptions;
    FCulturePtr TargetCulture;
};
 
class FTextHistory_AsNumber : public FTextHistory_FormatNumber
{
public:
    FTextHistory_AsNumber() = default;
    FTextHistory_AsNumber(FString&& InDisplayString, FFormatArgumentValue InSourceValue, const FNumberFormattingOptions* const InFormatOptions, FCulturePtr InTargetCulture);
 
    //~ Begin FTextHistory Interface
    OVERRIDE_TEXT_HISTORY_STRINGIFICATION;
    virtual ETextHistoryType GetType() const override { return ETextHistoryType::AsNumber; }
    virtual FString BuildLocalizedDisplayString() const override;
    virtual FString BuildInvariantDisplayString() const override;
    virtual void Serialize(FStructuredArchive::FRecord Record) override;
    virtual bool GetHistoricNumericData(const FText& InText, FHistoricTextNumericData& OutHistoricNumericData) const override;
    //~ End FTextHistory interface
};
 
class FTextHistory_AsPercent : public FTextHistory_FormatNumber
{
public:
    FTextHistory_AsPercent() = default;
    FTextHistory_AsPercent(FString&& InDisplayString, FFormatArgumentValue InSourceValue, const FNumberFormattingOptions* const InFormatOptions, FCulturePtr InTargetCulture);
 
    //~ Begin FTextHistory Interface
    OVERRIDE_TEXT_HISTORY_STRINGIFICATION;
    virtual ETextHistoryType GetType() const override { return ETextHistoryType::AsPercent; }
    virtual FString BuildLocalizedDisplayString() const override;
    virtual FString BuildInvariantDisplayString() const override;
    virtual void Serialize(FStructuredArchive::FRecord Record) override;
    virtual bool GetHistoricNumericData(const FText& InText, FHistoricTextNumericData& OutHistoricNumericData) const override;
    //~ End FTextHistory interface
};
 
class FTextHistory_AsCurrency : public FTextHistory_FormatNumber
{
public:
    FTextHistory_AsCurrency() = default;
    FTextHistory_AsCurrency(FString&& InDisplayString, FFormatArgumentValue InSourceValue, FString InCurrencyCode, const FNumberFormattingOptions* const InFormatOptions, FCulturePtr InTargetCulture);
 
    //~ Begin FTextHistory Interface
    OVERRIDE_TEXT_HISTORY_STRINGIFICATION;
    virtual ETextHistoryType GetType() const override { return ETextHistoryType::AsCurrency; }
    virtual FString BuildLocalizedDisplayString() const override;
    virtual FString BuildInvariantDisplayString() const override;
    virtual void Serialize(FStructuredArchive::FRecord Record) override;
    //~ End FTextHistory Interface
 
private:
    FString CurrencyCode;
};
 
class FTextHistory_AsDate : public FTextHistory_Generated
{
public:
    FTextHistory_AsDate() = default;
    FTextHistory_AsDate(FString&& InDisplayString, FDateTime InSourceDateTime, const EDateTimeStyle::Type InDateStyle, FString InTimeZone, FCulturePtr InTargetCulture);
 
    //~ Begin FTextHistory Interface
    OVERRIDE_TEXT_HISTORY_STRINGIFICATION;
    virtual ETextHistoryType GetType() const override { return ETextHistoryType::AsDate; }
    virtual bool IdenticalTo(const FTextHistory& Other, const ETextIdenticalModeFlags CompareModeFlags) const override;
    virtual FString BuildLocalizedDisplayString() const override;
    virtual FString BuildInvariantDisplayString() const override;
    virtual void Serialize(FStructuredArchive::FRecord Record) override;
    //~ End FTextHistory Interface
 
private:
    FDateTime SourceDateTime;
    EDateTimeStyle::Type DateStyle;
    FString TimeZone;
    FCulturePtr TargetCulture;
};
 
class FTextHistory_AsTime : public FTextHistory_Generated
{
public:
    FTextHistory_AsTime() = default;
    FTextHistory_AsTime(FString&& InDisplayString, FDateTime InSourceDateTime, const EDateTimeStyle::Type InTimeStyle, FString InTimeZone, FCulturePtr InTargetCulture);
 
    //~ Begin FTextHistory Interface
    OVERRIDE_TEXT_HISTORY_STRINGIFICATION;
    virtual ETextHistoryType GetType() const override { return ETextHistoryType::AsTime; }
    virtual bool IdenticalTo(const FTextHistory& Other, const ETextIdenticalModeFlags CompareModeFlags) const override;
    virtual FString BuildLocalizedDisplayString() const override;
    virtual FString BuildInvariantDisplayString() const override;
    virtual void Serialize(FStructuredArchive::FRecord Record) override;
    //~ End FTextHistory Interface
 
private:
    FDateTime SourceDateTime;
    EDateTimeStyle::Type TimeStyle;
    FString TimeZone;
    FCulturePtr TargetCulture;
};
 
class FTextHistory_AsDateTime : public FTextHistory_Generated
{
public:
    FTextHistory_AsDateTime() = default;
    FTextHistory_AsDateTime(FString&& InDisplayString, FDateTime InSourceDateTime, const EDateTimeStyle::Type InDateStyle, const EDateTimeStyle::Type InTimeStyle, FString InTimeZone, FCulturePtr InTargetCulture);
    FTextHistory_AsDateTime(FString&& InDisplayString, FDateTime InSourceDateTime, FString InCustomPattern, FString InTimeZone, FCulturePtr InTargetCulture);
 
    //~ Begin FTextHistory Interface
    OVERRIDE_TEXT_HISTORY_STRINGIFICATION;
    virtual ETextHistoryType GetType() const override { return ETextHistoryType::AsDateTime; }
    virtual bool IdenticalTo(const FTextHistory& Other, const ETextIdenticalModeFlags CompareModeFlags) const override;
    virtual FString BuildLocalizedDisplayString() const override;
    virtual FString BuildInvariantDisplayString() const override;
    virtual void Serialize(FStructuredArchive::FRecord Record) override;
    //~ End FTextHistory Interfaces
 
private:
    FDateTime SourceDateTime;
    EDateTimeStyle::Type DateStyle;
    EDateTimeStyle::Type TimeStyle;
    FString CustomPattern;
    FString TimeZone;
    FCulturePtr TargetCulture;
};
 
class FTextHistory_Transform : public FTextHistory_Generated
{
public:
    enum class ETransformType : uint8
    {
        ToLower = 0,
        ToUpper,
 
        // Add new enum types at the end only! They are serialized by index.
    };
 
    FTextHistory_Transform() = default;
    FTextHistory_Transform(FString&& InDisplayString, FText InSourceText, const ETransformType InTransformType);
 
    //~ Begin FTextHistory Interface
    OVERRIDE_TEXT_HISTORY_STRINGIFICATION;
    virtual ETextHistoryType GetType() const override { return ETextHistoryType::Transform; }
    virtual bool IdenticalTo(const FTextHistory& Other, const ETextIdenticalModeFlags CompareModeFlags) const override;
    virtual FString BuildLocalizedDisplayString() const override;
    virtual FString BuildInvariantDisplayString() const override;
    virtual void Serialize(FStructuredArchive::FRecord Record) override;
    virtual void GetHistoricFormatData(const FText& InText, TArray<FHistoricTextFormatData>& OutHistoricFormatData) const override;
    virtual bool GetHistoricNumericData(const FText& InText, FHistoricTextNumericData& OutHistoricNumericData) const override;
    //~ End FTextHistory Interfaces
 
private:
    FText SourceText;
    ETransformType TransformType;
};
 
class FTextHistory_StringTableEntry : public FTextHistory
{
public:
    FTextHistory_StringTableEntry() = default;
    FTextHistory_StringTableEntry(FName InTableId, const FTextKey& InKey, const EStringTableLoadingPolicy InLoadingPolicy);
 
    //~ Begin FTextHistory Interface
    OVERRIDE_TEXT_HISTORY_STRINGIFICATION;
    virtual ETextHistoryType GetType() const override { return ETextHistoryType::StringTableEntry; }
    virtual FTextId GetTextId() const override final;
    virtual FTextConstDisplayStringPtr GetLocalizedString() const override;
    virtual const FString& GetSourceString() const override;
    virtual const FString& GetDisplayString() const override;
    virtual FString BuildInvariantDisplayString() const override;
    virtual bool IdenticalTo(const FTextHistory& Other, const ETextIdenticalModeFlags CompareModeFlags) const override;
    virtual void Serialize(FStructuredArchive::FRecord Record) override;
    virtual void UpdateDisplayString() override;
    //~ End FTextHistory Interface
 
    void GetTableIdAndKey(FName& OutTableId, FTextKey& OutKey) const;
 
private:
    enum class EStringTableLoadingPhase : uint8
    {
        PendingLoad,
        Loading,
        Loaded,
    };
 
    class FStringTableReferenceData : public TSharedFromThis<FStringTableReferenceData, ESPMode::ThreadSafe>
    {
    public:
        void Initialize(FName InTableId, const FTextKey& InKey, const EStringTableLoadingPolicy InLoadingPolicy);
 
        bool IsIdentical(const FStringTableReferenceData& Other) const;
 
        FName GetTableId() const;
 
        FTextKey GetKey() const;
 
        void GetTableIdAndKey(FName& OutTableId, FTextKey& OutKey) const;
 
        void CollectStringTableAssetReferences(FStructuredArchive::FRecord Record);
 
        FTextId GetTextId();
 
        FStringTableEntryConstPtr ResolveStringTableEntry();
 
        FTextConstDisplayStringPtr ResolveDisplayString(const bool bForceRefresh = false);
 
    private:
        void ConditionalBeginAssetLoad();
 
        FName TableId;
 
        FTextKey Key;
 
        EStringTableLoadingPhase LoadingPhase = EStringTableLoadingPhase::PendingLoad;
 
        FStringTableEntryConstWeakPtr StringTableEntry;
 
        FTextConstDisplayStringPtr DisplayString;
 
        mutable FTransactionallySafeCriticalSection DataCS;
    };
    typedef TSharedPtr<FStringTableReferenceData, ESPMode::ThreadSafe> FStringTableReferenceDataPtr;
    typedef TWeakPtr<FStringTableReferenceData, ESPMode::ThreadSafe> FStringTableReferenceDataWeakPtr;
 
    FStringTableReferenceDataPtr StringTableReferenceData;
};
 
class FTextHistory_TextGenerator : public FTextHistory_Generated
{
public:
    FTextHistory_TextGenerator() = default;
    FTextHistory_TextGenerator(FString&& InDisplayString, const TSharedRef<ITextGenerator>& InTextGenerator);
 
    //~ Begin FTextHistory Interface
    virtual ETextHistoryType GetType() const override { return ETextHistoryType::TextGenerator; }
    virtual bool IdenticalTo(const FTextHistory& Other, const ETextIdenticalModeFlags CompareModeFlags) const override;
    virtual FString BuildLocalizedDisplayString() const override;
    virtual FString BuildInvariantDisplayString() const override;
    virtual void Serialize(FStructuredArchive::FRecord Record) override;
    //~ End FTextHistory Interface
 
private:
    TSharedPtr<ITextGenerator> TextGenerator;
};
 
#undef OVERRIDE_TEXT_HISTORY_STRINGIFICATION