UnrealString.h.inl

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
// HEADER_UNIT_SKIP - Should not be included directly
// IWYU pragma: private
 
/*******************************************************************************************************************
 * NOTICE                                                                                                          *
 *                                                                                                                 *
 * This file is not intended to be included directly - it will be included by other .h files which have predefined *
 * some macros to be expanded within this file.  As such, it does not have a #pragma once as it is intended to be  *
 * included multiple times with different macro definitions.                                                       *
 *                                                                                                                 *
 * #includes needed to compile this file need to be specified in UnrealStringIncludes.h.inl file rather than here. *
 *******************************************************************************************************************/
#define UE_INCLUDETOOL_IGNORE_INCONSISTENT_STATE
 
#ifndef UE_STRING_CLASS
    #error "UnrealString.h.inl should only be included after defining UE_STRING_CLASS"
#endif
#ifndef UE_STRING_CHARTYPE
    #error "UnrealString.h.inl should only be included after defining UE_STRING_CHARTYPE"
#endif
#ifndef UE_STRING_CHARTYPE_IS_TCHAR
    #error "UnrealString.h.inl should only be included after defining UE_STRING_CHARTYPE_IS_TCHAR"
#endif
#ifndef UE_STRING_PRINTF_FMT_CHARTYPE
    #error "UnrealString.h.inl should only be included after defining UE_STRING_PRINTF_FMT_CHARTYPE"
#endif
#ifndef UE_STRING_DEPRECATED
    #error "UnrealString.h.inl should only be included after defining UE_STRING_DEPRECATED"
#endif
 
struct FStringFormatArg;
template<typename InKeyType,typename InValueType,typename SetAllocator ,typename KeyFuncs > class TMap;
 
using PREPROCESSOR_JOIN(UE_STRING_CLASS, FormatNamedArguments) = TMap<UE_STRING_CLASS, FStringFormatArg>;
using FStringFormatOrderedArguments = TArray<FStringFormatArg>;
 
[[nodiscard]] UE_STRING_CHARTYPE*       GetData(UE_STRING_CLASS&);
[[nodiscard]] const UE_STRING_CHARTYPE* GetData(const UE_STRING_CLASS&);
[[nodiscard]] int32                     GetNum(const UE_STRING_CLASS& String);
 
class UE_STRING_CLASS
{
public:
    using AllocatorType = TSizedDefaultAllocator<32>;
    using ElementType   = UE_STRING_CHARTYPE;
    using FmtCharType   = UE_STRING_PRINTF_FMT_CHARTYPE;
 
#ifdef UE_STRING_PRINTF_FMT_CHARTYPE2
    // Alternate formatting string type, particularly used for FUtf8String which can accept both "..." and UTF8TEXT("...") for formatting strings
    using FmtCharType2 = UE_STRING_PRINTF_FMT_CHARTYPE2;
#endif
 
private:
    typedef TArray<ElementType, AllocatorType> DataType;
    DataType Data;
 
public:
    [[nodiscard]] UE_STRING_CLASS() = default;
    [[nodiscard]] explicit consteval UE_STRING_CLASS(EConstEval) 
        : Data(ConstEval)
    {
    }
    [[nodiscard]] UE_STRING_CLASS(UE_STRING_CLASS&&) = default;
    [[nodiscard]] UE_STRING_CLASS(const UE_STRING_CLASS&) = default;
    UE_STRING_CLASS& operator=(UE_STRING_CLASS&&) = default;
    UE_STRING_CLASS& operator=(const UE_STRING_CLASS&) = default;
 
