Implement [variant.get] for QVariant [2/2]: get()

This second patch of the series implements get().

Unlike other get() implementations in Qt, don't use my trick with the
constrained friend free function here. Instead, provide the four
overloads manually, like mandated by the standard library for
std::variant (and, indeed, tuple), such that these functions can also
be used on subclasses of QVariant.

[ChangeLog][QtCore][QVariant] Implemented the type-based std::variant
access protocol (get<T>()/get_if<T>()) to allow easier access to the
contained element than the previous solution of casting data(), as
well as to allow generic code to treat QVariant and std::variant the
same. The holds_alternative<T>() function is not provided, since it's
the same as get_if<T> != nullptr. The index-based variant access
functions (get<I>()/get_if<I>()) are also not provided, because,
unlike std::variant, QVariant does not have a bounded number of
alternative types, and QMetaType IDs are not (all) compile-time
constants.

Fixes: QTBUG-111598
Change-Id: Id7bc41f7d91761b3483ec5604f1a4685c8079844
Reviewed-by: Fabian Kosmale <fabian.kosmale@qt.io>

1 files changed, 88 insertions, 1 deletions

diff --git a/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp b/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
index e5ffe14c97..cbe3f90b94 100644
--- a/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
+++ b/tests/auto/corelib/kernel/qvariant/tst_qvariant.cpp
@@ -17,9 +17,17 @@ constexpr inline bool my_is_same_v<T, T> = true;
 #define CHECK_GET_IF(Variant, cvref) \
     CHECK_IMPL(get_if, int, Variant, cvref *, int)
 
+#define CHECK_GET(Variant, cvref) \
+    CHECK_IMPL(get, int, Variant, cvref, int)
+
 CHECK_GET_IF(QVariant, /* unadorned */);
 CHECK_GET_IF(QVariant, const);
 
+CHECK_GET(QVariant, &);
+CHECK_GET(QVariant, const &);
+CHECK_GET(QVariant, &&);
+CHECK_GET(QVariant, const &&);
+
 // check for a type derived from QVariant:
 
 struct MyVariant : QVariant
@@ -30,7 +38,13 @@ struct MyVariant : QVariant
 CHECK_GET_IF(MyVariant, /* unadorned */);
 CHECK_GET_IF(MyVariant, const);
 
+CHECK_GET(MyVariant, &);
+CHECK_GET(MyVariant, const &);
+CHECK_GET(MyVariant, &&);
+CHECK_GET(MyVariant, const &&);
+
 #undef CHECK_GET_IF
+#undef CHECK_GET
 #undef CHECK_IMPL
 
 #include <QTest>
@@ -368,6 +382,10 @@ private slots:
     void getIf_QString() { getIf_impl(u"string"_s); };
     void getIf_NonDefaultConstructible();
 
+    void get_int() { get_impl(42); }
+    void get_QString() { get_impl(u"string"_s); }
+    void get_NonDefaultConstructible();
+
 private:
     using StdVariant = std::variant<std::monostate,
             // list here all the types with which we instantiate getIf_impl:
@@ -377,6 +395,8 @@ private:
         >;
     template <typename T>
     void getIf_impl(T t) const;
+    template <typename T>
+    void get_impl(T t) const;
     void dataStream_data(QDataStream::Version version);
     void loadQVariantFromDataStream(QDataStream::Version version);
     void saveQVariantFromDataStream(QDataStream::Version version);
@@ -5688,12 +5708,14 @@ void tst_QVariant::copyNonDefaultConstructible()
     QVERIFY(var.constData() != &ndc);
 
     // qvariant_cast<T> and QVariant::value<T> don't compile
-    QCOMPARE(*static_cast<const NonDefaultConstructible *>(var.constData()), ndc);
+    QCOMPARE(get<NonDefaultConstructible>(std::as_const(var)), ndc);
 
     QVariant var2 = var;
     var2.detach();      // force another copy
     QVERIFY(var2.isDetached());
     QVERIFY(var2.constData() != var.constData());
+    QCOMPARE(get<NonDefaultConstructible>(std::as_const(var2)),
+             get<NonDefaultConstructible>(std::as_const(var)));
     QCOMPARE(var2, var);
 }
 
@@ -5702,6 +5724,11 @@ void tst_QVariant::getIf_NonDefaultConstructible()
     getIf_impl(NonDefaultConstructible{42});
 }
 
+void tst_QVariant::get_NonDefaultConstructible()
+{
+    get_impl(NonDefaultConstructible{42});
+}
+
 template <typename T>
 T mutate(const T &t) { return t + t; }
 template <>
@@ -5813,5 +5840,65 @@ void tst_QVariant::getIf_impl(T t) const
     }
 }
 
+template <typename T>
+void tst_QVariant::get_impl(T t) const
+{
+    QVariant v = QVariant::fromValue(t);
+
+    // for behavioral comparison:
+    StdVariant stdv = t;
+
+    #define FOR_EACH_CVREF(op) \
+        op(/*unadorned*/, &&) \
+        op(&, &) \
+        op(&&, &&) \
+        op(const, const &&) \
+        op(const &, const &) \
+        op(const &&, const &&) \
+        /* end */
+
+
+    #define CHECK_RETURN_TYPE_OF(Variant, cvref_in, cvref_out) \
+        static_assert(std::is_same_v< \
+                decltype(get<T>(std::declval<Variant cvref_in >())), \
+                T cvref_out \
+            >); \
+        /* end */
+    #define CHECK_RETURN_TYPE(cvref_in, cvref_out) \
+        CHECK_RETURN_TYPE_OF(StdVariant, cvref_in, cvref_out) \
+        CHECK_RETURN_TYPE_OF(QVariant,   cvref_in, cvref_out) \
+        /* end */
+    FOR_EACH_CVREF(CHECK_RETURN_TYPE)
+    #undef CHECK_RETURN_TYPE
+
+    #undef FOR_EACH_CVREF
+
+    // const access:
+    {
+        auto &&rs = get<T>(std::as_const(stdv));
+        QCOMPARE_EQ(rs, t);
+
+        auto &&rv = get<T>(std::as_const(v));
+        QCOMPARE_EQ(rv, t);
+    }
+
+    // mutable access:
+    {
+        T t2 = mutate(t);
+
+        auto &&rs = get<T>(stdv);
+        QCOMPARE_EQ(rs, t);
+        rs = t2;
+        auto &&rs2 = get<T>(stdv);
+        QCOMPARE_EQ(rs2, t2);
+
+        auto &&rv = get<T>(v);
+        QCOMPARE_EQ(rv, t);
+        rv = t2;
+        auto &&rv2 = get<T>(v);
+        QCOMPARE_EQ(rv2, t2);
+    }
+}
+
 QTEST_MAIN(tst_QVariant)
 #include "tst_qvariant.moc"