GenericPlatformString.h

Go to the documentation of this file.

// Copyright Epic Games, Inc. All Rights Reserved.
 
#pragma once
 
#include "CoreTypes.h"
#include "GenericPlatform/GenericPlatformStricmp.h"
#include "Templates/EnableIf.h"
#include "Traits/IsCharEncodingCompatibleWith.h"
#include "Traits/IsCharEncodingSimplyConvertibleTo.h"
#include "Traits/IsCharType.h"
#include "Traits/IsFixedWidthCharEncoding.h"
 
#include <type_traits>
 
namespace UE::Core::Private
{
    // The Dest parameter is just used for overload resolution
    CORE_API int32 GetConvertedLength(const UTF8CHAR* Dest, const WIDECHAR*  Src);
    CORE_API int32 GetConvertedLength(const UTF8CHAR* Dest, const WIDECHAR*  Src, int32 SrcLen);
    CORE_API int32 GetConvertedLength(const UTF8CHAR* Dest, const UCS2CHAR*  Src);
    CORE_API int32 GetConvertedLength(const UTF8CHAR* Dest, const UCS2CHAR*  Src, int32 SrcLen);
    CORE_API int32 GetConvertedLength(const UTF8CHAR* Dest, const UTF32CHAR* Src);
    CORE_API int32 GetConvertedLength(const UTF8CHAR* Dest, const UTF32CHAR* Src, int32 SrcLen);
    CORE_API int32 GetConvertedLength(const ANSICHAR* Dest, const UTF8CHAR*  Src);
    CORE_API int32 GetConvertedLength(const ANSICHAR* Dest, const UTF8CHAR*  Src, int32 SrcLen);
    CORE_API int32 GetConvertedLength(const WIDECHAR* Dest, const UTF8CHAR*  Src);
    CORE_API int32 GetConvertedLength(const WIDECHAR* Dest, const UTF8CHAR*  Src, int32 SrcLen);
    CORE_API int32 GetConvertedLength(const UCS2CHAR* Dest, const UTF8CHAR*  Src);
    CORE_API int32 GetConvertedLength(const UCS2CHAR* Dest, const UTF8CHAR*  Src, int32 SrcLen);
 
    CORE_API UTF8CHAR* Convert(UTF8CHAR* Dest, int32 DestLen, const WIDECHAR*  Src);
    CORE_API UTF8CHAR* Convert(UTF8CHAR* Dest, int32 DestLen, const WIDECHAR*  Src, int32 SrcLen);
    CORE_API UTF8CHAR* Convert(UTF8CHAR* Dest, int32 DestLen, const UCS2CHAR*  Src);
    CORE_API UTF8CHAR* Convert(UTF8CHAR* Dest, int32 DestLen, const UCS2CHAR*  Src, int32 SrcLen);
    CORE_API UTF8CHAR* Convert(UTF8CHAR* Dest, int32 DestLen, const UTF32CHAR* Src);
    CORE_API UTF8CHAR* Convert(UTF8CHAR* Dest, int32 DestLen, const UTF32CHAR* Src, int32 SrcLen);
    CORE_API ANSICHAR* Convert(ANSICHAR* Dest, int32 DestLen, const UTF8CHAR*  Src);
    CORE_API ANSICHAR* Convert(ANSICHAR* Dest, int32 DestLen, const UTF8CHAR*  Src, int32 SrcLen);
    CORE_API WIDECHAR* Convert(WIDECHAR* Dest, int32 DestLen, const UTF8CHAR*  Src);
    CORE_API WIDECHAR* Convert(WIDECHAR* Dest, int32 DestLen, const UTF8CHAR*  Src, int32 SrcLen);
    CORE_API UCS2CHAR* Convert(UCS2CHAR* Dest, int32 DestLen, const UTF8CHAR*  Src);
    CORE_API UCS2CHAR* Convert(UCS2CHAR* Dest, int32 DestLen, const UTF8CHAR*  Src, int32 SrcLen);
}
 
// These will be moved inside GenericPlatformString.cpp when the platform layer handles UTF-16
// instead of StringConv.h.
#define HIGH_SURROGATE_START_CODEPOINT    ((uint16)0xD800)
#define HIGH_SURROGATE_END_CODEPOINT      ((uint16)0xDBFF)
#define LOW_SURROGATE_START_CODEPOINT     ((uint16)0xDC00)
#define LOW_SURROGATE_END_CODEPOINT       ((uint16)0xDFFF)
#define ENCODED_SURROGATE_START_CODEPOINT ((uint32)0x10000)
#define ENCODED_SURROGATE_END_CODEPOINT   ((uint32)0x10FFFF)
 
