AK: Make it possible to use HashMap<K, NonnullOwnPtr>::get()

Add the concept of a PeekType to Traits<T>. This is the type we'll
return (wrapped in an Optional) from HashMap::get().

The PeekType for OwnPtr<T> and NonnullOwnPtr<T> is const T*,
which means that HashMap::get() will return an Optional<const T*> for
maps-of-those.

AK/HashMap.h

@@ -68,7 +68,7 @@ class HashMap {
 
  void dump() const { m_table.dump(); }
 
- Optional<V> get(const K& key) const
+ Optional<typename Traits<V>::PeekType> get(const K& key) const
  {
  auto it = find(key);
  if (it == end())

AK/NonnullOwnPtr.h

@@ -142,6 +142,7 @@ make(Args&&... args)
 
 template<typename T>
 struct Traits<NonnullOwnPtr<T>> : public GenericTraits<NonnullOwnPtr<T>> {
+ using PeekType = const T*;
  static unsigned hash(const NonnullOwnPtr<T>& p) { return (unsigned)p.ptr(); }
  static void dump(const NonnullOwnPtr<T>& p) { kprintf("%p", p.ptr()); }
  static bool equals(const NonnullOwnPtr<T>& a, const NonnullOwnPtr<T>& b) { return a.ptr() == b.ptr(); }

AK/OwnPtr.h

@@ -164,6 +164,7 @@ class OwnPtr {
 
 template<typename T>
 struct Traits<OwnPtr<T>> : public GenericTraits<OwnPtr<T>> {
+ using PeekType = const T*;
  static unsigned hash(const OwnPtr<T>& p) { return (unsigned)p.ptr(); }
  static void dump(const OwnPtr<T>& p) { kprintf("%p", p.ptr()); }
  static bool equals(const OwnPtr<T>& a, const OwnPtr<T>& b) { return a.ptr() == b.ptr(); }

AK/RefPtr.h

@@ -183,6 +183,12 @@ class RefPtr {
  return exchange(m_ptr, nullptr);
  }
 
+ NonnullRefPtr<T> release_nonnull()
+ {
+ ASSERT(m_ptr);
+ return NonnullRefPtr<T>(NonnullRefPtr<T>::Adopt, *leak_ref());
+ }
+
  T* ptr() { return m_ptr; }
  const T* ptr() const { return m_ptr; }
 

AK/Tests/TestHashMap.cpp

@@ -76,4 +76,33 @@ TEST_CASE(assert_on_iteration_during_clear)
  map.clear();
 }
 
+TEST_CASE(hashmap_of_nonnullownptr_get)
+{
+ struct Object {
+ Object(const String& s) : string(s) {}
+ String string;
+ };
+
+ HashMap<int, NonnullOwnPtr<Object>> objects;
+ objects.set(1, make<Object>("One"));
+ objects.set(2, make<Object>("Two"));
+ objects.set(3, make<Object>("Three"));
+
+ {
+ auto x = objects.get(2);
+ EXPECT_EQ(x.has_value(), true);
+ EXPECT_EQ(x.value()->string, "Two");
+ }
+
+ {
+ // Do it again to make sure that peeking into the map above didn't
+ // remove the value from the map.
+ auto x = objects.get(2);
+ EXPECT_EQ(x.has_value(), true);
+ EXPECT_EQ(x.value()->string, "Two");
+ }
+
+ EXPECT_EQ(objects.size(), 3);
+}
+
 TEST_MAIN(HashMap)

AK/Traits.h

@@ -7,6 +7,7 @@ namespace AK {
 
 template<typename T>
 struct GenericTraits {
+ using PeekType = T;
  static constexpr bool is_trivial() { return false; }
  static bool equals(const T& a, const T& b) { return a == b; }
 };
@@ -44,7 +45,7 @@ struct Traits<char> : public GenericTraits<char> {
 };
 
 template<typename T>
-struct Traits<T*> {
+struct Traits<T*> : public GenericTraits<T*> {
  static unsigned hash(const T* p)
  {
  return int_hash((unsigned)(__PTRDIFF_TYPE__)p);