Text.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
 
#include "CoreTypes.h"
#include "HAL/PlatformAtomics.h"
#include "Misc/AssertionMacros.h"
#include "Misc/EnumClassFlags.h"
#include "Templates/UnrealTypeTraits.h"
#include "Containers/Array.h"
#include "Containers/UnrealString.h"
#include "Containers/SortedMap.h"
#include "Containers/EnumAsByte.h"
#include "Templates/SharedPointer.h"
#include "Internationalization/TextKey.h"
#include "Internationalization/LocKeyFuncs.h"
#include "Internationalization/CulturePointer.h"
#include "Internationalization/TextComparison.h"
#include "Internationalization/TextLocalizationManager.h"
#include "Internationalization/StringTableCoreFwd.h"
#include "Internationalization/ITextData.h"
#include "Misc/Optional.h"
#include "Templates/UniquePtr.h"
#include "Templates/IsConstructible.h"
#include "Templates/Requires.h"
 
#include <type_traits>
 
class FText;
class FTextHistory;
class FTextFormatData;
class FFormatArgumentValue;
class FHistoricTextFormatData;
class FHistoricTextNumericData;
class FTextFormatPatternDefinition;
class ITextGenerator;
 
//DECLARE_CYCLE_STAT_EXTERN( TEXT("Format Text"), STAT_TextFormat, STATGROUP_Text, );
 
namespace ETextFlag
{
    enum Type
    {
        Transient = (1 << 0),
        CultureInvariant = (1 << 1),
        ConvertedProperty = (1 << 2),
        Immutable = (1 << 3),
        InitializedFromString = (1<<4),  // this ftext was initialized using FromString
    };
}
 
enum class ETextIdenticalModeFlags : uint8
{
    None = 0,
 
    DeepCompare = 1<<0,
 
    LexicalCompareInvariants = 1<<1,
};
ENUM_CLASS_FLAGS(ETextIdenticalModeFlags);
 
enum class ETextFormatFlags : uint8
{
    None = 0,
 
    EvaluateArgumentModifiers = 1<<0,
 
    Default = EvaluateArgumentModifiers,
};
ENUM_CLASS_FLAGS(ETextFormatFlags);
 
enum class ETextPluralType : uint8
{
    Cardinal,
    Ordinal,
};
 
enum class ETextPluralForm : uint8
{
    Zero = 0,
    One,    // Singular
    Two,    // Dual
    Few,    // Paucal
    Many,   // Also used for fractions if they have a separate class
    Other,  // General plural form, also used if the language only has a single form
    Count,  // Number of entries in this enum
};
 
enum class ETextGender : uint8
{
    Masculine,
    Feminine,
    Neuter,
    // Add new enum types at the end only! They are serialized by index.
};
CORE_API bool LexTryParseString(ETextGender& OutValue, const TCHAR* Buffer);
CORE_API void LexFromString(ETextGender& OutValue, const TCHAR* Buffer);
CORE_API const TCHAR* LexToString(ETextGender InValue);
 
namespace EDateTimeStyle
{
    enum Type : int
    {
        Default,
        Short,
        Medium,
        Long,
        Full,
        Custom, // Internal use only
        // Add new enum types at the end only! They are serialized by index.
    };
}
CORE_API bool LexTryParseString(EDateTimeStyle::Type& OutValue, const TCHAR* Buffer);
CORE_API void LexFromString(EDateTimeStyle::Type& OutValue, const TCHAR* Buffer);
CORE_API const TCHAR* LexToString(EDateTimeStyle::Type InValue);
 
namespace EFormatArgumentType
{
    enum Type : int
    {
        Int,
        UInt,
        Float,
        Double,
        Text,
        Gender,
        // Add new enum types at the end only! They are serialized by index.
    };
}
 
typedef TSortedMap<FString, FFormatArgumentValue, FDefaultAllocator, FLocKeySortedMapLess> FFormatNamedArguments;
typedef TArray<FFormatArgumentValue> FFormatOrderedArguments;
 
typedef TSharedRef<FTextFormatPatternDefinition, ESPMode::ThreadSafe> FTextFormatPatternDefinitionRef;
typedef TSharedPtr<FTextFormatPatternDefinition, ESPMode::ThreadSafe> FTextFormatPatternDefinitionPtr;
typedef TSharedRef<const FTextFormatPatternDefinition, ESPMode::ThreadSafe> FTextFormatPatternDefinitionConstRef;
typedef TSharedPtr<const FTextFormatPatternDefinition, ESPMode::ThreadSafe> FTextFormatPatternDefinitionConstPtr;
 
enum ERoundingMode : int
{
    HalfToEven,
    HalfFromZero,
    HalfToZero,
    FromZero,
    ToZero,
    ToNegativeInfinity,
    ToPositiveInfinity,
 
 
    // Add new enum types at the end only! They are serialized by index.
};
CORE_API bool LexTryParseString(ERoundingMode& OutValue, const TCHAR* Buffer);
CORE_API void LexFromString(ERoundingMode& OutValue, const TCHAR* Buffer);
CORE_API const TCHAR* LexToString(ERoundingMode InValue);
 
enum EMemoryUnitStandard : int
{
    /* International Electrotechnical Commission (MiB) 1024-based */
    IEC,
    /* International System of Units 1000-based */
    SI
};
 
struct FNumberFormattingOptions
{
    CORE_API FNumberFormattingOptions();
 
    bool AlwaysSign;
    FNumberFormattingOptions& SetAlwaysSign( bool InValue ){ AlwaysSign = InValue; return *this; }
 
    bool UseGrouping;
    FNumberFormattingOptions& SetUseGrouping( bool InValue ){ UseGrouping = InValue; return *this; }
 
