#ifndef StringBuilder_h
#define StringBuilder_h
#include "wtf/WTFExport.h"
#include "wtf/text/AtomicString.h"
#include "wtf/text/WTFString.h"
namespace WTF {
class WTF_EXPORT StringBuilder {
WTF_MAKE_NONCOPYABLE(StringBuilder);
public:
StringBuilder()
: m_bufferCharacters8(0)
, m_length(0)
, m_is8Bit(true)
{
}
void append(const UChar*, unsigned);
void append(const LChar*, unsigned);
ALWAYS_INLINE void append(const char* characters, unsigned length) { append(reinterpret_cast<const LChar*>(characters), length); }
void append(const String& string)
{
if (!string.length())
return;
if (!m_length && !m_buffer) {
m_string = string;
m_length = string.length();
m_is8Bit = m_string.is8Bit();
return;
}
if (string.is8Bit())
append(string.characters8(), string.length());
else
append(string.characters16(), string.length());
}
void append(const StringBuilder& other)
{
if (!other.m_length)
return;
if (!m_length && !m_buffer && !other.m_string.isNull()) {
m_string = other.m_string;
m_length = other.m_length;
return;
}
if (other.is8Bit())
append(other.characters8(), other.m_length);
else
append(other.characters16(), other.m_length);
}
void append(const String& string, unsigned offset, unsigned length)
{
if (!string.length())
return;
unsigned extent = offset + length;
if (extent < offset || extent > string.length())
return;
if (string.is8Bit())
append(string.characters8() + offset, length);
else
append(string.characters16() + offset, length);
}
void append(const StringView& string)
{
if (!string.length())
return;
if (string.is8Bit())
append(string.characters8(), string.length());
else
append(string.characters16(), string.length());
}
void append(const char* characters)
{
if (characters)
append(characters, strlen(characters));
}
void append(UChar c)
{
if (m_buffer && m_length < m_buffer->length() && m_string.isNull()) {
if (!m_is8Bit) {
m_bufferCharacters16[m_length++] = c;
return;
}
if (!(c & ~0xff)) {
m_bufferCharacters8[m_length++] = static_cast<LChar>(c);
return;
}
}
append(&c, 1);
}
void append(LChar c)
{
if (m_buffer && m_length < m_buffer->length() && m_string.isNull()) {
if (m_is8Bit)
m_bufferCharacters8[m_length++] = c;
else
m_bufferCharacters16[m_length++] = c;
} else
append(&c, 1);
}
void append(char c)
{
append(static_cast<LChar>(c));
}
void append(UChar32 c)
{
if (U_IS_BMP(c)) {
append(static_cast<UChar>(c));
return;
}
append(U16_LEAD(c));
append(U16_TRAIL(c));
}
template<unsigned charactersCount>
ALWAYS_INLINE void appendLiteral(const char (&characters)[charactersCount]) { append(characters, charactersCount - 1); }
void appendNumber(int);
void appendNumber(unsigned);
void appendNumber(long);
void appendNumber(unsigned long);
void appendNumber(long long);
void appendNumber(unsigned long long);
void appendNumber(double, unsigned precision = 6, TrailingZerosTruncatingPolicy = TruncateTrailingZeros);
String toString()
{
shrinkToFit();
if (m_string.isNull())
reifyString();
return m_string;
}
String substring(unsigned position, unsigned length) const
{
if (!m_length)
return emptyString();
if (!m_string.isNull())
return m_string.substring(position, length);
return reifySubstring(position, length);
}
AtomicString toAtomicString() const
{
if (!m_length)
return emptyAtom;
if (canShrink()) {
if (is8Bit())
return AtomicString(characters8(), length());
return AtomicString(characters16(), length());
}
if (!m_string.isNull())
return AtomicString(m_string);
ASSERT(m_buffer);
return AtomicString(m_buffer.get(), 0, m_length);
}
unsigned length() const
{
return m_length;
}
bool isEmpty() const { return !m_length; }
void reserveCapacity(unsigned newCapacity);
unsigned capacity() const
{
return m_buffer ? m_buffer->length() : m_length;
}
void resize(unsigned newSize);
bool canShrink() const;
void shrinkToFit();
UChar operator[](unsigned i) const
{
ASSERT_WITH_SECURITY_IMPLICATION(i < m_length);
if (m_is8Bit)
return characters8()[i];
return characters16()[i];
}
const LChar* characters8() const
{
ASSERT(m_is8Bit);
if (!m_length)
return 0;
if (!m_string.isNull())
return m_string.characters8();
ASSERT(m_buffer);
return m_buffer->characters8();
}
const UChar* characters16() const
{
ASSERT(!m_is8Bit);
if (!m_length)
return 0;
if (!m_string.isNull())
return m_string.characters16();
ASSERT(m_buffer);
return m_buffer->characters16();
}
bool is8Bit() const { return m_is8Bit; }
void clear()
{
m_length = 0;
m_string = String();
m_buffer = nullptr;
m_bufferCharacters8 = 0;
m_is8Bit = true;
}
void swap(StringBuilder& stringBuilder)
{
std::swap(m_length, stringBuilder.m_length);
m_string.swap(stringBuilder.m_string);
m_buffer.swap(stringBuilder.m_buffer);
std::swap(m_is8Bit, stringBuilder.m_is8Bit);
std::swap(m_bufferCharacters8, stringBuilder.m_bufferCharacters8);
}
private:
void allocateBuffer(const LChar* currentCharacters, unsigned requiredLength);
void allocateBuffer(const UChar* currentCharacters, unsigned requiredLength);
void allocateBufferUpConvert(const LChar* currentCharacters, unsigned requiredLength);
template <typename CharType>
void reallocateBuffer(unsigned requiredLength);
template <typename CharType>
ALWAYS_INLINE CharType* appendUninitialized(unsigned length);
template <typename CharType>
CharType* appendUninitializedSlow(unsigned length);
template <typename CharType>
ALWAYS_INLINE CharType * getBufferCharacters();
void reifyString();
String reifySubstring(unsigned position, unsigned length) const;
String m_string;
RefPtr<StringImpl> m_buffer;
union {
LChar* m_bufferCharacters8;
UChar* m_bufferCharacters16;
};
unsigned m_length;
bool m_is8Bit;
};
template <>
ALWAYS_INLINE LChar* StringBuilder::getBufferCharacters<LChar>()
{
ASSERT(m_is8Bit);
return m_bufferCharacters8;
}
template <>
ALWAYS_INLINE UChar* StringBuilder::getBufferCharacters<UChar>()
{
ASSERT(!m_is8Bit);
return m_bufferCharacters16;
}
template <typename CharType>
bool equal(const StringBuilder& s, const CharType* buffer, unsigned length)
{
if (s.length() != length)
return false;
if (s.is8Bit())
return equal(s.characters8(), buffer, length);
return equal(s.characters16(), buffer, length);
}
template<typename CharType>
bool equalIgnoringCase(const StringBuilder& s, const CharType* buffer, unsigned length)
{
if (s.length() != length)
return false;
if (s.is8Bit())
return equalIgnoringCase(s.characters8(), buffer, length);
return equalIgnoringCase(s.characters16(), buffer, length);
}
inline bool equalIgnoringCase(const StringBuilder& s, const char* string)
{
return equalIgnoringCase(s, reinterpret_cast<const LChar*>(string), strlen(string));
}
template <typename StringType>
bool equal(const StringBuilder& a, const StringType& b)
{
if (a.length() != b.length())
return false;
if (!a.length())
return true;
if (a.is8Bit()) {
if (b.is8Bit())
return equal(a.characters8(), b.characters8(), a.length());
return equal(a.characters8(), b.characters16(), a.length());
}
if (b.is8Bit())
return equal(a.characters16(), b.characters8(), a.length());
return equal(a.characters16(), b.characters16(), a.length());
}
template <typename StringType>
bool equalIgnoringCase(const StringBuilder& a, const StringType& b)
{
if (a.length() != b.length())
return false;
if (!a.length())
return true;
if (a.is8Bit()) {
if (b.is8Bit())
return equalIgnoringCase(a.characters8(), b.characters8(), a.length());
return equalIgnoringCase(a.characters8(), b.characters16(), a.length());
}
if (b.is8Bit())
return equalIgnoringCase(a.characters16(), b.characters8(), a.length());
return equalIgnoringCase(a.characters16(), b.characters16(), a.length());
}
inline bool operator==(const StringBuilder& a, const StringBuilder& b) { return equal(a, b); }
inline bool operator!=(const StringBuilder& a, const StringBuilder& b) { return !equal(a, b); }
inline bool operator==(const StringBuilder& a, const String& b) { return equal(a, b); }
inline bool operator!=(const StringBuilder& a, const String& b) { return !equal(a, b); }
inline bool operator==(const String& a, const StringBuilder& b) { return equal(b, a); }
inline bool operator!=(const String& a, const StringBuilder& b) { return !equal(b, a); }
}
using WTF::StringBuilder;
#endif