Add a DoublyLinkedList template and start using it for HashTable.

AK/DoublyLinkedList.h

@@ -0,0 +1,142 @@
+#pragma once
+
+#include <utility>
+
+namespace AK {
+
+template<typename T>
+class DoublyLinkedList {
+private:
+    struct Node {
+        explicit Node(T&& v) : value(v) { }
+        T value;
+        Node* next { nullptr };
+        Node* prev { nullptr };
+    };
+
+public:
+    DoublyLinkedList() { }
+    ~DoublyLinkedList() { clear(); }
+
+    bool isEmpty() const { return !head(); }
+
+    void clear()
+    {
+        for (auto* node = m_head; node; ) {
+            auto* next = node->next;
+            delete node;
+            node = next;
+        }
+        m_head = nullptr;
+        m_tail = nullptr;
+    }
+
+    T& first() { ASSERT(head()); return head()->value; }
+    const T& first() const { ASSERT(head()); return head()->value; }
+    T& last() { ASSERT(head()); return tail()->value; }
+    const T& last() const { ASSERT(head()); return tail()->value; }
+
+    void append(T&& value)
+    {
+        auto* node = new Node(std::move(value));
+        if (!m_head) {
+            m_head = node;
+            m_tail = node;
+            return;
+        }
+        m_tail->next = node;
+        node->prev = m_tail;
+        m_tail = node;
+    }
+
+    bool containsSlow(const T& value) const
+    {
+        for (auto* node = m_head; node; node = node->next) {
+            if (node->value == value)
+                return true;
+        }
+        return false;
+    }
+
+    class Iterator {
+    public:
+        bool operator!=(const Iterator& other) { return m_node != other.m_node; }
+        Iterator& operator++() { m_node = m_node->next; return *this; }
+        T& operator*() { return m_node->value; }
+        bool isEnd() const { return !m_node; }
+        static Iterator universalEnd() { return Iterator(nullptr); }
+    private:
+        friend class DoublyLinkedList;
+        explicit Iterator(DoublyLinkedList::Node* node) : m_node(node) { }
+        DoublyLinkedList::Node* m_node;
+    };
+
+    Iterator begin() { return Iterator(m_head); }
+    Iterator end() { return Iterator::universalEnd(); }
+
+    class ConstIterator {
+    public:
+        bool operator!=(const ConstIterator& other) { return m_node != other.m_node; }
+        ConstIterator& operator++() { m_node = m_node->next; return *this; }
+        const T& operator*() const { return m_node->value; }
+        bool isEnd() const { return !m_node; }
+        static ConstIterator universalEnd() { return ConstIterator(nullptr); }
+    private:
+        friend class DoublyLinkedList;
+        explicit ConstIterator(const DoublyLinkedList::Node* node) : m_node(node) { }
+        const DoublyLinkedList::Node* m_node;
+    };
+
+    ConstIterator begin() const { return ConstIterator(m_head); }
+    ConstIterator end() const { return ConstIterator::universalEnd(); }
+
+    ConstIterator find(const T& value) const
+    {
+        for (auto* node = m_head; node; node = node->next) {
+            if (node->value == value)
+                return ConstIterator(node);
+        }
+        return end();
+    }
+
+    Iterator find(const T& value)
+    {
+        for (auto* node = m_head; node; node = node->next) {
+            if (node->value == value)
+                return Iterator(node);
+        }
+        return end();
+    }
+
+    void remove(Iterator& it)
+    {
+        ASSERT(it.m_node);
+        auto* node = it.m_node;
+        if (node->prev)
+            node->prev->next = node->next;
+        if (node->next)
+            node->next->prev = node->prev;
+        if (m_head == node)
+            m_head = node->next;
+        if (m_tail == node)
+            m_tail = node->prev;
+        delete node;
+    }
+
+private:
+    friend class Iterator;
+
+    Node* head() { return m_head; }
+    const Node* head() const { return m_head; }
+
+    Node* tail() { return m_tail; }
+    const Node* tail() const { return m_tail; }
+
+    Node* m_head { nullptr };
+    Node* m_tail { nullptr };
+};
+
+}
+
+using AK::DoublyLinkedList;
+

