StringSpan.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/Result.h"
#include "../Foundation/Span.h"
 
namespace SC
{
#if SC_PLATFORM_WINDOWS
#define SC_NATIVE_STR(str) L##str
#else
#define SC_NATIVE_STR(str) str
#endif
 
enum class StringEncoding : uint8_t
{
    Ascii = 0, 
    Utf8  = 1, 
    Utf16 = 2, 
#if SC_PLATFORM_WINDOWS
    Native = Utf16, 
#else
    Native = Utf8 
#endif
};
 
constexpr uint32_t StringEncodingGetSize(StringEncoding encoding) { return encoding == StringEncoding::Utf16 ? 2 : 1; }
 
struct SC_COMPILER_EXPORT StringSpan
{
    // clang-format off
    
    constexpr StringSpan(StringEncoding encoding = StringEncoding::Ascii) : text(nullptr), textSizeInBytes(0), encoding(static_cast<uint8_t>(encoding)), hasNullTerm(0) {}
 
    constexpr StringSpan(Span<const char> text, bool nullTerm, StringEncoding encoding) : text(text.data()), textSizeInBytes(text.sizeInBytes()), encoding(static_cast<uint8_t>(encoding)), hasNullTerm(nullTerm ? 1 : 0) {}
 
    template <size_t N>
    constexpr StringSpan(const char (&str)[N]) : text(str), textSizeInBytes(N - 1), encoding(static_cast<uint8_t>(StringEncoding::Ascii)), hasNullTerm(true) {}
 
    static constexpr StringSpan fromNullTerminated(const char* text, StringEncoding encoding) { return text == nullptr ? StringSpan(encoding) : StringSpan({text, ::strlen(text)}, true, encoding); }
 
#if SC_PLATFORM_WINDOWS
    constexpr StringSpan(Span<const wchar_t> textSpan, bool nullTerm, StringEncoding encoding = StringEncoding::Native) : textWide(textSpan.data()), textSizeInBytes(textSpan.sizeInBytes()), encoding(static_cast<uint8_t>(encoding)), hasNullTerm(nullTerm ? 1 : 0) {}
 
    template <size_t N>
    constexpr StringSpan(const wchar_t (&str)[N]) : textWide(str), textSizeInBytes((N - 1)* sizeof(wchar_t)), encoding(static_cast<uint8_t>(StringEncoding::Native)), hasNullTerm(true) {}
    static constexpr StringSpan fromNullTerminated(const wchar_t* text, StringEncoding encoding) { return text == nullptr ? StringSpan(encoding) : StringSpan({text, ::wcslen(text)}, true); }
#endif
    constexpr bool operator ==(const StringSpan other) const { return textSizeInBytes == other.textSizeInBytes and ::memcmp(text, other.text, textSizeInBytes) == 0; }
    // clang-format on
 
    [[nodiscard]] Span<const char> toCharSpan() const { return {text, textSizeInBytes}; }
 
    [[nodiscard]] constexpr bool isEmpty() const { return text == nullptr or textSizeInBytes == 0; }
 
    [[nodiscard]] constexpr bool isNullTerminated() const { return hasNullTerm; }
 
    [[nodiscard]] constexpr size_t sizeInBytes() const { return textSizeInBytes; }
 
    [[nodiscard]] size_t sizeInBytesIncludingTerminator() const;
 
    [[nodiscard]] constexpr StringEncoding getEncoding() const { return static_cast<StringEncoding>(encoding); }
 
    [[nodiscard]] constexpr const char* bytesWithoutTerminator() const { return text; }
 
    [[nodiscard]] const char* bytesIncludingTerminator() const;
 
#if SC_PLATFORM_WINDOWS
    [[nodiscard]] const wchar_t* getNullTerminatedNative() const { return textWide; }
#else
    [[nodiscard]] const char* getNullTerminatedNative() const { return text; }
#endif
 
    struct NativeWritable
    {
        Span<native_char_t> writableSpan;
        size_t              length = 0;
 
        StringSpan view() const { return {{writableSpan.data(), length}, true, StringEncoding::Native}; }
    };
 
    Result writeNullTerminatedTo(NativeWritable& string) const;
 
    Result appendNullTerminatedTo(NativeWritable& string, bool removePreviousNullTerminator = true) const;
 
  protected:
    friend struct StringView;
    union
    {
        const char* text;
#if SC_PLATFORM_WINDOWS
        const wchar_t* textWide;
#endif
    };
 
    static constexpr size_t NumOptionBits = 3;
    static constexpr size_t MaxLength     = (~static_cast<size_t>(0)) >> NumOptionBits;
 
    size_t textSizeInBytes : sizeof(size_t) * 8 - NumOptionBits;
    size_t encoding    : 2;
    size_t hasNullTerm : 1;
};
 
} // namespace SC