Sqlite: Inline Utf8String

Actually you should use Utils::SmallString for new code because the
biggest overhead of Utf8String is the allocation on the heap and the
atomics.

Change-Id: Ic3d072ba47cb2a49ae3d7d158c6a58feb4b82769
Reviewed-by: hjk <hjk@qt.io>
Reviewed-by: Tim Jenssen <tim.jenssen@theqtcompany.com>

src/libs/sqlite/utf8string.cpp

@@ -30,238 +30,10 @@
 #include <QString>
 #include <QDebug>
 
-#ifdef QT_TESTLIB_LIB
-#include <QTest>
-#endif
-
 #include <QDataStream>
 
 #include <ostream>
 
-Utf8String::Utf8String(const char *utf8Text, int size)
-    : byteArray(utf8Text, size)
-{
-}
-
-Utf8String::Utf8String(const QString &text)
-    : byteArray(text.toUtf8())
-{
-}
-
-const char *Utf8String::constData() const
-{
-    return byteArray.constData();
-}
-
-int Utf8String::byteSize() const
-{
-    return byteArray.size();
-}
-
-Utf8String Utf8String::fromUtf8(const char *utf8Text)
-{
-    return Utf8String(utf8Text, -1);
-}
-
-Utf8String::Utf8String(const QByteArray &utf8ByteArray)
-    : byteArray(utf8ByteArray)
-{
-}
-
-Utf8String Utf8String::fromByteArray(const QByteArray &utf8ByteArray)
-{
-    return Utf8String(utf8ByteArray);
-}
-
-const QByteArray &Utf8String::toByteArray() const
-{
-    return byteArray;
-}
-
-Utf8String Utf8String::fromString(const QString &text)
-{
-    return Utf8String::fromByteArray(text.toUtf8());
-}
-
-QString Utf8String::toString() const
-{
-    return QString::fromUtf8(byteArray, byteArray.size());
-}
-
-Utf8String Utf8String::mid(int position, int length) const
-{
-    return Utf8String(byteArray.mid(position, length));
-}
-
-void Utf8String::replace(const Utf8String &before, const Utf8String &after)
-{
-    byteArray.replace(before.byteArray, after.byteArray);
-}
-
-void Utf8String::replace(int position, int length, const Utf8String &after)
-{
-    byteArray.replace(position, length, after.byteArray);
-}
-
-Utf8StringVector Utf8String::split(char separator) const
-{
-    Utf8StringVector utf8Vector;
-
-    foreach (const QByteArray &byteArray, byteArray.split(separator))
-        utf8Vector.append(Utf8String::fromByteArray(byteArray));
-
-   return utf8Vector;
-}
-
-void Utf8String::clear()
-{
-    byteArray.clear();
-}
-
-void Utf8String::append(const Utf8String &textToAppend)
-{
-    byteArray.append(textToAppend.byteArray);
-}
-
-bool Utf8String::contains(const Utf8String &text) const
-{
-    return byteArray.contains(text.byteArray);
-}
-
-bool Utf8String::contains(const char *text) const
-{
-    return byteArray.contains(text);
-}
-
-bool Utf8String::contains(char character) const
-{
-    return byteArray.contains(character);
-}
-
-bool Utf8String::startsWith(const Utf8String &text) const
-{
-    return byteArray.startsWith(text.byteArray);
-}
-
-bool Utf8String::startsWith(const char *text) const
-{
-    return byteArray.startsWith(text);
-}
-
-bool Utf8String::startsWith(char character) const
-{
-    return byteArray.startsWith(character);
-}
-
-bool Utf8String::endsWith(const Utf8String &text) const
-{
-    return byteArray.endsWith(text.byteArray);
-}
-
-bool Utf8String::isNull() const
-{
-    return byteArray.isNull();
-}
-
-bool Utf8String::isEmpty() const
-{
-    return byteArray.isEmpty();
-}
-
-bool Utf8String::hasContent() const
-{
-    return !isEmpty();
-}
-
-void Utf8String::reserve(int reserveSize)
-{
-    byteArray.reserve(reserveSize);
-}
-
-Utf8String Utf8String::number(int number, int base)
-{
-    return Utf8String::fromByteArray(QByteArray::number(number, base));
-}
-
-const Utf8String &Utf8String::operator+=(const Utf8String &text)
-{
-    byteArray += text.byteArray;
-
-    return *this;
-}
-
-void Utf8String::registerType()
-{
-    qRegisterMetaType<Utf8String>("Utf8String");
-}
-
-Utf8String::operator const QByteArray &() const
-{
-    return byteArray;
-}
-
-Utf8String::operator QString() const
-{
-    return toString();
-}
-
-const Utf8String operator+(const Utf8String &first, const Utf8String &second)
-{
-    return Utf8String(first.byteArray + second.byteArray);
-}
-
-
-bool operator!=(const Utf8String &first, const Utf8String &second)
-{
-    return first.byteArray != second.byteArray;
-}
-
-
-bool operator==(const Utf8String &first, const Utf8String &second)
-{
-    return first.byteArray == second.byteArray;
-}
-
-bool operator==(const Utf8String &first, const char *second)
-{
-    return first.byteArray == second;
-}
-
-bool operator==(const char *first, const Utf8String &second)
-{
-    return second == first;
-}
-
-bool operator==(const Utf8String &first, const QString &second)
-{
-    return first.byteArray == second.toUtf8();
-}
-
-bool operator<(const Utf8String &first, const Utf8String &second)
-{
-    if (first.byteSize() == second.byteSize())
-        return first.byteArray < second.byteArray;
-
-    return first.byteSize() < second.byteSize();
-}
-
-
-QDataStream &operator<<(QDataStream &datastream, const Utf8String &text)
-{
-    datastream << text.byteArray;
-
-    return datastream;
-}
-
-
-QDataStream &operator>>(QDataStream &datastream, Utf8String &text)
-{
-    datastream >> text.byteArray;
-
-    return datastream;
-}
-
-
 QDebug operator<<(QDebug debug, const Utf8String &text)
 {
     debug << text.constData();
@@ -282,7 +54,12 @@ std::ostream& operator<<(std::ostream &os, const Utf8String &utf8String)
     return os;
 }
 