    bool IndicateNearlyInteger;
    FNumberFormattingOptions& SetIndicateNearlyInteger( bool InValue ) { IndicateNearlyInteger = InValue; return *this; }
 
    ERoundingMode RoundingMode;
    FNumberFormattingOptions& SetRoundingMode( ERoundingMode InValue ){ RoundingMode = InValue; return *this; }
 
    int32 MinimumIntegralDigits;
    FNumberFormattingOptions& SetMinimumIntegralDigits( int32 InValue ){ MinimumIntegralDigits = InValue; return *this; }
 
    int32 MaximumIntegralDigits;
    FNumberFormattingOptions& SetMaximumIntegralDigits( int32 InValue ){ MaximumIntegralDigits = InValue; return *this; }
 
    int32 MinimumFractionalDigits;
    FNumberFormattingOptions& SetMinimumFractionalDigits( int32 InValue ){ MinimumFractionalDigits = InValue; return *this; }
 
    int32 MaximumFractionalDigits;
    FNumberFormattingOptions& SetMaximumFractionalDigits( int32 InValue ){ MaximumFractionalDigits = InValue; return *this; }
 
    friend CORE_API void operator<<(FStructuredArchive::FSlot Slot, FNumberFormattingOptions& Value);
 
    friend CORE_API uint32 GetTypeHash( const FNumberFormattingOptions& Key );
 
    CORE_API bool IsIdentical( const FNumberFormattingOptions& Other ) const;
 
    static CORE_API const FNumberFormattingOptions& DefaultWithGrouping();
 
    static CORE_API const FNumberFormattingOptions& DefaultNoGrouping();
};
 
struct FNumberParsingOptions
{
    CORE_API FNumberParsingOptions();
 
    bool UseGrouping;
    FNumberParsingOptions& SetUseGrouping( bool InValue ){ UseGrouping = InValue; return *this; }
 
    bool InsideLimits;
    FNumberParsingOptions& SetInsideLimits(bool InValue) { InsideLimits = InValue; return *this; }
 
    bool UseClamping;
    FNumberParsingOptions& SetUseClamping(bool InValue) { UseClamping = InValue; return *this; }
 
    friend CORE_API void operator<<(FStructuredArchive::FSlot Slot, FNumberParsingOptions& Value);
 
    friend CORE_API uint32 GetTypeHash( const FNumberParsingOptions& Key );
 
    CORE_API bool IsIdentical( const FNumberParsingOptions& Other ) const;
 
    static CORE_API const FNumberParsingOptions& DefaultWithGrouping();
 
    static CORE_API const FNumberParsingOptions& DefaultNoGrouping();
};
 
class FTextFormat
{
    friend class FTextFormatter;
 
public:
    enum class EExpressionType
    {
        Invalid,
        Simple,
        Complex,
    };
 
    CORE_API FTextFormat();
 
    CORE_API FTextFormat(const FText& InText, ETextFormatFlags InFormatFlags = ETextFormatFlags::Default);
 
    CORE_API FTextFormat(const FText& InText, FTextFormatPatternDefinitionConstRef InCustomPatternDef, ETextFormatFlags InFormatFlags = ETextFormatFlags::Default);
 
    static CORE_API FTextFormat FromString(const FString& InString, ETextFormatFlags InFormatFlags = ETextFormatFlags::Default);
    static CORE_API FTextFormat FromString(FString&& InString, ETextFormatFlags InFormatFlags = ETextFormatFlags::Default);
 
    static CORE_API FTextFormat FromString(const FString& InString, FTextFormatPatternDefinitionConstRef InCustomPatternDef, ETextFormatFlags InFormatFlags = ETextFormatFlags::Default);
    static CORE_API FTextFormat FromString(FString&& InString, FTextFormatPatternDefinitionConstRef InCustomPatternDef, ETextFormatFlags InFormatFlags = ETextFormatFlags::Default);
 
    CORE_API bool IsValid() const;
 
    CORE_API bool IdenticalTo(const FTextFormat& Other, const ETextIdenticalModeFlags CompareModeFlags) const;
 
    CORE_API FText GetSourceText() const;
 
    CORE_API const FString& GetSourceString() const;
 
    CORE_API EExpressionType GetExpressionType() const;
 
    CORE_API ETextFormatFlags GetFormatFlags() const;
 
    CORE_API FTextFormatPatternDefinitionConstRef GetPatternDefinition() const;
 
    CORE_API bool ValidatePattern(const FCulturePtr& InCulture, TArray<FString>& OutValidationErrors) const;
 
    CORE_API void GetFormatArgumentNames(TArray<FString>& OutArgumentNames) const;
 
private:
    CORE_API FTextFormat(FString&& InString, FTextFormatPatternDefinitionConstRef InCustomPatternDef, ETextFormatFlags InFormatFlags);
 
    TSharedRef<FTextFormatData, ESPMode::ThreadSafe> TextFormatData;
};
 
class FCulture;
 
class FText
{
public:
 
    static CORE_API const FText& GetEmpty();
 
public:
 
    CORE_API FText();
    
    FText(const FText&) = default;
    FText& operator=(const FText&) = default;
    
    CORE_API FText(FText&& Other);
    CORE_API FText& operator=(FText&& Other);
 
    // Safely copies an FText from the open to a closed transaction.
    // See AutoRTFM::Open().
    static CORE_API void AutoRTFMAssignFromOpenToClosed(FText& Closed, const FText& Open);
 
    [[nodiscard]] static CORE_API FText AsNumber(float Val, const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL);
    [[nodiscard]] static CORE_API FText AsNumber(double Val,    const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL);
    [[nodiscard]] static CORE_API FText AsNumber(int8 Val,      const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL);
    [[nodiscard]] static CORE_API FText AsNumber(int16 Val, const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL);
    [[nodiscard]] static CORE_API FText AsNumber(int32 Val, const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL);
    [[nodiscard]] static CORE_API FText AsNumber(int64 Val, const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL);
    [[nodiscard]] static CORE_API FText AsNumber(uint8 Val, const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL);
    [[nodiscard]] static CORE_API FText AsNumber(uint16 Val,    const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL);
    [[nodiscard]] static CORE_API FText AsNumber(uint32 Val,    const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL);
    [[nodiscard]] static CORE_API FText AsNumber(uint64 Val,    const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL);
    [[nodiscard]] static CORE_API FText AsNumber(long Val,      const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL);
 
 
    [[nodiscard]] static CORE_API FText AsCurrency(float Val,  const FString& CurrencyCode = FString(), const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL);
    [[nodiscard]] static CORE_API FText AsCurrency(double Val, const FString& CurrencyCode = FString(), const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL);
    [[nodiscard]] static CORE_API FText AsCurrency(int8 Val,   const FString& CurrencyCode = FString(), const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL);
    [[nodiscard]] static CORE_API FText AsCurrency(int16 Val,  const FString& CurrencyCode = FString(), const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL);
    [[nodiscard]] static CORE_API FText AsCurrency(int32 Val,  const FString& CurrencyCode = FString(), const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL);
    [[nodiscard]] static CORE_API FText AsCurrency(int64 Val,  const FString& CurrencyCode = FString(), const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL);
    [[nodiscard]] static CORE_API FText AsCurrency(uint8 Val,  const FString& CurrencyCode = FString(), const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL);
    [[nodiscard]] static CORE_API FText AsCurrency(uint16 Val, const FString& CurrencyCode = FString(), const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL);
    [[nodiscard]] static CORE_API FText AsCurrency(uint32 Val, const FString& CurrencyCode = FString(), const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL);
    [[nodiscard]] static CORE_API FText AsCurrency(uint64 Val, const FString& CurrencyCode = FString(), const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL);
    [[nodiscard]] static CORE_API FText AsCurrency(long Val,   const FString& CurrencyCode = FString(), const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL);
 
    [[nodiscard]] static CORE_API FText AsCurrencyBase(int64 BaseVal, const FString& CurrencyCode, const FCulturePtr& TargetCulture = NULL, int32 ForceDecimalPlaces = -1);
 
    [[nodiscard]] static CORE_API FText AsPercent(float Val,    const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL);
    [[nodiscard]] static CORE_API FText AsPercent(double Val,   const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL);
 
    [[nodiscard]] static CORE_API FText AsDate(const FDateTime& DateTime, const EDateTimeStyle::Type DateStyle = EDateTimeStyle::Default, const FString& TimeZone = FString(), const FCulturePtr& TargetCulture = NULL);
    [[nodiscard]] static CORE_API FText AsDateTime(const FDateTime& DateTime, const EDateTimeStyle::Type DateStyle = EDateTimeStyle::Default, const EDateTimeStyle::Type TimeStyle = EDateTimeStyle::Default, const FString& TimeZone = FString(), const FCulturePtr& TargetCulture = NULL);
    [[nodiscard]] static CORE_API FText AsDateTime(const FDateTime& DateTime, const FString& CustomPattern, const FString& TimeZone = FString(), const FCulturePtr& TargetCulture = NULL);
    [[nodiscard]] static CORE_API FText AsTime(const FDateTime& DateTime, const EDateTimeStyle::Type TimeStyle = EDateTimeStyle::Default, const FString& TimeZone = FString(), const FCulturePtr& TargetCulture = NULL);
 
    [[nodiscard]] static CORE_API FText AsTimespan(const FTimespan& Timespan, const FCulturePtr& TargetCulture = NULL);
 
    [[nodiscard]] static CORE_API FString GetInvariantTimeZone();
 
    [[nodiscard]] static CORE_API FText AsMemory(uint64 NumBytes, const FNumberFormattingOptions* const Options = NULL, const FCulturePtr& TargetCulture = NULL, EMemoryUnitStandard UnitStandard = EMemoryUnitStandard::IEC);
 
    [[nodiscard]] static CORE_API FText AsMemory(uint64 NumBytes, EMemoryUnitStandard UnitStandard);
 
    [[nodiscard]] static CORE_API FText FromStringTable(const FName InTableId, const FTextKey& InKey, const EStringTableLoadingPolicy InLoadingPolicy = EStringTableLoadingPolicy::FindOrLoad);
 
    [[nodiscard]] static CORE_API FText FromName( const FName& Val);
    
    [[nodiscard]] static CORE_API FText FromString( const ANSICHAR* String );
    [[nodiscard]] static CORE_API FText FromString( const UTF8CHAR* String );
    [[nodiscard]] static CORE_API FText FromString( const WIDECHAR* String );
    [[nodiscard]] static CORE_API FText FromString( const FAnsiString& String );
    [[nodiscard]] static CORE_API FText FromString( const FString& String );
    [[nodiscard]] static CORE_API FText FromString( FString&& String );
    [[nodiscard]] static CORE_API FText FromString( const FUtf8String& String );
 
    [[nodiscard]] static CORE_API FText FromStringView(FAnsiStringView InString);
    [[nodiscard]] static CORE_API FText FromStringView(FUtf8StringView InString);
    [[nodiscard]] static CORE_API FText FromStringView(FWideStringView InString);
 
    [[nodiscard]] static CORE_API FText AsCultureInvariant( const ANSICHAR* String );
    [[nodiscard]] static CORE_API FText AsCultureInvariant( const UTF8CHAR* String );
    [[nodiscard]] static CORE_API FText AsCultureInvariant( const WIDECHAR* String );
    [[nodiscard]] static CORE_API FText AsCultureInvariant( FAnsiStringView String );
    [[nodiscard]] static CORE_API FText AsCultureInvariant( FUtf8StringView String );
    [[nodiscard]] static CORE_API FText AsCultureInvariant( FWideStringView String );
    [[nodiscard]] static CORE_API FText AsCultureInvariant( FString&& String );
 
    [[nodiscard]] static CORE_API FText AsCultureInvariant( FText Text );
 
    [[nodiscard]] static CORE_API FText AsLocalizable_Advanced(const FTextKey& Namespace, const FTextKey& Key, const TCHAR* String);
    [[nodiscard]] static CORE_API FText AsLocalizable_Advanced(const FTextKey& Namespace, const FTextKey& Key, FStringView String);
    [[nodiscard]] static CORE_API FText AsLocalizable_Advanced(const FTextKey& Namespace, const FTextKey& Key, FString&& String);
    [[nodiscard]] static CORE_API FText AsLocalizable_Advanced_LocText(const TCHAR* Namespace, const TCHAR* Key, const TCHAR* String); // For use by LOCTEXT to avoid constructing temp FTextKeys in every caller
 
    static CORE_API bool FindTextInLiveTable_Advanced(const FTextKey& Namespace, const FTextKey& Key, FText& OutText, const FString* const SourceString = nullptr);
 
    UE_DEPRECATED(5.5, "FText::FindText is deprecated as it can no longer find untranslated text. Consider FText::FindTextInLiveTable_Advanced or FText::AsLocalizable_Advanced as a replacement, depending on your use-case.")
    static UE_FORCEINLINE_HINT bool FindText(const FTextKey& Namespace, const FTextKey& Key, FText& OutText, const FString* const SourceString = nullptr)
    {
        return FText::FindTextInLiveTable_Advanced(Namespace, Key, OutText, SourceString);
    }
 
    [[nodiscard]] CORE_API const FString& ToString() const;
 
    [[nodiscard]] CORE_API FString BuildSourceString() const;
 
    [[nodiscard]] CORE_API bool IsNumeric() const;
 
    [[nodiscard]] CORE_API int32 CompareTo( const FText& Other, const ETextComparisonLevel::Type ComparisonLevel = ETextComparisonLevel::Default ) const;
    [[nodiscard]] CORE_API int32 CompareToCaseIgnored( const FText& Other ) const;
 
    [[nodiscard]] CORE_API bool EqualTo( const FText& Other, const ETextComparisonLevel::Type ComparisonLevel = ETextComparisonLevel::Default ) const;
    [[nodiscard]] CORE_API bool EqualToCaseIgnored( const FText& Other ) const;
 
    [[nodiscard]] CORE_API bool IdenticalTo( const FText& Other, const ETextIdenticalModeFlags CompareModeFlags = ETextIdenticalModeFlags::None ) const;
 
    class FSortPredicate
    {
    public:
        CORE_API FSortPredicate(const ETextComparisonLevel::Type ComparisonLevel = ETextComparisonLevel::Default);
 
        CORE_API bool operator()(const FText& A, const FText& B) const;
 
    private:
#if UE_ENABLE_ICU
        class FSortPredicateImplementation;
        TSharedRef<FSortPredicateImplementation> Implementation;
#endif
    };
 
    [[nodiscard]] CORE_API bool IsEmpty() const;
 
    [[nodiscard]] CORE_API bool IsEmptyOrWhitespace() const;
 
    [[nodiscard]] CORE_API FText ToLower() const;
 
    [[nodiscard]] CORE_API FText ToUpper() const;
 
    [[nodiscard]] static CORE_API FText TrimPreceding( const FText& );
 
    [[nodiscard]] static CORE_API FText TrimTrailing( const FText& );
 
    [[nodiscard]] static CORE_API FText TrimPrecedingAndTrailing( const FText& );
 
    UE_DEPRECATED(5.7, "FText::IsWhitespace is deprecated. Use FTextChar::IsWhitespace instead.")
    [[nodiscard]] static CORE_API bool IsWhitespace( const TCHAR Char );
 
    static CORE_API void GetFormatPatternParameters(const FTextFormat& Fmt, TArray<FString>& ParameterNames);
 
    [[nodiscard]] static CORE_API FText Format(FTextFormat Fmt, const FFormatNamedArguments& InArguments);
    [[nodiscard]] static CORE_API FText Format(FTextFormat Fmt, FFormatNamedArguments&& InArguments);
 
    [[nodiscard]] static CORE_API FText Format(FTextFormat Fmt, const FFormatOrderedArguments& InArguments);
    [[nodiscard]] static CORE_API FText Format(FTextFormat Fmt, FFormatOrderedArguments&& InArguments);
 
    template <typename... ArgTypes>
    [[nodiscard]] static inline FText Format(FTextFormat Fmt, ArgTypes... Args)
    {
        static_assert((TIsConstructible<FFormatArgumentValue, ArgTypes>::Value && ...), "Invalid argument type passed to FText::Format");
        static_assert(sizeof...(Args) > 0, "FText::Format expects at least one non-format argument"); // we do this to ensure that people don't call Format for no good reason
 
        // We do this to force-select the correct overload, because overload resolution will cause compile
        // errors when it tries to instantiate the FFormatNamedArguments overloads.
        FText (*CorrectFormat)(FTextFormat, FFormatOrderedArguments&&) = Format;
 
        return CorrectFormat(MoveTemp(Fmt), FFormatOrderedArguments{ MoveTemp(Args)... });
    }
 
    template < typename... TArguments >
    [[nodiscard]] static FText FormatNamed( FTextFormat Fmt, TArguments&&... Args );
 
    template < typename... TArguments >
    [[nodiscard]] static FText FormatOrdered( FTextFormat Fmt, TArguments&&... Args );
 
