RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-05-31 14:38:11 +00:00
Code Issues Activity Actions

AK+Everywhere: Reduce the number of template parameters of IntrusiveList

Browse source 
This makes the user-facing type only take the node member pointer, and
lets the compiler figure out the other needed types from that.
This commit is contained in:
Ali Mohammad Pur 2021-09-09 16:30:59 +04:30 • committed by Idan Horowitz
parent 93cf01ad7d
commit 5a0cdb15b0
41 changed files with 111 additions and 92 deletions
Download patch file Download diff file Expand all files Collapse all files

104
AK/IntrusiveList.h
View file

@ -13,29 +13,34 @@
#include <AK/Noncopyable.h> #include <AK/Noncopyable.h>
#include <AK/StdLibExtras.h> #include <AK/StdLibExtras.h>
namespace AK { namespace AK::Detail {
namespace Detail {
template<typename T, typename Container = RawPtr<T>> template<typename T, typename Container = RawPtr<T>>
class IntrusiveListNode; class IntrusiveListNode;
}
struct ExtractIntrusiveListTypes {
template<typename V, typename Container, typename T>
static V value(IntrusiveListNode<V, Container> T::*x);
template<typename V, typename Container, typename T>
static Container container(IntrusiveListNode<V, Container> T::*x);
};
template<typename T, typename Container = RawPtr<T>> template<typename T, typename Container = RawPtr<T>>
using IntrusiveListNode = Detail::IntrusiveListNode<T, typename Detail::SubstituteIntrusiveContainerType<T, Container>::Type>; using SubstitutedIntrusiveListNode = IntrusiveListNode<T, typename Detail::SubstituteIntrusiveContainerType<T, Container>::Type>;
template<typename T, typename Container> template<typename T, typename Container>
class IntrusiveListStorage { class IntrusiveListStorage {
private: private:
friend class Detail::IntrusiveListNode<T, Container>; friend class IntrusiveListNode<T, Container>;
template<class T_, typename Container_, IntrusiveListNode<T_, Container_> T_::*member> template<class T_, typename Container_, SubstitutedIntrusiveListNode<T_, Container_> T_::*member>
friend class IntrusiveList; friend class IntrusiveList;
IntrusiveListNode<T, Container>* m_first { nullptr }; SubstitutedIntrusiveListNode<T, Container>* m_first { nullptr };
IntrusiveListNode<T, Container>* m_last { nullptr }; SubstitutedIntrusiveListNode<T, Container>* m_last { nullptr };
}; };
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member> template<class T, typename Container, SubstitutedIntrusiveListNode<T, Container> T::*member>
class IntrusiveList { class IntrusiveList {
AK_MAKE_NONCOPYABLE(IntrusiveList); AK_MAKE_NONCOPYABLE(IntrusiveList);
AK_MAKE_NONMOVABLE(IntrusiveList); AK_MAKE_NONMOVABLE(IntrusiveList);
@ -144,12 +149,10 @@ private:
static T* prev(T* current); static T* prev(T* current);
static const T* next(const T* current); static const T* next(const T* current);
static const T* prev(const T* current); static const T* prev(const T* current);
static T* node_to_value(IntrusiveListNode<T, Container>& node); static T* node_to_value(SubstitutedIntrusiveListNode<T, Container>& node);
IntrusiveListStorage<T, Container> m_storage; IntrusiveListStorage<T, Container> m_storage;
}; };
namespace Detail {
template<typename T, typename Container> template<typename T, typename Container>
class IntrusiveListNode { class IntrusiveListNode {
public: public:
@ -159,23 +162,21 @@ public:
static constexpr bool IsRaw = IsPointer<Container>; static constexpr bool IsRaw = IsPointer<Container>;
// Note: For some reason, clang does not consider `member` as declared here, and as declared above (`IntrusiveListNode<T, Container> T::*`) // Note: For some reason, clang does not consider `member` as declared here, and as declared above (`SubstitutedIntrusiveListNode<T, Container> T::*`)
// to be of equal types. so for now, just make the members public on clang. // to be of equal types. so for now, just make the members public on clang.
#ifndef __clang__ #ifndef __clang__
private: private:
template<class T_, typename Container_, IntrusiveListNode<T_, Container_> T_::*member> template<class T_, typename Container_, SubstitutedIntrusiveListNode<T_, Container_> T_::*member>
friend class ::AK::IntrusiveList; friend class ::AK::Detail::IntrusiveList;
#endif #endif
IntrusiveListStorage<T, Container>* m_storage = nullptr; IntrusiveListStorage<T, Container>* m_storage = nullptr;
IntrusiveListNode<T, Container>* m_next = nullptr; SubstitutedIntrusiveListNode<T, Container>* m_next = nullptr;
IntrusiveListNode<T, Container>* m_prev = nullptr; SubstitutedIntrusiveListNode<T, Container>* m_prev = nullptr;
[[no_unique_address]] SelfReferenceIfNeeded<Container, IsRaw> m_self; [[no_unique_address]] SelfReferenceIfNeeded<Container, IsRaw> m_self;
}; };
} template<class T, typename Container, SubstitutedIntrusiveListNode<T, Container> T::*member>
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member>
inline typename IntrusiveList<T, Container, member>::Iterator& IntrusiveList<T, Container, member>::Iterator::erase() inline typename IntrusiveList<T, Container, member>::Iterator& IntrusiveList<T, Container, member>::Iterator::erase()
{ {
auto old = m_value; auto old = m_value;
@ -184,26 +185,26 @@ inline typename IntrusiveList<T, Container, member>::Iterator& IntrusiveList<T,
return *this; return *this;
} }
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member> template<class T, typename Container, SubstitutedIntrusiveListNode<T, Container> T::*member>
inline IntrusiveList<T, Container, member>::~IntrusiveList() inline IntrusiveList<T, Container, member>::~IntrusiveList()
{ {
clear(); clear();
} }
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member> template<class T, typename Container, SubstitutedIntrusiveListNode<T, Container> T::*member>
inline void IntrusiveList<T, Container, member>::clear() inline void IntrusiveList<T, Container, member>::clear()
{ {
while (m_storage.m_first) while (m_storage.m_first)
m_storage.m_first->remove(); m_storage.m_first->remove();
} }
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member> template<class T, typename Container, SubstitutedIntrusiveListNode<T, Container> T::*member>
inline bool IntrusiveList<T, Container, member>::is_empty() const inline bool IntrusiveList<T, Container, member>::is_empty() const
{ {
return m_storage.m_first == nullptr; return m_storage.m_first == nullptr;
} }
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member> template<class T, typename Container, SubstitutedIntrusiveListNode<T, Container> T::*member>
inline size_t IntrusiveList<T, Container, member>::size_slow() const inline size_t IntrusiveList<T, Container, member>::size_slow() const
{ {
size_t size = 0; size_t size = 0;
@ -214,7 +215,7 @@ inline size_t IntrusiveList<T, Container, member>::size_slow() const
return size; return size;
} }
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member> template<class T, typename Container, SubstitutedIntrusiveListNode<T, Container> T::*member>
inline void IntrusiveList<T, Container, member>::append(T& n) inline void IntrusiveList<T, Container, member>::append(T& n)
{ {
remove(n); remove(n);
@ -233,7 +234,7 @@ inline void IntrusiveList<T, Container, member>::append(T& n)
m_storage.m_first = &nnode; m_storage.m_first = &nnode;
} }
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member> template<class T, typename Container, SubstitutedIntrusiveListNode<T, Container> T::*member>
inline void IntrusiveList<T, Container, member>::prepend(T& n) inline void IntrusiveList<T, Container, member>::prepend(T& n)
{ {
remove(n); remove(n);
@ -252,7 +253,7 @@ inline void IntrusiveList<T, Container, member>::prepend(T& n)
m_storage.m_last = &nnode; m_storage.m_last = &nnode;
} }
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member> template<class T, typename Container, SubstitutedIntrusiveListNode<T, Container> T::*member>
inline void IntrusiveList<T, Container, member>::insert_before(T& bn, T& n) inline void IntrusiveList<T, Container, member>::insert_before(T& bn, T& n)
{ {
remove(n); remove(n);
@ -274,7 +275,7 @@ inline void IntrusiveList<T, Container, member>::insert_before(T& bn, T& n)
new_node.m_self.reference = &n; new_node.m_self.reference = &n;
} }
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member> template<class T, typename Container, SubstitutedIntrusiveListNode<T, Container> T::*member>
inline void IntrusiveList<T, Container, member>::remove(T& n) inline void IntrusiveList<T, Container, member>::remove(T& n)
{ {
auto& nnode = n.*member; auto& nnode = n.*member;
@ -282,20 +283,20 @@ inline void IntrusiveList<T, Container, member>::remove(T& n)
nnode.remove(); nnode.remove();
} }
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member> template<class T, typename Container, SubstitutedIntrusiveListNode<T, Container> T::*member>
inline bool IntrusiveList<T, Container, member>::contains(const T& n) const inline bool IntrusiveList<T, Container, member>::contains(const T& n) const
{ {
auto& nnode = n.*member; auto& nnode = n.*member;
return nnode.m_storage == &m_storage; return nnode.m_storage == &m_storage;
} }
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member> template<class T, typename Container, SubstitutedIntrusiveListNode<T, Container> T::*member>
inline Container IntrusiveList<T, Container, member>::first() const inline Container IntrusiveList<T, Container, member>::first() const
{ {
return m_storage.m_first ? node_to_value(*m_storage.m_first) : nullptr; return m_storage.m_first ? node_to_value(*m_storage.m_first) : nullptr;
} }
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member> template<class T, typename Container, SubstitutedIntrusiveListNode<T, Container> T::*member>
inline Container IntrusiveList<T, Container, member>::take_first() inline Container IntrusiveList<T, Container, member>::take_first()
{ {
if (Container ptr = first()) { if (Container ptr = first()) {
@ -305,7 +306,7 @@ inline Container IntrusiveList<T, Container, member>::take_first()
return nullptr; return nullptr;
} }
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member> template<class T, typename Container, SubstitutedIntrusiveListNode<T, Container> T::*member>
inline Container IntrusiveList<T, Container, member>::take_last() inline Container IntrusiveList<T, Container, member>::take_last()
{ {
if (Container ptr = last()) { if (Container ptr = last()) {
@ -315,13 +316,13 @@ inline Container IntrusiveList<T, Container, member>::take_last()
return nullptr; return nullptr;
} }
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member> template<class T, typename Container, SubstitutedIntrusiveListNode<T, Container> T::*member>
inline Container IntrusiveList<T, Container, member>::last() const inline Container IntrusiveList<T, Container, member>::last() const
{ {
return m_storage.m_last ? node_to_value(*m_storage.m_last) : nullptr; return m_storage.m_last ? node_to_value(*m_storage.m_last) : nullptr;
} }
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member> template<class T, typename Container, SubstitutedIntrusiveListNode<T, Container> T::*member>
inline const T* IntrusiveList<T, Container, member>::next(const T* current) inline const T* IntrusiveList<T, Container, member>::next(const T* current)
{ {
auto& nextnode = (current->*member).m_next; auto& nextnode = (current->*member).m_next;
@ -329,7 +330,7 @@ inline const T* IntrusiveList<T, Container, member>::next(const T* current)
return nextstruct; return nextstruct;
} }
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member> template<class T, typename Container, SubstitutedIntrusiveListNode<T, Container> T::*member>
inline const T* IntrusiveList<T, Container, member>::prev(const T* current) inline const T* IntrusiveList<T, Container, member>::prev(const T* current)
{ {
auto& prevnode = (current->*member).m_prev; auto& prevnode = (current->*member).m_prev;
@ -337,7 +338,7 @@ inline const T* IntrusiveList<T, Container, member>::prev(const T* current)
return prevstruct; return prevstruct;
} }
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member> template<class T, typename Container, SubstitutedIntrusiveListNode<T, Container> T::*member>
inline T* IntrusiveList<T, Container, member>::next(T* current) inline T* IntrusiveList<T, Container, member>::next(T* current)
{ {
auto& nextnode = (current->*member).m_next; auto& nextnode = (current->*member).m_next;
@ -345,7 +346,7 @@ inline T* IntrusiveList<T, Container, member>::next(T* current)
return nextstruct; return nextstruct;
} }
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member> template<class T, typename Container, SubstitutedIntrusiveListNode<T, Container> T::*member>
inline T* IntrusiveList<T, Container, member>::prev(T* current) inline T* IntrusiveList<T, Container, member>::prev(T* current)
{ {
auto& prevnode = (current->*member).m_prev; auto& prevnode = (current->*member).m_prev;
@ -353,26 +354,26 @@ inline T* IntrusiveList<T, Container, member>::prev(T* current)
return prevstruct; return prevstruct;
} }
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member> template<class T, typename Container, SubstitutedIntrusiveListNode<T, Container> T::*member>
inline typename IntrusiveList<T, Container, member>::Iterator IntrusiveList<T, Container, member>::begin() 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(); return m_storage.m_first ? Iterator(node_to_value(*m_storage.m_first)) : Iterator();
} }
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member> template<class T, typename Container, SubstitutedIntrusiveListNode<T, Container> T::*member>
inline typename IntrusiveList<T, Container, member>::ReverseIterator IntrusiveList<T, Container, member>::rbegin() inline typename IntrusiveList<T, Container, member>::ReverseIterator IntrusiveList<T, Container, member>::rbegin()
{ {
return m_storage.m_last ? ReverseIterator(node_to_value(*m_storage.m_last)) : ReverseIterator(); return m_storage.m_last ? ReverseIterator(node_to_value(*m_storage.m_last)) : ReverseIterator();
} }
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member> template<class T, typename Container, SubstitutedIntrusiveListNode<T, Container> T::*member>
inline typename IntrusiveList<T, Container, member>::ConstIterator IntrusiveList<T, Container, member>::begin() const 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(); return m_storage.m_first ? ConstIterator(node_to_value(*m_storage.m_first)) : ConstIterator();
} }
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member> template<class T, typename Container, SubstitutedIntrusiveListNode<T, Container> T::*member>
inline T* IntrusiveList<T, Container, member>::node_to_value(IntrusiveListNode<T, Container>& node) inline T* IntrusiveList<T, Container, member>::node_to_value(SubstitutedIntrusiveListNode<T, Container>& node)
{ {
// Note: Since this might seem odd, here's an explanation on what this function actually does: // 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 // `node` is a reference that resides in some part of the actual value (of type T), the
@ -383,8 +384,6 @@ inline T* IntrusiveList<T, Container, member>::node_to_value(IntrusiveListNode<T
return bit_cast<T*>(bit_cast<unsigned char*>(&node) - bit_cast<unsigned char*>(member)); return bit_cast<T*>(bit_cast<unsigned char*>(&node) - bit_cast<unsigned char*>(member));
} }
namespace Detail {
template<typename T, typename Container> template<typename T, typename Container>
inline IntrusiveListNode<T, Container>::~IntrusiveListNode() inline IntrusiveListNode<T, Container>::~IntrusiveListNode()
{ {
@ -416,13 +415,11 @@ inline bool IntrusiveListNode<T, Container>::is_in_list() const
return m_storage != nullptr; return m_storage != nullptr;
} }
}
// Specialise IntrusiveList for NonnullRefPtr // Specialise IntrusiveList for NonnullRefPtr
// By default, intrusive lists cannot contain null entries anyway, so switch to RefPtr // By default, intrusive lists cannot contain null entries anyway, so switch to RefPtr
// and just make the user-facing functions deref the pointers. // and just make the user-facing functions deref the pointers.
template<class T, IntrusiveListNode<T, NonnullRefPtr<T>> T::*member> template<class T, SubstitutedIntrusiveListNode<T, NonnullRefPtr<T>> T::*member>
class IntrusiveList<T, NonnullRefPtr<T>, member> : public IntrusiveList<T, RefPtr<T>, member> { class IntrusiveList<T, NonnullRefPtr<T>, member> : public IntrusiveList<T, RefPtr<T>, member> {
public: public:
[[nodiscard]] NonnullRefPtr<T> first() const { return *IntrusiveList<T, RefPtr<T>, member>::first(); } [[nodiscard]] NonnullRefPtr<T> first() const { return *IntrusiveList<T, RefPtr<T>, member>::first(); }
@ -434,5 +431,18 @@ public:
} }
namespace AK {
template<typename T, typename Container = RawPtr<T>>
using IntrusiveListNode = Detail::SubstitutedIntrusiveListNode<T, Container>;
template<auto member>
using IntrusiveList = Detail::IntrusiveList<
decltype(Detail::ExtractIntrusiveListTypes::value(member)),
decltype(Detail::ExtractIntrusiveListTypes::container(member)),
member>;
}
using AK::IntrusiveList; using AK::IntrusiveList;
using AK::IntrusiveListNode; using AK::IntrusiveListNode;

9
AK/IntrusiveListRelaxedConst.h
View file

@ -9,6 +9,7 @@
#include <AK/IntrusiveList.h> #include <AK/IntrusiveList.h>
namespace AK { namespace AK {
namespace Detail {
template<class T, typename Container, IntrusiveListNode<T, Container> T::*member> template<class T, typename Container, IntrusiveListNode<T, Container> T::*member>
class IntrusiveListRelaxedConst : public IntrusiveList<T, Container, member> { class IntrusiveListRelaxedConst : public IntrusiveList<T, Container, member> {
@ -26,4 +27,12 @@ public:
} }
template<auto member>
using IntrusiveListRelaxedConst = Detail::IntrusiveListRelaxedConst<
decltype(Detail::ExtractIntrusiveListTypes::value(member)),
decltype(Detail::ExtractIntrusiveListTypes::container(member)),
member>;
}
using AK::IntrusiveListRelaxedConst; using AK::IntrusiveListRelaxedConst;

2
AK/Queue.h
View file

@ -76,7 +76,7 @@ private:
IntrusiveListNode<QueueSegment> node; IntrusiveListNode<QueueSegment> node;
}; };
IntrusiveList<QueueSegment, RawPtr<QueueSegment>, &QueueSegment::node> m_segments; IntrusiveList<&QueueSegment::node> m_segments;
size_t m_index_into_first { 0 }; size_t m_index_into_first { 0 };
size_t m_size { 0 }; size_t m_size { 0 };
}; };

2
Kernel/Bus/USB/SysFSUSB.h
View file

@ -54,7 +54,7 @@ private:
RefPtr<SysFSUSBDeviceInformation> device_node_for(USB::Device& device); RefPtr<SysFSUSBDeviceInformation> device_node_for(USB::Device& device);
IntrusiveList<SysFSUSBDeviceInformation, RefPtr<SysFSUSBDeviceInformation>, &SysFSUSBDeviceInformation::m_list_node> m_device_nodes; IntrusiveList<&SysFSUSBDeviceInformation::m_list_node> m_device_nodes;
mutable Spinlock m_lock; mutable Spinlock m_lock;
}; };