#define UNICODE_BOGUS_CHAR_CODEPOINT '?'
static_assert(sizeof(UNICODE_BOGUS_CHAR_CODEPOINT) <= sizeof(ANSICHAR) && (UNICODE_BOGUS_CHAR_CODEPOINT) >= 32 && (UNICODE_BOGUS_CHAR_CODEPOINT) <= 127, "The Unicode Bogus character point is expected to fit in a single ANSICHAR here");
 
struct FGenericPlatformString : public FGenericPlatformStricmp
{
    template <typename DestEncoding, typename SourceEncoding>
    static constexpr bool CanConvertCodepoint(SourceEncoding Codepoint)
    {
        // It is assumed that the incoming codepoint is already valid and we're only testing if it can be converted to DestEncoding.
 
        static_assert(TIsCharType<SourceEncoding>::Value, "Source encoding is not a char type");
        static_assert(TIsCharType<DestEncoding  >::Value, "Destination encoding is not a char type");
 
        // This is only defined for fixed-width encodings, because codepoints cannot be represented in a single variable-width code unit.
        static_assert(TIsFixedWidthCharEncoding_V<SourceEncoding>, "Source encoding is not fixed-width");
 
        if constexpr (TIsCharEncodingSimplyConvertibleTo_V<SourceEncoding, DestEncoding>)
        {
            // Simple conversions mean conversion is always possible
            return true;
        }
        else if constexpr (!TIsFixedWidthCharEncoding_V<DestEncoding>)
        {
            // Converting all codepoints to a variable-width encoding should always be possible
            return true;
        }
        else if constexpr (std::is_same_v<DestEncoding, ANSICHAR>)
        {
            return (uint32)Codepoint <= 0x7F;
        }
        else
        {
            // The logic above should hopefully mean this branch is only taken for UTF32CHAR->UCS2CHAR.
            // There's a variety of '16-bit' char types between platforms though, so let's just test sizes.
            static_assert(sizeof(SourceEncoding) == 4 && sizeof(DestEncoding) == 2, "Unimplemented conversion");
 
            // Can't encode more than 16-bit in UCS-2
            return (uint32)Codepoint <= 0xFFFF;
        }
    }
 
 
    template <typename Encoding>
    static const TCHAR* GetEncodingTypeName();
 
    static const ANSICHAR* GetEncodingName()
    {
#if PLATFORM_TCHAR_IS_4_BYTES
        return "UTF-32LE";
#else
        return "UTF-16LE";
#endif
    }
 
    static constexpr bool IsUnicodeEncoded = true;
 
 
    template <typename SourceEncoding, typename DestEncoding>
    static inline DestEncoding* Convert(DestEncoding* Dest, int32 DestSize, const SourceEncoding* Src)
    {
        if constexpr (TIsCharEncodingSimplyConvertibleTo_V<SourceEncoding, DestEncoding>)
        {
            for (;;)
            {
                if (DestSize == 0)
                {
                    return nullptr;
                }
 
                if (!(*Dest++ = (DestEncoding)*Src++))
                {
                    return Dest;
                }
 
                --DestSize;
            }
        }
        else if constexpr (TIsFixedWidthCharEncoding_V<SourceEncoding> && TIsFixedWidthCharEncoding_V<DestEncoding>)
        {
            DestEncoding*         DestCopy     = Dest;
            const SourceEncoding* SrcCopy      = Src;
            int32                 DestSizeCopy = DestSize;
 
            bool bInvalidChars = false;
            for (;;)
            {
                if (DestSize == 0)
                {
                    Dest = nullptr;
                    break;
                }
 
                SourceEncoding SrcCh = *Src++;
                *Dest++ = (DestEncoding)SrcCh;
                if (!SrcCh)
                {
                    break;
                }
                bInvalidChars |= !CanConvertCodepoint<DestEncoding>(SrcCh);
 
                --DestSize;
            }
 
            if (bInvalidChars)
            {
                for (;;)
                {
                    if (DestSizeCopy == 0)
                    {
                        break;
                    }
 
                    SourceEncoding SrcCh = *SrcCopy++;
                    if (!SrcCh)
                    {
                        break;
                    }
                    if (!CanConvertCodepoint<DestEncoding>(SrcCh))
                    {
                        *DestCopy = UNICODE_BOGUS_CHAR_CODEPOINT;
                    }
                    ++DestCopy;
 
                    --DestSizeCopy;
                }
            }
 
            return Dest;
        }
        else
        {
            DestEncoding* Result = UE::Core::Private::Convert(Dest, DestSize, Src);
            if (Result)
            {
                *Result++ = (DestEncoding)0;
            }
            return Result;
        }
    }
 
