Implement emplace() for QHash and QMultiHash

At the same time use the opportunity to refactor the
insertion code inside the implementation of QHash to
avoid copy and move constructors as much as possible
and always construct nodes in place.

Change-Id: I951b4cf2c77a17f7db825c6a776aae38c2662d23
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>

1 files changed, 79 insertions, 6 deletions

diff --git a/tests/auto/corelib/tools/qhash/tst_qhash.cpp b/tests/auto/corelib/tools/qhash/tst_qhash.cpp
index da1cb15cd8..c3e5d8d083 100644
--- a/tests/auto/corelib/tools/qhash/tst_qhash.cpp
+++ b/tests/auto/corelib/tools/qhash/tst_qhash.cpp
@@ -70,6 +70,8 @@ private slots:
     void equal_range();
     void insert_hash();
 
+    void emplace();
+
     void badHashFunction();
 };
 
@@ -96,26 +98,53 @@ int Foo::count = 0;
 class MyClass
 {
 public:
-    MyClass() { ++count;
+    MyClass()
+    {
+        ++count;
+    }
+    MyClass( const QString& c)
+    {
+        count++;
+        str = c;
     }
-    MyClass( const QString& c) {
-        count++; str = c;
+    MyClass(const QString &a, const QString &b)
+    {
+        count++;
+        str = a + b;
     }
     ~MyClass() {
         count--;
     }
     MyClass( const MyClass& c ) {
-        count++; str = c.str;
+        count++;
+        ++copies;
+        str = c.str;
     }
     MyClass &operator =(const MyClass &o) {
-        str = o.str; return *this;
+        str = o.str;
+        ++copies;
+        return *this;
+    }
+    MyClass(MyClass &&c) {
+        count++;
+        ++moves;
+        str = c.str;
+    }
+    MyClass &operator =(MyClass &&o) {
+        str = o.str;
+        ++moves;
+        return *this;
     }
 
     QString str;
     static int count;
+    static int copies;
+    static int moves;
 };
 
-int MyClass::count = 0;
+int MyClass::count  = 0;
+int MyClass::copies = 0;
+int MyClass::moves  = 0;
 
 typedef QHash<QString, MyClass> MyMap;
 
@@ -1650,6 +1679,50 @@ void tst_QHash::insert_hash()
     }
 }
 
+void tst_QHash::emplace()
+{
+    {
+        QHash<QString, MyClass> hash;
+        MyClass::copies = 0;
+        MyClass::moves = 0;
+
+        hash.emplace(QString("a"), QString("a"));
+        QCOMPARE(hash["a"].str, "a");
+        QCOMPARE(MyClass::copies, 0);
+        QCOMPARE(MyClass::moves, 0);
+        hash.emplace(QString("ab"), QString("ab"));
+        QCOMPARE(hash["ab"].str, "ab");
+        QCOMPARE(MyClass::copies, 0);
+        QCOMPARE(MyClass::moves, 0);
+        hash.emplace(QString("ab"), QString("abc"));
+        QCOMPARE(hash["ab"].str, "abc");
+        QCOMPARE(MyClass::copies, 0);
+        QCOMPARE(MyClass::moves, 1);
+    }
+    {
+        QMultiHash<QString, MyClass> hash;
+        MyClass::copies = 0;
+        MyClass::moves = 0;
+
+        hash.emplace(QString("a"), QString("a"));
+        QCOMPARE(hash["a"].str, "a");
+        QCOMPARE(MyClass::copies, 0);
+        QCOMPARE(MyClass::moves, 0);
+        hash.emplace(QString("ab"), QString("ab"));
+        QCOMPARE(hash["ab"].str, "ab");
+        QCOMPARE(MyClass::copies, 0);
+        QCOMPARE(MyClass::moves, 0);
+        hash.emplace(QString("ab"), QString("abc"));
+        QCOMPARE(hash["ab"].str, "abc");
+        QCOMPARE(MyClass::copies, 0);
+        QCOMPARE(MyClass::moves, 0);
+        hash.emplaceReplace(QString("ab"), QString("abcd"));
+        QCOMPARE(hash["ab"].str, "abcd");
+        QCOMPARE(MyClass::copies, 0);
+        QCOMPARE(MyClass::moves, 1);
+    }
+}
+
 struct BadKey {
     int k;
     BadKey(int i) : k(i) {}