    [[nodiscard]] static CORE_API FText Join(const FText& Delimiter, const FFormatOrderedArguments& Args);
    [[nodiscard]] static CORE_API FText Join(const FText& Delimiter, const TArray<FText>& Args);
 
    template <typename... ArgTypes>
    [[nodiscard]] static inline FText Join(const FText& Delimiter, ArgTypes... Args)
    {
        static_assert((TIsConstructible<FFormatArgumentValue, ArgTypes>::Value && ...), "Invalid argument type passed to FText::Join");
        static_assert(sizeof...(Args) > 0, "FText::Join expects at least one non-format argument"); // we do this to ensure that people don't call Join for no good reason
 
        return Join(Delimiter, FFormatOrderedArguments{ MoveTemp(Args)... });
    }
 
    [[nodiscard]] static CORE_API FText FromTextGenerator( const TSharedRef<ITextGenerator>& TextGenerator );
 
    DECLARE_DELEGATE_RetVal_OneParam( TSharedRef<ITextGenerator>, FCreateTextGeneratorDelegate, FStructuredArchive::FRecord );
    [[nodiscard]] static CORE_API FCreateTextGeneratorDelegate FindRegisteredTextGenerator( FName TypeID );
 
    static CORE_API void RegisterTextGenerator( FName TypeID, FCreateTextGeneratorDelegate FactoryFunction );
 
    template < typename T >
    static void RegisterTextGenerator( FName TypeID )
    {
        RegisterTextGenerator(TypeID, FCreateTextGeneratorDelegate::CreateStatic( &CreateTextGenerator<T> ));
    }
 
    template < typename T >
    static void RegisterTextGenerator()
    {
        RegisterTextGenerator<T>( T::TypeID );
    }
 
    static CORE_API void UnregisterTextGenerator( FName TypeID );
 
    template < typename T >
    static void UnregisterTextGenerator()
    {
        UnregisterTextGenerator( T::TypeID );
    }
 
    [[nodiscard]] CORE_API bool IsTransient() const;
    [[nodiscard]] CORE_API bool IsCultureInvariant() const;
    [[nodiscard]] CORE_API bool IsInitializedFromString() const;
    [[nodiscard]] CORE_API bool IsFromStringTable() const;
 
    [[nodiscard]] CORE_API bool ShouldGatherForLocalization() const;
    
    static CORE_API void PreloadStringTable( FName InTableId, const FTextKey& InKey );
 
#if WITH_EDITORONLY_DATA
    [[nodiscard]] static CORE_API FText ChangeKey( const FTextKey& Namespace, const FTextKey& Key, const FText& Text );
#endif
 
    // Start - intrusive TOptional<FText> state        //
    constexpr static bool bHasIntrusiveUnsetOptionalState = true;
    using IntrusiveUnsetOptionalStateType = FText;
 
    explicit FText(FIntrusiveUnsetOptionalState)
    : TextData(nullptr)
    , Flags(0)
    {
    }
    bool operator==(FIntrusiveUnsetOptionalState) const
    {
        return TextData == nullptr;
    }
    // End - intrusive TOptional<FText> state      //
private:
    template <
        typename HistoryType
        UE_REQUIRES(std::is_convertible_v<HistoryType*, ITextData*>)
    >
    explicit FText( TRefCountPtr<HistoryType>&& InTextData )
        : TextData(MoveTemp(InTextData))
        , Flags(0)
    {
    }
 
    CORE_API explicit FText( FString&& InSourceString );
 
    CORE_API FText( FName InTableId, const FTextKey& InKey, const EStringTableLoadingPolicy InLoadingPolicy );
 
    CORE_API FText( FString&& InSourceString, const FTextKey& InNamespace, const FTextKey& InKey, uint32 InFlags=0 );
 
    static CORE_API void SerializeText( FArchive& Ar, FText& Value );
    static CORE_API void SerializeText(FStructuredArchive::FSlot Slot, FText& Value);
 
    CORE_API void GetHistoricFormatData(TArray<FHistoricTextFormatData>& OutHistoricFormatData) const;
 
    CORE_API bool GetHistoricNumericData(FHistoricTextNumericData& OutHistoricNumericData) const;
 
    CORE_API void Rebuild() const;
 
    static CORE_API FText FormatNamedImpl(FTextFormat&& Fmt, FFormatNamedArguments&& InArguments);
    static CORE_API FText FormatOrderedImpl(FTextFormat&& Fmt, FFormatOrderedArguments&& InArguments);
 
private:
    template<typename T1, typename T2>
    static FText AsNumberTemplate(T1 Val, const FNumberFormattingOptions* const Options, const FCulturePtr& TargetCulture);
    template<typename T1, typename T2>
    static FText AsCurrencyTemplate(T1 Val, const FString& CurrencyCode, const FNumberFormattingOptions* const Options, const FCulturePtr& TargetCulture);
    template<typename T1, typename T2>
    static FText AsPercentTemplate(T1 Val, const FNumberFormattingOptions* const Options, const FCulturePtr& TargetCulture);
 
private:
    template < typename T >
    static TSharedRef<ITextGenerator> CreateTextGenerator(FStructuredArchive::FRecord Record);
 
    const ITextData& GetTextData() const;
 
private:
    TRefCountPtr<ITextData> TextData;
 
