QQmlValueTypeProvider: Use QMetaType

We can create, compare, convert registered types without going through
special virtual value type providers.

Change-Id: I0431256540b8dd6861ff3a945570ea7df45ed98d
Reviewed-by: Lars Knoll <lars.knoll@qt.io>

1 files changed, 0 insertions, 136 deletions

diff --git a/src/quick/util/qquickglobal.cpp b/src/quick/util/qquickglobal.cpp
index e6000e352a..bf636407ed 100644
--- a/src/quick/util/qquickglobal.cpp
+++ b/src/quick/util/qquickglobal.cpp
@@ -607,39 +607,6 @@ public:
         return nullptr;
     }
 
-    bool init(int type, QVariant& dst) override
-    {
-        switch (type) {
-        case QMetaType::QColor:
-            dst.setValue<QColor>(QColor());
-            return true;
-        case QMetaType::QColorSpace:
-            dst.setValue<QColorSpace>(QColorSpace());
-            return true;
-        case QMetaType::QFont:
-            dst.setValue<QFont>(QFont());
-            return true;
-        case QMetaType::QVector2D:
-            dst.setValue<QVector2D>(QVector2D());
-            return true;
-        case QMetaType::QVector3D:
-            dst.setValue<QVector3D>(QVector3D());
-            return true;
-        case QMetaType::QVector4D:
-            dst.setValue<QVector4D>(QVector4D());
-            return true;
-        case QMetaType::QQuaternion:
-            dst.setValue<QQuaternion>(QQuaternion());
-            return true;
-        case QMetaType::QMatrix4x4:
-            dst.setValue<QMatrix4x4>(QMatrix4x4());
-            return true;
-        default: break;
-        }
-
-        return false;
-    }
-
     bool create(int type, int argc, const void *argv[], QVariant *v) override
     {
         switch (type) {
@@ -797,37 +764,6 @@ public:
     }
 
     template<typename T>
-    bool typedEqual(const void *lhs, const QVariant& rhs)
-    {
-        return (*(reinterpret_cast<const T *>(lhs)) == rhs.value<T>());
-    }
-
-    bool equal(int type, const void *lhs, const QVariant &rhs) override
-    {
-        switch (type) {
-        case QMetaType::QColor:
-            return typedEqual<QColor>(lhs, rhs);
-        case QMetaType::QColorSpace:
-            return typedEqual<QColorSpace>(lhs, rhs);
-        case QMetaType::QFont:
-            return typedEqual<QFont>(lhs, rhs);
-        case QMetaType::QVector2D:
-            return typedEqual<QVector2D>(lhs, rhs);
-        case QMetaType::QVector3D:
-            return typedEqual<QVector3D>(lhs, rhs);
-        case QMetaType::QVector4D:
-            return typedEqual<QVector4D>(lhs, rhs);
-        case QMetaType::QQuaternion:
-            return typedEqual<QQuaternion>(lhs, rhs);
-        case QMetaType::QMatrix4x4:
-            return typedEqual<QMatrix4x4>(lhs, rhs);
-        default: break;
-        }
-
-        return false;
-    }
-
-    template<typename T>
     bool typedStore(const void *src, void *dst, size_t dstSize)
     {
         ASSERT_VALID_SIZE(dstSize, sizeof(T));
@@ -855,78 +791,6 @@ public:
         return false;
     }
 
-    template<typename T>
-    bool typedRead(const QVariant& src, int dstType, void *dst)
-    {
-        T *dstT = reinterpret_cast<T *>(dst);
-        if (src.userType() == dstType) {
-            *dstT = src.value<T>();
-        } else {
-            *dstT = T();
-        }
-        return true;
-    }
-
-    bool read(const QVariant &src, void *dst, int dstType) override
-    {
-        switch (dstType) {
-        case QMetaType::QColor:
-            return typedRead<QColor>(src, dstType, dst);
-        case QMetaType::QColorSpace:
-            return typedRead<QColorSpace>(src, dstType, dst);
-        case QMetaType::QFont:
-            return typedRead<QFont>(src, dstType, dst);
-        case QMetaType::QVector2D:
-            return typedRead<QVector2D>(src, dstType, dst);
-        case QMetaType::QVector3D:
-            return typedRead<QVector3D>(src, dstType, dst);
-        case QMetaType::QVector4D:
-            return typedRead<QVector4D>(src, dstType, dst);
-        case QMetaType::QQuaternion:
-            return typedRead<QQuaternion>(src, dstType, dst);
-        case QMetaType::QMatrix4x4:
-            return typedRead<QMatrix4x4>(src, dstType, dst);
-        default: break;
-        }
-
-        return false;
-    }
-
-    template<typename T>
-    bool typedWrite(const void *src, QVariant& dst)
-    {
-        const T *srcT = reinterpret_cast<const T *>(src);
-        if (dst.value<T>() != *srcT) {
-            dst = *srcT;
-            return true;
-        }
-        return false;
-    }
-
-    bool write(int type, const void *src, QVariant& dst) override
-    {
-        switch (type) {
-        case QMetaType::QColor:
-            return typedWrite<QColor>(src, dst);
-        case QMetaType::QColorSpace:
-            return typedWrite<QColorSpace>(src, dst);
-        case QMetaType::QFont:
-            return typedWrite<QFont>(src, dst);
-        case QMetaType::QVector2D:
-            return typedWrite<QVector2D>(src, dst);
-        case QMetaType::QVector3D:
-            return typedWrite<QVector3D>(src, dst);
-        case QMetaType::QVector4D:
-            return typedWrite<QVector4D>(src, dst);
-        case QMetaType::QQuaternion:
-            return typedWrite<QQuaternion>(src, dst);
-        case QMetaType::QMatrix4x4:
-            return typedWrite<QMatrix4x4>(src, dst);
-        default: break;
-        }
-
-        return false;
-    }
 #undef ASSERT_VALID_SIZE
 };