String.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/StringSpan.h"
#include "../Memory/Buffer.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(StringSpan({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]] StringSpan 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); }
 
    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;
    }
 
    [[nodiscard]] bool operator<(const StringSpan other) const { return view() < other; }
 
    template <size_t N>
    String& operator=(const char (&text)[N])
    {
        SC_ASSERT_RELEASE(assign(StringSpan({text, N - 1}, true, StringEncoding::Ascii)));
        return *this;
    }
 
    String& operator=(StringSpan view);
 
  protected:
    struct Internal;
 
    friend struct StringTest;
    template <typename T>
    friend struct Reflection::Reflect;
 
    template <typename T>
    friend struct GrowableBuffer;
    struct SC_COMPILER_EXPORT GrowableImplementation
    {
        String& string;
 
        IGrowableBuffer::DirectAccess& da;
 
        GrowableImplementation(String& string, IGrowableBuffer::DirectAccess& da) noexcept;
        ~GrowableImplementation() noexcept;
        void finalize() noexcept;
        bool tryGrowTo(size_t newSize) noexcept;
    };
 
    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(StringSpan({text, Q - 1}, true, StringEncoding::Ascii))
    {}
 
  private:
    uint64_t inlineCapacity = N;
    char     buffer[N];
};
 
namespace SC
{
template <int N>
using SmallStringNative = 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 SC_COMPILER_EXPORT GrowableBuffer<String> : public IGrowableBuffer
{
    String::GrowableImplementation gi;
    GrowableBuffer(String& string)
        : IGrowableBuffer(&GrowableBuffer::tryGrowTo), gi(string, IGrowableBuffer::directAccess)
    {}
    static bool tryGrowTo(IGrowableBuffer& gb, size_t newSize) noexcept
    {
        return static_cast<GrowableBuffer&>(gb).gi.tryGrowTo(newSize);
    }
    static auto getEncodingFor(const String& str) noexcept { return str.getEncoding(); }
    void        finalize() noexcept { gi.finalize(); }
};
 
template <int N>
struct SC_COMPILER_EXPORT GrowableBuffer<SmallString<N>> : public IGrowableBuffer
{
    String::GrowableImplementation gi;
    GrowableBuffer(String& string)
        : IGrowableBuffer(&GrowableBuffer::tryGrowTo), gi(string, IGrowableBuffer::directAccess)
    {}
    static bool tryGrowTo(IGrowableBuffer& gb, size_t newSize) noexcept
    {
        return static_cast<GrowableBuffer&>(gb).gi.tryGrowTo(newSize);
    }
    static auto getEncodingFor(const SmallString<N>& str) noexcept { return str.getEncoding(); }
    void        finalize() noexcept { gi.finalize(); }
};
} // namespace SC