RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-27 16:27:35 +00:00
Code Issues Activity Actions

AK+Kernel: Make IntrusiveList capable of holding non-raw pointers

Browse source 
This should allow creating intrusive lists that have smart pointers,
while remaining free (compared to the impl before this commit) when
holding raw pointers :^)
As a sidenote, this also adds a `RawPtr<T>` type, which is just
equivalent to `T*`.
Note that this does not actually use such functionality, but is only
expected to pave the way for #6369, to replace NonnullRefPtrVector<T>
with intrusive lists.

As it is with zero-cost things, this makes the interface a bit less nice
by requiring the type name of what an `IntrusiveListNode` holds (and
optionally its container, if not RawPtr), and also requiring the type of
the container (normally `RawPtr`) on the `IntrusiveList` instance.
This commit is contained in:
AnotherTest 2021-04-16 16:33:24 +04:30 • committed by Andreas Kling
parent fb814ee720
commit e4412f1f59
11 changed files with 143 additions and 80 deletions
Download patch file Download diff file Expand all files Collapse all files

180
AK/IntrusiveList.h
View file

@ -28,20 +28,25 @@
#include <AK/Assertions.h>
#include <AK/BitCast.h>
#include <AK/Forward.h>
#include <AK/StdLibExtras.h>
namespace AK {
template<typename T, typename Container = RawPtr<T>>
class IntrusiveListNode;
template<typename T, typename Container>
class IntrusiveListStorage {
private:
friend class IntrusiveListNode;
template<class T, IntrusiveListNode T::*member>
friend class IntrusiveListNode<T, Container>;
template<class T_, typename Container_, IntrusiveListNode<T_, Container_> T_::*member>
friend class IntrusiveList;
IntrusiveListNode* m_first { nullptr };
IntrusiveListNode* m_last { nullptr };
IntrusiveListNode<T, Container>* m_first { nullptr };
IntrusiveListNode<T, Container>* m_last { nullptr };
};
template<class T, IntrusiveListNode T::*member>
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member>
class IntrusiveList {
public:
IntrusiveList();
@ -53,27 +58,29 @@ public:
void prepend(T& n);
void remove(T& n);
[[nodiscard]] bool contains(const T&) const;
[[nodiscard]] T* first() const;
[[nodiscard]] T* last() const;
[[nodiscard]] Container first() const;
[[nodiscard]] Container last() const;
[[nodiscard]] T* take_first();
[[nodiscard]] T* take_last();
[[nodiscard]] Container take_first();
[[nodiscard]] Container take_last();
class Iterator {
public:
Iterator() = default;
Iterator(T* value)
: m_value(value)
: m_value(move(value))
{
}
T& operator*() const { return *m_value; }
T* operator->() const { return m_value; }
const T& operator*() const { return *m_value; }
auto operator->() const { return m_value; }
T& operator*() { return *m_value; }
auto operator->() { return m_value; }
bool operator==(const Iterator& other) const { return other.m_value == m_value; }
bool operator!=(const Iterator& other) const { return !(*this == other); }
Iterator& operator++()
{
m_value = IntrusiveList<T, member>::next(m_value);
m_value = IntrusiveList<T, Container, member>::next(m_value);
return *this;
}
Iterator& erase();
@ -94,12 +101,12 @@ public:
}
const T& operator*() const { return *m_value; }
const T* operator->() const { return m_value; }
auto operator->() const { return m_value; }
bool operator==(const ConstIterator& other) const { return other.m_value == m_value; }
bool operator!=(const ConstIterator& other) const { return !(*this == other); }
ConstIterator& operator++()
{
m_value = IntrusiveList<T, member>::next(const_cast<T*>(m_value));
m_value = IntrusiveList<T, Container, member>::next(m_value);
return *this;
}
@ -112,68 +119,81 @@ public:
private:
static T* next(T* current);
static T* node_to_value(IntrusiveListNode& node);
IntrusiveListStorage m_storage;
static const T* next(const T* current);
static T* node_to_value(IntrusiveListNode<T, Container>& node);
IntrusiveListStorage<T, Container> m_storage;
};
template<typename Contained, bool _IsRaw>
struct SelfReferenceIfNeeded {
Contained reference = nullptr;
};
template<typename Contained>
struct SelfReferenceIfNeeded<Contained, true> {
};
template<typename T, typename Container>
class IntrusiveListNode {
public:
~IntrusiveListNode();
void remove();
bool is_in_list() const;
static constexpr bool IsRaw = IsPointer<Container>;
private:
template<class T, IntrusiveListNode T::*member>
template<class T_, typename Container_, IntrusiveListNode<T_, Container_> T_::*member>
friend class IntrusiveList;
IntrusiveListStorage* m_storage = nullptr;
IntrusiveListNode* m_next = nullptr;
IntrusiveListNode* m_prev = nullptr;
IntrusiveListStorage<T, Container>* m_storage = nullptr;
IntrusiveListNode<T, Container>* m_next = nullptr;
IntrusiveListNode<T, Container>* m_prev = nullptr;
SelfReferenceIfNeeded<Container, IsRaw> m_self;
};
template<class T, IntrusiveListNode T::*member>
inline typename IntrusiveList<T, member>::Iterator& IntrusiveList<T, member>::Iterator::erase()
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member>
inline typename IntrusiveList<T, Container, member>::Iterator& IntrusiveList<T, Container, member>::Iterator::erase()
{
T* old = m_value;
m_value = IntrusiveList<T, member>::next(m_value);
auto old = m_value;
m_value = IntrusiveList<T, Container, member>::next(m_value);
(old->*member).remove();
return *this;
}
template<class T, IntrusiveListNode T::*member>
inline IntrusiveList<T, member>::IntrusiveList()
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member>
inline IntrusiveList<T, Container, member>::IntrusiveList()
{
}
template<class T, IntrusiveListNode T::*member>
inline IntrusiveList<T, member>::~IntrusiveList()
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member>
inline IntrusiveList<T, Container, member>::~IntrusiveList()
{
clear();
}
template<class T, IntrusiveListNode T::*member>
inline void IntrusiveList<T, member>::clear()
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member>
inline void IntrusiveList<T, Container, member>::clear()
{
while (m_storage.m_first)
m_storage.m_first->remove();
}
template<class T, IntrusiveListNode T::*member>
inline bool IntrusiveList<T, member>::is_empty() const
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member>
inline bool IntrusiveList<T, Container, member>::is_empty() const
{
return m_storage.m_first == nullptr;
}
template<class T, IntrusiveListNode T::*member>
inline void IntrusiveList<T, member>::append(T& n)
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member>
inline void IntrusiveList<T, Container, member>::append(T& n)
{
auto& nnode = n.*member;
if (nnode.m_storage)
nnode.remove();
remove(n);
auto& nnode = n.*member;
nnode.m_storage = &m_storage;
nnode.m_prev = m_storage.m_last;
nnode.m_next = nullptr;
if constexpr (!RemoveReference<decltype(nnode)>::IsRaw)
nnode.m_self.reference = &n; // Note: Self-reference ensures that the object will keep a ref to itself when the Container is a smart pointer.
if (m_storage.m_last)
m_storage.m_last->m_next = &nnode;
@ -182,8 +202,8 @@ inline void IntrusiveList<T, member>::append(T& n)
m_storage.m_first = &nnode;
}
template<class T, IntrusiveListNode T::*member>
inline void IntrusiveList<T, member>::prepend(T& n)
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member>
inline void IntrusiveList<T, Container, member>::prepend(T& n)
{
auto& nnode = n.*member;
if (nnode.m_storage)
@ -192,6 +212,8 @@ inline void IntrusiveList<T, member>::prepend(T& n)
nnode.m_storage = &m_storage;
nnode.m_prev = nullptr;
nnode.m_next = m_storage.m_first;
if constexpr (!RemoveReference<decltype(nnode)>::IsRaw)
nnode.m_self.reference = &n;
if (m_storage.m_first)
m_storage.m_first->m_prev = &nnode;
@ -200,29 +222,29 @@ inline void IntrusiveList<T, member>::prepend(T& n)
m_storage.m_last = &nnode;
}
template<class T, IntrusiveListNode T::*member>
inline void IntrusiveList<T, member>::remove(T& n)
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member>
inline void IntrusiveList<T, Container, member>::remove(T& n)
{
auto& nnode = n.*member;
if (nnode.m_storage)
nnode.remove();
}
template<class T, IntrusiveListNode T::*member>
inline bool IntrusiveList<T, member>::contains(const T& n) const
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member>
inline bool IntrusiveList<T, Container, member>::contains(const T& n) const
{
auto& nnode = n.*member;
return nnode.m_storage == &m_storage;
}
template<class T, IntrusiveListNode T::*member>
inline T* IntrusiveList<T, member>::first() const
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member>
inline Container IntrusiveList<T, Container, member>::first() const
{
return m_storage.m_first ? node_to_value(*m_storage.m_first) : nullptr;
}
template<class T, IntrusiveListNode T::*member>
inline T* IntrusiveList<T, member>::take_first()
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member>
inline Container IntrusiveList<T, Container, member>::take_first()
{
if (auto* ptr = first()) {
remove(*ptr);
@ -231,8 +253,8 @@ inline T* IntrusiveList<T, member>::take_first()
return nullptr;
}
template<class T, IntrusiveListNode T::*member>
inline T* IntrusiveList<T, member>::take_last()
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member>
inline Container IntrusiveList<T, Container, member>::take_last()
{
if (auto* ptr = last()) {
remove(*ptr);
@ -241,34 +263,42 @@ inline T* IntrusiveList<T, member>::take_last()
return nullptr;
}
template<class T, IntrusiveListNode T::*member>
inline T* IntrusiveList<T, member>::last() const
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member>
inline Container IntrusiveList<T, Container, member>::last() const
{
return m_storage.m_last ? node_to_value(*m_storage.m_last) : nullptr;
}
template<class T, IntrusiveListNode T::*member>
inline T* IntrusiveList<T, member>::next(T* current)
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member>
inline const T* IntrusiveList<T, Container, member>::next(const T* current)
{
auto& nextnode = (current->*member).m_next;
const T* nextstruct = nextnode ? node_to_value(*nextnode) : nullptr;
return nextstruct;
}
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member>
inline T* IntrusiveList<T, Container, member>::next(T* current)
{
auto& nextnode = (current->*member).m_next;
T* nextstruct = nextnode ? node_to_value(*nextnode) : nullptr;
return nextstruct;
}
template<class T, IntrusiveListNode T::*member>
inline typename IntrusiveList<T, member>::Iterator IntrusiveList<T, member>::begin()
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member>
inline typename IntrusiveList<T, Container, member>::Iterator IntrusiveList<T, Container, member>::begin()
{
return m_storage.m_first ? Iterator(node_to_value(*m_storage.m_first)) : Iterator();
}
template<class T, IntrusiveListNode T::*member>
inline typename IntrusiveList<T, member>::ConstIterator IntrusiveList<T, member>::begin() const
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member>
inline typename IntrusiveList<T, Container, member>::ConstIterator IntrusiveList<T, Container, member>::begin() const
{
return m_storage.m_first ? ConstIterator(node_to_value(*m_storage.m_first)) : ConstIterator();
}
template<class T, IntrusiveListNode T::*member>
inline T* IntrusiveList<T, member>::node_to_value(IntrusiveListNode& node)
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member>
inline T* IntrusiveList<T, Container, member>::node_to_value(IntrusiveListNode<T, Container>& node)
{
// Note: Since this might seem odd, here's an explanation on what this function actually does:
// `node` is a reference that resides in some part of the actual value (of type T), the
@ -279,13 +309,15 @@ inline T* IntrusiveList<T, member>::node_to_value(IntrusiveListNode& node)
return bit_cast<T*>(bit_cast<unsigned char*>(&node) - bit_cast<unsigned char*>(member));
}
inline IntrusiveListNode::~IntrusiveListNode()
template<typename T, typename Container>
inline IntrusiveListNode<T, Container>::~IntrusiveListNode()
{
if (m_storage)
remove();
}
inline void IntrusiveListNode::remove()
template<typename T, typename Container>
inline void IntrusiveListNode<T, Container>::remove()
{
VERIFY(m_storage);
if (m_storage->m_first == this)
@ -299,13 +331,33 @@ inline void IntrusiveListNode::remove()
m_prev = nullptr;
m_next = nullptr;
m_storage = nullptr;
if constexpr (!IsRaw)
m_self.reference = nullptr;
}
inline bool IntrusiveListNode::is_in_list() const
template<typename T, typename Container>
inline bool IntrusiveListNode<T, Container>::is_in_list() const
{
return m_storage != nullptr;
}
// Specialise IntrusiveList(Node) for NonnullRefPtr
// By default, intrusive lists cannot contain null entries anyway, so switch to RefPtr
// and just make the user-facing functions deref the pointers.
template<typename T>
struct IntrusiveListNode<T, NonnullRefPtr<T>> : public IntrusiveListNode<T, RefPtr<T>> {
};
template<class T, IntrusiveListNode<T, NonnullRefPtr<T>> T::*member>
class IntrusiveList<T, NonnullRefPtr<T>, member> : public IntrusiveList<T, RefPtr<T>, member> {
public:
[[nodiscard]] NonnullRefPtr<T> first() const { return *IntrusiveList<T, RefPtr<T>, member>::first(); }
[[nodiscard]] NonnullRefPtr<T> last() const { return *IntrusiveList<T, RefPtr<T>, member>::last(); }
[[nodiscard]] NonnullRefPtr<T> take_first() { return *IntrusiveList<T, RefPtr<T>, member>::take_first(); }
[[nodiscard]] NonnullRefPtr<T> take_last() { return *IntrusiveList<T, RefPtr<T>, member>::take_last(); }
};
}
using AK::IntrusiveList;