-uint qHash(const Utf8String &utf8String)
+Utf8StringVector Utf8String::split(char separator) const
 {
-    return qHash(utf8String.byteArray);
+    Utf8StringVector utf8Vector;
+
+    for (const QByteArray &byteArrayPart : byteArray.split(separator))
+        utf8Vector.append(Utf8String::fromByteArray(byteArrayPart));
+
+    return utf8Vector;
 }

src/libs/sqlite/utf8string.h

@@ -28,101 +28,244 @@
 #include "sqliteglobal.h"
 
 #include <QByteArray>
+#include <QHashFunctions>
 #include <QMetaType>
+#include <QString>
 
 #include <iosfwd>
 
 class Utf8StringVector;
 class Utf8String;
 
-class SQLITE_EXPORT Utf8String
+class Utf8String
 {
     friend class Utf8StringVector;
 
-    friend SQLITE_EXPORT const Utf8String operator+(const Utf8String &first, const Utf8String &second);
-
-    friend SQLITE_EXPORT bool operator!=(const Utf8String &first, const Utf8String &second);
-    friend SQLITE_EXPORT bool operator==(const Utf8String &first, const Utf8String &second);
-    friend SQLITE_EXPORT bool operator==(const Utf8String &first, const char *second);
-    friend SQLITE_EXPORT bool operator==(const char *first, const Utf8String &second);
-    friend SQLITE_EXPORT bool operator==(const Utf8String &first, const QString &second);
-    friend SQLITE_EXPORT bool operator<(const Utf8String &first, const Utf8String &second);
-
-    friend SQLITE_EXPORT QDataStream &operator<<(QDataStream &datastream, const Utf8String &text);
-    friend SQLITE_EXPORT QDataStream &operator>>(QDataStream &datastream, Utf8String &text);
-
-    friend SQLITE_EXPORT uint qHash(const Utf8String &utf8String);
-
 public:
     Utf8String() = default;
-    explicit Utf8String(const char *utf8Text, int size);
-    Utf8String(const QString &text);
 
-    const char *constData() const;
+    explicit Utf8String(const char *utf8Text, int size)
+        : byteArray(utf8Text, size)
+    {
+    }
 
-    int byteSize() const;
+    Utf8String(const QString &text)
+        : byteArray(text.toUtf8())
+    {
+    }
 
-    static Utf8String fromUtf8(const char *utf8Text);
+    const char *constData() const
-    static Utf8String fromByteArray(const QByteArray &utf8ByteArray);
+    {
-    const QByteArray &toByteArray() const;
+        return byteArray.constData();
+    }
 
-    static Utf8String fromString(const QString &text);
+    int byteSize() const
-    QString toString() const;
+    {
+        return byteArray.size();
+    }
 
-    Utf8String mid(int position, int length = -1) const;
+    static Utf8String fromUtf8(const char *utf8Text)
-    void replace(const Utf8String &before, const Utf8String &after);
+    {
-    void replace(int position, int length, const Utf8String &after);
+        return Utf8String(utf8Text, -1);
-    Utf8StringVector split(char separator) const;
+    }
 
-    void clear();
+    static Utf8String fromByteArray(const QByteArray &utf8ByteArray)
+    {
+        return Utf8String(utf8ByteArray);
+    }
+    const QByteArray &toByteArray() const
+    {
+        return byteArray;
+    }
 
-    void append(const Utf8String &textToAppend);
+    static Utf8String fromString(const QString &text)
-    bool contains(const Utf8String &text) const;
+    {
-    bool contains(const char *text) const;
+        return Utf8String::fromByteArray(text.toUtf8());
-    bool contains(char character) const;
+    }
-    bool startsWith(const Utf8String &text) const;
-    bool startsWith(const char *text) const;
-    bool startsWith(char character) const;
-    bool endsWith(const Utf8String &text) const;
-    bool isNull() const;
-    bool isEmpty() const;
-    bool hasContent() const;
 
-    void reserve(int reserveSize);
+    QString toString() const
+    {
+        return QString::fromUtf8(byteArray, byteArray.size());
+    }
 
-    static Utf8String number(int number, int base=10);
+    Utf8String mid(int position, int length = -1) const
+    {
+        return Utf8String(byteArray.mid(position, length));
+    }
 
-    const Utf8String &operator+=(const Utf8String &text);
+    void replace(const Utf8String &before, const Utf8String &after)
+    {
+        byteArray.replace(before.byteArray, after.byteArray);
+    }
 
-    static void registerType();
+    void replace(int position, int length, const Utf8String &after)
+    {
+        byteArray.replace(position, length, after.byteArray);
+    }
 
-    operator QString () const;
+    SQLITE_EXPORT Utf8StringVector split(char separator) const;
-    operator const QByteArray & () const;
+
+    void clear()
+    {
+        byteArray.clear();
+    }
+
+    void append(const Utf8String &textToAppend)
+    {
+        byteArray.append(textToAppend.byteArray);
+    }
+
+    bool contains(const Utf8String &text) const
+    {
+        return byteArray.contains(text.byteArray);
+    }
+
+    bool contains(const char *text) const
+    {
+        return byteArray.contains(text);
+    }
+
+    bool contains(char character) const
+    {
+        return byteArray.contains(character);
+    }
+
+    bool startsWith(const Utf8String &text) const
+    {
+        return byteArray.startsWith(text.byteArray);
+    }
+
+    bool startsWith(const char *text) const
+    {
+        return byteArray.startsWith(text);
+    }
+
+    bool startsWith(char character) const
+    {
+        return byteArray.startsWith(character);
+    }
+
+    bool endsWith(const Utf8String &text) const
+    {
+        return byteArray.endsWith(text.byteArray);
+    }
+
+    bool isNull() const
+    {
+        return byteArray.isNull();
+    }
+
+    bool isEmpty() const
+    {
+        return byteArray.isEmpty();
+    }
+
+    bool hasContent() const
+    {
+        return !isEmpty();
+    }
+
+    void reserve(int reserveSize)
+    {
+        byteArray.reserve(reserveSize);
+    }
+
+    static Utf8String number(int number, int base=10)
+    {
+        return Utf8String::fromByteArray(QByteArray::number(number, base));
+    }
+
+    const Utf8String &operator+=(const Utf8String &text)
+    {
+        byteArray += text.byteArray;
+
+        return *this;
+    }
+
+    static void registerType()
+    {
+        qRegisterMetaType<Utf8String>("Utf8String");
+    }
+
+    operator QString() const
+    {
+        return toString();
+    }
+
+    operator const QByteArray &() const
+    {
+        return byteArray;
+    }
+
+    friend const Utf8String operator+(const Utf8String &first, const Utf8String &second)
+    {
+        return Utf8String(first.byteArray + second.byteArray);
+    }
+
+    friend bool operator!=(const Utf8String &first, const Utf8String &second)
+    {
+        return first.byteArray != second.byteArray;
+    }
+
+    friend bool operator==(const Utf8String &first, const Utf8String &second)
+    {
+        return first.byteArray == second.byteArray;
+    }
+
+    friend bool operator==(const Utf8String &first, const char *second)
+    {
+        return first.byteArray == second;
+    }
+
+    friend bool operator==(const char *first, const Utf8String &second)
+    {
+        return second == first;
+    }
+
+    friend bool operator==(const Utf8String &first, const QString &second)
+    {
+        return first.byteArray == second.toUtf8();
+    }
+
+    friend bool operator<(const Utf8String &first, const Utf8String &second)
+    {
+        if (first.byteSize() == second.byteSize())
+            return first.byteArray < second.byteArray;
+
+        return first.byteSize() < second.byteSize();
+    }
+
+    friend  QDataStream &operator<<(QDataStream &datastream, const Utf8String &text)
+    {
+        datastream << text.byteArray;
+
+        return datastream;
+    }
+
+    friend QDataStream &operator>>(QDataStream &datastream, Utf8String &text)
+    {
+        datastream >> text.byteArray;
+
+        return datastream;
+    }
+
+    friend uint qHash(const Utf8String &utf8String)
+    {
+        return qHash(utf8String.byteArray);
+    }
 
 protected:
-    explicit Utf8String(const QByteArray &utf8ByteArray);
+    explicit Utf8String(const QByteArray &utf8ByteArray)
+        : byteArray(utf8ByteArray)
+    {
+    }
 
 private:
     QByteArray byteArray;
 };
 