2
Kernel/Bus/USB/USBController.h
View file

@ -33,7 +33,7 @@ private:
IntrusiveListNode<USBController, NonnullRefPtr<USBController>> m_controller_list_node; IntrusiveListNode<USBController, NonnullRefPtr<USBController>> m_controller_list_node;
public: public:
using List = IntrusiveList<USBController, NonnullRefPtr<USBController>, &USBController::m_controller_list_node>; using List = IntrusiveList<&USBController::m_controller_list_node>;
}; };
} }

2
Kernel/Bus/USB/USBDevice.h
View file

@ -64,6 +64,6 @@ private:
IntrusiveListNode<Device, NonnullRefPtr<Device>> m_hub_child_node; IntrusiveListNode<Device, NonnullRefPtr<Device>> m_hub_child_node;
public: public:
using List = IntrusiveList<Device, NonnullRefPtr<Device>, &Device::m_hub_child_node>; using List = IntrusiveList<&Device::m_hub_child_node>;
}; };
} }

2
Kernel/Devices/AsyncDeviceRequest.h
View file

@ -143,7 +143,7 @@ private:
RequestResult m_result { Pending }; RequestResult m_result { Pending };
IntrusiveListNode<AsyncDeviceRequest, RefPtr<AsyncDeviceRequest>> m_list_node; IntrusiveListNode<AsyncDeviceRequest, RefPtr<AsyncDeviceRequest>> m_list_node;
using AsyncDeviceSubRequestList = IntrusiveList<AsyncDeviceRequest, RefPtr<AsyncDeviceRequest>, &AsyncDeviceRequest::m_list_node>; using AsyncDeviceSubRequestList = IntrusiveList<&AsyncDeviceRequest::m_list_node>;
AsyncDeviceSubRequestList m_sub_requests_pending; AsyncDeviceSubRequestList m_sub_requests_pending;
AsyncDeviceSubRequestList m_sub_requests_complete; AsyncDeviceSubRequestList m_sub_requests_complete;