    uint32 Flags;
 
public:
    friend class FTextCache;
    friend class FTextFormatter;
    friend class FTextFormatData;
    friend class FTextSnapshot;
    friend class FTextInspector;
    friend class FTextStringHelper;
    friend class FStringTableRegistry;
    friend class FArchive;
    friend class FArchiveFromStructuredArchiveImpl;
    friend class FJsonArchiveInputFormatter;
    friend class FJsonArchiveOutputFormatter;
    friend class FTextProperty;
    friend class FFormatArgumentValue;
    friend class FTextHistory_NamedFormat;
    friend class FTextHistory_ArgumentDataFormat;
    friend class FTextHistory_OrderedFormat;
    friend class FTextHistory_Transform;
    friend class FScopedTextIdentityPreserver;
};
 
class FFormatArgumentValue
{
public:
    FFormatArgumentValue()
        : Type(EFormatArgumentType::Text)
        , TextValue(FText::GetEmpty())
    {
    }
 
    CORE_API FFormatArgumentValue(const class FCbValue& Value);
 
    FFormatArgumentValue(const int32 Value)
        : Type(EFormatArgumentType::Int)
    {
        IntValue = Value;
    }
 
    FFormatArgumentValue(const uint32 Value)
        : Type(EFormatArgumentType::UInt)
    {
        UIntValue = Value;
    }
 
    FFormatArgumentValue(const int64 Value)
        : Type(EFormatArgumentType::Int)
    {
        IntValue = Value;
    }
 
    FFormatArgumentValue(const uint64 Value)
        : Type(EFormatArgumentType::UInt)
    {
        UIntValue = Value;
    }
 
    FFormatArgumentValue(const float Value)
        : Type(EFormatArgumentType::Float)
    {
        FloatValue = Value;
    }
 
    FFormatArgumentValue(const double Value)
        : Type(EFormatArgumentType::Double)
    {
        DoubleValue = Value;
    }
 
    FFormatArgumentValue(const FText& Value)
        : Type(EFormatArgumentType::Text)
        , TextValue(Value)
    {
    }
 
    FFormatArgumentValue(FText&& Value)
        : Type(EFormatArgumentType::Text)
        , TextValue(MoveTemp(Value))
    {
    }
 
    FFormatArgumentValue(ETextGender Value)
        : Type(EFormatArgumentType::Gender)
    {
        UIntValue = (uint64)Value;
    }
 
    friend void operator<<(FStructuredArchive::FSlot Slot, FFormatArgumentValue& Value);
 
    CORE_API bool IdenticalTo(const FFormatArgumentValue& Other, const ETextIdenticalModeFlags CompareModeFlags) const;
 
    CORE_API FString ToFormattedString(const bool bInRebuildText, const bool bInRebuildAsSource) const;
    CORE_API void ToFormattedString(const bool bInRebuildText, const bool bInRebuildAsSource, FString& OutResult) const;
 
    CORE_API FString ToExportedString(const bool bStripPackageNamespace = false) const;
    CORE_API void ToExportedString(FString& OutResult, const bool bStripPackageNamespace = false) const;
    CORE_API const TCHAR* FromExportedString(const TCHAR* InBuffer);
 
    UE_FORCEINLINE_HINT EFormatArgumentType::Type GetType() const
    {
        return Type;
    }
 
    inline int64 GetIntValue() const
    {
        check(Type == EFormatArgumentType::Int);
        return IntValue;
    }
 
    inline uint64 GetUIntValue() const
    {
        check(Type == EFormatArgumentType::UInt);
        return UIntValue;
    }
 
    inline float GetFloatValue() const
    {
        check(Type == EFormatArgumentType::Float);
        return FloatValue;
    }
 
    inline double GetDoubleValue() const
    {
        check(Type == EFormatArgumentType::Double);
        return DoubleValue;
    }
 
    inline const FText& GetTextValue() const
    {
        check(Type == EFormatArgumentType::Text);
        return TextValue.GetValue();
    }
 
    inline ETextGender GetGenderValue() const
    {
        check(Type == EFormatArgumentType::Gender);
        return (ETextGender)UIntValue;
    }
 
private:
    EFormatArgumentType::Type Type;
    union
    {
        int64 IntValue;
        uint64 UIntValue;
        float FloatValue;
        double DoubleValue;
    };
    TOptional<FText> TextValue;
};
 
template < typename T >
inline TSharedRef<ITextGenerator> FText::CreateTextGenerator(FStructuredArchive::FRecord Record)
{
    return MakeShared<T>();
}
 
struct FFormatArgumentData
{
    FFormatArgumentData()
    {
        ResetValue();
    }
 
    CORE_API void ResetValue();
 
    CORE_API FFormatArgumentValue ToArgumentValue() const;
 
    friend void operator<<(FStructuredArchive::FSlot Slot, FFormatArgumentData& Value);
 
    FString ArgumentName;
 
    // This is a non-unioned version of FFormatArgumentValue that only accepts the types needed by Blueprints
    // It's used as a marshaller to create a real FFormatArgumentValue when performing a format
    TEnumAsByte<EFormatArgumentType::Type> ArgumentValueType;
    FText ArgumentValue;
    int64 ArgumentValueInt;
    float ArgumentValueFloat;
    double ArgumentValueDouble;
    ETextGender ArgumentValueGender;
};
 
namespace TextFormatUtil
{
 
    template < typename TName, typename TValue >
    void FormatNamed( OUT FFormatNamedArguments& Result, TName&& Name, TValue&& Value )
    {
        Result.Emplace( Forward< TName >( Name ), Forward< TValue >( Value ) );
    }
    
    template < typename TName, typename TValue, typename... TArguments >
    void FormatNamed( OUT FFormatNamedArguments& Result, TName&& Name, TValue&& Value, TArguments&&... Args )
    {
        FormatNamed( Result, Forward< TName >( Name ), Forward< TValue >( Value ) );
        FormatNamed( Result, Forward< TArguments >( Args )... );
    }
    
    template < typename TValue >
    void FormatOrdered( OUT FFormatOrderedArguments& Result, TValue&& Value )
    {
        Result.Emplace( Forward< TValue >( Value ) );
    }
    
