Commit 19d941d2 authored by Marco Bubke's avatar Marco Bubke Committed by Tim Jenssen
Browse files

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: default avatarhjk <hjk@qt.io>
Reviewed-by: default avatarTim Jenssen <tim.jenssen@theqtcompany.com>
parent 80b229a7
......@@ -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;
}
......@@ -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);
public:
Utf8String() = default;
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);
explicit Utf8String(const char *utf8Text, int size)
: byteArray(utf8Text, size)
{
}
friend SQLITE_EXPORT QDataStream &operator<<(QDataStream &datastream, const Utf8String &text);
friend SQLITE_EXPORT QDataStream &operator>>(QDataStream &datastream, Utf8String &text);
Utf8String(const QString &text)
: byteArray(text.toUtf8())
{
}
friend SQLITE_EXPORT uint qHash(const Utf8String &utf8String);
const char *constData() const
{
return byteArray.constData();
}
public:
Utf8String() = default;
explicit Utf8String(const char *utf8Text, int size);
Utf8String(const QString &text);
int byteSize() const
{
return byteArray.size();
}
static Utf8String fromUtf8(const char *utf8Text)
{
return Utf8String(utf8Text, -1);
}
static Utf8String fromByteArray(const QByteArray &utf8ByteArray)
{
return Utf8String(utf8ByteArray);
}
const QByteArray &toByteArray() const
{
return byteArray;
}
static Utf8String fromString(const QString &text)
{
return Utf8String::fromByteArray(text.toUtf8());
}
QString toString() const
{
return QString::fromUtf8(byteArray, byteArray.size());
}
Utf8String mid(int position, int length = -1) const
{
return Utf8String(byteArray.mid(position, length));
}
void replace(const Utf8String &before, const Utf8String &after)
{
byteArray.replace(before.byteArray, after.byteArray);
}
void replace(int position, int length, const Utf8String &after)
{
byteArray.replace(position, length, after.byteArray);
}
SQLITE_EXPORT Utf8StringVector split(char separator) 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);
}
const char *constData() const;
bool startsWith(const char *text) const
{
return byteArray.startsWith(text);
}
int byteSize() const;
bool startsWith(char character) const
{
return byteArray.startsWith(character);
}
static Utf8String fromUtf8(const char *utf8Text);
static Utf8String fromByteArray(const QByteArray &utf8ByteArray);
const QByteArray &toByteArray() const;
bool endsWith(const Utf8String &text) const
{
return byteArray.endsWith(text.byteArray);
}
static Utf8String fromString(const QString &text);
QString toString() const;
bool isNull() const
{
return byteArray.isNull();
}
Utf8String mid(int position, int length = -1) const;
void replace(const Utf8String &before, const Utf8String &after);
void replace(int position, int length, const Utf8String &after);
Utf8StringVector split(char separator) const;
bool isEmpty() const
{
return byteArray.isEmpty();
}
void clear();
bool hasContent() const
{
return !isEmpty();
}
void append(const Utf8String &textToAppend);
bool contains(const Utf8String &text) const;
bool contains(const char *text) const;
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)
{
byteArray.reserve(reserveSize);
}
void reserve(int reserveSize);
static Utf8String number(int number, int base=10)
{
return Utf8String::fromByteArray(QByteArray::number(number, base));
}
static Utf8String number(int number, int base=10);
const Utf8String &operator+=(const Utf8String &text)
{
byteArray += text.byteArray;
const Utf8String &operator+=(const Utf8String &text);
return *this;
}
static void registerType();
static void registerType()
{
qRegisterMetaType<Utf8String>("Utf8String");
}
operator QString () const;
operator const QByteArray & () const;
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)
Markdown is supported
0% or .
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment