From ba24125cbfdbe78b48e8000ee6030f0d81a86491 Mon Sep 17 00:00:00 2001
From: Thiago Macieira <thiago.macieira@intel.com>
Date: Tue, 5 Mar 2024 16:48:57 -0800
Subject: [PATCH] QHash/QMultiHash: further simplify the key() and value()
 overloads
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Complements commit 7fe5611365aa9d5065fe8ba62fed9a07c722ea1c by moving
the default value selection into a lambda that is passed to the Impl
function. This makes the two pairs of overloads in each of the classes
be a single line.

Change-Id: I6818d78a57394e37857bfffd17ba067beb3a42fa
Reviewed-by: Mårten Nordheim <marten.nordheim@qt.io>
---
 src/corelib/tools/qhash.h | 64 ++++++++++++---------------------------
 1 file changed, 20 insertions(+), 44 deletions(-)

diff --git a/src/corelib/tools/qhash.h b/src/corelib/tools/qhash.h
index 216d710cc9..cdb4c119cf 100644
--- a/src/corelib/tools/qhash.h
+++ b/src/corelib/tools/qhash.h
@@ -1000,61 +1000,49 @@ public:
     }
 
 private:
-    const Key *keyImpl(const T &value) const noexcept
+    template <typename Fn> Key keyImpl(const T &value, Fn &&defaultFn) const noexcept
     {
         if (d) {
             const_iterator i = begin();
             while (i != end()) {
                 if (i.value() == value)
-                    return &i.key();
+                    return i.key();
                 ++i;
             }
         }
 
-        return nullptr;
+        return defaultFn();
     }
 
 public:
     Key key(const T &value) const noexcept
     {
-        if (auto *k = keyImpl(value))
-            return *k;
-        else
-            return Key();
+        return keyImpl(value, [] { return Key(); });
     }
     Key key(const T &value, const Key &defaultKey) const noexcept
     {
-        if (auto *k = keyImpl(value))
-            return *k;
-        else
-            return defaultKey;
+        return keyImpl(value, [&] { return defaultKey; });
     }
 
 private:
-    T *valueImpl(const Key &key) const noexcept
+    template <typename Fn> T valueImpl(const Key &key, Fn &&defaultValue) const noexcept
     {
         if (d) {
             Node *n = d->findNode(key);
             if (n)
-                return &n->value;
+                return n->value;
         }
-        return nullptr;
+        return defaultValue();
     }
 public:
     T value(const Key &key) const noexcept
     {
-        if (T *v = valueImpl(key))
-            return *v;
-        else
-            return T();
+        return valueImpl(key, [] { return T(); });
     }
 
     T value(const Key &key, const T &defaultValue) const noexcept
     {
-        if (T *v = valueImpl(key))
-            return *v;
-        else
-            return defaultValue;
+        return valueImpl(key, [&] { return defaultValue; });
     }
 
     T &operator[](const Key &key)
@@ -1572,62 +1560,50 @@ public:
     }
 
 private:
-    const Key *keyImpl(const T &value) const noexcept
+    template <typename Fn> Key keyImpl(const T &value, Fn &&defaultValue) const noexcept
     {
         if (d) {
             auto i = d->begin();
             while (i != d->end()) {
                 Chain *e = i.node()->value;
                 if (e->contains(value))
-                    return &i.node()->key;
+                    return i.node()->key;
                 ++i;
             }
         }
 
-        return nullptr;
+        return defaultValue();
     }
 public:
     Key key(const T &value) const noexcept
     {
-        if (auto *k = keyImpl(value))
-            return *k;
-        else
-            return Key();
+        return keyImpl(value, [] { return Key(); });
     }
     Key key(const T &value, const Key &defaultKey) const noexcept
     {
-        if (auto *k = keyImpl(value))
-            return *k;
-        else
-            return defaultKey;
+        return keyImpl(value, [&] { return defaultKey; });
     }
 
 private:
-    T *valueImpl(const Key &key) const noexcept
+    template <typename Fn> T valueImpl(const Key &key, Fn &&defaultValue) const noexcept
     {
         if (d) {
             Node *n = d->findNode(key);
             if (n) {
                 Q_ASSERT(n->value);
-                return &n->value->value;
+                return n->value->value;
             }
         }
-        return nullptr;
+        return defaultValue();
     }
 public:
     T value(const Key &key) const noexcept
     {
-        if (auto *v = valueImpl(key))
-            return *v;
-        else
-            return T();
+        return valueImpl(key, [] { return T(); });
     }
     T value(const Key &key, const T &defaultValue) const noexcept
     {
-        if (auto *v = valueImpl(key))
-            return *v;
-        else
-            return defaultValue;
+        return valueImpl(key, [&] { return defaultValue; });
     }
 
     T &operator[](const Key &key)