From 9784dd8d06565177a302d4dabec0b6555a958e53 Mon Sep 17 00:00:00 2001 From: Stephen Kelly Date: Tue, 24 Jul 2012 16:10:52 +0200 Subject: Implement implicit constructors for built-in classes. Change-Id: I6b0b104bc1da3252d014615c50b81830de42e722 Reviewed-by: Marc Mutz Reviewed-by: Olivier Goffart --- src/corelib/kernel/qvariant.cpp | 126 +++++++++++++++++++++ src/corelib/kernel/qvariant.h | 12 ++ src/gui/painting/qpolygon.cpp | 5 + src/gui/painting/qpolygon.h | 2 + .../auto/corelib/kernel/qvariant/tst_qvariant.cpp | 50 ++++++++ .../kernel/qguivariant/test/tst_qguivariant.cpp | 47 ++++++++ .../kernel/qwidgetsvariant/tst_qwidgetsvariant.cpp | 24 ++++ 7 files changed, 266 insertions(+) diff --git a/src/corelib/kernel/qvariant.cpp b/src/corelib/kernel/qvariant.cpp index 9b1c444db9..6ec8ef8870 100644 --- a/src/corelib/kernel/qvariant.cpp +++ b/src/corelib/kernel/qvariant.cpp @@ -1227,6 +1227,48 @@ QVariant::QVariant(const char *val) Constructs a new variant with an easing curve value, \a val. */ +/*! + \since 5.0 + \fn QVariant::QVariant(const QUuid &val) + + Constructs a new variant with an uuid value, \a val. +*/ + +/*! + \since 5.0 + \fn QVariant::QVariant(const QModelIndex &val) + + Constructs a new variant with an modelIndex value, \a val. +*/ + +/*! + \since 5.0 + \fn QVariant::QVariant(const QJsonValue &val) + + Constructs a new variant with a json value, \a val. +*/ + +/*! + \since 5.0 + \fn QVariant::QVariant(const QJsonObject &val) + + Constructs a new variant with a json object value, \a val. +*/ + +/*! + \since 5.0 + \fn QVariant::QVariant(const QJsonArray &val) + + Constructs a new variant with a json array value, \a val. +*/ + +/*! + \since 5.0 + \fn QVariant::QVariant(const QJsonDocument &val) + + Constructs a new variant with a json document value, \a val. +*/ + /*! \fn QVariant::QVariant(const QByteArray &val) @@ -1448,6 +1490,12 @@ QVariant::QVariant(const QLocale &l) { d.is_null = false; d.type = Locale; v_con QVariant::QVariant(const QRegExp ®Exp) { d.is_null = false; d.type = RegExp; v_construct(&d, regExp); } #ifndef QT_BOOTSTRAPPED QVariant::QVariant(const QRegularExpression &re) { d.is_null = false; d.type = QMetaType::QRegularExpression; v_construct(&d, re); } +QVariant::QVariant(const QUuid &uuid) { d.is_null = false; d.type = QMetaType::QUuid; v_construct(&d, uuid); } +QVariant::QVariant(const QModelIndex &modelIndex) { d.is_null = false; d.type = QMetaType::QModelIndex; v_construct(&d, modelIndex); } +QVariant::QVariant(const QJsonValue &jsonValue) { d.is_null = false; d.type = QMetaType::QJsonValue; v_construct(&d, jsonValue); } +QVariant::QVariant(const QJsonObject &jsonObject) { d.is_null = false; d.type = QMetaType::QJsonObject; v_construct(&d, jsonObject); } +QVariant::QVariant(const QJsonArray &jsonArray) { d.is_null = false; d.type = QMetaType::QJsonArray; v_construct(&d, jsonArray); } +QVariant::QVariant(const QJsonDocument &jsonDocument) { d.is_null = false; d.type = QMetaType::QJsonDocument; v_construct(&d, jsonDocument); } #endif // QT_BOOTSTRAPPED #endif // QT_NO_REGEXP @@ -2127,6 +2175,84 @@ QRegularExpression QVariant::toRegularExpression() const return qVariantToHelper(d, handlerManager); } #endif + +/*! + \since 5.0 + + Returns the variant as a QUuid if the variant has type() \l + QUuid; otherwise returns a default constructed QUuid. + + \sa canConvert(), convert() +*/ +QUuid QVariant::toUuid() const +{ + return qVariantToHelper(d, handlerManager); +} + +/*! + \since 5.0 + + Returns the variant as a QModelIndex if the variant has type() \l + QModelIndex; otherwise returns a default constructed QModelIndex. + + \sa canConvert(), convert() +*/ +QModelIndex QVariant::toModelIndex() const +{ + return qVariantToHelper(d, handlerManager); +} + +/*! + \since 5.0 + + Returns the variant as a QJsonValue if the variant has type() \l + QJsonValue; otherwise returns a default constructed QJsonValue. + + \sa canConvert(), convert() +*/ +QJsonValue QVariant::toJsonValue() const +{ + return qVariantToHelper(d, handlerManager); +} + +/*! + \since 5.0 + + Returns the variant as a QJsonObject if the variant has type() \l + QJsonObject; otherwise returns a default constructed QJsonObject. + + \sa canConvert(), convert() +*/ +QJsonObject QVariant::toJsonObject() const +{ + return qVariantToHelper(d, handlerManager); +} + +/*! + \since 5.0 + + Returns the variant as a QJsonArray if the variant has type() \l + QJsonArray; otherwise returns a default constructed QJsonArray. + + \sa canConvert(), convert() +*/ +QJsonArray QVariant::toJsonArray() const +{ + return qVariantToHelper(d, handlerManager); +} + +/*! + \since 5.0 + + Returns the variant as a QJsonDocument if the variant has type() \l + QJsonDocument; otherwise returns a default constructed QJsonDocument. + + \sa canConvert(), convert() +*/ +QJsonDocument QVariant::toJsonDocument() const +{ + return qVariantToHelper(d, handlerManager); +} #endif /*! diff --git a/src/corelib/kernel/qvariant.h b/src/corelib/kernel/qvariant.h index c06a441468..8d342cb122 100644 --- a/src/corelib/kernel/qvariant.h +++ b/src/corelib/kernel/qvariant.h @@ -247,6 +247,12 @@ class Q_CORE_EXPORT QVariant #ifndef QT_BOOTSTRAPPED QVariant(const QUrl &url); QVariant(const QEasingCurve &easing); + QVariant(const QUuid &uuid); + QVariant(const QModelIndex &modelIndex); + QVariant(const QJsonValue &jsonValue); + QVariant(const QJsonObject &jsonObject); + QVariant(const QJsonArray &jsonArray); + QVariant(const QJsonDocument &jsonDocument); #endif QVariant& operator=(const QVariant &other); @@ -314,6 +320,12 @@ class Q_CORE_EXPORT QVariant #ifndef QT_BOOTSTRAPPED QUrl toUrl() const; QEasingCurve toEasingCurve() const; + QUuid toUuid() const; + QModelIndex toModelIndex() const; + QJsonValue toJsonValue() const; + QJsonObject toJsonObject() const; + QJsonArray toJsonArray() const; + QJsonDocument toJsonDocument() const; #endif #ifndef QT_NO_DATASTREAM diff --git a/src/gui/painting/qpolygon.cpp b/src/gui/painting/qpolygon.cpp index d3d90ff6d2..06fec9a849 100644 --- a/src/gui/painting/qpolygon.cpp +++ b/src/gui/painting/qpolygon.cpp @@ -990,4 +990,9 @@ QPolygonF QPolygonF::subtracted(const QPolygonF &r) const return subject.subtracted(clip).toFillPolygon(); } +QPolygonF::operator QVariant() const +{ + return QVariant(QMetaType::QPolygonF, this); +} + QT_END_NAMESPACE diff --git a/src/gui/painting/qpolygon.h b/src/gui/painting/qpolygon.h index 726ed434ed..df94a2570e 100644 --- a/src/gui/painting/qpolygon.h +++ b/src/gui/painting/qpolygon.h @@ -142,6 +142,8 @@ public: /*implicit*/ QPolygonF(const QPolygon &a); inline void swap(QPolygonF &other) { QVector::swap(other); } // prevent QVector<->QPolygonF swaps + operator QVariant() const; + inline void translate(qreal dx, qreal dy); void translate(const QPointF &offset); diff --git a/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp b/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp index b6382d3896..7fc092b44d 100644 --- a/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp +++ b/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp @@ -234,6 +234,8 @@ private slots: void loadQt5Stream(); void saveQt5Stream_data(); void saveQt5Stream(); + + void implicitConstruction(); private: void dataStream_data(QDataStream::Version version); void loadQVariantFromDataStream(QDataStream::Version version); @@ -3254,5 +3256,53 @@ void tst_QVariant::debugStreamType() QVERIFY(msgHandler.testPassed()); } +void tst_QVariant::implicitConstruction() +{ + // This is a compile-time test + QVariant v; + +#define FOR_EACH_CORE_CLASS(F) \ + F(Char) \ + F(String) \ + F(StringList) \ + F(ByteArray) \ + F(BitArray) \ + F(Date) \ + F(Time) \ + F(DateTime) \ + F(Url) \ + F(Locale) \ + F(Rect) \ + F(RectF) \ + F(Size) \ + F(SizeF) \ + F(Line) \ + F(LineF) \ + F(Point) \ + F(PointF) \ + F(RegExp) \ + F(EasingCurve) \ + F(Uuid) \ + F(ModelIndex) \ + F(RegularExpression) \ + F(JsonValue) \ + F(JsonObject) \ + F(JsonArray) \ + F(JsonDocument) \ + +#define CONSTRUCT(TYPE) \ + { \ + Q##TYPE t; \ + v = t; \ + t = v.to##TYPE(); \ + QVERIFY(true); \ + } + + FOR_EACH_CORE_CLASS(CONSTRUCT) + +#undef CONSTRUCT +#undef FOR_EACH_CORE_CLASS +} + QTEST_MAIN(tst_QVariant) #include "tst_qvariant.moc" diff --git a/tests/auto/gui/kernel/qguivariant/test/tst_qguivariant.cpp b/tests/auto/gui/kernel/qguivariant/test/tst_qguivariant.cpp index 301d8891bb..5a8ff7b760 100644 --- a/tests/auto/gui/kernel/qguivariant/test/tst_qguivariant.cpp +++ b/tests/auto/gui/kernel/qguivariant/test/tst_qguivariant.cpp @@ -59,6 +59,8 @@ #include #include #include +#include +#include #include #include "tst_qvariant_common.h" @@ -118,6 +120,8 @@ private slots: void debugStream_data(); void debugStream(); + void implicitConstruction(); + void guiVariantAtExit(); }; @@ -626,6 +630,49 @@ void tst_QGuiVariant::debugStream() QVERIFY(msgHandler.testPassed()); } +void tst_QGuiVariant::implicitConstruction() +{ + // This is a compile-time test + QVariant v; + +#define FOR_EACH_GUI_CLASS(F) \ + F(Font) \ + F(Pixmap) \ + F(Brush) \ + F(Color) \ + F(Palette) \ + F(Icon) \ + F(Image) \ + F(Polygon) \ + F(Region) \ + F(Bitmap) \ + F(Cursor) \ + F(KeySequence) \ + F(Pen) \ + F(TextLength) \ + F(TextFormat) \ + F(Matrix) \ + F(Transform) \ + F(Matrix4x4) \ + F(Vector2D) \ + F(Vector3D) \ + F(Vector4D) \ + F(Quaternion) \ + F(PolygonF) \ + +#define CONSTRUCT(TYPE) \ + { \ + Q##TYPE t; \ + v = t; \ + QVERIFY(true); \ + } + + FOR_EACH_GUI_CLASS(CONSTRUCT) + +#undef CONSTRUCT +#undef FOR_EACH_GUI_CLASS +} + void tst_QGuiVariant::guiVariantAtExit() { // crash test, it should not crash at QGuiApplication exit diff --git a/tests/auto/widgets/kernel/qwidgetsvariant/tst_qwidgetsvariant.cpp b/tests/auto/widgets/kernel/qwidgetsvariant/tst_qwidgetsvariant.cpp index ccb9492a9a..90238b5d9b 100644 --- a/tests/auto/widgets/kernel/qwidgetsvariant/tst_qwidgetsvariant.cpp +++ b/tests/auto/widgets/kernel/qwidgetsvariant/tst_qwidgetsvariant.cpp @@ -69,6 +69,8 @@ private slots: void debugStream_data(); void debugStream(); + void implicitConstruction(); + void widgetsVariantAtExit(); }; @@ -254,5 +256,27 @@ void tst_QWidgetsVariant::widgetsVariantAtExit() QVERIFY(true); } + +void tst_QWidgetsVariant::implicitConstruction() +{ + // This is a compile-time test + QVariant v; + +#define FOR_EACH_WIDGETS_CLASS(F) \ + F(SizePolicy) \ + +#define CONSTRUCT(TYPE) \ + { \ + Q##TYPE t; \ + v = t; \ + QVERIFY(true); \ + } + + FOR_EACH_WIDGETS_CLASS(CONSTRUCT) + +#undef CONSTRUCT +#undef FOR_EACH_WIDGETS_CLASS +} + QTEST_MAIN(tst_QWidgetsVariant) #include "tst_qwidgetsvariant.moc" -- cgit v1.2.3