4
Kernel/FileSystem/BlockBasedFileSystem.cpp
View file

@ -97,8 +97,8 @@ public:
private: private:
BlockBasedFileSystem& m_fs; BlockBasedFileSystem& m_fs;
mutable HashMap<BlockBasedFileSystem::BlockIndex, CacheEntry*> m_hash; mutable HashMap<BlockBasedFileSystem::BlockIndex, CacheEntry*> m_hash;
mutable IntrusiveList<CacheEntry, RawPtr<CacheEntry>, &CacheEntry::list_node> m_clean_list; mutable IntrusiveList<&CacheEntry::list_node> m_clean_list;
mutable IntrusiveList<CacheEntry, RawPtr<CacheEntry>, &CacheEntry::list_node> m_dirty_list; mutable IntrusiveList<&CacheEntry::list_node> m_dirty_list;
NonnullOwnPtr<KBuffer> m_cached_block_data; NonnullOwnPtr<KBuffer> m_cached_block_data;
NonnullOwnPtr<KBuffer> m_entries; NonnullOwnPtr<KBuffer> m_entries;
bool m_dirty { false }; bool m_dirty { false };

2
Kernel/FileSystem/Custody.h
View file

@ -50,7 +50,7 @@ private:
mutable IntrusiveListNode<Custody> m_all_custodies_list_node; mutable IntrusiveListNode<Custody> m_all_custodies_list_node;
public: public:
using AllCustodiesList = IntrusiveList<Custody, RawPtr<Custody>, &Custody::m_all_custodies_list_node>; using AllCustodiesList = IntrusiveList<&Custody::m_all_custodies_list_node>;
}; };
} }

