String.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Containers/Vector.h"
#include "../Strings/StringView.h"
 
namespace SC
{
struct SC_COMPILER_EXPORT String;
namespace Reflection
{
template <typename T>
struct Reflect;
}
// Allows using this type across Plugin boundaries
SC_COMPILER_EXTERN template struct SC_COMPILER_EXPORT Vector<char>;
 
} // namespace SC
 
 
struct SC::String
{
    String(StringEncoding encoding = StringEncoding::Utf8) : encoding(encoding) {}
 
    String(StringView sv) { SC_ASSERT_RELEASE(assign(sv)); }
 
    template <size_t N>
    String(const char (&text)[N])
    {
        SC_ASSERT_RELEASE(assign(StringView({text, N - 1}, true, StringEncoding::Ascii)));
    }
 
    [[nodiscard]] bool owns(StringView view) const;
 
    [[nodiscard]] bool assign(StringView sv);
 
    [[nodiscard]] StringEncoding getEncoding() const { return encoding; }
 
    [[nodiscard]] size_t sizeInBytesIncludingTerminator() const { return data.size(); }
 
    [[nodiscard]] const char* bytesIncludingTerminator() const { return data.data(); }
 
    [[nodiscard]] bool isEmpty() const { return data.isEmpty(); }
 
    [[nodiscard]] StringView view() const SC_LANGUAGE_LIFETIME_BOUND;
 
    [[nodiscard]] bool operator==(const String& other) const { return view() == (other.view()); }
 
    [[nodiscard]] bool operator!=(const String& other) const { return not operator==(other); }
 
    [[nodiscard]] bool operator==(const StringView other) const { return view() == (other); }
 
    [[nodiscard]] bool operator!=(const StringView other) const { return not operator==(other); }
 
    [[nodiscard]] bool operator<(const StringView other) const { return view() < other; }
 
    template <size_t N>
    [[nodiscard]] bool operator==(const char (&other)[N]) const
    {
        return view() == other;
    }
    template <size_t N>
    [[nodiscard]] bool operator!=(const char (&other)[N]) const
    {
        return view() != other;
    }
 
    template <size_t N>
    String& operator=(const char (&text)[N])
    {
        SC_ASSERT_RELEASE(assign(StringView({text, N - 1}, true, StringEncoding::Ascii)));
        return *this;
    }
 
  protected:
    // TODO: nativeWritableBytesIncludingTerminator should be removed
    [[nodiscard]] auto nativeWritableBytesIncludingTerminator();
 
    // All these friendships are made to leverage writing directly to the Vector<char>
    // but while still keeping it an implementation detail
    friend struct SmallStringTest;
    friend struct StringBuilder;
    friend struct StringConverter;
    friend struct FileDescriptor;
    friend struct FileSystem;
    template <int>
    friend struct SmallString;
    template <typename T>
    friend struct Reflection::Reflect;
    StringEncoding encoding;
#if SC_COMPILER_MSVC
#pragma warning(push)
#pragma warning(disable : 4324) // useless warning on 32 bit... (structure was padded due to __declspec(align()))
#endif
    // alignas(alignof(SegmentHeader)) is needed on 32 bit to fix distance with SmallString::buffer
    alignas(alignof(SegmentHeader)) Vector<char> data;
#if SC_COMPILER_MSVC
#pragma warning(pop)
#endif
};
 
//-----------------------------------------------------------------------------------------------------------------------
// Implementations Details
//-----------------------------------------------------------------------------------------------------------------------
 
inline bool SC::String::owns(StringView view) const
{
    return (view.bytesWithoutTerminator() >= this->view().bytesWithoutTerminator()) and
           (view.bytesWithoutTerminator() <= (this->view().bytesWithoutTerminator() + this->view().sizeInBytes()));
}
 
inline bool SC::String::assign(StringView sv)
{
    encoding             = sv.getEncoding();
    const size_t length  = sv.sizeInBytes();
    const size_t numZero = StringEncodingGetSize(encoding);
    if (not data.resizeWithoutInitializing(length + numZero))
        return false;
    if (sv.isNullTerminated())
    {
        memcpy(data.items, sv.bytesWithoutTerminator(), length + numZero);
    }
    else
    {
        if (length > 0)
        {
            memcpy(data.items, sv.bytesWithoutTerminator(), length);
        }
        for (size_t idx = 0; idx < numZero; ++idx)
        {
            data.items[length + idx] = 0;
        }
    }
    return true;
}
 
inline SC::StringView SC::String::view() const SC_LANGUAGE_LIFETIME_BOUND
{
    const bool  isEmpty = data.isEmpty();
    const char* items   = isEmpty ? nullptr : data.items;
    return StringView({items, isEmpty ? 0 : data.size() - StringEncodingGetSize(encoding)}, not isEmpty, encoding);
}
 
inline auto SC::String::nativeWritableBytesIncludingTerminator()
{
#if SC_PLATFORM_WINDOWS
    SC_ASSERT_RELEASE(encoding == StringEncoding::Utf16);
    return reinterpret_cast<wchar_t*>(data.data());
#else
    SC_ASSERT_RELEASE(encoding < StringEncoding::Utf16);
    return data.data();
#endif
}