17 #ifndef _TBB_intrusive_list_H 18 #define _TBB_intrusive_list_H 40 template <
class List,
class T>
52 template<
class Iterator>
54 Iterator&
self () {
return *
static_cast<Iterator*
>(
this); }
71 Iterator& operator = (
const Iterator& it ) {
72 return my_pos = it.my_pos;
75 Iterator& operator = (
const T& val ) {
76 return my_pos = &node(val);
80 return my_pos == it.my_pos;
84 return my_pos != it.my_pos;
87 Iterator& operator++ () {
92 Iterator& operator-- () {
97 Iterator operator++ (
int ) {
98 Iterator result =
self();
103 Iterator operator-- (
int ) {
104 Iterator result =
self();
112 (my_head.
my_next_node != &my_head && my_size >0),
"intrusive_list_base corrupted" );
113 #if TBB_USE_ASSERT >= 2 130 T* operator-> ()
const {
return &this->item(); }
132 T& operator* ()
const {
return this->item(); }
143 const T* operator-> ()
const {
return &this->item(); }
145 const T& operator* ()
const {
return this->item(); }
155 size_t size ()
const {
return my_size; }
159 iterator
end () {
return iterator(&my_head); }
163 const_iterator
end ()
const {
return const_iterator(&my_head); }
167 "Object with intrusive list node can be part of only one intrusive list simultaneously" );
169 node(val).my_prev_node = &my_head;
177 void remove( T& val ) {
181 node(val).my_next_node->my_prev_node = node(val).my_prev_node;
182 node(val).my_prev_node->my_next_node = node(val).my_next_node;
184 node(val).my_prev_node = node(val).my_next_node = &node(val);
208 template <
class T,
class U,
intrusive_list_node U::*NodePtr>
220 return *
reinterpret_cast<T*
>((
char*)node - ((ptrdiff_t)&(
reinterpret_cast<T*
>(0x1000)->*NodePtr) - 0x1000));
static T & item(intrusive_list_node *node)
Double linked list of items of type T containing a member of type intrusive_list_node.
intrusive_list_node * my_prev_node
intrusive_list_node * my_pos
Node the iterator points to at the moment.
static intrusive_list_node & node(T &item)
iterator_impl(intrusive_list_node *pos)
iterator erase(iterator it)
static intrusive_list_node & node(T &val)
List of element of type T, where T is derived from intrusive_list_node.
iterator(intrusive_list_node *pos)
intrusive_list_node my_head
Pointer to the head node.
const_iterator(const intrusive_list_node *pos)
size_t my_size
Number of list elements.
const_iterator begin() const
Data structure to be inherited by the types that can form intrusive lists.
static T & item(intrusive_list_node *node)
static T & item(intrusive_list_node *node)
#define __TBB_ASSERT(predicate, comment)
No-op version of __TBB_ASSERT.
static intrusive_list_node & node(T &val)
bool operator!=(const vector_iterator< Container, T > &i, const vector_iterator< Container, U > &j)
bool operator==(const vector_iterator< Container, T > &i, const vector_iterator< Container, U > &j)
Double linked list of items of type T that is derived from intrusive_list_node class.
intrusive_list_node * my_next_node
const_iterator end() const