String.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Memory/Buffer.h"
#include "../Strings/StringView.h"
 
namespace SC
{
struct SC_COMPILER_EXPORT String;
template <int N>
struct SmallString;
namespace Reflection
{
template <typename T>
struct Reflect;
}
} // namespace SC
 
 
struct SC::String
{
    String(StringEncoding encoding = StringEncoding::Utf8) : encoding(encoding) {}
 
    String(StringSpan sv) { SC_ASSERT_RELEASE(assign(sv)); }
 
    String(Buffer&& otherData, StringEncoding encoding);
 
    template <size_t N>
    String(const char (&text)[N])
    {
        SC_ASSERT_RELEASE(assign(StringView({text, N - 1}, true, StringEncoding::Ascii)));
    }
 
    [[nodiscard]] bool owns(StringSpan view) const;
 
    [[nodiscard]] bool assign(StringSpan 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 StringSpan other) const { return view() == (other); }
 
    [[nodiscard]] bool operator!=(const StringSpan other) const { return not operator==(other); }
 
    [[nodiscard]] bool operator<(const StringSpan 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;
    }
 
    String& operator=(StringSpan view);
 
  protected:
    // TODO: nativeWritableBytesIncludingTerminator should be removed
    [[nodiscard]] native_char_t* nativeWritableBytesIncludingTerminator();
 
    // All these friendships are made to leverage writing directly to the Buffer
    // but while still keeping it an implementation detail
    friend struct StringTest;
    friend struct StringBuilder;
    friend struct StringConverter;
    friend struct File;
    friend struct FileSystem;
    template <typename T>
    friend struct Reflection::Reflect;
    template <typename T>
    friend struct GrowableBuffer;
    StringEncoding encoding;
    Buffer         data;
 
    String(StringEncoding encoding, uint32_t inlineCapacity);
    String(Buffer&& otherData, StringEncoding encoding, uint32_t inlineCapacity);
};
 
template <int N>
struct SC::SmallString : public String
{
    // Unfortunately we have to repeat all these overloads to set inline capacity and hasInlineData flag
    SmallString(StringEncoding encoding = StringEncoding::Utf8) : String(encoding, N) {}
    SmallString(const SmallString& other) : SmallString(other.getEncoding()) { String::operator=(other); }
    SmallString(SmallString&& other) : SmallString(other.getEncoding()) { String::operator=(move(other)); }
    String& operator=(const SmallString& other) { return String::operator=(other); }
    String& operator=(SmallString&& other) { return String::operator=(move(other)); }
 
    SmallString(const String& other) : SmallString(other.getEncoding()) { String::operator=(other); }
    SmallString(String&& other) : SmallString(other.getEncoding()) { String::operator=(move(other)); }
    SmallString(StringSpan other) : SmallString(other.getEncoding()) { String::operator=(move(other)); }
    SmallString(Buffer&& otherData, StringEncoding encoding) : String(move(otherData), encoding, N) {}
    template <size_t Q>
    SmallString(const char (&text)[Q]) : SmallString(StringView({text, Q - 1}, true, StringEncoding::Ascii))
    {}
 
  private:
    uint64_t inlineCapacity = N;
    char     buffer[N];
};
 
namespace SC
{
template <int N>
using StringNative = SmallString<N * sizeof(native_char_t)>;
 
// Allows using this type across Plugin boundaries
SC_COMPILER_EXTERN template struct SC_COMPILER_EXPORT SmallString<64>;
SC_COMPILER_EXTERN template struct SC_COMPILER_EXPORT SmallString<128 * sizeof(native_char_t)>;
SC_COMPILER_EXTERN template struct SC_COMPILER_EXPORT SmallString<255 * sizeof(native_char_t)>;
SC_COMPILER_EXTERN template struct SC_COMPILER_EXPORT SmallString<512 * sizeof(native_char_t)>;
SC_COMPILER_EXTERN template struct SC_COMPILER_EXPORT SmallString<1024 * sizeof(native_char_t)>;
 
// Enables File library from reading data from file descriptor into a String
template <>
struct GrowableBuffer<String> : public IGrowableBuffer
{
    String& string;
    size_t  numZeroes;
    GrowableBuffer(String& string) : string(string) { numZeroes = StringEncodingGetSize(string.getEncoding()); }
 
    virtual ~GrowableBuffer() override
    {
        if (string.data.size() + numZeroes <= string.data.capacity())
        {
            // Add null-terminator
            (void)string.data.resize(string.data.size() + numZeroes, 0);
        }
    }
    virtual DirectAccess getDirectAccess() override final
    {
        return {string.data.size(), string.data.capacity(), string.data.data()};
    }
    virtual bool tryGrowTo(size_t newSize) override final
    {
        if (newSize > 0)
        {
            return string.data.reserve(newSize + numZeroes) and string.data.resizeWithoutInitializing(newSize);
        }
        else
        {
            string.data.clear();
            return true;
        }
    }
};
 
} // namespace SC