mirror of
https://github.com/RGBCube/serenity
synced 2025-07-27 23:07:35 +00:00
AK+Kernel: Make IntrusiveList capable of holding non-raw pointers
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:
parent
fb814ee720
commit
e4412f1f59
11 changed files with 143 additions and 80 deletions
|
@ -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;
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue