String.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Foundation/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(StringView 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(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;
    }
 
    String& operator=(StringView 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;
    StringEncoding encoding;
    Buffer         data;
 
    String(StringEncoding encoding, SegmentHeader& header, uint32_t inlineCapacity);
    String(Buffer&& otherData, StringEncoding encoding, SegmentHeader& header, uint32_t inlineCapacity);
};
 
template <int N>
struct SC::SmallString : public String
{
    // Unfortunately we have to repeat all these overloads.
    // 'using String::operator=' or 'using String::String' would invoke default memberwise copy
    // constructors also for SmallString::header and buffer, that would cause a disaster.
 
    SmallString(StringEncoding encoding = StringEncoding::Utf8) : String(encoding, header, 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)); }
    String& operator=(const String& other) { return String::operator=(other); }
    String& operator=(String&& 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(StringView other) : SmallString(other.getEncoding()) { String::operator=(move(other)); }
    String& operator=(StringView view) { return String::operator=(view); }
 
    SmallString(Buffer&& otherData, StringEncoding encoding) : String(move(otherData), encoding, header, N) {}
 
    template <size_t Q>
    SmallString(const char (&text)[Q]) : SmallString(StringView({text, Q - 1}, true, StringEncoding::Ascii))
    {}
 
    template <size_t Q>
    String& operator=(const char (&text)[Q])
    {
        return String::operator=(text);
    }
 
  private:
    SegmentHeader header;
    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)>;
} // namespace SC