    template <typename SourceEncoding, typename DestEncoding>
    static inline DestEncoding* Convert(DestEncoding* Dest, int32 DestSize, const SourceEncoding* Src, int32 SrcSize)
    {
        if constexpr (TIsCharEncodingCompatibleWith_V<SourceEncoding, DestEncoding>)
        {
            if (DestSize < SrcSize)
            {
                return nullptr;
            }
 
            return (DestEncoding*)Memcpy(Dest, Src, SrcSize * sizeof(SourceEncoding)) + SrcSize;
        }
        else if constexpr (TIsCharEncodingSimplyConvertibleTo_V<SourceEncoding, DestEncoding>)
        {
            const int32 Size = DestSize <= SrcSize ? DestSize : SrcSize;
            for (int I = 0; I < Size; ++I)
            {
                SourceEncoding SrcCh = Src[I];
                Dest[I] = (DestEncoding)SrcCh;
            }
 
            return DestSize < SrcSize ? nullptr : Dest + Size;
        }
        else if constexpr (TIsFixedWidthCharEncoding_V<SourceEncoding> && TIsFixedWidthCharEncoding_V<DestEncoding>)
        {
            const int32 Size = DestSize <= SrcSize ? DestSize : SrcSize;
            bool bInvalidChars = false;
            for (int I = 0; I < Size; ++I)
            {
                SourceEncoding SrcCh = Src[I];
                Dest[I] = (DestEncoding)SrcCh;
                bInvalidChars |= !CanConvertCodepoint<DestEncoding>(SrcCh);
            }
 
            if (bInvalidChars)
            {
                for (int I = 0; I < Size; ++I)
                {
                    if (!CanConvertCodepoint<DestEncoding>(Src[I]))
                    {
                        Dest[I] = UNICODE_BOGUS_CHAR_CODEPOINT;
                    }
                }
            }
 
            return DestSize < SrcSize ? nullptr : Dest + Size;
        }
        else
        {
            return UE::Core::Private::Convert(Dest, DestSize, Src, SrcSize);
        }
    }
 
 
    template <typename DestEncoding, typename SourceEncoding>
    static int32 ConvertedLength(const SourceEncoding* Src)
    {
        if constexpr (TIsCharEncodingSimplyConvertibleTo_V<SourceEncoding, DestEncoding> || (TIsFixedWidthCharEncoding_V<SourceEncoding> && TIsFixedWidthCharEncoding_V<DestEncoding>))
        {
            int32 Result = 0;
            while (*Src)
            {
                ++Src;
                ++Result;
            }
            return Result + 1;
        }
        else
        {
            return UE::Core::Private::GetConvertedLength((DestEncoding*)nullptr, Src) + 1;
        }
    }
 
    template <typename DestEncoding, typename SourceEncoding>
    static int32 ConvertedLength(const SourceEncoding* Src, int32 SrcSize)
    {
        if constexpr (TIsCharEncodingSimplyConvertibleTo_V<SourceEncoding, DestEncoding> || (TIsFixedWidthCharEncoding_V<SourceEncoding> && TIsFixedWidthCharEncoding_V<DestEncoding>))
        {
            return SrcSize;
        }
        else
        {
            return UE::Core::Private::GetConvertedLength((DestEncoding*)nullptr, Src, SrcSize);
        }
    }
 
    CORE_API static int32 Strncmp(const ANSICHAR* String1, const ANSICHAR* String2, SIZE_T Count);
    CORE_API static int32 Strncmp(const WIDECHAR* String1, const ANSICHAR* String2, SIZE_T Count);
    CORE_API static int32 Strncmp(const UTF8CHAR* String1, const ANSICHAR* String2, SIZE_T Count);
    CORE_API static int32 Strncmp(const ANSICHAR* String1, const WIDECHAR* String2, SIZE_T Count);
    CORE_API static int32 Strncmp(const WIDECHAR* String1, const WIDECHAR* String2, SIZE_T Count);
    CORE_API static int32 Strncmp(const UTF8CHAR* String1, const WIDECHAR* String2, SIZE_T Count);
    CORE_API static int32 Strncmp(const ANSICHAR* String1, const UTF8CHAR* String2, SIZE_T Count);
    CORE_API static int32 Strncmp(const WIDECHAR* String1, const UTF8CHAR* String2, SIZE_T Count);
    CORE_API static int32 Strncmp(const UTF8CHAR* String1, const UTF8CHAR* String2, SIZE_T Count);
 
private:
    static CORE_API void* Memcpy(void* Dest, const void* Src, SIZE_T Count);
};