AK/HashTable.h

@@ -1,7 +1,7 @@
 #pragma once
 
 #include "Assertions.h"
-#include "SinglyLinkedList.h"
+#include "DoublyLinkedList.h"
 #include "Traits.h"
 #include <cstdlib>
 #include <utility>
@@ -16,7 +16,7 @@ template<typename T, typename TraitsForT>
 class HashTable {
 private:
     struct Bucket {
-        SinglyLinkedList<T> chain;
+        DoublyLinkedList<T> chain;
     };
 
 public:
@@ -104,12 +104,12 @@ public:
         }
     private:
         friend class HashTable;
-        explicit Iterator(HashTable& table, bool isEnd, typename SinglyLinkedList<T>::Iterator bucketIterator = SinglyLinkedList<T>::Iterator::universalEnd())
+        explicit Iterator(HashTable& table, bool isEnd, typename DoublyLinkedList<T>::Iterator bucketIterator = DoublyLinkedList<T>::Iterator::universalEnd())
             : m_table(table)
             , m_isEnd(isEnd)
             , m_bucketIterator(bucketIterator)
         {
-            if (!isEnd && !m_table.isEmpty() && !(m_bucketIterator != SinglyLinkedList<T>::Iterator::universalEnd())) {
+            if (!isEnd && !m_table.isEmpty() && !(m_bucketIterator != DoublyLinkedList<T>::Iterator::universalEnd())) {
 #ifdef HASHTABLE_DEBUG
                 printf("bucket iterator init!\n");
 #endif
@@ -122,7 +122,7 @@ public:
         HashTable& m_table;
         unsigned m_bucketIndex { 0 };
         bool m_isEnd { false };
-        typename SinglyLinkedList<T>::Iterator m_bucketIterator;
+        typename DoublyLinkedList<T>::Iterator m_bucketIterator;
     };
 
     Iterator begin() { return Iterator(*this, false); }
@@ -168,7 +168,7 @@ public:
                         m_isEnd = true;
                         return;
                     }
-                    const SinglyLinkedList<T>& chain = m_table.m_buckets[m_bucketIndex].chain;
+                    const DoublyLinkedList<T>& chain = m_table.m_buckets[m_bucketIndex].chain;
                     m_bucketIterator = chain.begin();
                 } else {
                     ++m_bucketIterator;
@@ -179,16 +179,16 @@ public:
         }
     private:
         friend class HashTable;
-        ConstIterator(const HashTable& table, bool isEnd, typename SinglyLinkedList<T>::ConstIterator bucketIterator = SinglyLinkedList<T>::ConstIterator::universalEnd())
+        ConstIterator(const HashTable& table, bool isEnd, typename DoublyLinkedList<T>::ConstIterator bucketIterator = DoublyLinkedList<T>::ConstIterator::universalEnd())
             : m_table(table)
             , m_isEnd(isEnd)
             , m_bucketIterator(bucketIterator)
         {
-            if (!isEnd && !m_table.isEmpty() && !(m_bucketIterator != SinglyLinkedList<T>::ConstIterator::universalEnd())) {
+            if (!isEnd && !m_table.isEmpty() && !(m_bucketIterator != DoublyLinkedList<T>::ConstIterator::universalEnd())) {
 #ifdef HASHTABLE_DEBUG
                 printf("bucket iterator init!\n");
 #endif
-                const SinglyLinkedList<T>& chain = m_table.m_buckets[0].chain;
+                const DoublyLinkedList<T>& chain = m_table.m_buckets[0].chain;
                 m_bucketIterator = chain.begin();
                 
                 skipToNext();
@@ -198,7 +198,7 @@ public:
         const HashTable& m_table;
         unsigned m_bucketIndex { 0 };
         bool m_isEnd { false };
-        typename SinglyLinkedList<T>::ConstIterator m_bucketIterator;
+        typename DoublyLinkedList<T>::ConstIterator m_bucketIterator;
     };
 
     ConstIterator begin() const { return ConstIterator(*this, false); }