2
Kernel/FileSystem/DevTmpFS.h
View file

@ -143,7 +143,7 @@ protected:
DevTmpFSDirectoryInode(DevTmpFS&, NonnullOwnPtr<KString> name); DevTmpFSDirectoryInode(DevTmpFS&, NonnullOwnPtr<KString> name);
// ^Inode // ^Inode
OwnPtr<KString> m_name; OwnPtr<KString> m_name;
IntrusiveList<DevTmpFSInode, NonnullRefPtr<DevTmpFSInode>, &DevTmpFSInode::m_list_node> m_nodes; IntrusiveList<&DevTmpFSInode::m_list_node> m_nodes;
private: private:
explicit DevTmpFSDirectoryInode(DevTmpFS&); explicit DevTmpFSDirectoryInode(DevTmpFS&);

2
Kernel/FileSystem/Inode.h
View file

@ -134,7 +134,7 @@ private:
Vector<Flock> m_flocks; Vector<Flock> m_flocks;
public: public:
using AllInstancesList = IntrusiveList<Inode, RawPtr<Inode>, &Inode::m_inode_list_node>; using AllInstancesList = IntrusiveList<&Inode::m_inode_list_node>;
static SpinlockProtected<Inode::AllInstancesList>& all_instances(); static SpinlockProtected<Inode::AllInstancesList>& all_instances();
}; };

