StringBuilder.h

// Copyright (c) Stefano Cristiano
// SPDX-License-Identifier: MIT
#pragma once
#include "../Strings/StringConverter.h" // popNullTermIfNotEmpty
#include "../Strings/StringFormat.h"
namespace SC
{
struct String;
 
struct SC_COMPILER_EXPORT StringBuilder
{
    enum Flags
    {
        Clear,     
        DoNotClear 
    };
    StringBuilder(Vector<char>& stringData, StringEncoding encoding, Flags flags = DoNotClear);
 
    StringBuilder(String& str, Flags flags = DoNotClear);
 
 
    template <typename... Types>
    [[nodiscard]] bool format(StringView fmt, Types&&... args);
 
 
    template <typename... Types>
    [[nodiscard]] bool append(StringView fmt, Types&&... args);
 
    [[nodiscard]] bool format(StringView text);
 
    [[nodiscard]] bool append(StringView str);
 
    [[nodiscard]] bool appendReplaceAll(StringView source, StringView occurrencesOf, StringView with);
 
    struct ReplacePair
    {
        StringView searchFor;   
        StringView replaceWith; 
    };
 
    [[nodiscard]] bool appendReplaceMultiple(StringView source, Span<const ReplacePair> substitutions);
 
    enum class AppendHexCase
    {
        UpperCase,
        LowerCase,
    };
    [[nodiscard]] bool appendHex(Span<const uint8_t> data, AppendHexCase casing);
 
  private:
    void clear();
 
    Vector<char>&  stringData;
    StringEncoding encoding;
};
 
} // namespace SC
 
//-----------------------------------------------------------------------------------------------------------------------
// Implementations Details
//-----------------------------------------------------------------------------------------------------------------------
template <typename... Types>
inline bool SC::StringBuilder::format(StringView fmt, Types&&... args)
{
    clear();
    return append(fmt, forward<Types>(args)...);
}
 
template <typename... Types>
inline bool SC::StringBuilder::append(StringView fmt, Types&&... args)
{
    if (fmt.getEncoding() == StringEncoding::Utf16)
    {
        return false; // UTF16 format strings are not supported
    }
    const bool hadNullTerminator = StringConverter::popNullTermIfNotEmpty(stringData, encoding);
    // 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, stringData);
    if (StringFormat<StringIteratorASCII>::format(sfo, fmt, forward<Types>(args)...))
    {
        return true;
    }
    else
    {
        if (hadNullTerminator)
        {
            // Even if format failed, let's not leave a broken string without a null-terminator
            (void)StringConverter::pushNullTerm(stringData, encoding);
        }
        return false;
    }
}