FCL/sf/mw/qt: comparison src/corelib/tools/qstringbuilder.h

equal deleted inserted replaced

-:b72c6db6890b
+:5dc02b23752f
 public:
 QStringBuilder(const A &a_, const B &b_) : a(a_), b(b_) {}
 operator QString() const
 {
-QString s(QConcatenable< QStringBuilder<A, B> >::size(*this),
+const uint size = QConcatenable< QStringBuilder<A, B> >::size(*this);
-Qt::Uninitialized);
+QString s(size, Qt::Uninitialized);
 QChar *d = s.data();
+const QChar * const start = d;
 QConcatenable< QStringBuilder<A, B> >::appendTo(*this, d);
-// this resize is necessary since we allocate a bit too much
-// when dealing with variable sized 8-bit encodings
+if (!QConcatenable< QStringBuilder<A, B> >::ExactSize && int(size) != d - start) {
-s.resize(d - s.data());
+// this resize is necessary since we allocate a bit too much
+// when dealing with variable sized 8-bit encodings
+s.resize(d - start);
+}
 return s;
 }
 QByteArray toLatin1() const { return QString(*this).toLatin1(); }
 const A &a;
 const B &b;
 };
+template <>
+class QStringBuilder <QString, QString>
+{
+public:
+QStringBuilder(const QString &a_, const QString &b_) : a(a_), b(b_) {}
+operator QString() const
+{ QString r(a); r += b; return r; }
+QByteArray toLatin1() const { return QString(*this).toLatin1(); }
+const QString &a;
+const QString &b;
+};
 template <> struct QConcatenable<char> : private QAbstractConcatenable
 {
 typedef char type;
+enum { ExactSize = true };
 static int size(const char) { return 1; }
 static inline void appendTo(const char c, QChar *&out)
 {
 QAbstractConcatenable::convertFromAscii(c, out);
 }
 };
 template <> struct QConcatenable<QLatin1Char>
 {
 typedef QLatin1Char type;
+enum { ExactSize = true };
 static int size(const QLatin1Char) { return 1; }
 static inline void appendTo(const QLatin1Char c, QChar *&out)
 {
 *out++ = c;
 }
 };
 template <> struct QConcatenable<QChar>
 {
 typedef QChar type;
+enum { ExactSize = true };
 static int size(const QChar) { return 1; }
 static inline void appendTo(const QChar c, QChar *&out)
 {
 *out++ = c;
 }
 };
 template <> struct QConcatenable<QCharRef>
 {
 typedef QCharRef type;
+enum { ExactSize = true };
 static int size(const QCharRef &) { return 1; }
 static inline void appendTo(const QCharRef &c, QChar *&out)
 {
 *out++ = QChar(c);
 }
 };
 template <> struct QConcatenable<QLatin1String>
 {
 typedef QLatin1String type;
+enum { ExactSize = true };
 static int size(const QLatin1String &a) { return qstrlen(a.latin1()); }
 static inline void appendTo(const QLatin1String &a, QChar *&out)
 {
 for (const char *s = a.latin1(); *s; )
 *out++ = QLatin1Char(*s++);
 };
 template <> struct QConcatenable<QLatin1Literal>
 {
 typedef QLatin1Literal type;
+enum { ExactSize = true };
 static int size(const QLatin1Literal &a) { return a.size(); }
 static inline void appendTo(const QLatin1Literal &a, QChar *&out)
 {
 for (const char *s = a.data(); *s; )
 *out++ = QLatin1Char(*s++);
 };
 template <> struct QConcatenable<QString>
 {
 typedef QString type;
+enum { ExactSize = true };
 static int size(const QString &a) { return a.size(); }
 static inline void appendTo(const QString &a, QChar *&out)
 {
 const int n = a.size();
 memcpy(out, reinterpret_cast<const char*>(a.constData()), sizeof(QChar) * n);
 };
 template <> struct QConcatenable<QStringRef>
 {
 typedef QStringRef type;
+enum { ExactSize = true };
 static int size(const QStringRef &a) { return a.size(); }
 static inline void appendTo(QStringRef a, QChar *&out)
 {
 const int n = a.size();
 memcpy(out, reinterpret_cast<const char*>(a.constData()), sizeof(QChar) * n);
 #ifndef QT_NO_CAST_FROM_ASCII
 template <int N> struct QConcatenable<char[N]> : private QAbstractConcatenable
 {
 typedef char type[N];
+enum { ExactSize = false };
 static int size(const char[N])
 {
 return N - 1;
 }
 static inline void appendTo(const char a[N], QChar *&out)
 };
 template <int N> struct QConcatenable<const char[N]> : private QAbstractConcatenable
 {
 typedef const char type[N];
+enum { ExactSize = false };
 static int size(const char[N]) { return N - 1; }
 static inline void appendTo(const char a[N], QChar *&out)
 {
 QAbstractConcatenable::convertFromAscii(a, N, out);
 }
 };
 template <> struct QConcatenable<const char *> : private QAbstractConcatenable
 {
 typedef char const *type;
+enum { ExactSize = false };
 static int size(const char *a) { return qstrlen(a); }
 static inline void appendTo(const char *a, QChar *&out)
 {
 QAbstractConcatenable::convertFromAscii(a, -1, out);
 }
 };
 template <> struct QConcatenable<QByteArray> : private QAbstractConcatenable
 {
 typedef QByteArray type;
+enum { ExactSize = false };
 static int size(const QByteArray &ba) { return qstrnlen(ba.constData(), ba.size()); }
 static inline void appendTo(const QByteArray &ba, QChar *&out)
 {
 QAbstractConcatenable::convertFromAscii(ba.constData(), -1, out);
 }
 template <typename A, typename B>
 struct QConcatenable< QStringBuilder<A, B> >
 {
 typedef QStringBuilder<A, B> type;
+enum { ExactSize = QConcatenable<A>::ExactSize && QConcatenable<B>::ExactSize };
 static int size(const type &p)
 {
 return QConcatenable<A>::size(p.a) + QConcatenable<B>::size(p.b);
 }
 static inline void appendTo(const QStringBuilder<A, B> &p, QChar *&out)

changeset 30	5dc02b23752f
parent 18	2f34d5167611