2
Kernel/FileSystem/SysFS.h
View file

@ -81,7 +81,7 @@ private:
}; };
class SysFSComponentRegistry { class SysFSComponentRegistry {
using DevicesList = MutexProtected<IntrusiveList<SysFSDeviceComponent, NonnullRefPtr<SysFSDeviceComponent>, &SysFSDeviceComponent::m_list_node>>; using DevicesList = MutexProtected<IntrusiveList<&SysFSDeviceComponent::m_list_node>>;
public: public:
static SysFSComponentRegistry& the(); static SysFSComponentRegistry& the();

2
Kernel/FileSystem/TmpFS.h
View file

@ -79,7 +79,7 @@ private:
NonnullOwnPtr<KString> name; NonnullOwnPtr<KString> name;
NonnullRefPtr<TmpFSInode> inode; NonnullRefPtr<TmpFSInode> inode;
IntrusiveListNode<Child> list_node {}; IntrusiveListNode<Child> list_node {};
using List = IntrusiveList<Child, RawPtr<Child>, &Child::list_node>; using List = IntrusiveList<&Child::list_node>;
}; };
Child* find_child_by_name(StringView); Child* find_child_by_name(StringView);

2
Kernel/Interrupts/GenericInterruptHandler.h
View file

@ -68,6 +68,6 @@ private:
IntrusiveListNode<GenericInterruptHandler> m_list_node; IntrusiveListNode<GenericInterruptHandler> m_list_node;
public: public:
using List = IntrusiveList<GenericInterruptHandler, RawPtr<GenericInterruptHandler>, &GenericInterruptHandler::m_list_node>; using List = IntrusiveList<&GenericInterruptHandler::m_list_node>;
}; };
} }

2
Kernel/Locking/Mutex.h
View file

@ -69,7 +69,7 @@ public:
} }
private: private:
using BlockedThreadList = IntrusiveList<Thread, RawPtr<Thread>, &Thread::m_blocked_threads_list_node>; using BlockedThreadList = IntrusiveList<&Thread::m_blocked_threads_list_node>;
ALWAYS_INLINE BlockedThreadList& thread_list_for_mode(Mode mode) ALWAYS_INLINE BlockedThreadList& thread_list_for_mode(Mode mode)
{ {

2
Kernel/Memory/PhysicalZone.h
View file

@ -89,7 +89,7 @@ private:
IntrusiveListNode<PhysicalZone> m_list_node; IntrusiveListNode<PhysicalZone> m_list_node;
public: public:
using List = IntrusiveList<PhysicalZone, RawPtr<PhysicalZone>, &PhysicalZone::m_list_node>; using List = IntrusiveList<&PhysicalZone::m_list_node>;
}; };
} }

4
Kernel/Memory/Region.h
View file

@ -217,8 +217,8 @@ private:
IntrusiveListNode<Region> m_vmobject_list_node; IntrusiveListNode<Region> m_vmobject_list_node;
public: public:
using ListInMemoryManager = IntrusiveList<Region, RawPtr<Region>, &Region::m_memory_manager_list_node>; using ListInMemoryManager = IntrusiveList<&Region::m_memory_manager_list_node>;
using ListInVMObject = IntrusiveList<Region, RawPtr<Region>, &Region::m_vmobject_list_node>; using ListInVMObject = IntrusiveList<&Region::m_vmobject_list_node>;
}; };
AK_ENUM_BITWISE_OPERATORS(Region::Access) AK_ENUM_BITWISE_OPERATORS(Region::Access)

2
Kernel/Memory/VMObject.h
View file

@ -73,7 +73,7 @@ private:
Region::ListInVMObject m_regions; Region::ListInVMObject m_regions;
public: public:
using AllInstancesList = IntrusiveList<VMObject, RawPtr<VMObject>, &VMObject::m_list_node>; using AllInstancesList = IntrusiveList<&VMObject::m_list_node>;
static SpinlockProtected<VMObject::AllInstancesList>& all_instances(); static SpinlockProtected<VMObject::AllInstancesList>& all_instances();
}; };

2
Kernel/Net/IPv4Socket.h
View file

@ -133,7 +133,7 @@ private:
IntrusiveListNode<IPv4Socket> m_list_node; IntrusiveListNode<IPv4Socket> m_list_node;
public: public:
using List = IntrusiveList<IPv4Socket, RawPtr<IPv4Socket>, &IPv4Socket::m_list_node>; using List = IntrusiveList<&IPv4Socket::m_list_node>;
static MutexProtected<IPv4Socket::List>& all_sockets(); static MutexProtected<IPv4Socket::List>& all_sockets();
}; };

2
Kernel/Net/LocalSocket.h
View file

@ -105,7 +105,7 @@ private:
IntrusiveListNode<LocalSocket> m_list_node; IntrusiveListNode<LocalSocket> m_list_node;
public: public:
using List = IntrusiveList<LocalSocket, RawPtr<LocalSocket>, &LocalSocket::m_list_node>; using List = IntrusiveList<&LocalSocket::m_list_node>;
}; };
} }

2
Kernel/Net/NetworkAdapter.h
View file

@ -111,7 +111,7 @@ private:
// FIXME: Make this configurable // FIXME: Make this configurable
static constexpr size_t max_packet_buffers = 1024; static constexpr size_t max_packet_buffers = 1024;
using PacketList = IntrusiveList<PacketWithTimestamp, RefPtr<PacketWithTimestamp>, &PacketWithTimestamp::packet_node>; using PacketList = IntrusiveList<&PacketWithTimestamp::packet_node>;
PacketList m_packet_queue; PacketList m_packet_queue;
size_t m_packet_queue_size { 0 }; size_t m_packet_queue_size { 0 };

2
Kernel/Net/TCPSocket.h
View file

@ -225,7 +225,7 @@ private:
IntrusiveListNode<TCPSocket> m_retransmit_list_node; IntrusiveListNode<TCPSocket> m_retransmit_list_node;
public: public:
using RetransmitList = IntrusiveList<TCPSocket, RawPtr<TCPSocket>, &TCPSocket::m_retransmit_list_node>; using RetransmitList = IntrusiveList<&TCPSocket::m_retransmit_list_node>;
static MutexProtected<TCPSocket::RetransmitList>& sockets_for_retransmit(); static MutexProtected<TCPSocket::RetransmitList>& sockets_for_retransmit();
}; };

2
Kernel/Process.h
View file

@ -807,7 +807,7 @@ private:
u8 m_protected_values_padding[PAGE_SIZE - sizeof(ProtectedValues)]; u8 m_protected_values_padding[PAGE_SIZE - sizeof(ProtectedValues)];
public: public:
using List = IntrusiveListRelaxedConst<Process, RawPtr<Process>, &Process::m_list_node>; using List = IntrusiveListRelaxedConst<&Process::m_list_node>;
}; };
// Note: Process object should be 2 pages of 4096 bytes each. // Note: Process object should be 2 pages of 4096 bytes each.

2
Kernel/ProcessGroup.h
View file

@ -40,7 +40,7 @@ private:
ProcessGroupID m_pgid; ProcessGroupID m_pgid;
public: public:
using List = IntrusiveList<ProcessGroup, RawPtr<ProcessGroup>, &ProcessGroup::m_list_node>; using List = IntrusiveList<&ProcessGroup::m_list_node>;
}; };
SpinlockProtected<ProcessGroup::List>& process_groups(); SpinlockProtected<ProcessGroup::List>& process_groups();

2
Kernel/Scheduler.cpp
View file

@ -38,7 +38,7 @@ Atomic<bool> g_finalizer_has_work { false };
READONLY_AFTER_INIT static Process* s_colonel_process; READONLY_AFTER_INIT static Process* s_colonel_process;
struct ThreadReadyQueue { struct ThreadReadyQueue {
IntrusiveList<Thread, RawPtr<Thread>, &Thread::m_ready_queue_node> thread_list; IntrusiveList<&Thread::m_ready_queue_node> thread_list;
}; };
struct ThreadReadyQueues { struct ThreadReadyQueues {

2
Kernel/Storage/StorageManagement.h
View file

@ -51,7 +51,7 @@ private:
String m_boot_argument; String m_boot_argument;
WeakPtr<BlockDevice> m_boot_block_device; WeakPtr<BlockDevice> m_boot_block_device;
NonnullRefPtrVector<StorageController> m_controllers; NonnullRefPtrVector<StorageController> m_controllers;
IntrusiveList<StorageDevice, RefPtr<StorageDevice>, &StorageDevice::m_list_node> m_storage_devices; IntrusiveList<&StorageDevice::m_list_node> m_storage_devices;
}; };
} }

2
Kernel/TTY/SlavePTY.h
View file

@ -49,7 +49,7 @@ private:
mutable IntrusiveListNode<SlavePTY> m_list_node; mutable IntrusiveListNode<SlavePTY> m_list_node;
public: public:
using List = IntrusiveList<SlavePTY, RawPtr<SlavePTY>, &SlavePTY::m_list_node>; using List = IntrusiveList<&SlavePTY::m_list_node>;
static SpinlockProtected<SlavePTY::List>& all_instances(); static SpinlockProtected<SlavePTY::List>& all_instances();
}; };

4
Kernel/Thread.h
View file

@ -1372,8 +1372,8 @@ private:
mutable IntrusiveListNode<Thread> m_global_thread_list_node; mutable IntrusiveListNode<Thread> m_global_thread_list_node;
public: public:
using ListInProcess = IntrusiveList<Thread, RawPtr<Thread>, &Thread::m_process_thread_list_node>; using ListInProcess = IntrusiveList<&Thread::m_process_thread_list_node>;
using GlobalList = IntrusiveList<Thread, RawPtr<Thread>, &Thread::m_global_thread_list_node>; using GlobalList = IntrusiveList<&Thread::m_global_thread_list_node>;
static SpinlockProtected<GlobalList>& all_instances(); static SpinlockProtected<GlobalList>& all_instances();
}; };

2
Kernel/TimerQueue.h
View file

@ -77,7 +77,7 @@ private:
public: public:
IntrusiveListNode<Timer> m_list_node; IntrusiveListNode<Timer> m_list_node;
using List = IntrusiveList<Timer, RawPtr<Timer>, &Timer::m_list_node>; using List = IntrusiveList<&Timer::m_list_node>;
}; };
class TimerQueue { class TimerQueue {

2
Kernel/WorkQueue.h
View file

@ -51,7 +51,7 @@ private:
RefPtr<Thread> m_thread; RefPtr<Thread> m_thread;
WaitQueue m_wait_queue; WaitQueue m_wait_queue;
IntrusiveList<WorkItem, RawPtr<WorkItem>, &WorkItem::m_node> m_items; IntrusiveList<&WorkItem::m_node> m_items;
Spinlock m_lock; Spinlock m_lock;
}; };

6
Tests/AK/TestIntrusiveList.cpp
View file

@ -15,7 +15,7 @@ public:
IntrusiveTestItem() = default; IntrusiveTestItem() = default;
IntrusiveListNode<IntrusiveTestItem> m_list_node; IntrusiveListNode<IntrusiveTestItem> m_list_node;
}; };
using IntrusiveTestList = IntrusiveList<IntrusiveTestItem, RawPtr<IntrusiveTestItem>, &IntrusiveTestItem::m_list_node>; using IntrusiveTestList = IntrusiveList<&IntrusiveTestItem::m_list_node>;
TEST_CASE(construct) TEST_CASE(construct)
{ {
@ -91,7 +91,7 @@ public:
IntrusiveRefPtrItem() = default; IntrusiveRefPtrItem() = default;
IntrusiveListNode<IntrusiveRefPtrItem, RefPtr<IntrusiveRefPtrItem>> m_list_node; IntrusiveListNode<IntrusiveRefPtrItem, RefPtr<IntrusiveRefPtrItem>> m_list_node;
}; };
using IntrusiveRefPtrList = IntrusiveList<IntrusiveRefPtrItem, RefPtr<IntrusiveRefPtrItem>, &IntrusiveRefPtrItem::m_list_node>; using IntrusiveRefPtrList = IntrusiveList<&IntrusiveRefPtrItem::m_list_node>;
TEST_CASE(intrusive_ref_ptr_no_ref_leaks) TEST_CASE(intrusive_ref_ptr_no_ref_leaks)
{ {
@ -138,7 +138,7 @@ public:
IntrusiveNonnullRefPtrItem() = default; IntrusiveNonnullRefPtrItem() = default;
IntrusiveListNode<IntrusiveNonnullRefPtrItem, NonnullRefPtr<IntrusiveNonnullRefPtrItem>> m_list_node; IntrusiveListNode<IntrusiveNonnullRefPtrItem, NonnullRefPtr<IntrusiveNonnullRefPtrItem>> m_list_node;
}; };
using IntrusiveNonnullRefPtrList = IntrusiveList<IntrusiveNonnullRefPtrItem, NonnullRefPtr<IntrusiveNonnullRefPtrItem>, &IntrusiveNonnullRefPtrItem::m_list_node>; using IntrusiveNonnullRefPtrList = IntrusiveList<&IntrusiveNonnullRefPtrItem::m_list_node>;
TEST_CASE(intrusive_nonnull_ref_ptr_intrusive) TEST_CASE(intrusive_nonnull_ref_ptr_intrusive)
{ {

2
Userland/Libraries/LibC/mallocdefs.h
View file

@ -75,5 +75,5 @@ struct ChunkedBlock : public CommonHeader {
size_t used_chunks() const { return chunk_capacity() - m_free_chunks; } size_t used_chunks() const { return chunk_capacity() - m_free_chunks; }
size_t chunk_capacity() const { return (block_size - sizeof(ChunkedBlock)) / m_size; } size_t chunk_capacity() const { return (block_size - sizeof(ChunkedBlock)) / m_size; }
using List = IntrusiveList<ChunkedBlock, RawPtr<ChunkedBlock>, &ChunkedBlock::m_list_node>; using List = IntrusiveList<&ChunkedBlock::m_list_node>;
}; };

4
Userland/Libraries/LibCore/Object.cpp
View file

@ -14,9 +14,9 @@
namespace Core { namespace Core {
IntrusiveList<Object, RawPtr<Object>, &Object::m_all_objects_list_node>& Object::all_objects() IntrusiveList<&Object::m_all_objects_list_node>& Object::all_objects()
{ {
static IntrusiveList<Object, RawPtr<Object>, &Object::m_all_objects_list_node> objects; static IntrusiveList<&Object::m_all_objects_list_node> objects;
return objects; return objects;
} }

2
Userland/Libraries/LibCore/Object.h
View file

@ -137,7 +137,7 @@ public:
JsonValue property(String const& name) const; JsonValue property(String const& name) const;
const HashMap<String, NonnullOwnPtr<Property>>& properties() const { return m_properties; } const HashMap<String, NonnullOwnPtr<Property>>& properties() const { return m_properties; }
static IntrusiveList<Object, RawPtr<Object>, &Object::m_all_objects_list_node>& all_objects(); static IntrusiveList<&Object::m_all_objects_list_node>& all_objects();
void dispatch_event(Core::Event&, Object* stay_within = nullptr); void dispatch_event(Core::Event&, Object* stay_within = nullptr);

2
Userland/Libraries/LibGUI/MouseTracker.h
View file

@ -26,7 +26,7 @@ protected:
private: private:
IntrusiveListNode<MouseTracker> m_list_node; IntrusiveListNode<MouseTracker> m_list_node;
using List = IntrusiveList<MouseTracker, RawPtr<MouseTracker>, &MouseTracker::m_list_node>; using List = IntrusiveList<&MouseTracker::m_list_node>;
static List s_trackers; static List s_trackers;
}; };

2
Userland/Libraries/LibJS/Heap/CellAllocator.h
View file

@ -43,7 +43,7 @@ public:
private: private:
const size_t m_cell_size; const size_t m_cell_size;
using BlockList = IntrusiveList<HeapBlock, RawPtr<HeapBlock>, &HeapBlock::m_list_node>; using BlockList = IntrusiveList<&HeapBlock::m_list_node>;
BlockList m_full_blocks; BlockList m_full_blocks;
BlockList m_usable_blocks; BlockList m_usable_blocks;
}; };

2
Userland/Libraries/LibJS/Heap/Handle.h
View file

@ -35,7 +35,7 @@ private:
IntrusiveListNode<HandleImpl> m_list_node; IntrusiveListNode<HandleImpl> m_list_node;
public: public:
using List = IntrusiveList<HandleImpl, RawPtr<HandleImpl>, &HandleImpl::m_list_node>; using List = IntrusiveList<&HandleImpl::m_list_node>;
}; };
template<class T> template<class T>

2
Userland/Libraries/LibJS/Runtime/MarkedValueList.h
View file

@ -39,7 +39,7 @@ private:
IntrusiveListNode<MarkedValueList> m_list_node; IntrusiveListNode<MarkedValueList> m_list_node;
public: public:
using List = IntrusiveList<MarkedValueList, RawPtr<MarkedValueList>, &MarkedValueList::m_list_node>; using List = IntrusiveList<&MarkedValueList::m_list_node>;
}; };
} }

2
Userland/Libraries/LibJS/Runtime/WeakContainer.h
View file

@ -27,7 +27,7 @@ private:
IntrusiveListNode<WeakContainer> m_list_node; IntrusiveListNode<WeakContainer> m_list_node;
public: public:
using List = IntrusiveList<WeakContainer, RawPtr<WeakContainer>, &WeakContainer::m_list_node>; using List = IntrusiveList<&WeakContainer::m_list_node>;
}; };
} }

2
Userland/Services/WindowServer/Compositor.h
View file

@ -220,7 +220,7 @@ private:
bool m_invalidated_cursor { false }; bool m_invalidated_cursor { false };
bool m_overlay_rects_changed { false }; bool m_overlay_rects_changed { false };
IntrusiveList<Overlay, RawPtr<Overlay>, &Overlay::m_list_node> m_overlay_list; IntrusiveList<&Overlay::m_list_node> m_overlay_list;
Gfx::DisjointRectSet m_overlay_rects; Gfx::DisjointRectSet m_overlay_rects;
Gfx::DisjointRectSet m_dirty_screen_rects; Gfx::DisjointRectSet m_dirty_screen_rects;
Gfx::DisjointRectSet m_opaque_wallpaper_rects; Gfx::DisjointRectSet m_opaque_wallpaper_rects;

2
Userland/Services/WindowServer/Window.h
View file

@ -469,7 +469,7 @@ private:
RefPtr<Animation> m_animation; RefPtr<Animation> m_animation;
public: public:
using List = IntrusiveList<Window, RawPtr<Window>, &Window::m_list_node>; using List = IntrusiveList<&Window::m_list_node>;
}; };
} }