    template < typename TValue, typename... TArguments >
    void FormatOrdered( OUT FFormatOrderedArguments& Result, TValue&& Value, TArguments&&... Args )
    {
        FormatOrdered( Result, Forward< TValue >( Value ) );
        FormatOrdered( Result, Forward< TArguments >( Args )... );
    }
 
} // namespace TextFormatUtil
 
template < typename... TArguments >
FText FText::FormatNamed( FTextFormat Fmt, TArguments&&... Args )
{
    static_assert( sizeof...( TArguments ) % 2 == 0, "FormatNamed requires an even number of Name <-> Value pairs" );
 
    FFormatNamedArguments FormatArguments;
    FormatArguments.Reserve( sizeof...( TArguments ) / 2 );
    TextFormatUtil::FormatNamed( FormatArguments, Forward< TArguments >( Args )... );
    return FormatNamedImpl( MoveTemp( Fmt ), MoveTemp( FormatArguments ) );
}
 
template < typename... TArguments >
FText FText::FormatOrdered( FTextFormat Fmt, TArguments&&... Args )
{
    FFormatOrderedArguments FormatArguments;
    FormatArguments.Reserve( sizeof...( TArguments ) );
    TextFormatUtil::FormatOrdered( FormatArguments, Forward< TArguments >( Args )... );
    return FormatOrderedImpl( MoveTemp( Fmt ), MoveTemp( FormatArguments ) );
}
 
class FHistoricTextFormatData
{
public:
    FHistoricTextFormatData()
    {
    }
 
    FHistoricTextFormatData(FText InFormattedText, FTextFormat&& InSourceFmt, FFormatNamedArguments&& InArguments)
        : FormattedText(MoveTemp(InFormattedText))
        , SourceFmt(MoveTemp(InSourceFmt))
        , Arguments(MoveTemp(InArguments))
    {
    }
 
    FText FormattedText;
 
    FTextFormat SourceFmt;
 
    FFormatNamedArguments Arguments;
};
 
class FHistoricTextNumericData
{
public:
    enum class EType : uint8
    {
        AsNumber,
        AsPercent,
    };
 
    FHistoricTextNumericData()
        : FormatType(EType::AsNumber)
    {
    }
 
    FHistoricTextNumericData(const EType InFormatType, const FFormatArgumentValue& InSourceValue, const TOptional<FNumberFormattingOptions>& InFormatOptions)
        : FormatType(InFormatType)
        , SourceValue(InSourceValue)
        , FormatOptions(InFormatOptions)
    {
    }
 
    EType FormatType;
 
    FFormatArgumentValue SourceValue;
 
    TOptional<FNumberFormattingOptions> FormatOptions;
};
 
class FTextSnapshot
{
public:
    CORE_API FTextSnapshot();
 
    CORE_API explicit FTextSnapshot(const FText& InText);
 
    CORE_API bool IdenticalTo(const FText& InText) const;
 
    CORE_API bool IsDisplayStringEqualTo(const FText& InText) const;
 
private:
 
    static uint16 GetGlobalHistoryRevisionForText(const FText& InText);
 
    static uint16 GetLocalHistoryRevisionForText(const FText& InText);
 
    TRefCountPtr<ITextData> TextDataPtr;
 
    FTextConstDisplayStringPtr LocalizedStringPtr;
 
    uint16 GlobalHistoryRevision = 0;
 
    uint16 LocalHistoryRevision = 0;
 
    uint32 Flags = 0;
};
 
class FTextInspector
{
private:
    FTextInspector() {}
    ~FTextInspector() {}
 
public:
    static CORE_API bool ShouldGatherForLocalization(const FText& Text);
    static CORE_API TOptional<FString> GetNamespace(const FText& Text);
    static CORE_API TOptional<FString> GetKey(const FText& Text);
    static CORE_API FTextId GetTextId(const FText& Text);
    static CORE_API const FString* GetSourceString(const FText& Text);
    static CORE_API const FString& GetDisplayString(const FText& Text);
    static CORE_API bool GetTableIdAndKey(const FText& Text, FName& OutTableId, FString& OutKey);
    static CORE_API bool GetTableIdAndKey(const FText& Text, FName& OutTableId, FTextKey& OutKey);
    static CORE_API uint32 GetFlags(const FText& Text);
    static CORE_API void GetHistoricFormatData(const FText& Text, TArray<FHistoricTextFormatData>& OutHistoricFormatData);
    static CORE_API bool GetHistoricNumericData(const FText& Text, FHistoricTextNumericData& OutHistoricNumericData);
    static CORE_API const void* GetSharedDataId(const FText& Text);
};
 
class FTextStringHelper
{
public:
    static CORE_API FText CreateFromBuffer(const TCHAR* Buffer, const TCHAR* TextNamespace = nullptr, const TCHAR* PackageNamespace = nullptr, const bool bRequiresQuotes = false);
 
    static CORE_API const TCHAR* ReadFromBuffer(const TCHAR* Buffer, FText& OutValue, const TCHAR* TextNamespace = nullptr, const TCHAR* PackageNamespace = nullptr, const bool bRequiresQuotes = false);
    
    UE_DEPRECATED(4.22, "FTextStringHelper::ReadFromString is deprecated. Use FTextStringHelper::ReadFromBuffer instead.")
    static CORE_API bool ReadFromString(const TCHAR* Buffer, FText& OutValue, const TCHAR* TextNamespace = nullptr, const TCHAR* PackageNamespace = nullptr, int32* OutNumCharsRead = nullptr, const bool bRequiresQuotes = false, const EStringTableLoadingPolicy InLoadingPolicy = EStringTableLoadingPolicy::FindOrLoad);
 
