StringBuilder.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Strings/StringFormat.h"
namespace SC
{
 
struct SC_COMPILER_EXPORT StringBuilder
{
    enum Flags
    {
        Clear,     
        DoNotClear 
    };
    template <typename T>
    StringBuilder(T& buffer, StringEncoding encoding, Flags flags = DoNotClear)
    {
        GrowableBuffer<T>& bufferT = bufferStorage.reinterpret_as<GrowableBuffer<T>>();
        placementNew(bufferT, buffer);
        initWithEncoding(bufferT, encoding, flags);
    }
 
    template <typename T>
    StringBuilder(T& string, Flags flags = DoNotClear)
    {
        GrowableBuffer<T>& bufferT = bufferStorage.reinterpret_as<GrowableBuffer<T>>();
        placementNew(bufferT, string);
        initWithEncoding(bufferT, string.getEncoding(), flags);
    }
 
    StringBuilder(IGrowableBuffer& bufferT, StringEncoding encoding, Flags flags);
 
    ~StringBuilder();
 
    StringView finalize();
 
    [[nodiscard]] StringView view();
 
    template <typename T, typename... Types>
    [[nodiscard]] static bool format(T& buffer, StringView fmt, Types&&... args);
 
    template <typename T>
    [[nodiscard]] static bool format(T& buffer, StringView text);
 
    template <typename... Types>
    [[nodiscard]] bool append(StringView fmt, Types&&... args);
 
    [[nodiscard]] bool append(StringView str);
 
    [[nodiscard]] bool appendReplaceAll(StringView source, StringView occurrencesOf, StringView with);
 
    enum class AppendHexCase
    {
        UpperCase,
        LowerCase,
    };
    [[nodiscard]] bool appendHex(Span<const uint8_t> data, AppendHexCase casing);
 
  private:
    void initWithEncoding(IGrowableBuffer& bufferT, StringEncoding stringEncoding, Flags flags);
    void clear();
 
    IGrowableBuffer* buffer        = nullptr;
    bool             destroyBuffer = true;
 
    AlignedStorage<6 * sizeof(void*)> bufferStorage;
 
    StringEncoding encoding;
    StringView     finalizedView;
};
 
} // namespace SC
 
//-----------------------------------------------------------------------------------------------------------------------
// Implementations Details
//-----------------------------------------------------------------------------------------------------------------------
template <typename T>
bool SC::StringBuilder::format(T& buffer, StringView fmt)
{
    StringBuilder sb(buffer, Clear);
    const bool    res = sb.append(fmt);
    sb.finalize();
    return res;
}
 
template <typename T, typename... Types>
inline bool SC::StringBuilder::format(T& buffer, StringView fmt, Types&&... args)
{
    StringBuilder sb(buffer, Clear);
    const bool    res = sb.append(fmt, forward<Types>(args)...);
    sb.finalize();
    return res;
}
 
template <typename... Types>
inline bool SC::StringBuilder::append(StringView fmt, Types&&... args)
{
    SC_TRY(fmt.getEncoding() != StringEncoding::Utf16); // UTF16 format strings are not supported
    // It's ok parsing format string '{' and '}' both for utf8 and ascii with StringIteratorASCII
    // because on a valid UTF8 string, these chars are unambiguously recognizable
    StringFormatOutput sfo(encoding, *buffer);
    return StringFormat<StringIteratorASCII>::format(sfo, fmt, forward<Types>(args)...);
}