    [[nodiscard]] UE_FORCEINLINE_HINT UE_STRING_CLASS(const UE_STRING_CLASS& Other, int32 ExtraSlack)
        : Data(Other.Data, ExtraSlack + ((Other.Data.Num() || !ExtraSlack) ? 0 : 1)) // Add 1 if the source string array is empty and we want some slack, because we'll need to include a null terminator which is currently missing
    {
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT UE_STRING_CLASS(UE_STRING_CLASS&& Other, int32 ExtraSlack)
        : Data(MoveTemp(Other.Data), ExtraSlack + ((Other.Data.Num() || !ExtraSlack) ? 0 : 1)) // Add 1 if the source string array is empty and we want some slack, because we'll need to include a null terminator which is currently missing
    {
    }
 
    [[nodiscard]] CORE_API UE_STRING_CLASS(const ANSICHAR* Str);
    [[nodiscard]] CORE_API UE_STRING_CLASS(const WIDECHAR* Str);
    [[nodiscard]] CORE_API UE_STRING_CLASS(const UTF8CHAR* Str);
    [[nodiscard]] CORE_API UE_STRING_CLASS(const UCS2CHAR* Str);
    [[nodiscard]] CORE_API UE_STRING_CLASS(const UTF32CHAR* Str);
 
    UE_STRING_DEPRECATED(5.4, "This constructor has been deprecated - please use " PREPROCESSOR_TO_STRING(UE_STRING_CLASS) "::ConstructFromPtrSize(Ptr, Size) instead.") [[nodiscard]] CORE_API UE_STRING_CLASS(int32 Len, const ANSICHAR* Str);
    UE_STRING_DEPRECATED(5.4, "This constructor has been deprecated - please use " PREPROCESSOR_TO_STRING(UE_STRING_CLASS) "::ConstructFromPtrSize(Ptr, Size) instead.") [[nodiscard]] CORE_API UE_STRING_CLASS(int32 Len, const WIDECHAR* Str);
    UE_STRING_DEPRECATED(5.4, "This constructor has been deprecated - please use " PREPROCESSOR_TO_STRING(UE_STRING_CLASS) "::ConstructFromPtrSize(Ptr, Size) instead.") [[nodiscard]] CORE_API UE_STRING_CLASS(int32 Len, const UTF8CHAR* Str);
    UE_STRING_DEPRECATED(5.4, "This constructor has been deprecated - please use " PREPROCESSOR_TO_STRING(UE_STRING_CLASS) "::ConstructFromPtrSize(Ptr, Size) instead.") [[nodiscard]] CORE_API UE_STRING_CLASS(int32 Len, const UCS2CHAR* Str);
 
    UE_STRING_DEPRECATED(5.4, "This constructor has been deprecated - please use " PREPROCESSOR_TO_STRING(UE_STRING_CLASS) "::ConstructWithSlack(Ptr, Size) instead.") [[nodiscard]] CORE_API UE_STRING_CLASS(const ANSICHAR* Str, int32 ExtraSlack);
    UE_STRING_DEPRECATED(5.4, "This constructor has been deprecated - please use " PREPROCESSOR_TO_STRING(UE_STRING_CLASS) "::ConstructWithSlack(Ptr, Size) instead.") [[nodiscard]] CORE_API UE_STRING_CLASS(const WIDECHAR* Str, int32 ExtraSlack);
    UE_STRING_DEPRECATED(5.4, "This constructor has been deprecated - please use " PREPROCESSOR_TO_STRING(UE_STRING_CLASS) "::ConstructWithSlack(Ptr, Size) instead.") [[nodiscard]] CORE_API UE_STRING_CLASS(const UTF8CHAR* Str, int32 ExtraSlack);
    UE_STRING_DEPRECATED(5.4, "This constructor has been deprecated - please use " PREPROCESSOR_TO_STRING(UE_STRING_CLASS) "::ConstructWithSlack(Ptr, Size) instead.") [[nodiscard]] CORE_API UE_STRING_CLASS(const UCS2CHAR* Str, int32 ExtraSlack);
 
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConstructWithSlack(const ANSICHAR* Str, int32 ExtraSlack);
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConstructWithSlack(const WIDECHAR* Str, int32 ExtraSlack);
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConstructWithSlack(const UTF8CHAR* Str, int32 ExtraSlack);
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConstructWithSlack(const UCS2CHAR* Str, int32 ExtraSlack);
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConstructWithSlack(const UTF32CHAR* Str, int32 ExtraSlack);
 
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConstructFromPtrSize(const ANSICHAR* Str, int32 Size);
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConstructFromPtrSize(const WIDECHAR* Str, int32 Size);
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConstructFromPtrSize(const UTF8CHAR* Str, int32 Size);
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConstructFromPtrSize(const UCS2CHAR* Str, int32 Size);
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConstructFromPtrSize(const UTF32CHAR* Str, int32 Size);
 
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConstructFromPtrSizeWithSlack(const ANSICHAR* Str, int32 Size, int32 ExtraSlack);
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConstructFromPtrSizeWithSlack(const WIDECHAR* Str, int32 Size, int32 ExtraSlack);
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConstructFromPtrSizeWithSlack(const UTF8CHAR* Str, int32 Size, int32 ExtraSlack);
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConstructFromPtrSizeWithSlack(const UCS2CHAR* Str, int32 Size, int32 ExtraSlack);
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConstructFromPtrSizeWithSlack(const UTF32CHAR* Str, int32 Size, int32 ExtraSlack);
 
    template <
        typename CharRangeType,
        typename CharRangeElementType = TElementType_T<CharRangeType>
        UE_REQUIRES(
            TIsContiguousContainer<CharRangeType>::Value &&
            !std::is_array_v<std::remove_reference_t<CharRangeType>> &&
            TIsCharType_V<CharRangeElementType> &&
            !std::is_base_of_v<UE_STRING_CLASS, std::decay_t<CharRangeType>>
        )
    >
    [[nodiscard]] UE_FORCEINLINE_HINT explicit UE_STRING_CLASS(CharRangeType&& Str)
    {
        *this = UE_STRING_CLASS::ConstructFromPtrSize(GetData(Forward<CharRangeType>(Str)), GetNum(Str));
    }
 
    template <
        typename CharRangeType,
        typename CharRangeElementType = TElementType_T<CharRangeType>
        UE_REQUIRES(
            TIsContiguousContainer<CharRangeType>::Value &&
            !std::is_array_v<std::remove_reference_t<CharRangeType>>&&
            TIsCharType_V<CharRangeElementType> &&
            !std::is_base_of_v<UE_STRING_CLASS, std::decay_t<CharRangeType>>
        )
    >
    [[nodiscard]] explicit UE_STRING_CLASS(CharRangeType&& Str, int32 ExtraSlack)
    {
        uint32 InLen = GetNum(Str);
        Reserve(InLen + ExtraSlack);
        AppendChars(GetData(Forward<CharRangeType>(Str)), InLen);
    }
 
public:
 
#if PLATFORM_APPLE && UE_STRING_CHARTYPE_IS_TCHAR
    [[nodiscard]] inline UE_STRING_CLASS(const CFStringRef In)
    {
        uint32_t StringLength = In ? CFStringGetLength(In) : 0;
 
        if (StringLength > 0)
        {
            // Convert the NSString data into the native TCHAR format for UE4
            // This returns a buffer of bytes, but they can be safely cast to a buffer of TCHARs
#if PLATFORM_TCHAR_IS_4_BYTES
            const CFStringEncoding Encoding = kCFStringEncodingUTF32LE;
#else
            const CFStringEncoding Encoding = kCFStringEncodingUTF16LE;
#endif
 
            CFRange Range = CFRangeMake(0, StringLength);
            CFIndex BytesNeeded;
            if (CFStringGetBytes(In, Range, Encoding, '?', false, NULL, 0, &BytesNeeded) > 0)
            {
                const size_t Length = BytesNeeded / sizeof(TCHAR);
                Data.Reserve(Length + 1);
                Data.AddUninitialized(Length + 1);
                CFStringGetBytes(In, Range, Encoding, '?', false, (uint8*)Data.GetData(), Length * sizeof(TCHAR) + 1, NULL);
                Data[Length] = 0;
            }
        }
    }
#endif
 
    // Start - intrusive TOptional<UE_STRING_CLASS> state //
    constexpr static bool bHasIntrusiveUnsetOptionalState = true;
    using IntrusiveUnsetOptionalStateType = UE_STRING_CLASS;
 
    [[nodiscard]] explicit UE_STRING_CLASS(FIntrusiveUnsetOptionalState Tag)
        : Data(Tag)
    {
    }
    [[nodiscard]] bool UEOpEquals(FIntrusiveUnsetOptionalState Tag) const
    {
        return Data == Tag;
    }
    // End - intrusive TOptional<UE_STRING_CLASS> state //
 
#if defined(__OBJC__) && UE_STRING_CHARTYPE_IS_TCHAR
    [[nodiscard]] UE_FORCEINLINE_HINT UE_STRING_CLASS(const NSString* In) : UE_STRING_CLASS((__bridge CFStringRef)In)
    {
    }
#endif
 
    CORE_API UE_STRING_CLASS& operator=(const ElementType* Str);
 
    template <
        typename CharRangeType,
        typename CharRangeElementType = TElementType_T<CharRangeType>
        UE_REQUIRES(
            TIsContiguousContainer<CharRangeType>::Value &&
            !std::is_array_v<std::remove_reference_t<CharRangeType>> &&
            std::is_same_v<ElementType, CharRangeElementType>
        )
    >
    inline UE_STRING_CLASS& operator=(CharRangeType&& Range)
    {
        AssignRange(GetData(Range), GetNum(Range));
        return *this;
    }
 
private:
    CORE_API void AssignRange(const ElementType* Str, int32 Len);
 
public:
    [[nodiscard]] inline ElementType& operator[](int32 Index) UE_LIFETIMEBOUND
    {
        checkf(IsValidIndex(Index), TEXT("String index out of bounds: Index %i from a string with a length of %i"), Index, Len());
        return Data.GetData()[Index];
    }
 
    [[nodiscard]] inline const ElementType& operator[](int32 Index) const UE_LIFETIMEBOUND
    {
        checkf(IsValidIndex(Index), TEXT("String index out of bounds: Index %i from a string with a length of %i"), Index, Len());
        return Data.GetData()[Index];
    }
 
    typedef DataType::TIterator      TIterator;
    typedef DataType::TConstIterator TConstIterator;
 
    [[nodiscard]] UE_FORCEINLINE_HINT TIterator CreateIterator()
    {
        return Data.CreateIterator();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT TConstIterator CreateConstIterator() const
    {
        return Data.CreateConstIterator();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT DataType::RangedForIteratorType             begin ()       { auto Result = Data.begin();                                return Result; }
    [[nodiscard]] UE_FORCEINLINE_HINT DataType::RangedForConstIteratorType        begin () const { auto Result = Data.begin();                                return Result; }
    [[nodiscard]] UE_FORCEINLINE_HINT DataType::RangedForIteratorType             end   ()       { auto Result = Data.end();    if (Data.Num()) { --Result; } return Result; }
    [[nodiscard]] UE_FORCEINLINE_HINT DataType::RangedForConstIteratorType        end   () const { auto Result = Data.end();    if (Data.Num()) { --Result; } return Result; }
    [[nodiscard]] UE_FORCEINLINE_HINT DataType::RangedForReverseIteratorType      rbegin()       { auto Result = Data.rbegin(); if (Data.Num()) { ++Result; } return Result; }
    [[nodiscard]] UE_FORCEINLINE_HINT DataType::RangedForConstReverseIteratorType rbegin() const { auto Result = Data.rbegin(); if (Data.Num()) { ++Result; } return Result; }
    [[nodiscard]] UE_FORCEINLINE_HINT DataType::RangedForReverseIteratorType      rend  ()       { auto Result = Data.rend();                                 return Result; }
    [[nodiscard]] UE_FORCEINLINE_HINT DataType::RangedForConstReverseIteratorType rend  () const { auto Result = Data.rend();                                 return Result; }
 
    [[nodiscard]] UE_FORCEINLINE_HINT SIZE_T GetAllocatedSize() const
    {
        return Data.GetAllocatedSize();
    }
 
    inline void CheckInvariants() const
    {
        int32 Num = Data.Num();
        checkSlow(Num >= 0);
        checkSlow(!Num || !Data.GetData()[Num - 1]);
        checkSlow(Data.GetSlack() >= 0);
    }
 
    CORE_API void Empty();
    CORE_API void Empty(int32 Slack);
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsEmpty() const
    {
        return Data.Num() <= 1;
    }
 
    CORE_API void Reset(int32 NewReservedSize = 0);
 
    CORE_API void Shrink();
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool IsValidIndex(int32 Index) const
    {
        return Index >= 0 && Index < Len();
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT const ElementType* operator*() const UE_LIFETIMEBOUND
    {
        return Data.Num() ? Data.GetData() : CHARTEXT(ElementType, "");
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT DataType& GetCharArray() UE_LIFETIMEBOUND
    {
        return Data;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT const DataType& GetCharArray() const UE_LIFETIMEBOUND
    {
        return Data;
    }
 
#if PLATFORM_APPLE
    [[nodiscard]] CORE_API CFStringRef GetCFString() const;
#endif
 
#ifdef __OBJC__
    [[nodiscard]] CORE_API NSString* GetNSString() const;
#endif
    CORE_API void AppendChars(const ANSICHAR* Str, int32 Count);
    CORE_API void AppendChars(const WIDECHAR* Str, int32 Count);
    CORE_API void AppendChars(const UCS2CHAR* Str, int32 Count);
    CORE_API void AppendChars(const UTF8CHAR* Str, int32 Count);
    CORE_API void AppendChars(const UTF32CHAR* Str, int32 Count);
 
    template<class CharType>
    inline UE_STRING_CLASS& Append(const CharType* Str, int32 Count)
    {
        AppendChars(Str, Count);
        return *this;
    }
    
    template<class CharType>
    inline UE_STRING_CLASS& Append(/* no const! */ CharType* Str)
    {
        checkSlow(Str);
        AppendChars(Str, TCString<std::remove_const_t<CharType>>::Strlen(Str));
        return *this;
    }
 
    template <
        typename CharRangeType,
        typename CharRangeElementType = TElementType_T<CharRangeType>
        UE_REQUIRES(TIsContiguousContainer<CharRangeType>::Value && TIsCharType_V<CharRangeElementType>)
    >
    inline UE_STRING_CLASS& Append(CharRangeType&& Str)
    {
        AppendChars(GetData(Str), GetNum(Str));
        return *this;
    }
 
    CORE_API UE_STRING_CLASS& AppendChar(ElementType InChar);
 
    template <typename StrType>
    UE_FORCEINLINE_HINT auto operator+=(StrType&& Str) -> decltype(Append(Forward<StrType>(Str)))
    {
        return Append(Forward<StrType>(Str));
    }
 
    template <
        typename AppendedCharType
        UE_REQUIRES(TIsCharType_V<AppendedCharType>)
    >
    inline UE_STRING_CLASS& operator+=(AppendedCharType Char)
    {
        if constexpr (TIsCharEncodingSimplyConvertibleTo_V<AppendedCharType, ElementType>)
        {
            return AppendChar((ElementType)Char);
        }
        else
        {
            AppendChars(&Char, 1);
            return *this;
        }
    }
 
    CORE_API void InsertAt(int32 Index, ElementType Character);
    CORE_API void InsertAt(int32 Index, const UE_STRING_CLASS& Characters);
 
    CORE_API void RemoveAt(int32 Index, EAllowShrinking AllowShrinking = EAllowShrinking::Default);
 
    CORE_API void RemoveAt(int32 Index, int32 Count, EAllowShrinking AllowShrinking = EAllowShrinking::Default);
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("RemoveAt")
    UE_FORCEINLINE_HINT void RemoveAt(int32 Index, int32 Count, bool bAllowShrinking)
    {
        RemoveAt(Index, Count, bAllowShrinking ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
 
    template <
        typename CharRangeType,
        typename CharRangeElementType = TElementType_T<CharRangeType>
        UE_REQUIRES(
            TIsContiguousContainer<CharRangeType>::Value &&
            !std::is_array_v<std::remove_reference_t<CharRangeType>>&&
            TIsCharType_V<CharRangeElementType> &&
            !std::is_base_of_v<UE_STRING_CLASS, std::decay_t<CharRangeType>>
        )
    >
    bool RemoveFromStart(CharRangeType&& InPrefix, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase)
    {
        static_assert(std::is_same_v<CharRangeElementType, ElementType>, "Expected a range of ElementType");
        return RemoveFromStart(GetData(InPrefix), GetNum(InPrefix), SearchCase);
    }
 
    bool RemoveFromStart(const ElementType* InPrefix, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase)
    {
        return RemoveFromStart(InPrefix, InPrefix ? TCString<ElementType>::Strlen(InPrefix) : 0, SearchCase);
    }
 
    bool RemoveFromStart(const UE_STRING_CLASS& InPrefix, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase)
    {
        return RemoveFromStart(*InPrefix, InPrefix.Len(), SearchCase);
    }
 
    CORE_API bool RemoveFromStart(const ElementType* InPrefix, int32 InPrefixLen, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase);
 
    template <
        typename CharRangeType,
        typename CharRangeElementType = TElementType_T<CharRangeType>
        UE_REQUIRES(
            TIsContiguousContainer<CharRangeType>::Value &&
            !std::is_array_v<std::remove_reference_t<CharRangeType>>&&
            TIsCharType_V<CharRangeElementType> &&
            !std::is_base_of_v<UE_STRING_CLASS, std::decay_t<CharRangeType>>
        )
    >
    bool RemoveFromEnd(CharRangeType&& InSuffix, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase)
    {
        static_assert(std::is_same_v<CharRangeElementType, ElementType>, "Expected a range of ElementType");
        return RemoveFromEnd(GetData(InSuffix), GetNum(InSuffix), SearchCase);
    }
 
    bool RemoveFromEnd(const ElementType* InSuffix, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase)
    {
        return RemoveFromEnd(InSuffix, InSuffix ? TCString<ElementType>::Strlen(InSuffix) : 0, SearchCase);
    }
 
    bool RemoveFromEnd(const UE_STRING_CLASS& InSuffix, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase)
    {
        return RemoveFromEnd(*InSuffix, InSuffix.Len(), SearchCase);
    }
 
    CORE_API bool RemoveFromEnd(const ElementType* InSuffix, int32 InSuffixLen, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase);
 
    CORE_API void PathAppend(const ElementType* Str, int32 StrLength);
 
    template <
        typename CharType
        UE_REQUIRES(TIsCharType_V<CharType>)
    >
    [[nodiscard]] inline friend UE_STRING_CLASS operator+(const UE_STRING_CLASS& Lhs, CharType Rhs)
    {
        Lhs.CheckInvariants();
 
        UE_STRING_CLASS Result(Lhs, 1);
        Result += Rhs;
 
        return Result;
    }
 
    template <
        typename CharType
        UE_REQUIRES(TIsCharType_V<CharType>)
    >
    [[nodiscard]] inline friend UE_STRING_CLASS operator+(UE_STRING_CLASS&& Lhs, CharType Rhs)
    {
        Lhs.CheckInvariants();
 
        UE_STRING_CLASS Result(MoveTemp(Lhs), 1);
        Result += Rhs;
 
        return Result;
    }
 
private:
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConcatFF(const UE_STRING_CLASS& Lhs, const UE_STRING_CLASS& Rhs);
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConcatFF(UE_STRING_CLASS&& Lhs, const UE_STRING_CLASS& Rhs);
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConcatFF(const UE_STRING_CLASS& Lhs, UE_STRING_CLASS&& Rhs);
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConcatFF(UE_STRING_CLASS&& Lhs, UE_STRING_CLASS&& Rhs);
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConcatFC(const UE_STRING_CLASS& Lhs, const ElementType* Rhs);
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConcatFC(UE_STRING_CLASS&& Lhs,   const ElementType* Rhs);
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConcatCF(const ElementType* Lhs, const UE_STRING_CLASS& Rhs);
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConcatCF(const ElementType* Lhs, UE_STRING_CLASS&& Rhs);
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConcatFR(const UE_STRING_CLASS& Lhs, const ElementType* Rhs, int32 RhsLen);
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConcatFR(UE_STRING_CLASS&& Lhs,   const ElementType* Rhs, int32 RhsLen);
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConcatRF(const ElementType* Lhs, int32 LhsLen, const UE_STRING_CLASS& Rhs);
    [[nodiscard]] static CORE_API UE_STRING_CLASS ConcatRF(const ElementType* Lhs, int32 LhsLen, UE_STRING_CLASS&& Rhs);
 
public:
    [[nodiscard]] UE_FORCEINLINE_HINT friend UE_STRING_CLASS operator+(const UE_STRING_CLASS& Lhs, const UE_STRING_CLASS& Rhs)  { return ConcatFF(Lhs, Rhs); }
    [[nodiscard]] UE_FORCEINLINE_HINT friend UE_STRING_CLASS operator+(UE_STRING_CLASS&& Lhs, const UE_STRING_CLASS& Rhs)       { return ConcatFF(MoveTemp(Lhs), Rhs); }
    [[nodiscard]] UE_FORCEINLINE_HINT friend UE_STRING_CLASS operator+(const UE_STRING_CLASS& Lhs, UE_STRING_CLASS&& Rhs)       { return ConcatFF(Lhs,MoveTemp(Rhs)); }
    [[nodiscard]] UE_FORCEINLINE_HINT friend UE_STRING_CLASS operator+(UE_STRING_CLASS&& Lhs, UE_STRING_CLASS&& Rhs)                { return ConcatFF(MoveTemp(Lhs), MoveTemp(Rhs)); }
    [[nodiscard]] UE_FORCEINLINE_HINT friend UE_STRING_CLASS operator+(const ElementType* Lhs, const UE_STRING_CLASS& Rhs)      { return ConcatCF(Lhs, Rhs); }
    [[nodiscard]] UE_FORCEINLINE_HINT friend UE_STRING_CLASS operator+(const ElementType* Lhs, UE_STRING_CLASS&& Rhs)           { return ConcatCF(Lhs, MoveTemp(Rhs)); }
    [[nodiscard]] UE_FORCEINLINE_HINT friend UE_STRING_CLASS operator+(const UE_STRING_CLASS& Lhs, const ElementType* Rhs)      { return ConcatFC(Lhs, Rhs); }
    [[nodiscard]] UE_FORCEINLINE_HINT friend UE_STRING_CLASS operator+(UE_STRING_CLASS&& Lhs, const ElementType* Rhs)           { return ConcatFC(MoveTemp(Lhs), Rhs); }
 
    template <
        typename CharRangeType,
        typename CharRangeElementType = TElementType_T<CharRangeType>
        UE_REQUIRES(
            TIsContiguousContainer<CharRangeType>::Value &&
            !std::is_array_v<std::remove_reference_t<CharRangeType>> &&
            std::is_same_v<ElementType, CharRangeElementType> &&
            !std::is_base_of_v<UE_STRING_CLASS, std::decay_t<CharRangeType>>
        )
    >
    [[nodiscard]] UE_FORCEINLINE_HINT friend UE_STRING_CLASS operator+(CharRangeType&& Lhs, const UE_STRING_CLASS& Rhs)
    {
        return ConcatRF(GetData(Lhs), GetNum(Lhs), Rhs);
    }
    template <
        typename CharRangeType,
        typename CharRangeElementType = TElementType_T<CharRangeType>
        UE_REQUIRES(
            TIsContiguousContainer<CharRangeType>::Value &&
            !std::is_array_v<std::remove_reference_t<CharRangeType>>&&
            std::is_same_v<ElementType, CharRangeElementType> &&
            !std::is_base_of_v<UE_STRING_CLASS, std::decay_t<CharRangeType>>
        )
    >
    [[nodiscard]] UE_FORCEINLINE_HINT friend UE_STRING_CLASS operator+(CharRangeType&& Lhs, UE_STRING_CLASS&& Rhs)
    {
        return ConcatRF(GetData(Lhs), GetNum(Lhs), MoveTemp(Rhs));
    }
    template <
        typename CharRangeType,
        typename CharRangeElementType = TElementType_T<CharRangeType>
        UE_REQUIRES(
            TIsContiguousContainer<CharRangeType>::Value &&
            !std::is_array_v<std::remove_reference_t<CharRangeType>>&&
            std::is_same_v<ElementType, CharRangeElementType> &&
            !std::is_base_of_v<UE_STRING_CLASS, std::decay_t<CharRangeType>>
        )
    >
    [[nodiscard]] UE_FORCEINLINE_HINT friend UE_STRING_CLASS operator+(const UE_STRING_CLASS& Lhs, CharRangeType&& Rhs)
    {
        return ConcatFR(Lhs, GetData(Rhs), GetNum(Rhs));
    }
    template <
        typename CharRangeType,
        typename CharRangeElementType = TElementType_T<CharRangeType>
        UE_REQUIRES(
            TIsContiguousContainer<CharRangeType>::Value &&
            !std::is_array_v<std::remove_reference_t<CharRangeType>>&&
            std::is_same_v<ElementType, CharRangeElementType> &&
            !std::is_base_of_v<UE_STRING_CLASS, std::decay_t<CharRangeType>>
        )
    >
    [[nodiscard]] UE_FORCEINLINE_HINT friend UE_STRING_CLASS operator+(UE_STRING_CLASS&& Lhs, CharRangeType&& Rhs)
    {
        return ConcatFR(MoveTemp(Lhs), GetData(Rhs), GetNum(Rhs));
    }
 
    inline UE_STRING_CLASS& operator/=(const ElementType* Str)
    {
        checkSlow(Str);
 
        PathAppend(Str, TCString<ElementType>::Strlen(Str));
        return *this;
    }
 
    template <
        typename CharRangeType,
        typename CharRangeElementType = TElementType_T<CharRangeType>
        UE_REQUIRES(
            TIsContiguousContainer<CharRangeType>::Value &&
            !std::is_array_v<std::remove_reference_t<CharRangeType>>&&
            std::is_same_v<ElementType, CharRangeElementType>
        )
    >
    inline UE_STRING_CLASS& operator/=(CharRangeType&& Str)
    {
        PathAppend(GetData(Str), GetNum(Str));
        return *this;
    }
 
    template <
        typename CharType
        UE_REQUIRES(TIsCharType_V<CharType>)
    >
    inline UE_STRING_CLASS& operator/=(const CharType* Str)
    {
        UE_STRING_CLASS Temp = Str;
        PathAppend(GetData(Temp), GetNum(Temp));
        return *this;
    }
 
    [[nodiscard]] inline friend UE_STRING_CLASS operator/(const UE_STRING_CLASS& Lhs, const ElementType* Rhs)
    {
        checkSlow(Rhs);
 
        int32 StrLength = TCString<ElementType>::Strlen(Rhs);
 
        UE_STRING_CLASS Result(Lhs, StrLength + 1);
        Result.PathAppend(Rhs, StrLength);
        return Result;
    }
 
    [[nodiscard]] inline friend UE_STRING_CLASS operator/(UE_STRING_CLASS&& Lhs, const ElementType* Rhs)
    {
        checkSlow(Rhs);
 
        int32 StrLength = TCString<ElementType>::Strlen(Rhs);
 
        UE_STRING_CLASS Result(MoveTemp(Lhs), StrLength + 1);
        Result.PathAppend(Rhs, StrLength);
        return Result;
    }
 
    [[nodiscard]] inline friend UE_STRING_CLASS operator/(const UE_STRING_CLASS& Lhs, const UE_STRING_CLASS& Rhs)
    {
        int32 StrLength = Rhs.Len();
 
        UE_STRING_CLASS Result(Lhs, StrLength + 1);
        Result.PathAppend(Rhs.Data.GetData(), StrLength);
        return Result;
    }
 
    [[nodiscard]] inline friend UE_STRING_CLASS operator/(UE_STRING_CLASS&& Lhs, const UE_STRING_CLASS& Rhs)
    {
        int32 StrLength = Rhs.Len();
 
        UE_STRING_CLASS Result(MoveTemp(Lhs), StrLength + 1);
        Result.PathAppend(Rhs.Data.GetData(), StrLength);
        return Result;
    }
 
    [[nodiscard]] inline friend UE_STRING_CLASS operator/(const ElementType* Lhs, const UE_STRING_CLASS& Rhs)
    {
        int32 StrLength = Rhs.Len();
 
        UE_STRING_CLASS Result(UE_STRING_CLASS(Lhs), StrLength + 1);
        Result.PathAppend(Rhs.Data.GetData(), Rhs.Len());
        return Result;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool UEOpLessThan(const UE_STRING_CLASS& Rhs) const
    {
        return FPlatformString::Stricmp(**this, *Rhs) < 0;
    }
 
    template <typename CharType>
    [[nodiscard]] UE_FORCEINLINE_HINT bool UEOpLessThan(const CharType* Rhs) const
    {
        return FPlatformString::Stricmp(**this, Rhs) < 0;
    }
 
    template <typename CharType>
    [[nodiscard]] UE_FORCEINLINE_HINT bool UEOpGreaterThan(const CharType* Rhs) const
    {
        return FPlatformString::Stricmp(**this, Rhs) > 0;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool UEOpEquals(const UE_STRING_CLASS& Rhs) const
    {
        return Equals(Rhs, ESearchCase::IgnoreCase);
    }
 
    template <typename CharType>
    [[nodiscard]] UE_FORCEINLINE_HINT bool UEOpEquals(const CharType* Rhs) const
    {
        return FPlatformString::Stricmp(**this, Rhs) == 0;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT int32 Len() const
    {
        return Data.Num() ? Data.Num() - 1 : 0;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT SIZE_T NumBytesWithoutNull() const
    {
        return static_cast<SIZE_T>(Len()) * sizeof(ElementType);
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT SIZE_T NumBytesWithNull() const
    {
        return (static_cast<SIZE_T>(Len()) + 1) * sizeof(ElementType);
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT UE_STRING_CLASS Left(int32 Count) const &
    {
        return UE_STRING_CLASS::ConstructFromPtrSize(**this, FMath::Clamp(Count, 0, Len()));
    }
 
    [[nodiscard]] inline UE_STRING_CLASS Left(int32 Count) &&
    {
        LeftInline(Count, EAllowShrinking::No);
        return MoveTemp(*this);
    }
 
    inline void LeftInline(int32 Count, EAllowShrinking AllowShrinking = EAllowShrinking::Default)
    {
        const int32 Length = Len();
        Count = FMath::Clamp(Count, 0, Length);
        RemoveAt(Count, Length-Count, AllowShrinking);
    }
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("LeftInline")
    UE_FORCEINLINE_HINT void LeftInline(int32 Count, bool bAllowShrinking)
    {
        LeftInline(Count, bAllowShrinking ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
 
    [[nodiscard]] inline UE_STRING_CLASS LeftChop(int32 Count) const &
    {
        const int32 Length = Len();
        return UE_STRING_CLASS::ConstructFromPtrSize(**this, FMath::Clamp(Length - Count, 0, Length));
    }
 
    [[nodiscard]] inline UE_STRING_CLASS LeftChop(int32 Count) &&
    {
        LeftChopInline(Count, EAllowShrinking::No);
        return MoveTemp(*this);
    }
 
    inline void LeftChopInline(int32 Count, EAllowShrinking AllowShrinking = EAllowShrinking::Default)
    {
        const int32 Length = Len();
        RemoveAt(FMath::Clamp(Length-Count, 0, Length), Count, AllowShrinking);
    }
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("LeftChopInline")
    UE_FORCEINLINE_HINT void LeftChopInline(int32 Count, bool bAllowShrinking)
    {
        LeftChopInline(Count, bAllowShrinking ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
 
    [[nodiscard]] inline UE_STRING_CLASS Right(int32 Count) const &
    {
        const int32 Length = Len();
        return UE_STRING_CLASS(**this + Length - FMath::Clamp(Count, 0, Length));
    }
 
    [[nodiscard]] inline UE_STRING_CLASS Right(int32 Count) &&
    {
        RightInline(Count, EAllowShrinking::No);
        return MoveTemp(*this);
    }
 
    inline void RightInline(int32 Count, EAllowShrinking AllowShrinking = EAllowShrinking::Default)
    {
        const int32 Length = Len();
        RemoveAt(0, Length-FMath::Clamp(Count,0,Length), AllowShrinking);
    }
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("RightInline")
    UE_FORCEINLINE_HINT void RightInline(int32 Count, bool bAllowShrinking)
    {
        RightInline(Count, bAllowShrinking ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
 
    [[nodiscard]] CORE_API UE_STRING_CLASS RightChop(int32 Count) const &;
 
    [[nodiscard]] inline UE_STRING_CLASS RightChop(int32 Count) &&
    {
        RightChopInline(Count, EAllowShrinking::No);
        return MoveTemp(*this);
    }
 
    UE_FORCEINLINE_HINT void RightChopInline(int32 Count, EAllowShrinking AllowShrinking = EAllowShrinking::Default)
    {
        RemoveAt(0, Count, AllowShrinking);
    }
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("RightChopInline")
    UE_FORCEINLINE_HINT void RightChopInline(int32 Count, bool bAllowShrinking)
    {
        RightChopInline(Count, bAllowShrinking ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
 
    [[nodiscard]] CORE_API UE_STRING_CLASS Mid(int32 Start, int32 Count) const &;
    [[nodiscard]] CORE_API UE_STRING_CLASS Mid(int32 Start, int32 Count) &&;
 
    [[nodiscard]] UE_FORCEINLINE_HINT UE_STRING_CLASS Mid(int32 Start) const & { return RightChop(Start); }
    [[nodiscard]] UE_FORCEINLINE_HINT UE_STRING_CLASS Mid(int32 Start) && { return ((UE_STRING_CLASS&&)*this).RightChop(Start); }
 
    inline void MidInline(int32 Start, int32 Count = MAX_int32, EAllowShrinking AllowShrinking = EAllowShrinking::Default)
    {
        if (Count != MAX_int32 && int64(Start) + Count < MAX_int32)
        {
            LeftInline(Count + Start, EAllowShrinking::No);
        }
        RightChopInline(Start, AllowShrinking);
    }
    UE_ALLOWSHRINKING_BOOL_DEPRECATED("MidInline")
    UE_FORCEINLINE_HINT void MidInline(int32 Start, int32 Count, bool bAllowShrinking)
    {
        MidInline(Start, Count, bAllowShrinking ? EAllowShrinking::Yes : EAllowShrinking::No);
    }
 
    template <
        typename CharRangeType,
        typename CharRangeElementType = TElementType_T<CharRangeType>
        UE_REQUIRES(
            TIsContiguousContainer<CharRangeType>::Value &&
            !std::is_array_v<std::remove_reference_t<CharRangeType>>&&
            TIsCharType_V<CharRangeElementType> &&
            !std::is_base_of_v<UE_STRING_CLASS, std::decay_t<CharRangeType>>
        )
    >
    [[nodiscard]] int32 Find(CharRangeType&& SubStr, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase,
        ESearchDir::Type SearchDir = ESearchDir::FromStart, int32 StartPosition = INDEX_NONE) const
    {
        static_assert(std::is_same_v<CharRangeElementType, ElementType>, "Expected a range of ElementType");
        return Find(GetData(SubStr), GetNum(SubStr), SearchCase, SearchDir, StartPosition);
    }
 
    [[nodiscard]] int32 Find(const ElementType* SubStr, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase,
        ESearchDir::Type SearchDir = ESearchDir::FromStart, int32 StartPosition = INDEX_NONE) const
    {
        return SubStr ? Find(SubStr, TCString<ElementType>::Strlen(SubStr), SearchCase, SearchDir, StartPosition) : INDEX_NONE;
    }
 
    [[nodiscard]] int32 Find(const UE_STRING_CLASS& SubStr, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase,
        ESearchDir::Type SearchDir = ESearchDir::FromStart, int32 StartPosition = INDEX_NONE) const
    {
        return Find(*SubStr, SubStr.Len(), SearchCase, SearchDir, StartPosition);
    }
 
    [[nodiscard]] CORE_API int32 Find(const ElementType* SubStr, int32 InSubStrLen, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase,
        ESearchDir::Type SearchDir = ESearchDir::FromStart, int32 StartPosition = INDEX_NONE) const;
 
 
    template <
        typename CharRangeType,
        typename CharRangeElementType = TElementType_T<CharRangeType>
        UE_REQUIRES(
            TIsContiguousContainer<CharRangeType>::Value &&
            !std::is_array_v<std::remove_reference_t<CharRangeType>>&&
            TIsCharType_V<CharRangeElementType> &&
            !std::is_base_of_v<UE_STRING_CLASS, std::decay_t<CharRangeType>>
        )
    >
    [[nodiscard]] inline bool Contains(CharRangeType&& SubStr, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase,
        ESearchDir::Type SearchDir = ESearchDir::FromStart) const
    {
        static_assert(std::is_same_v<CharRangeElementType, ElementType>, "Expected a range of characters");
        return Find(Forward<CharRangeType>(SubStr), SearchCase, SearchDir) != INDEX_NONE;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool Contains(const ElementType* SubStr, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase,
        ESearchDir::Type SearchDir = ESearchDir::FromStart) const
    {
        return Find(SubStr, SearchCase, SearchDir) != INDEX_NONE;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool Contains(const UE_STRING_CLASS& SubStr, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase,
                              ESearchDir::Type SearchDir = ESearchDir::FromStart) const
    {
        return Find(*SubStr, SearchCase, SearchDir) != INDEX_NONE;
    }
 
    [[nodiscard]] UE_FORCEINLINE_HINT bool Contains(const ElementType* SubStr, int32 SubStrLen,
        ESearchCase::Type SearchCase = ESearchCase::IgnoreCase, ESearchDir::Type SearchDir = ESearchDir::FromStart) const
    {
        return Find(SubStr, SubStrLen, SearchCase, SearchDir) != INDEX_NONE;
    }
 
    UE_FORCEINLINE_HINT bool FindChar(ElementType InChar, int32& OutIndex) const
    {
        return Data.Find(InChar, OutIndex);
    }
 
    UE_FORCEINLINE_HINT bool FindLastChar(ElementType InChar, int32& OutIndex) const
    {
        return Data.FindLast(InChar, OutIndex);
    }
 
    template <typename Predicate>
    inline int32 FindLastCharByPredicate(Predicate Pred, int32 Count) const
    {
        check(Count >= 0 && Count <= this->Len());
        return Data.FindLastByPredicate(Pred, Count);
    }
 
    template <typename Predicate>
    UE_FORCEINLINE_HINT int32 FindLastCharByPredicate(Predicate Pred) const
    {
        return Data.FindLastByPredicate(Pred, this->Len());
    }
 
    [[nodiscard]] inline bool Equals(const UE_STRING_CLASS& Other, ESearchCase::Type SearchCase = ESearchCase::CaseSensitive) const
    {
        int32 Num = Data.Num();
        int32 OtherNum = Other.Data.Num();
 
        if (Num != OtherNum)
        {
            // Handle special case where FString() == FString("")
            return Num + OtherNum == 1;
        }
        else if (Num > 1)
        {
            if (SearchCase == ESearchCase::CaseSensitive)
            {
                return TCString<ElementType>::Strcmp(Data.GetData(), Other.Data.GetData()) == 0; 
            }
            else
            {
                return TCString<ElementType>::Stricmp(Data.GetData(), Other.Data.GetData()) == 0;
            }
        }
 
        return true;
    }
 
    [[nodiscard]] inline int32 Compare(const UE_STRING_CLASS& Other, ESearchCase::Type SearchCase = ESearchCase::CaseSensitive) const
    {
        if (SearchCase == ESearchCase::CaseSensitive)
        {
            return TCString<ElementType>::Strcmp(**this, *Other); 
        }
        else
        {
            return TCString<ElementType>::Stricmp(**this, *Other);
        }
    }
 
    CORE_API bool Split(const UE_STRING_CLASS& InStr, UE_STRING_CLASS* LeftS, UE_STRING_CLASS* RightS, ESearchCase::Type SearchCase,
        ESearchDir::Type SearchDir = ESearchDir::FromStart) const;
 
    CORE_API bool Split(const UE_STRING_CLASS& InStr, UE_STRING_CLASS* LeftS, UE_STRING_CLASS* RightS) const;
 
    [[nodiscard]] CORE_API UE_STRING_CLASS ToUpper() const &;
 
    [[nodiscard]] CORE_API UE_STRING_CLASS ToUpper() &&;
 
    CORE_API void ToUpperInline();
 
    [[nodiscard]] CORE_API UE_STRING_CLASS ToLower() const &;
 
    [[nodiscard]] CORE_API UE_STRING_CLASS ToLower() &&;
 
    CORE_API void ToLowerInline();
 
    [[nodiscard]] CORE_API UE_STRING_CLASS LeftPad(int32 ChCount) const;
 
    [[nodiscard]] CORE_API UE_STRING_CLASS RightPad(int32 ChCount) const;
    
    [[nodiscard]] CORE_API bool IsNumeric() const;
    
    CORE_API void RemoveSpacesInline();
 
    template <typename... Types>
    [[nodiscard]] static UE_STRING_CLASS Printf(UE::Core::TCheckedFormatString<FmtCharType, Types...> Fmt, Types... Args)
    {
        return PrintfImpl((const ElementType*)Fmt.FormatString, Args...);
    }
#ifdef UE_STRING_PRINTF_FMT_CHARTYPE2
    template <typename... Types>
    [[nodiscard]] static UE_STRING_CLASS Printf(UE::Core::TCheckedFormatString<FmtCharType2, Types...> Fmt, Types... Args)
    {
        return PrintfImpl((const ElementType*)Fmt.FormatString, Args...);
    }
#endif
 
    template <typename... Types>
    UE_STRING_CLASS& Appendf(UE::Core::TCheckedFormatString<FmtCharType, Types...> Fmt, Types... Args)
    {
        AppendfImpl(*this, (const ElementType*)Fmt.FormatString, Args...);
        return *this;
    }
#ifdef UE_STRING_PRINTF_FMT_CHARTYPE2
    template <typename... Types>
    UE_STRING_CLASS& Appendf(UE::Core::TCheckedFormatString<FmtCharType2, Types...> Fmt, Types... Args)
    {
        AppendfImpl(*this, (const ElementType*)Fmt.FormatString, Args...);
        return *this;
    }
#endif
 
private:
    static CORE_API UE_STRING_CLASS VARARGS PrintfImpl(const ElementType* Fmt, ...);
    static CORE_API void VARARGS AppendfImpl(UE_STRING_CLASS& AppendToMe, const ElementType* Fmt, ...);
public:
 
    [[nodiscard]] static UE_STRING_CLASS Format(const FmtCharType* InFormatString, const PREPROCESSOR_JOIN(UE_STRING_CLASS, FormatNamedArguments)& InNamedArguments)
    {
        return FormatImpl((const ElementType*)InFormatString, InNamedArguments);
    }
#ifdef UE_STRING_PRINTF_FMT_CHARTYPE2
    [[nodiscard]] static UE_STRING_CLASS Format(const FmtCharType2* InFormatString, const PREPROCESSOR_JOIN(UE_STRING_CLASS, FormatNamedArguments)& InNamedArguments)
    {
        return FormatImpl((const ElementType*)InFormatString, InNamedArguments);
    }
#endif
 
    [[nodiscard]] static UE_STRING_CLASS Format(const FmtCharType* InFormatString, const FStringFormatOrderedArguments& InOrderedArguments)
    {
        return FormatImpl((const ElementType*)InFormatString, InOrderedArguments);
    }
#ifdef UE_STRING_PRINTF_FMT_CHARTYPE2
    [[nodiscard]] static UE_STRING_CLASS Format(const FmtCharType2* InFormatString, const FStringFormatOrderedArguments& InOrderedArguments)
    {
        return FormatImpl((const ElementType*)InFormatString, InOrderedArguments);
    }
#endif
 
private:
    static CORE_API UE_STRING_CLASS FormatImpl(const ElementType* InFormatString, const PREPROCESSOR_JOIN(UE_STRING_CLASS, FormatNamedArguments)& InNamedArguments);
    static CORE_API UE_STRING_CLASS FormatImpl(const ElementType* InFormatString, const FStringFormatOrderedArguments& InOrderedArguments);
public:
 
    [[nodiscard]] static CORE_API UE_STRING_CLASS Chr(ElementType Ch);
 
    [[nodiscard]] static CORE_API UE_STRING_CLASS ChrN(int32 NumCharacters, ElementType Char);
 
    friend CORE_API FArchive& operator<<(FArchive& Ar, UE_STRING_CLASS& Str);
 
 
    template <
        typename CharRangeType,
        typename CharRangeElementType = TElementType_T<CharRangeType>
        UE_REQUIRES(
            TIsContiguousContainer<CharRangeType>::Value &&
            !std::is_array_v<std::remove_reference_t<CharRangeType>>&&
            TIsCharType_V<CharRangeElementType> &&
            !std::is_base_of_v<UE_STRING_CLASS, std::decay_t<CharRangeType>>
        )
    >
    [[nodiscard]] bool StartsWith(CharRangeType&& InPrefix, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase) const
    {
        static_assert(std::is_same_v<CharRangeElementType, ElementType>, "Expected a range of characters");
        return StartsWith(GetData(InPrefix), GetNum(InPrefix), SearchCase);
    }
 
    [[nodiscard]] bool StartsWith(const ElementType* InPrefix, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase) const
    {
        return StartsWith(InPrefix, InPrefix ? TCString<ElementType>::Strlen(InPrefix) : 0, SearchCase);
    }
 
    [[nodiscard]] bool StartsWith(const UE_STRING_CLASS& InPrefix, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase) const
    {
        return StartsWith(*InPrefix, InPrefix.Len(), SearchCase);
    }
 
    [[nodiscard]] CORE_API bool StartsWith(const ElementType* InPrefix, int32 InPrefixLen, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase) const;
 
    template <
        typename CharRangeType,
        typename CharRangeElementType = TElementType_T<CharRangeType>
        UE_REQUIRES(
            TIsContiguousContainer<CharRangeType>::Value &&
            !std::is_array_v<std::remove_reference_t<CharRangeType>>&&
            TIsCharType_V<CharRangeElementType> &&
            !std::is_base_of_v<UE_STRING_CLASS, std::decay_t<CharRangeType>>
        )
    >
    [[nodiscard]] bool EndsWith(CharRangeType&& InSuffix, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase) const
    {
        static_assert(std::is_same_v<CharRangeElementType, ElementType>, "Expected a range of characters");
        return EndsWith(GetData(InSuffix), GetNum(InSuffix), SearchCase);
    }
 
    [[nodiscard]] bool EndsWith(const ElementType* InSuffix, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase) const
    {
        return EndsWith(InSuffix, InSuffix ? TCString<ElementType>::Strlen(InSuffix) : 0, SearchCase);
    }
 
    [[nodiscard]] bool EndsWith(const UE_STRING_CLASS& InSuffix, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase) const
    {
        return EndsWith(*InSuffix, InSuffix.Len(), SearchCase);
    }
 
    [[nodiscard]] CORE_API bool EndsWith(const ElementType* InSuffix, int32 InSuffixLen, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase) const;
 
    template <
        typename CharRangeType,
        typename CharRangeElementType = TElementType_T<CharRangeType>
        UE_REQUIRES(
            TIsContiguousContainer<CharRangeType>::Value &&
            !std::is_array_v<std::remove_reference_t<CharRangeType>>&&
            TIsCharType_V<CharRangeElementType> &&
            !std::is_base_of_v<UE_STRING_CLASS, std::decay_t<CharRangeType>>
        )
    >
    [[nodiscard]] bool MatchesWildcard(CharRangeType&& Wildcard, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase) const
    {
        static_assert(std::is_same_v<CharRangeElementType, ElementType>, "Expected a range of characters");
        return MatchesWildcard(GetData(Wildcard), GetNum(Wildcard), SearchCase);
    }
 
    [[nodiscard]] bool MatchesWildcard(const ElementType* Wildcard, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase) const
    {
        return MatchesWildcard(Wildcard, Wildcard ? TCString<ElementType>::Strlen(Wildcard) : 0, SearchCase);
    }
 
    [[nodiscard]] bool MatchesWildcard(const UE_STRING_CLASS& Wildcard, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase) const
    {
        return MatchesWildcard(*Wildcard, Wildcard.Len(), SearchCase);
    }
 
    [[nodiscard]] CORE_API bool MatchesWildcard(const ElementType* Wildcard, int32 WildcardLen, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase) const;
 
    CORE_API void TrimStartAndEndInline();
 
    [[nodiscard]] CORE_API UE_STRING_CLASS TrimStartAndEnd() const &;
 
    [[nodiscard]] CORE_API UE_STRING_CLASS TrimStartAndEnd() &&;
 
    CORE_API void TrimStartInline();
 
    [[nodiscard]] CORE_API UE_STRING_CLASS TrimStart() const &;
 
    [[nodiscard]] CORE_API UE_STRING_CLASS TrimStart() &&;
 
    CORE_API void TrimEndInline();
 
    [[nodiscard]] CORE_API UE_STRING_CLASS TrimEnd() const &;
 
    [[nodiscard]] CORE_API UE_STRING_CLASS TrimEnd() &&;
 
    CORE_API void TrimToNullTerminator();
 
 
    CORE_API void TrimQuotesInline(bool* bQuotesRemoved = nullptr);
 
    CORE_API void TrimCharInline(ElementType CharacterToTrim, bool* bCharRemoved);
 
    [[nodiscard]] CORE_API UE_STRING_CLASS TrimQuotes(bool* bQuotesRemoved = nullptr) const &;
 
    [[nodiscard]] CORE_API UE_STRING_CLASS TrimQuotes(bool* bQuotesRemoved = nullptr) &&;
    
    [[nodiscard]] CORE_API UE_STRING_CLASS TrimChar(ElementType CharacterToTrim, bool* bCharRemoved = nullptr) const &;
 
    [[nodiscard]] CORE_API UE_STRING_CLASS TrimChar(ElementType CharacterToTrim, bool* bCharRemoved = nullptr) &&;
 
    CORE_API int32 ParseIntoArray(TArray<UE_STRING_CLASS>& OutArray, const ElementType* pchDelim, bool bInCullEmpty = true) const;
 
    CORE_API int32 ParseIntoArrayWS(TArray<UE_STRING_CLASS>& OutArray, const ElementType* pchExtraDelim = nullptr, bool bInCullEmpty = true) const;
 
    CORE_API int32 ParseIntoArrayLines(TArray<UE_STRING_CLASS>& OutArray, bool bInCullEmpty = true) const;
 
    CORE_API int32 ParseIntoArray(TArray<UE_STRING_CLASS>& OutArray, const ElementType*const* DelimArray, int32 NumDelims, bool bInCullEmpty = true) const;
 
    static CORE_API int32 CullArray(TArray<UE_STRING_CLASS>* InOutArray);
 
    [[nodiscard]] CORE_API UE_STRING_CLASS Reverse() const &;
 
    [[nodiscard]] CORE_API UE_STRING_CLASS Reverse() &&;
 
    CORE_API void ReverseString();
 
    [[nodiscard]] CORE_API UE_STRING_CLASS Replace(const ElementType* From, const ElementType* To, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase) const &;
 
    [[nodiscard]] CORE_API UE_STRING_CLASS Replace(const ElementType* From, const ElementType* To, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase) &&;
 
    CORE_API int32 ReplaceInline(const ElementType* SearchText, const ElementType* ReplacementText, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase);
 
    void ReplaceCharInline(ElementType From, ElementType To, ESearchCase::Type SearchCase = ESearchCase::IgnoreCase)
    {
        if (SearchCase == ESearchCase::IgnoreCase && TChar<ElementType>::IsAlpha(From))
        {
            ReplaceCharInlineIgnoreCase(From, To);
        }
        else
        {
            ReplaceCharInlineCaseSensitive(From, To);
        }
    }
 
private:
    CORE_API void ReplaceCharInlineCaseSensitive(ElementType From, ElementType To);
    CORE_API void ReplaceCharInlineIgnoreCase(ElementType From, ElementType To);
 
public:
 
    [[nodiscard]] UE_STRING_CLASS ReplaceQuotesWithEscapedQuotes() const &
    {
        UE_STRING_CLASS Result(*this);
        return MoveTemp(Result).ReplaceQuotesWithEscapedQuotes();
    }
 
    [[nodiscard]] CORE_API UE_STRING_CLASS ReplaceQuotesWithEscapedQuotes() &&;
 
    CORE_API void ReplaceCharWithEscapedCharInline(const TArray<ElementType>* Chars = nullptr);
 
    [[nodiscard]] UE_STRING_CLASS ReplaceCharWithEscapedChar(const TArray<ElementType>* Chars = nullptr) const &
    {
        UE_STRING_CLASS Result(*this);
        Result.ReplaceCharWithEscapedCharInline(Chars);
        return Result;
    }
 
    [[nodiscard]] UE_STRING_CLASS ReplaceCharWithEscapedChar(const TArray<ElementType>* Chars = nullptr) &&
    {
        ReplaceCharWithEscapedCharInline(Chars);
        return MoveTemp(*this);
    }
 
    CORE_API void ReplaceEscapedCharWithCharInline(const TArray<ElementType>* Chars = nullptr);
 
    [[nodiscard]] UE_STRING_CLASS ReplaceEscapedCharWithChar(const TArray<ElementType>* Chars = nullptr) const &
    {
        UE_STRING_CLASS Result(*this);
        Result.ReplaceEscapedCharWithCharInline(Chars);
        return Result;
    }
 
    [[nodiscard]] UE_STRING_CLASS ReplaceEscapedCharWithChar(const TArray<ElementType>* Chars = nullptr) &&
    {
        ReplaceEscapedCharWithCharInline(Chars);
        return MoveTemp(*this);
    }
 
    CORE_API void ConvertTabsToSpacesInline(const int32 InSpacesPerTab);
 
    [[nodiscard]] UE_STRING_CLASS ConvertTabsToSpaces(const int32 InSpacesPerTab) const &
    {
        UE_STRING_CLASS FinalString(*this);
        FinalString.ConvertTabsToSpacesInline(InSpacesPerTab);
        return FinalString;
    }
 
    [[nodiscard]] UE_STRING_CLASS ConvertTabsToSpaces(const int32 InSpacesPerTab) &&
    {
        ConvertTabsToSpacesInline(InSpacesPerTab);
        return MoveTemp(*this);
    }
 
    // Takes the number passed in and formats the string in comma format (12345 becomes "12,345")
    [[nodiscard]] static CORE_API UE_STRING_CLASS FormatAsNumber(int32 InNumber);
 
    // To allow more efficient memory handling, automatically adds one for the string termination.
    CORE_API void Reserve(int32 CharacterCount);
 
    CORE_API void SerializeAsANSICharArray(FArchive& Ar, int32 MinCharacters = 0) const;
 
 
    [[nodiscard]] static inline UE_STRING_CLASS FromInt(int32 Num)
    {
        UE_STRING_CLASS Ret;
        Ret.AppendInt(Num); 
        return Ret;
    }
 
    CORE_API void AppendInt(int32 InNum);
 
    [[nodiscard]] CORE_API bool ToBool() const;
 
    [[nodiscard]] static CORE_API UE_STRING_CLASS FromBlob(const uint8* SrcBuffer, const uint32 SrcSize);
 
    static CORE_API bool ToBlob(const UE_STRING_CLASS& Source,uint8* DestBuffer, const uint32 DestSize);
 
    [[nodiscard]] static CORE_API UE_STRING_CLASS FromHexBlob(const uint8* SrcBuffer, const uint32 SrcSize);
 
    static CORE_API bool ToHexBlob(const UE_STRING_CLASS& Source, uint8* DestBuffer, const uint32 DestSize);
 
    [[nodiscard]] static CORE_API UE_STRING_CLASS SanitizeFloat(double InFloat, const int32 InMinFractionalDigits = 1);
 
    template <typename RangeType>
    [[nodiscard]] static UE_STRING_CLASS Join(const RangeType& Range, const ElementType* Separator)
    {
        UE_STRING_CLASS Result;
        bool            First = true;
        for (const auto& Element : Range)
        {
            if (First)
            {
                First = false;
            }
            else
            {
                Result += Separator;
            }
 
            Result += Element;
        }
 
        return Result;
    }
 
    template <typename RangeType, typename ProjectionType>
    [[nodiscard]] static UE_STRING_CLASS JoinBy(const RangeType& Range, const ElementType* Separator, ProjectionType Proj)
    {
        UE_STRING_CLASS Result;
        bool            First = true;
        for (const auto& Element : Range)
        {
            if (First)
            {
                First = false;
            }
            else
            {
                Result += Separator;
            }
 
            Result += Invoke(Proj, Element);
        }
 
        return Result;
    }
 
    UE_FORCEINLINE_HINT void CountBytes(FArchive& Ar) const
    {
        Data.CountBytes(Ar);
    }
 
    [[nodiscard]] friend UE_FORCEINLINE_HINT uint32 GetTypeHash(const UE_STRING_CLASS& S)
    {
        // This must match the GetTypeHash behavior of FStringView
        return FCrc::Strihash_DEPRECATED(S.Len(), *S);
    }
 
    static void AutoRTFMAssignFromOpenToClosed(UE_STRING_CLASS& Closed, const UE_STRING_CLASS& Open)
    {
        const AutoRTFM::EContextStatus Status = AutoRTFM::Close([&] { Closed = Open; });
        ensure(AutoRTFM::EContextStatus::OnTrack == Status);
    }
};
 
template<> struct TIsZeroConstructType<UE_STRING_CLASS> { enum { Value = true }; };
 
template<>
struct TNameOf<UE_STRING_CLASS>
{
    [[nodiscard]] UE_FORCEINLINE_HINT static TCHAR const* GetName()
    {
        return TEXT(PREPROCESSOR_TO_STRING(UE_STRING_CLASS));
    }
};
 
[[nodiscard]] inline UE_STRING_CLASS::ElementType* GetData(UE_STRING_CLASS& String)
{
    return String.GetCharArray().GetData();
}
 
[[nodiscard]] inline const UE_STRING_CLASS::ElementType* GetData(const UE_STRING_CLASS& String)
{
    return String.GetCharArray().GetData();
}
 
[[nodiscard]] inline int32 GetNum(const UE_STRING_CLASS& String)
{
    return String.Len();
}
 
CORE_API void BytesToHex(const uint8* Bytes, int32 NumBytes, UE_STRING_CLASS& Out);
CORE_API void BytesToHexLower(const uint8* Bytes, int32 NumBytes, UE_STRING_CLASS& Out);
 
CORE_API int32 HexToBytes(const UE_STRING_CLASS& HexString, uint8* OutBytes);
 
inline void LexFromString(int8& OutValue,               const UE_STRING_CHARTYPE* Buffer)   {   OutValue = (int8)TCString<UE_STRING_CHARTYPE>::Atoi(Buffer);        }
inline void LexFromString(int16& OutValue,              const UE_STRING_CHARTYPE* Buffer)   {   OutValue = (int16)TCString<UE_STRING_CHARTYPE>::Atoi(Buffer);       }
inline void LexFromString(int32& OutValue,              const UE_STRING_CHARTYPE* Buffer)   {   OutValue = (int32)TCString<UE_STRING_CHARTYPE>::Atoi(Buffer);       }
inline void LexFromString(int64& OutValue,              const UE_STRING_CHARTYPE* Buffer)   {   OutValue = TCString<UE_STRING_CHARTYPE>::Atoi64(Buffer);    }
inline void LexFromString(uint8& OutValue,              const UE_STRING_CHARTYPE* Buffer)   {   OutValue = (uint8)TCString<UE_STRING_CHARTYPE>::Atoi(Buffer);       }
inline void LexFromString(uint16& OutValue,             const UE_STRING_CHARTYPE* Buffer)   {   OutValue = (uint16)TCString<UE_STRING_CHARTYPE>::Atoi(Buffer);      }
inline void LexFromString(uint32& OutValue,             const UE_STRING_CHARTYPE* Buffer)   {   OutValue = (uint32)TCString<UE_STRING_CHARTYPE>::Atoi64(Buffer);    }   //64 because this unsigned and so Atoi might overflow
inline void LexFromString(uint64& OutValue,             const UE_STRING_CHARTYPE* Buffer)   {   OutValue = TCString<UE_STRING_CHARTYPE>::Strtoui64(Buffer, nullptr, 0); }
inline void LexFromString(float& OutValue,              const UE_STRING_CHARTYPE* Buffer)   {   OutValue = TCString<UE_STRING_CHARTYPE>::Atof(Buffer);      }
inline void LexFromString(double& OutValue,             const UE_STRING_CHARTYPE* Buffer)   {   OutValue = TCString<UE_STRING_CHARTYPE>::Atod(Buffer);      }
inline void LexFromString(bool& OutValue,               const UE_STRING_CHARTYPE* Buffer)   {   OutValue = TCString<UE_STRING_CHARTYPE>::ToBool(Buffer);    }
inline void LexFromString(UE_STRING_CLASS& OutValue,    const UE_STRING_CHARTYPE* Buffer)   {   OutValue = Buffer;                      }
 
template <UE::CArithmetic T>
bool LexTryParseString(T& OutValue, const UE_STRING_CHARTYPE* Buffer)
{
    if (Buffer[0] == '\0')
    {
        OutValue = 0;
        return false;
    }
 
    LexFromString(OutValue, Buffer);
    if (OutValue == 0 && FMath::IsFinite((float)OutValue)) //@TODO:FLOATPRECISION: ? huh ?
    {
        bool bSawZero = false;
        UE_STRING_CHARTYPE C = *Buffer;
        while (C != CHARTEXT(UE_STRING_CHARTYPE, '\0') && (C == CHARTEXT(UE_STRING_CHARTYPE, '+') || C == CHARTEXT(UE_STRING_CHARTYPE, '-') || TChar<UE_STRING_CHARTYPE>::IsWhitespace(C)))
        {
            C = *(++Buffer);
        }
 
        while (C != CHARTEXT(UE_STRING_CHARTYPE, '\0') && !TChar<UE_STRING_CHARTYPE>::IsWhitespace(C) && (std::is_floating_point_v<T> || C != CHARTEXT(UE_STRING_CHARTYPE, '.')))
        {
            bSawZero = bSawZero || (C == CHARTEXT(UE_STRING_CHARTYPE, '0'));
            if (!bSawZero && C != CHARTEXT(UE_STRING_CHARTYPE, '.'))
            {
                return false;
            }
 
            C = *(++Buffer);
        }
        return bSawZero;
    }
 
    return true;
}
 
inline bool LexTryParseString(bool& OutValue, const UE_STRING_CHARTYPE* Buffer)
{
    LexFromString(OutValue, Buffer);
    return true;
}
template <typename StringType = FString>
[[nodiscard]] UE_FORCEINLINE_HINT StringType LexToString(UE_STRING_CLASS&& Str)
{
    return MoveTemp(Str);
}
 
template <typename StringType = FString>
[[nodiscard]] UE_FORCEINLINE_HINT StringType LexToString(const UE_STRING_CLASS& Str)
{
    return Str;
}
 
[[nodiscard]] UE_FORCEINLINE_HINT const UE_STRING_CLASS::ElementType* ToCStr(const UE_STRING_CLASS& Str)
{
    return *Str;
}
 
[[nodiscard]] CORE_API int32 FindMatchingClosingParenthesis(const UE_STRING_CLASS& TargetString, const int32 StartSearch = 0);
 
[[nodiscard]] CORE_API UE_STRING_CLASS SlugStringForValidName(const UE_STRING_CLASS& DisplayString, const TCHAR* ReplaceWith = TEXT(""));
 
#undef UE_INCLUDETOOL_IGNORE_INCONSISTENT_STATE