    static CORE_API void WriteToBuffer(FString& Buffer, const FText& Value, const bool bRequiresQuotes = false, const bool bStripPackageNamespace = false);
    
    UE_DEPRECATED(4.22, "FTextStringHelper::WriteToString is deprecated. Use FTextStringHelper::WriteToBuffer instead.")
    static CORE_API bool WriteToString(FString& Buffer, const FText& Value, const bool bRequiresQuotes = false);
 
    static CORE_API bool IsComplexText(const TCHAR* Buffer);
 
private:
    static const TCHAR* ReadFromBuffer_ComplexText(const TCHAR* Buffer, FText& OutValue, const TCHAR* TextNamespace, const TCHAR* PackageNamespace);
};
 
class FTextBuilder
{
public:
    CORE_API void Indent();
 
    CORE_API void Unindent();
 
    CORE_API void AppendLine();
 
    CORE_API void AppendLine(const FText& Text);
 
    CORE_API void AppendLine(const FString& String);
 
    CORE_API void AppendLine(const FName& Name);
 
    CORE_API void AppendLineFormat(const FTextFormat& Pattern, const FFormatNamedArguments& Arguments);
 
    CORE_API void AppendLineFormat(const FTextFormat& Pattern, const FFormatOrderedArguments& Arguments);
 
    template <typename... ArgTypes>
    inline void AppendLineFormat(FTextFormat Pattern, ArgTypes... Args)
    {
        static_assert((TIsConstructible<FFormatArgumentValue, ArgTypes>::Value && ...), "Invalid argument type passed to FTextBuilder::AppendLineFormat");
        static_assert(sizeof...(Args) > 0, "FTextBuilder::AppendLineFormat expects at least one non-format argument"); // we do this to ensure that people don't call AppendLineFormat for no good reason
 
        BuildAndAppendLine(FText::Format(MoveTemp(Pattern), FFormatOrderedArguments{ MoveTemp(Args)... }));
    }
 
    CORE_API void Clear();
 
    CORE_API bool IsEmpty() const;
 
    CORE_API int32 GetNumLines() const;
 
    CORE_API FText ToText() const;
 
private:
    CORE_API void BuildAndAppendLine(FString&& Data);
    CORE_API void BuildAndAppendLine(FText&& Data);
 
    TArray<FText> Lines;
    int32 IndentCount = 0;
};
 
struct FUnicodeChar
{
    UE_DEPRECATED(5.7, "FUnicodeChar::CodepointToString is deprecated. Use FTextChar::ConvertCodepointToString instead.")
    static CORE_API bool CodepointToString(const uint32 InCodepoint, FString& OutString);
};
 
namespace TextBiDi
{
    enum class ETextDirection : uint8
    {
        LeftToRight,
        RightToLeft,
        Mixed,
    };
 
    struct FTextDirectionInfo
    {
        int32 StartIndex;
        int32 Length;
        ETextDirection TextDirection;
    };
 
    class ITextBiDi
    {
    public:
        virtual ~ITextBiDi() {}
 
        virtual ETextDirection ComputeTextDirection(const FText& InText) = 0;
        virtual ETextDirection ComputeTextDirection(const FString& InString) = 0;
        virtual ETextDirection ComputeTextDirection(const TCHAR* InString, const int32 InStringStartIndex, const int32 InStringLen) = 0;
 
        virtual ETextDirection ComputeTextDirection(const FText& InText, const ETextDirection InBaseDirection, TArray<FTextDirectionInfo>& OutTextDirectionInfo) = 0;
        virtual ETextDirection ComputeTextDirection(const FString& InString, const ETextDirection InBaseDirection, TArray<FTextDirectionInfo>& OutTextDirectionInfo) = 0;
        virtual ETextDirection ComputeTextDirection(const TCHAR* InString, const int32 InStringStartIndex, const int32 InStringLen, const ETextDirection InBaseDirection, TArray<FTextDirectionInfo>& OutTextDirectionInfo) = 0;
 
        virtual ETextDirection ComputeBaseDirection(const FText& InText) = 0;
        virtual ETextDirection ComputeBaseDirection(const FString& InString) = 0;
        virtual ETextDirection ComputeBaseDirection(const TCHAR* InString, const int32 InStringStartIndex, const int32 InStringLen) = 0;
    };
 
    CORE_API TUniquePtr<ITextBiDi> CreateTextBiDi();
 
    CORE_API ETextDirection ComputeTextDirection(const FText& InText);
    CORE_API ETextDirection ComputeTextDirection(const FString& InString);
    CORE_API ETextDirection ComputeTextDirection(const TCHAR* InString, const int32 InStringStartIndex, const int32 InStringLen);
 
    CORE_API ETextDirection ComputeTextDirection(const FText& InText, const ETextDirection InBaseDirection, TArray<FTextDirectionInfo>& OutTextDirectionInfo);
    CORE_API ETextDirection ComputeTextDirection(const FString& InString, const ETextDirection InBaseDirection, TArray<FTextDirectionInfo>& OutTextDirectionInfo);
    CORE_API ETextDirection ComputeTextDirection(const TCHAR* InString, const int32 InStringStartIndex, const int32 InStringLen, const ETextDirection InBaseDirection, TArray<FTextDirectionInfo>& OutTextDirectionInfo);
 
    CORE_API ETextDirection ComputeBaseDirection(const FText& InText);
    CORE_API ETextDirection ComputeBaseDirection(const FString& InString);
    CORE_API ETextDirection ComputeBaseDirection(const TCHAR* InString, const int32 InStringStartIndex, const int32 InStringLen);
 
    CORE_API bool IsControlCharacter(const TCHAR InChar);
} // namespace TextBiDi
 
Expose_TNameOf(FText)