From 211ae2145228d300c3743d25c689ab0275b23e33 Mon Sep 17 00:00:00 2001 From: Thierry Bastian Date: Thu, 26 Mar 2009 10:11:45 +0100 Subject: Avoids calling function pointer in constructor of QVariant Instead, it calls directly the v_construct template function. --- src/corelib/kernel/qvariant.cpp | 46 ++++++++++++++++++++--------------------- 1 file changed, 23 insertions(+), 23 deletions(-) diff --git a/src/corelib/kernel/qvariant.cpp b/src/corelib/kernel/qvariant.cpp index b4427c0..fa55100 100644 --- a/src/corelib/kernel/qvariant.cpp +++ b/src/corelib/kernel/qvariant.cpp @@ -1619,44 +1619,44 @@ QVariant::QVariant(double val) { d.is_null = false; d.type = Double; d.data.d = val; } QVariant::QVariant(const QByteArray &val) -{ create(ByteArray, &val); } +{ d.is_null = false; d.type = ByteArray; v_construct(&d, &val); } QVariant::QVariant(const QBitArray &val) -{ create(BitArray, &val); } +{ d.is_null = false; d.type = BitArray; v_construct(&d, &val); } QVariant::QVariant(const QString &val) -{ create(String, &val); } +{ d.is_null = false; d.type = String; v_construct(&d, &val); } QVariant::QVariant(const QChar &val) -{ create (Char, &val); } +{ d.is_null = false; d.type = Char; v_construct(&d, &val); } QVariant::QVariant(const QLatin1String &val) -{ QString str(val); create(String, &str); } +{ QString str(val); d.is_null = false; d.type = String; v_construct(&d, &str); } QVariant::QVariant(const QStringList &val) -{ create(StringList, &val); } +{ d.is_null = false; d.type = StringList; v_construct(&d, &val); } QVariant::QVariant(const QDate &val) -{ create(Date, &val); } +{ d.is_null = false; d.type = Date; v_construct(&d, &val); } QVariant::QVariant(const QTime &val) -{ create(Time, &val); } +{ d.is_null = false; d.type = Time; v_construct(&d, &val); } QVariant::QVariant(const QDateTime &val) -{ create(DateTime, &val); } +{ d.is_null = false; d.type = DateTime; v_construct(&d, &val); } QVariant::QVariant(const QList &list) -{ create(List, &list); } +{ d.is_null = false; d.type = List; v_construct(&d, &list); } QVariant::QVariant(const QMap &map) -{ create(Map, &map); } +{ d.is_null = false; d.type = Map; v_construct(&d, &map); } QVariant::QVariant(const QHash &hash) -{ create(Hash, &hash); } +{ d.is_null = false; d.type = Hash; v_construct(&d, &hash); } #ifndef QT_NO_GEOM_VARIANT -QVariant::QVariant(const QPoint &pt) { create(Point, &pt); } -QVariant::QVariant(const QPointF &pt) { create (PointF, &pt); } -QVariant::QVariant(const QRectF &r) { create (RectF, &r); } -QVariant::QVariant(const QLineF &l) { create (LineF, &l); } -QVariant::QVariant(const QLine &l) { create (Line, &l); } -QVariant::QVariant(const QRect &r) { create(Rect, &r); } -QVariant::QVariant(const QSize &s) { create(Size, &s); } -QVariant::QVariant(const QSizeF &s) { create(SizeF, &s); } +QVariant::QVariant(const QPoint &pt) { d.is_null = false; d.type = Point; v_construct(&d, &pt); } +QVariant::QVariant(const QPointF &pt) { d.is_null = false; d.type = PointF; v_construct(&d, &pt); } +QVariant::QVariant(const QRectF &r) { d.is_null = false; d.type = RectF; v_construct(&d, &r); } +QVariant::QVariant(const QLineF &l) { d.is_null = false; d.type = LineF; v_construct(&d, &l); } +QVariant::QVariant(const QLine &l) { d.is_null = false; d.type = Line; v_construct(&d, &l); } +QVariant::QVariant(const QRect &r) { d.is_null = false; d.type = Rect; v_construct(&d, &r); } +QVariant::QVariant(const QSize &s) { d.is_null = false; d.type = Size; v_construct(&d, &s); } +QVariant::QVariant(const QSizeF &s) { d.is_null = false; d.type = SizeF; v_construct(&d, &s); } #endif -QVariant::QVariant(const QUrl &u) { create(Url, &u); } -QVariant::QVariant(const QLocale &l) { create(Locale, &l); } +QVariant::QVariant(const QUrl &u) { d.is_null = false; d.type = Url; v_construct(&d, &u); } +QVariant::QVariant(const QLocale &l) { d.is_null = false; d.type = Locale; v_construct(&d, &l); } #ifndef QT_NO_REGEXP -QVariant::QVariant(const QRegExp ®Exp) { create(RegExp, ®Exp); } +QVariant::QVariant(const QRegExp ®Exp) { d.is_null = false; d.type = RegExp; v_construct(&d, ®Exp); } #endif QVariant::QVariant(Qt::GlobalColor color) { create(62, &color); } -- cgit v0.12 From 51467afe563ca66d01e41dfd0f287d886117c415 Mon Sep 17 00:00:00 2001 From: Thierry Bastian Date: Thu, 26 Mar 2009 10:27:34 +0100 Subject: Added template to the private classes to avoid double allocation in QVariant --- src/corelib/kernel/qvariant_p.h | 25 ++++++++++++++++++------- 1 file changed, 18 insertions(+), 7 deletions(-) diff --git a/src/corelib/kernel/qvariant_p.h b/src/corelib/kernel/qvariant_p.h index 727a390..72c09ec 100644 --- a/src/corelib/kernel/qvariant_p.h +++ b/src/corelib/kernel/qvariant_p.h @@ -91,13 +91,25 @@ inline T *v_cast(QVariant::Private *d, T * = 0) #endif + +//a simple template that avoids to allocate 2 memory chunks when creating a QVariant +template class QVariantPrivateSharedEx : public QVariant::PrivateShared +{ +public: + QVariantPrivateSharedEx() : QVariant::PrivateShared(&m_t) { } + QVariantPrivateSharedEx(const T&t) : QVariant::PrivateShared(&m_t), m_t(t) { } + +private: + T m_t; +}; + // constructs a new variant if copy is 0, otherwise copy-constructs template inline void v_construct(QVariant::Private *x, const void *copy, T * = 0) { if (sizeof(T) > sizeof(QVariant::Private::Data)) { - x->data.shared = copy ? new QVariant::PrivateShared(new T(*static_cast(copy))) - : new QVariant::PrivateShared(new T); + x->data.shared = copy ? new QVariantPrivateSharedEx(*static_cast(copy)) + : new QVariantPrivateSharedEx; x->is_shared = true; } else { if (copy) @@ -111,12 +123,11 @@ inline void v_construct(QVariant::Private *x, const void *copy, T * = 0) template inline void v_clear(QVariant::Private *d, T* = 0) { - if (sizeof(T) > sizeof(QVariant::Private::Data)) { - delete v_cast(d); + //now we need to call the destructor in any case + //because QVariant::PrivateShared doesn't have a virtual destructor + v_cast(d)->~T(); + if (sizeof(T) > sizeof(QVariant::Private::Data)) delete d->data.shared; - } else { - v_cast(d)->~T(); - } } QT_END_NAMESPACE -- cgit v0.12 From 262ce9e47036a60d5bd466e3f5cdc4006c7974e2 Mon Sep 17 00:00:00 2001 From: Thierry Bastian Date: Thu, 26 Mar 2009 10:31:42 +0100 Subject: small simplification in internals of QVariant constDataHelper dones't need to know about the type if the variant --- src/corelib/kernel/qvariant.cpp | 29 ++++------------------------- 1 file changed, 4 insertions(+), 25 deletions(-) diff --git a/src/corelib/kernel/qvariant.cpp b/src/corelib/kernel/qvariant.cpp index fa55100..76e5a00 100644 --- a/src/corelib/kernel/qvariant.cpp +++ b/src/corelib/kernel/qvariant.cpp @@ -71,27 +71,6 @@ QT_BEGIN_NAMESPACE # define FLT_DIG 6 #endif - -static const void *constDataHelper(const QVariant::Private &d) -{ - switch (d.type) { - case QVariant::Int: - return &d.data.i; - case QVariant::UInt: - return &d.data.u; - case QVariant::Bool: - return &d.data.b; - case QVariant::LongLong: - return &d.data.ll; - case QVariant::ULongLong: - return &d.data.ull; - case QVariant::Double: - return &d.data.d; - default: - return d.is_shared ? d.data.shared->ptr : reinterpret_cast(&d.data.ptr); - } -} - static void construct(QVariant::Private *x, const void *copy) { x->is_shared = false; @@ -1907,7 +1886,7 @@ void QVariant::load(QDataStream &s) } // const cast is safe since we operate on a newly constructed variant - if (!QMetaType::load(s, d.type, const_cast(constDataHelper(d)))) { + if (!QMetaType::load(s, d.type, const_cast(constData()))) { s.setStatus(QDataStream::ReadCorruptData); qWarning("QVariant::load: unable to load type %d.", d.type); } @@ -1947,7 +1926,7 @@ void QVariant::save(QDataStream &s) const return; } - if (!QMetaType::save(s, d.type, constDataHelper(d))) { + if (!QMetaType::save(s, d.type, constData())) { Q_ASSERT_X(false, "QVariant::save", "Invalid type to save"); qWarning("QVariant::save: unable to save type %d.", d.type); } @@ -2726,7 +2705,7 @@ bool QVariant::cmp(const QVariant &v) const const void *QVariant::constData() const { - return constDataHelper(d); + return d.is_shared ? d.data.shared->ptr : reinterpret_cast(&d.data.ptr); } /*! @@ -2739,7 +2718,7 @@ const void *QVariant::constData() const void* QVariant::data() { detach(); - return const_cast(constDataHelper(d)); + return const_cast(constData()); } -- cgit v0.12 From 5ca5a64a5c714b18ef23c093307f9f4061235731 Mon Sep 17 00:00:00 2001 From: Thierry Bastian Date: Thu, 26 Mar 2009 10:41:53 +0100 Subject: Improved qVariantSetValue by reusing the internals if possible This is possible if the type is the same of type < Char (simple types) --- src/corelib/kernel/qvariant.h | 13 ++++++++++++- 1 file changed, 12 insertions(+), 1 deletion(-) diff --git a/src/corelib/kernel/qvariant.h b/src/corelib/kernel/qvariant.h index d7b7e3c..284e68c 100644 --- a/src/corelib/kernel/qvariant.h +++ b/src/corelib/kernel/qvariant.h @@ -443,7 +443,18 @@ inline QVariant qVariantFromValue(const QVariant &t) { return t; } template inline void qVariantSetValue(QVariant &v, const T &t) { - v = QVariant(qMetaTypeId(reinterpret_cast(0)), &t); + //if possible we reuse the current QVariant private + const int type = qMetaTypeId(reinterpret_cast(0)); + QVariant::Private &d = v.data_ptr(); + if (type <= int(QVariant::Char) || (type == d.type && v.isDetached())) { + d.type = type; + T *old = reinterpret_cast(d.is_shared ? d.data.shared->ptr : &d.data.ptr); + if (QTypeInfo::isComplex) + old->~T(); + new (old) T(t); //call the copy constructor + } else { + v = QVariant(type, &t); + } } inline QVariant::QVariant() {} -- cgit v0.12 From f68ce7374bef952ebc17f1edb7816a3f81044b4a Mon Sep 17 00:00:00 2001 From: Thierry Bastian Date: Thu, 26 Mar 2009 11:17:39 +0100 Subject: add proper support for floats to QVariant --- src/corelib/kernel/qvariant.cpp | 26 +++++++++++++++++++------- src/corelib/kernel/qvariant.h | 2 ++ 2 files changed, 21 insertions(+), 7 deletions(-) diff --git a/src/corelib/kernel/qvariant.cpp b/src/corelib/kernel/qvariant.cpp index 76e5a00..16ca5b0 100644 --- a/src/corelib/kernel/qvariant.cpp +++ b/src/corelib/kernel/qvariant.cpp @@ -158,6 +158,9 @@ static void construct(QVariant::Private *x, const void *copy) case QVariant::Double: x->data.d = copy ? *static_cast(copy) : 0.0; break; + case QMetaType::Float: + x->data.f = copy ? *static_cast(copy) : 0.0f; + break; case QVariant::LongLong: x->data.ll = copy ? *static_cast(copy) : Q_INT64_C(0); break; @@ -253,6 +256,7 @@ static void clear(QVariant::Private *d) case QVariant::LongLong: case QVariant::ULongLong: case QVariant::Double: + case QMetaType::Float: break; case QVariant::Invalid: case QVariant::UserType: @@ -470,7 +474,7 @@ static qlonglong qMetaTypeNumber(const QVariant::Private *d) case QMetaType::Long: return qlonglong(*static_cast(d->data.shared->ptr)); case QMetaType::Float: - return qRound64(*static_cast(d->data.shared->ptr)); + return qRound64(d->data.f); case QVariant::Double: return qRound64(d->data.d); } @@ -607,7 +611,7 @@ static bool convert(const QVariant::Private *d, QVariant::Type t, void *result, *str = QString::number(qMetaTypeUNumber(d)); break; case QMetaType::Float: - *str = QString::number(*static_cast(d->data.shared->ptr), 'g', FLT_DIG); + *str = QString::number(d->data.f, 'g', FLT_DIG); break; case QVariant::Double: *str = QString::number(d->data.d, 'g', DBL_DIG); @@ -778,7 +782,7 @@ static bool convert(const QVariant::Private *d, QVariant::Type t, void *result, *ba = QByteArray::number(d->data.d, 'g', DBL_DIG); break; case QMetaType::Float: - *ba = QByteArray::number(*static_cast(d->data.shared->ptr), 'g', FLT_DIG); + *ba = QByteArray::number(d->data.f, 'g', FLT_DIG); break; case QMetaType::Char: case QMetaType::UChar: @@ -880,7 +884,7 @@ static bool convert(const QVariant::Private *d, QVariant::Type t, void *result, *f = double(d->data.b); break; case QMetaType::Float: - *f = *static_cast(d->data.shared->ptr); + *f = double(d->data.f); break; case QVariant::LongLong: case QVariant::Int: @@ -1334,7 +1338,7 @@ void QVariant::create(int type, const void *copy) QVariant::~QVariant() { - if (d.type > Char && (!d.is_shared || !d.data.shared->ref.deref())) + if (d.type > Char && d.type != QMetaType::Float && (!d.is_shared || !d.data.shared->ref.deref())) handler->clear(&d); } @@ -1350,7 +1354,7 @@ QVariant::QVariant(const QVariant &p) { if (d.is_shared) { d.data.shared->ref.ref(); - } else if (p.d.type > Char) { + } else if (p.d.type > Char && p.d.type != QMetaType::Float) { handler->construct(&d, p.constData()); d.is_null = p.d.is_null; } @@ -1544,6 +1548,12 @@ QVariant::QVariant(const char *val) */ /*! + \fn QVariant::QVariant(float val) + + Constructs a new variant with a floating point value, \a val. +*/ + +/*! \fn QVariant::QVariant(const QList &val) Constructs a new variant with a list value, \a val. @@ -1596,6 +1606,8 @@ QVariant::QVariant(bool val) { d.is_null = false; d.type = Bool; d.data.b = val; } QVariant::QVariant(double val) { d.is_null = false; d.type = Double; d.data.d = val; } +QVariant::QVariant(float val) +{ d.is_null = false; d.type = QMetaType::Float; d.data.f = val; } QVariant::QVariant(const QByteArray &val) { d.is_null = false; d.type = ByteArray; v_construct(&d, &val); } @@ -1700,7 +1712,7 @@ QVariant& QVariant::operator=(const QVariant &variant) if (variant.d.is_shared) { variant.d.data.shared->ref.ref(); d = variant.d; - } else if (variant.d.type > Char) { + } else if (variant.d.type > Char && variant.d.type != QMetaType::Float) { d.type = variant.d.type; handler->construct(&d, variant.constData()); d.is_null = variant.d.is_null; diff --git a/src/corelib/kernel/qvariant.h b/src/corelib/kernel/qvariant.h index 284e68c..ede8074 100644 --- a/src/corelib/kernel/qvariant.h +++ b/src/corelib/kernel/qvariant.h @@ -181,6 +181,7 @@ class Q_CORE_EXPORT QVariant QVariant(qulonglong ull); QVariant(bool b); QVariant(double d); + QVariant(float f); #ifndef QT_NO_CAST_FROM_ASCII QT_ASCII_CAST_WARN_CONSTRUCTOR QVariant(const char *str); #endif @@ -349,6 +350,7 @@ class Q_CORE_EXPORT QVariant uint u; bool b; double d; + float f; qlonglong ll; qulonglong ull; void *ptr; -- cgit v0.12 From 64cdff9b09b42514ef934e61dccba86834eec9b0 Mon Sep 17 00:00:00 2001 From: Thierry Bastian Date: Tue, 31 Mar 2009 10:48:52 +0200 Subject: small change wrt to destruction (patch suggested by ogoffart) --- src/corelib/kernel/qvariant_p.h | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/src/corelib/kernel/qvariant_p.h b/src/corelib/kernel/qvariant_p.h index 72c09ec..a5ba9ff 100644 --- a/src/corelib/kernel/qvariant_p.h +++ b/src/corelib/kernel/qvariant_p.h @@ -123,11 +123,15 @@ inline void v_construct(QVariant::Private *x, const void *copy, T * = 0) template inline void v_clear(QVariant::Private *d, T* = 0) { - //now we need to call the destructor in any case - //because QVariant::PrivateShared doesn't have a virtual destructor - v_cast(d)->~T(); - if (sizeof(T) > sizeof(QVariant::Private::Data)) - delete d->data.shared; + + if (sizeof(T) > sizeof(QVariant::Private::Data)) { + //now we need to cast + //because QVariant::PrivateShared doesn't have a virtual destructor + delete static_cast*>(d->data.shared); + } else { + v_cast(d)->~T(); + } + } QT_END_NAMESPACE -- cgit v0.12 From 400c5eac739c600e745a5467dcfe2c6ada300e2a Mon Sep 17 00:00:00 2001 From: Thierry Bastian Date: Tue, 31 Mar 2009 10:54:19 +0200 Subject: make the float constructor inline (improves construction/destruction performance by 20%) --- src/corelib/kernel/qvariant.cpp | 2 -- src/corelib/kernel/qvariant.h | 2 +- 2 files changed, 1 insertion(+), 3 deletions(-) diff --git a/src/corelib/kernel/qvariant.cpp b/src/corelib/kernel/qvariant.cpp index 16ca5b0..96e5b4e 100644 --- a/src/corelib/kernel/qvariant.cpp +++ b/src/corelib/kernel/qvariant.cpp @@ -1606,8 +1606,6 @@ QVariant::QVariant(bool val) { d.is_null = false; d.type = Bool; d.data.b = val; } QVariant::QVariant(double val) { d.is_null = false; d.type = Double; d.data.d = val; } -QVariant::QVariant(float val) -{ d.is_null = false; d.type = QMetaType::Float; d.data.f = val; } QVariant::QVariant(const QByteArray &val) { d.is_null = false; d.type = ByteArray; v_construct(&d, &val); } diff --git a/src/corelib/kernel/qvariant.h b/src/corelib/kernel/qvariant.h index ede8074..d73fcbc 100644 --- a/src/corelib/kernel/qvariant.h +++ b/src/corelib/kernel/qvariant.h @@ -181,7 +181,7 @@ class Q_CORE_EXPORT QVariant QVariant(qulonglong ull); QVariant(bool b); QVariant(double d); - QVariant(float f); + QVariant(float f) { d.is_null = false; d.type = QMetaType::Float; d.data.f = f; } #ifndef QT_NO_CAST_FROM_ASCII QT_ASCII_CAST_WARN_CONSTRUCTOR QVariant(const char *str); #endif -- cgit v0.12 From ba31fca51ce7bdbbc6acabda2f0ac05d2700507d Mon Sep 17 00:00:00 2001 From: Thierry Bastian Date: Tue, 31 Mar 2009 11:09:41 +0200 Subject: make construction for known type faster There is one less test thanks to usage of reference instead of pointers --- src/corelib/kernel/qvariant.cpp | 46 ++++++++++++++++++++--------------------- src/corelib/kernel/qvariant_p.h | 11 ++++++++++ 2 files changed, 34 insertions(+), 23 deletions(-) diff --git a/src/corelib/kernel/qvariant.cpp b/src/corelib/kernel/qvariant.cpp index 96e5b4e..ea66658 100644 --- a/src/corelib/kernel/qvariant.cpp +++ b/src/corelib/kernel/qvariant.cpp @@ -1608,44 +1608,44 @@ QVariant::QVariant(double val) { d.is_null = false; d.type = Double; d.data.d = val; } QVariant::QVariant(const QByteArray &val) -{ d.is_null = false; d.type = ByteArray; v_construct(&d, &val); } +{ d.is_null = false; d.type = ByteArray; v_construct(&d, val); } QVariant::QVariant(const QBitArray &val) -{ d.is_null = false; d.type = BitArray; v_construct(&d, &val); } +{ d.is_null = false; d.type = BitArray; v_construct(&d, val); } QVariant::QVariant(const QString &val) -{ d.is_null = false; d.type = String; v_construct(&d, &val); } +{ d.is_null = false; d.type = String; v_construct(&d, val); } QVariant::QVariant(const QChar &val) -{ d.is_null = false; d.type = Char; v_construct(&d, &val); } +{ d.is_null = false; d.type = Char; v_construct(&d, val); } QVariant::QVariant(const QLatin1String &val) -{ QString str(val); d.is_null = false; d.type = String; v_construct(&d, &str); } +{ QString str(val); d.is_null = false; d.type = String; v_construct(&d, str); } QVariant::QVariant(const QStringList &val) -{ d.is_null = false; d.type = StringList; v_construct(&d, &val); } +{ d.is_null = false; d.type = StringList; v_construct(&d, val); } QVariant::QVariant(const QDate &val) -{ d.is_null = false; d.type = Date; v_construct(&d, &val); } +{ d.is_null = false; d.type = Date; v_construct(&d, val); } QVariant::QVariant(const QTime &val) -{ d.is_null = false; d.type = Time; v_construct(&d, &val); } +{ d.is_null = false; d.type = Time; v_construct(&d, val); } QVariant::QVariant(const QDateTime &val) -{ d.is_null = false; d.type = DateTime; v_construct(&d, &val); } +{ d.is_null = false; d.type = DateTime; v_construct(&d, val); } QVariant::QVariant(const QList &list) -{ d.is_null = false; d.type = List; v_construct(&d, &list); } +{ d.is_null = false; d.type = List; v_construct(&d, list); } QVariant::QVariant(const QMap &map) -{ d.is_null = false; d.type = Map; v_construct(&d, &map); } +{ d.is_null = false; d.type = Map; v_construct(&d, map); } QVariant::QVariant(const QHash &hash) -{ d.is_null = false; d.type = Hash; v_construct(&d, &hash); } +{ d.is_null = false; d.type = Hash; v_construct(&d, hash); } #ifndef QT_NO_GEOM_VARIANT -QVariant::QVariant(const QPoint &pt) { d.is_null = false; d.type = Point; v_construct(&d, &pt); } -QVariant::QVariant(const QPointF &pt) { d.is_null = false; d.type = PointF; v_construct(&d, &pt); } -QVariant::QVariant(const QRectF &r) { d.is_null = false; d.type = RectF; v_construct(&d, &r); } -QVariant::QVariant(const QLineF &l) { d.is_null = false; d.type = LineF; v_construct(&d, &l); } -QVariant::QVariant(const QLine &l) { d.is_null = false; d.type = Line; v_construct(&d, &l); } -QVariant::QVariant(const QRect &r) { d.is_null = false; d.type = Rect; v_construct(&d, &r); } -QVariant::QVariant(const QSize &s) { d.is_null = false; d.type = Size; v_construct(&d, &s); } -QVariant::QVariant(const QSizeF &s) { d.is_null = false; d.type = SizeF; v_construct(&d, &s); } +QVariant::QVariant(const QPoint &pt) { d.is_null = false; d.type = Point; v_construct(&d, pt); } +QVariant::QVariant(const QPointF &pt) { d.is_null = false; d.type = PointF; v_construct(&d, pt); } +QVariant::QVariant(const QRectF &r) { d.is_null = false; d.type = RectF; v_construct(&d, r); } +QVariant::QVariant(const QLineF &l) { d.is_null = false; d.type = LineF; v_construct(&d, l); } +QVariant::QVariant(const QLine &l) { d.is_null = false; d.type = Line; v_construct(&d, l); } +QVariant::QVariant(const QRect &r) { d.is_null = false; d.type = Rect; v_construct(&d, r); } +QVariant::QVariant(const QSize &s) { d.is_null = false; d.type = Size; v_construct(&d, s); } +QVariant::QVariant(const QSizeF &s) { d.is_null = false; d.type = SizeF; v_construct(&d, s); } #endif -QVariant::QVariant(const QUrl &u) { d.is_null = false; d.type = Url; v_construct(&d, &u); } -QVariant::QVariant(const QLocale &l) { d.is_null = false; d.type = Locale; v_construct(&d, &l); } +QVariant::QVariant(const QUrl &u) { d.is_null = false; d.type = Url; v_construct(&d, u); } +QVariant::QVariant(const QLocale &l) { d.is_null = false; d.type = Locale; v_construct(&d, l); } #ifndef QT_NO_REGEXP -QVariant::QVariant(const QRegExp ®Exp) { d.is_null = false; d.type = RegExp; v_construct(&d, ®Exp); } +QVariant::QVariant(const QRegExp ®Exp) { d.is_null = false; d.type = RegExp; v_construct(&d, regExp); } #endif QVariant::QVariant(Qt::GlobalColor color) { create(62, &color); } diff --git a/src/corelib/kernel/qvariant_p.h b/src/corelib/kernel/qvariant_p.h index a5ba9ff..033b760 100644 --- a/src/corelib/kernel/qvariant_p.h +++ b/src/corelib/kernel/qvariant_p.h @@ -105,6 +105,17 @@ private: // constructs a new variant if copy is 0, otherwise copy-constructs template +inline void v_construct(QVariant::Private *x, const T &t) +{ + if (sizeof(T) > sizeof(QVariant::Private::Data)) { + x->data.shared = new QVariantPrivateSharedEx(t); + x->is_shared = true; + } else { + new (&x->data.ptr) T(t); + } +} + +template inline void v_construct(QVariant::Private *x, const void *copy, T * = 0) { if (sizeof(T) > sizeof(QVariant::Private::Data)) { -- cgit v0.12