-SQLITE_EXPORT const Utf8String operator+(const Utf8String &first, const Utf8String &second);
-
-SQLITE_EXPORT bool operator!=(const Utf8String &first, const Utf8String &second);
-SQLITE_EXPORT bool operator==(const Utf8String &first, const Utf8String &second);
-SQLITE_EXPORT bool operator==(const Utf8String &first, const char *second);
-SQLITE_EXPORT bool operator==(const char *first, const Utf8String &second);
-SQLITE_EXPORT bool operator==(const Utf8String &first, const QString &second);
-SQLITE_EXPORT bool operator<(const Utf8String &first, const Utf8String &second);
-
-SQLITE_EXPORT QDataStream &operator<<(QDataStream &datastream, const Utf8String &text);
-SQLITE_EXPORT QDataStream &operator>>(QDataStream &datastream, Utf8String &text);
 SQLITE_EXPORT QDebug operator<<(QDebug debug, const Utf8String &text);
 SQLITE_EXPORT void PrintTo(const Utf8String &text, ::std::ostream* os);
 SQLITE_EXPORT std::ostream& operator<<(std::ostream &os, const Utf8String &utf8String);
 
-SQLITE_EXPORT uint qHash(const Utf8String &utf8String);
-
 #define Utf8StringLiteral(str) Utf8String::fromByteArray(QByteArrayLiteral(str))
-
-Q_DECLARE_METATYPE(Utf8String)