ladybird/AK/DoublyLinkedList.h

164 lines
4.3 KiB
C
Raw Normal View History

#pragma once
#include "StdLibExtras.h"
namespace AK {
template<typename T>
class DoublyLinkedList {
private:
struct Node {
explicit Node(const T& v) : value(v) { }
explicit Node(T&& v) : value(move(v)) { }
T value;
Node* next { nullptr };
Node* prev { nullptr };
};
public:
DoublyLinkedList() { }
~DoublyLinkedList() { clear(); }
2018-12-21 01:10:45 +00:00
bool is_empty() 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)
{
append_node(new Node(move(value)));
}
void append(const T& value)
{
append_node(new Node(value));
}
bool contains_slow(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) const { return m_node != other.m_node; }
bool operator==(const Iterator& other) const { return m_node == other.m_node; }
Iterator& operator++() { m_node = m_node->next; return *this; }
T& operator*() { return m_node->value; }
2019-01-19 21:53:05 +00:00
bool is_end() const { return !m_node; }
static Iterator universal_end() { 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); }
2019-01-19 21:53:05 +00:00
Iterator end() { return Iterator::universal_end(); }
class ConstIterator {
public:
bool operator!=(const ConstIterator& other) const { return m_node != other.m_node; }
bool operator==(const ConstIterator& other) const { return m_node == other.m_node; }
ConstIterator& operator++() { m_node = m_node->next; return *this; }
const T& operator*() const { return m_node->value; }
2019-01-19 21:53:05 +00:00
bool is_end() const { return !m_node; }
static ConstIterator universal_end() { 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); }
2019-01-19 21:53:05 +00:00
ConstIterator end() const { return ConstIterator::universal_end(); }
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) {
ASSERT(node != m_head);
node->prev->next = node->next;
} else {
ASSERT(node == m_head);
m_head = node->next;
}
if (node->next) {
ASSERT(node != m_tail);
node->next->prev = node->prev;
} else {
ASSERT(node == m_tail);
m_tail = node->prev;
}
delete node;
}
private:
friend class Iterator;
void append_node(Node* node)
{
if (!m_head) {
ASSERT(!m_tail);
m_head = node;
m_tail = node;
return;
}
ASSERT(m_tail);
m_tail->next = node;
node->prev = m_tail;
m_tail = node;
}
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;