From d50360f5dd97505e057c1d0dc92717a745576feb Mon Sep 17 00:00:00 2001
From: Hendiadyoin1 <leon2002.la@gmail.com>
Date: Sun, 7 Nov 2021 14:52:20 +0100
Subject: [PATCH] AK: Allow hash-compatible key types in Hash[Table|Map] lookup

This will allow us to avoid some potentially expensive type conversion
during lookup, like form String to StringView, which would allocate
memory otherwise.
---
 AK/HashMap.h   | 46 ++++++++++++++++++++++++++++++++++++++++++++++
 AK/HashTable.h | 33 +++++++++++++++++++++++++++++++++
 2 files changed, 79 insertions(+)

diff --git a/AK/HashMap.h b/AK/HashMap.h
index 5303bdf32d..78a307e3ee 100644
--- a/AK/HashMap.h
+++ b/AK/HashMap.h
@@ -91,6 +91,19 @@ public:
         return m_table.find(hash, predicate);
     }
 
+    // FIXME: Use some sort of Traits to get the comparison operation
+    template<Concepts::HashCompatible<K> Key>
+    requires(IsSame<KeyTraits, Traits<K>>) [[nodiscard]] IteratorType find(Key const& value)
+    {
+        return m_table.find(Traits<Key>::hash(value), [&](auto& entry) { return value == entry.key; });
+    }
+
+    template<Concepts::HashCompatible<K> Key>
+    requires(IsSame<KeyTraits, Traits<K>>) [[nodiscard]] ConstIteratorType find(Key const& value) const
+    {
+        return m_table.find(Traits<Key>::hash(value), [&](auto& entry) { return value == entry.key; });
+    }
+
     void ensure_capacity(size_t capacity) { m_table.ensure_capacity(capacity); }
     ErrorOr<void> try_ensure_capacity(size_t capacity) { return m_table.try_ensure_capacity(capacity); }
 
@@ -118,11 +131,44 @@ public:
         return (*it).value;
     }
 
+    template<Concepts::HashCompatible<K> Key>
+    requires(IsSame<KeyTraits, Traits<K>>) Optional<typename Traits<V>::PeekType> get(const Key& key) const requires(!IsPointer<typename Traits<V>::PeekType>)
+    {
+        auto it = find(key);
+        if (it == end())
+            return {};
+        return (*it).value;
+    }
+
+    template<Concepts::HashCompatible<K> Key>
+    requires(IsSame<KeyTraits, Traits<K>>) Optional<typename Traits<V>::ConstPeekType> get(const Key& key) const requires(IsPointer<typename Traits<V>::PeekType>)
+    {
+        auto it = find(key);
+        if (it == end())
+            return {};
+        return (*it).value;
+    }
+
+    template<Concepts::HashCompatible<K> Key>
+    requires(IsSame<KeyTraits, Traits<K>>) Optional<typename Traits<V>::PeekType> get(const Key& key) requires(!IsConst<typename Traits<V>::PeekType>)
+    {
+        auto it = find(key);
+        if (it == end())
+            return {};
+        return (*it).value;
+    }
+
     [[nodiscard]] bool contains(const K& key) const
     {
         return find(key) != end();
     }
 
+    template<Concepts::HashCompatible<K> Key>
+    requires(IsSame<KeyTraits, Traits<K>>) [[nodiscard]] bool contains(Key const& value)
+    {
+        return find(value) != end();
+    }
+
     void remove(IteratorType it)
     {
         m_table.remove(it);
diff --git a/AK/HashTable.h b/AK/HashTable.h
index f736d5415b..5be70d5735 100644
--- a/AK/HashTable.h
+++ b/AK/HashTable.h
@@ -6,6 +6,7 @@
 
 #pragma once
 
+#include <AK/Concepts.h>
 #include <AK/Error.h>
 #include <AK/Forward.h>
 #include <AK/HashFunctions.h>
@@ -209,6 +210,12 @@ public:
         return find(value) != end();
     }
 
+    template<Concepts::HashCompatible<T> K>
+    requires(IsSame<TraitsForT, Traits<T>>) [[nodiscard]] bool contains(K const& value) const
+    {
+        return find(value) != end();
+    }
+
     using Iterator = Conditional<IsOrdered,
         OrderedHashTableIterator<HashTable, T, BucketType>,
         HashTableIterator<HashTable, T, BucketType>>;
@@ -329,6 +336,32 @@ public:
     {
         return find(TraitsForT::hash(value), [&](auto& other) { return TraitsForT::equals(value, other); });
     }
+    // FIXME: Use some Traits to get the comparison operation
+    // FIXME: Support for predicates, while guaranteeing that the predicate call
+    //        does not call a non trivial constructor each time invoked
+    template<Concepts::HashCompatible<T> K>
+    requires(IsSame<TraitsForT, Traits<T>>) [[nodiscard]] Iterator find(K const& value)
+    {
+        return find(Traits<K>::hash(value), [&](auto& other) { return value == other; });
+    }
+
+    template<Concepts::HashCompatible<T> K, typename TUnaryPredicate>
+    requires(IsSame<TraitsForT, Traits<T>>) [[nodiscard]] Iterator find(K const& value, TUnaryPredicate predicate)
+    {
+        return find(Traits<K>::hash(value), move(predicate));
+    }
+
+    template<Concepts::HashCompatible<T> K>
+    requires(IsSame<TraitsForT, Traits<T>>) [[nodiscard]] ConstIterator find(K const& value) const
+    {
+        return find(Traits<K>::hash(value), [&](auto& other) { return value == other; });
+    }
+
+    template<Concepts::HashCompatible<T> K, typename TUnaryPredicate>
+    requires(IsSame<TraitsForT, Traits<T>>) [[nodiscard]] ConstIterator find(K const& value, TUnaryPredicate predicate) const
+    {
+        return find(Traits<K>::hash(value), move(predicate));
+    }
 
     bool remove(const T& value)
     {