distortos  v0.4.0
object-oriented C++ RTOS for microcontrollers
IntrusiveList.hpp
Go to the documentation of this file.
1 
12 #ifndef ESTD_INTRUSIVELIST_HPP_
13 #define ESTD_INTRUSIVELIST_HPP_
14 
15 #include <iterator>
16 
17 #include <cstddef>
18 
19 namespace estd
20 {
21 
22 namespace internal
23 {
24 
25 class IntrusiveListBase;
26 
27 }
28 
39 {
40 public:
41 
45  {
47 
52  constexpr LinkAccessKey()
53  {
54 
55  }
56 
57  LinkAccessKey(const LinkAccessKey&) = delete;
58  LinkAccessKey(LinkAccessKey&&) = delete;
59  const LinkAccessKey& operator=(const LinkAccessKey&) = delete;
60  LinkAccessKey& operator=(LinkAccessKey&&) = delete;
61  };
62 
67  constexpr IntrusiveListNode() :
68  nextNode_{this},
69  previousNode_{this}
70  {
71 
72  }
73 
81  {
82  if (other.isLinked() == false)
83  {
84  reset();
85  return;
86  }
87 
88  nextNode_ = other.nextNode_;
89  previousNode_ = other.previousNode_;
90  nextNode_->previousNode_ = previousNode_->nextNode_ = this;
91  other.reset();
92  }
93 
101  {
102  unlink();
103  }
104 
110  {
111  return *nextNode_;
112  }
113 
119  {
120  return *previousNode_;
121  }
122 
127  bool isLinked() const
128  {
129  return nextNode_ != this;
130  }
131 
142  {
143  unlink();
144 
145  nextNode_ = &position;
146  previousNode_ = position.previousNode_;
147  position.previousNode_->nextNode_ = this;
148  position.previousNode_ = this;
149  }
150 
157  void swap(IntrusiveListNode& other)
158  {
159  const auto thisWasLinked = isLinked();
160  const auto otherWasLinked = other.isLinked();
161 
162  if (thisWasLinked == true || otherWasLinked == true)
163  {
164  using std::swap;
165  swap(nextNode_, other.nextNode_);
166  swap(previousNode_, other.previousNode_);
167 
168  if (thisWasLinked == true)
169  other.nextNode_->previousNode_ = other.previousNode_->nextNode_ = &other;
170  else
171  other.reset();
172 
173  if (otherWasLinked == true)
174  nextNode_->previousNode_ = previousNode_->nextNode_ = this;
175  else
176  reset();
177  }
178  }
179 
184  void unlink()
185  {
186  previousNode_->nextNode_ = nextNode_;
187  nextNode_->previousNode_ = previousNode_;
188 
189  reset();
190  }
191 
192  IntrusiveListNode(const IntrusiveListNode&) = delete;
193  const IntrusiveListNode& operator=(const IntrusiveListNode&) = delete;
194  IntrusiveListNode& operator=(IntrusiveListNode&&) = delete;
195 
196 private:
197 
202  void reset()
203  {
204  nextNode_ = this;
205  previousNode_ = this;
206  }
207 
210 
213 };
214 
215 namespace internal
216 {
217 
226 {
227 public:
228 
233  constexpr IntrusiveListBase() :
234  rootNode_{}
235  {
236 
237  }
238 
246  {
247  clear();
248  }
249 
255  {
256  return rootNode_.getNextNode();
257  }
258 
263  const IntrusiveListNode& begin() const
264  {
265  return rootNode_.getNextNode();
266  }
267 
272  const IntrusiveListNode& cbegin() const
273  {
274  return begin();
275  }
276 
281  const IntrusiveListNode& cend() const
282  {
283  return end();
284  }
285 
290  void clear()
291  {
292  while (empty() == false)
293  pop_front();
294  }
295 
300  bool empty() const
301  {
302  return &begin() == &end();
303  }
304 
310  {
311  return rootNode_;
312  }
313 
318  const IntrusiveListNode& end() const
319  {
320  return rootNode_;
321  }
322 
327  void pop_back()
328  {
329  erase(end().getPreviousNode());
330  }
331 
336  void pop_front()
337  {
338  erase(begin());
339  }
340 
348  {
349  insert(end(), newNode);
350  }
351 
359  {
360  insert(begin(), newNode);
361  }
362 
369  void swap(IntrusiveListBase& other)
370  {
371  rootNode_.swap(other.rootNode_);
372  }
373 
385  {
386  auto& next = position.getNextNode();
387  position.unlink();
388  return next;
389  }
390 
400  static void insert(IntrusiveListNode& position, IntrusiveListNode& newNode)
401  {
402  newNode.link(position, {});
403  }
404 
414  static void splice(IntrusiveListNode& position, IntrusiveListNode& splicedNode)
415  {
416  insert(position, splicedNode);
417  }
418 
419  IntrusiveListBase(const IntrusiveListBase&) = delete;
421  const IntrusiveListBase& operator=(const IntrusiveListBase&) = delete;
422  IntrusiveListBase& operator=(IntrusiveListBase&&) = delete;
423 
424 private:
425 
428 };
429 
437 inline void swap(IntrusiveListBase& left, IntrusiveListBase& right)
438 {
439  left.swap(right);
440 }
441 
442 } // namespace internal
443 
455 template<typename T, IntrusiveListNode T::* NodePointer, typename U = T>
457 {
458 public:
459 
461  using difference_type = ptrdiff_t;
462 
464  using iterator_category = std::bidirectional_iterator_tag;
465 
467  using pointer = U*;
468 
470  using reference = U&;
471 
473  using value_type = U;
474 
479  constexpr IntrusiveListIterator() :
480  node_{}
481  {
482 
483  }
484 
491  constexpr explicit IntrusiveListIterator(IntrusiveListNode* const node) :
492  node_{node}
493  {
494 
495  }
496 
503  constexpr explicit IntrusiveListIterator(reference element) :
504  node_{&(element.*NodePointer)}
505  {
506  static_assert(std::is_convertible<U, T>::value == true, "U must be implicitly convertible to T!");
507  }
508 
516  {
517  return getPointer();
518  }
519 
527  {
528  return *getPointer();
529  }
530 
538  {
539  node_ = &node_->getNextNode();
540  return *this;
541  }
542 
550  {
551  const auto temporary = *this;
552  node_ = &node_->getNextNode();
553  return temporary;
554  }
555 
563  {
564  node_ = &node_->getPreviousNode();
565  return *this;
566  }
567 
575  {
576  const auto temporary = *this;
577  node_ = &node_->getPreviousNode();
578  return temporary;
579  }
580 
589  bool operator==(const IntrusiveListIterator& other) const
590  {
591  return node_ == other.node_;
592  }
593 
594 private:
595 
603  {
604  static_assert(std::is_convertible<U, T>::value == true, "U must be implicitly convertible to T!");
605 
606  const auto offset = reinterpret_cast<size_t>(&(static_cast<pointer>(nullptr)->*NodePointer));
607  return reinterpret_cast<pointer>(reinterpret_cast<size_t>(node_) - offset);
608  }
609 
612 };
613 
628 template<typename T, IntrusiveListNode T::* NodePointer, typename U = T>
631 {
632  return (left == right) == false;
633 }
634 
646 template<typename T, const IntrusiveListNode T::* NodePointer, typename U = T>
648 {
649 public:
650 
652  using difference_type = ptrdiff_t;
653 
655  using iterator_category = std::bidirectional_iterator_tag;
656 
658  using pointer = const U*;
659 
661  using reference = const U&;
662 
664  using value_type = U;
665 
671  node_{}
672  {
673 
674  }
675 
682  constexpr explicit IntrusiveListConstIterator(const IntrusiveListNode* const node) :
683  node_{node}
684  {
685 
686  }
687 
694  constexpr explicit IntrusiveListConstIterator(reference element) :
695  node_{&(element.*NodePointer)}
696  {
697  static_assert(std::is_convertible<U, T>::value == true, "U must be implicitly convertible to T!");
698  }
699 
710  template<IntrusiveListNode T::* NonConstNodePointer>
712  IntrusiveListConstIterator{*iterator}
713  {
714 
715  }
716 
724  {
725  return getPointer();
726  }
727 
735  {
736  return *getPointer();
737  }
738 
746  {
747  node_ = &node_->getNextNode();
748  return *this;
749  }
750 
758  {
759  const auto temporary = *this;
760  node_ = &node_->getNextNode();
761  return temporary;
762  }
763 
771  {
772  node_ = &node_->getPreviousNode();
773  return *this;
774  }
775 
783  {
784  const auto temporary = *this;
785  node_ = &node_->getPreviousNode();
786  return temporary;
787  }
788 
797  bool operator==(const IntrusiveListConstIterator& other) const
798  {
799  return node_ == other.node_;
800  }
801 
802 private:
803 
811  {
812  static_assert(std::is_convertible<U, T>::value == true, "U must be implicitly convertible to T!");
813 
814  const auto offset = reinterpret_cast<size_t>(&(static_cast<pointer>(nullptr)->*NodePointer));
815  return reinterpret_cast<pointer>(reinterpret_cast<size_t>(node_) - offset);
816  }
817 
820 };
821 
836 template<typename T, const IntrusiveListNode T::* NodePointer, typename U = T>
839 {
840  return (left == right) == false;
841 }
842 
858 template<typename T, IntrusiveListNode T::* NodePointer, const IntrusiveListNode T::* ConstNodePointer, typename U = T>
861 {
862  return decltype(right){left} == right;
863 }
864 
880 template<typename T, IntrusiveListNode T::* NodePointer, const IntrusiveListNode T::* ConstNodePointer, typename U = T>
883 {
884  return (left == right) == false;
885 }
886 
902 template<typename T, IntrusiveListNode T::* NodePointer, const IntrusiveListNode T::* ConstNodePointer, typename U = T>
905 {
906  return right != left;
907 }
908 
922 template<typename T, IntrusiveListNode T::* NodePointer, typename U = T>
924 {
925 public:
926 
929 
931  using const_reverse_iterator = std::reverse_iterator<const_iterator>;
932 
934  using const_pointer = const U*;
935 
937  using const_reference = const U&;
938 
941 
943  using reverse_iterator = std::reverse_iterator<iterator>;
944 
946  using pointer = U*;
947 
949  using reference = U&;
950 
952  using value_type = U;
953 
958  constexpr IntrusiveList() :
959  intrusiveListBase_{}
960  {
961 
962  }
963 
969  {
970  return *--end();
971  }
972 
978  {
979  return *--end();
980  }
981 
987  {
988  return iterator{&intrusiveListBase_.begin()};
989  }
990 
996  {
997  return const_iterator{&intrusiveListBase_.begin()};
998  }
999 
1005  {
1006  return begin();
1007  }
1008 
1014  {
1015  return end();
1016  }
1017 
1022  void clear()
1023  {
1024  intrusiveListBase_.clear();
1025  }
1026 
1031  bool empty() const
1032  {
1033  return intrusiveListBase_.empty();
1034  }
1035 
1041  {
1042  return iterator{&intrusiveListBase_.end()};
1043  }
1044 
1050  {
1051  return const_iterator{&intrusiveListBase_.end()};
1052  }
1053 
1059  {
1060  return *begin();
1061  }
1062 
1068  {
1069  return *begin();
1070  }
1071 
1076  void pop_back()
1077  {
1078  erase(--end());
1079  }
1080 
1085  void pop_front()
1086  {
1087  erase(begin());
1088  }
1089 
1096  void push_back(reference newElement)
1097  {
1098  insert(end(), newElement);
1099  }
1100 
1107  void push_front(reference newElement)
1108  {
1109  insert(begin(), newElement);
1110  }
1111 
1118  void swap(IntrusiveList& other)
1119  {
1120  intrusiveListBase_.swap(other.intrusiveListBase_);
1121  }
1122 
1133  static iterator erase(const iterator position)
1134  {
1135  auto& positionNode = (*position).*NodePointer;
1136  auto& nextNode = internal::IntrusiveListBase::erase(positionNode);
1137  return iterator{&nextNode};
1138  }
1139 
1151  static iterator insert(const iterator position, reference newElement)
1152  {
1153  static_assert(std::is_convertible<U, T>::value == true, "U must be implicitly convertible to T!");
1154 
1155  auto& positionNode = (*position).*NodePointer;
1156  auto& newElementNode = newElement.*NodePointer;
1157  internal::IntrusiveListBase::insert(positionNode, newElementNode);
1158  return iterator{&newElementNode};
1159  }
1160 
1170  static void splice(const iterator position, const iterator splicedElement)
1171  {
1172  auto& positionNode = (*position).*NodePointer;
1173  auto& splicedElementNode = (*splicedElement).*NodePointer;
1174  internal::IntrusiveListBase::splice(positionNode, splicedElementNode);
1175  }
1176 
1177  IntrusiveList(const IntrusiveList&) = delete;
1178  IntrusiveList(IntrusiveList&&) = default;
1179  const IntrusiveList& operator=(const IntrusiveList&) = delete;
1180  IntrusiveList& operator=(IntrusiveList&&) = delete;
1181 
1182 private:
1183 
1186 };
1187 
1200 template<typename T, IntrusiveListNode T::* NodePointer, typename U = T>
1202 {
1203  left.swap(right);
1204 }
1205 
1206 } // namespace estd
1207 
1208 #endif // ESTD_INTRUSIVELIST_HPP_
void push_back(reference newElement)
Links the element at the end of the list.
Definition: IntrusiveList.hpp:1096
Collection of useful templates.
IntrusiveList class is an intrusive circular doubly linked list.
Definition: IntrusiveList.hpp:923
std::bidirectional_iterator_tag iterator_category
category of the iterator
Definition: IntrusiveList.hpp:464
const_reference back() const
Definition: IntrusiveList.hpp:977
IntrusiveListIterator operator++(int)
IntrusiveListIterator&#39;s unary postfix increment operator.
Definition: IntrusiveList.hpp:549
U & reference
reference to object "pointed to" by the iterator
Definition: IntrusiveList.hpp:470
const MutexControlBlock * const_pointer
const pointer to value linked in the list
Definition: IntrusiveList.hpp:934
IntrusiveListNode * nextNode_
reference to next node on the list
Definition: IntrusiveList.hpp:209
MutexControlBlock & reference
reference to value linked in the list
Definition: IntrusiveList.hpp:949
IntrusiveListNode * previousNode_
reference to previous node on the list
Definition: IntrusiveList.hpp:212
const_iterator begin() const
Definition: IntrusiveList.hpp:995
std::bidirectional_iterator_tag iterator_category
category of the iterator
Definition: IntrusiveList.hpp:655
IntrusiveListNode & getPreviousNode() const
Definition: IntrusiveList.hpp:118
const IntrusiveListNode & begin() const
Definition: IntrusiveList.hpp:263
const_iterator cend() const
Definition: IntrusiveList.hpp:1013
constexpr IntrusiveListConstIterator(reference element)
IntrusiveListConstIterator&#39;s constructor.
Definition: IntrusiveList.hpp:694
internal::IntrusiveListBase intrusiveListBase_
internal IntrusiveListBase object
Definition: IntrusiveList.hpp:1185
bool empty() const
Definition: IntrusiveList.hpp:1031
bool operator==(const IntrusiveListConstIterator &other) const
IntrusiveListConstIterator&#39;s "equal to" comparison operator.
Definition: IntrusiveList.hpp:797
const_iterator cbegin() const
Definition: IntrusiveList.hpp:1004
MutexControlBlock * pointer
pointer to value linked in the list
Definition: IntrusiveList.hpp:946
pointer getPointer() const
Converts contained pointer to IntrusiveListNode to pointer to object that contains this node...
Definition: IntrusiveList.hpp:602
IntrusiveListIterator & operator++()
IntrusiveListIterator&#39;s unary prefix increment operator.
Definition: IntrusiveList.hpp:537
IntrusiveListConstIterator class is a const iterator of elements on IntrusiveList.
Definition: IntrusiveList.hpp:647
U * pointer
pointer to object "pointed to" by the iterator
Definition: IntrusiveList.hpp:467
const IntrusiveListNode * node_
pointer to const IntrusiveListNode of the object "pointed to" by the iterator
Definition: IntrusiveList.hpp:819
constexpr IntrusiveListIterator()
IntrusiveListIterator&#39;s constructor.
Definition: IntrusiveList.hpp:479
constexpr IntrusiveListNode()
IntrusiveListNode&#39;s constructor.
Definition: IntrusiveList.hpp:67
void swap(IntrusiveListNode &other)
Swaps contents with another node.
Definition: IntrusiveList.hpp:157
void swap(IntrusiveList< T, NodePointer, U > &left, IntrusiveList< T, NodePointer, U > &right)
Swaps contents of two lists.
Definition: IntrusiveList.hpp:1201
~IntrusiveListNode()
IntrusiveListNode&#39;s destructor.
Definition: IntrusiveList.hpp:100
bool operator==(const IntrusiveListIterator &other) const
IntrusiveListIterator&#39;s "equal to" comparison operator.
Definition: IntrusiveList.hpp:589
void pop_front()
Unlinks the first node from the list.
Definition: IntrusiveList.hpp:336
static void insert(IntrusiveListNode &position, IntrusiveListNode &newNode)
Links the node in the list before position.
Definition: IntrusiveList.hpp:400
reference operator*() const
IntrusiveListConstIterator&#39;s unary prefix dereference operator.
Definition: IntrusiveList.hpp:734
void push_front(IntrusiveListNode &newNode)
Links the node at the beginning of the list.
Definition: IntrusiveList.hpp:358
const IntrusiveListNode & cbegin() const
Definition: IntrusiveList.hpp:272
MutexControlBlock value_type
value linked in the list
Definition: IntrusiveList.hpp:952
void reset()
Resets the node to the same state as right after construction.
Definition: IntrusiveList.hpp:202
void swap(IntrusiveList &other)
Swaps contents with another list.
Definition: IntrusiveList.hpp:1118
iterator end()
Definition: IntrusiveList.hpp:1040
IntrusiveListNode class is the node that is needed for the object to be linked in IntrusiveList...
Definition: IntrusiveList.hpp:38
IntrusiveListNode & end()
Definition: IntrusiveList.hpp:309
bool operator!=(const IntrusiveForwardListIterator< T, NodePointer, U > &left, const IntrusiveForwardListIterator< T, NodePointer, U > &right)
IntrusiveForwardListIterator&#39;s "not equal to" comparison operator.
Definition: IntrusiveForwardList.hpp:576
IntrusiveListConstIterator & operator--()
IntrusiveListConstIterator&#39;s unary prefix decrement operator.
Definition: IntrusiveList.hpp:770
bool empty() const
Definition: IntrusiveList.hpp:300
void push_back(IntrusiveListNode &newNode)
Links the node at the end of the list.
Definition: IntrusiveList.hpp:347
constexpr IntrusiveListConstIterator()
IntrusiveListConstIterator&#39;s constructor.
Definition: IntrusiveList.hpp:670
IntrusiveListBase class provides base functionalities for IntrusiveList class, but without any knowle...
Definition: IntrusiveList.hpp:225
void swap(IntrusiveListBase &other)
Swaps contents with another list.
Definition: IntrusiveList.hpp:369
static IntrusiveListNode & erase(IntrusiveListNode &position)
Unlinks the node at position from the list.
Definition: IntrusiveList.hpp:384
reference operator*() const
IntrusiveListIterator&#39;s unary prefix dereference operator.
Definition: IntrusiveList.hpp:526
void pop_back()
Unlinks the last node from the list.
Definition: IntrusiveList.hpp:327
void clear()
Unlinks all elements from the list.
Definition: IntrusiveList.hpp:1022
void unlink()
Unlinks the node from the list.
Definition: IntrusiveList.hpp:184
static void splice(const iterator position, const iterator splicedElement)
Transfers the element from one list to another list before position.
Definition: IntrusiveList.hpp:1170
U value_type
value "pointed to" by the iterator
Definition: IntrusiveList.hpp:473
U value_type
value "pointed to" by the iterator
Definition: IntrusiveList.hpp:664
std::reverse_iterator< const_iterator > const_reverse_iterator
const reverse iterator of elements on the list
Definition: IntrusiveList.hpp:931
IntrusiveListConstIterator operator--(int)
IntrusiveListConstIterator&#39;s unary postfix decrement operator.
Definition: IntrusiveList.hpp:782
void link(IntrusiveListNode &position, LinkAccessKey)
Links the node in the list before position.
Definition: IntrusiveList.hpp:141
~IntrusiveListBase()
IntrusiveListBase&#39;s destructor.
Definition: IntrusiveList.hpp:245
IntrusiveListNode(IntrusiveListNode &&other)
IntrusiveListNode&#39;s move constructor.
Definition: IntrusiveList.hpp:80
IntrusiveListConstIterator operator++(int)
IntrusiveListConstIterator&#39;s unary postfix increment operator.
Definition: IntrusiveList.hpp:757
pointer getPointer() const
Converts contained pointer to IntrusiveListNode to pointer to object that contains this node...
Definition: IntrusiveList.hpp:810
static void splice(IntrusiveListNode &position, IntrusiveListNode &splicedNode)
Transfers the node from one list to another list before position.
Definition: IntrusiveList.hpp:414
const_reference front() const
Definition: IntrusiveList.hpp:1067
IntrusiveListNode & getNextNode() const
Definition: IntrusiveList.hpp:109
constexpr IntrusiveListIterator(reference element)
IntrusiveListIterator&#39;s constructor.
Definition: IntrusiveList.hpp:503
bool isLinked() const
Definition: IntrusiveList.hpp:127
IntrusiveListNode & begin()
Definition: IntrusiveList.hpp:254
void push_front(reference newElement)
Links the element at the beginning of the list.
Definition: IntrusiveList.hpp:1107
iterator begin()
Definition: IntrusiveList.hpp:986
pointer operator->() const
IntrusiveListConstIterator&#39;s binary infix pointer member access operator.
Definition: IntrusiveList.hpp:723
const IntrusiveListNode & end() const
Definition: IntrusiveList.hpp:318
IntrusiveListNode * node_
pointer to IntrusiveListNode of the object "pointed to" by the iterator
Definition: IntrusiveList.hpp:611
constexpr IntrusiveListBase()
IntrusiveListBase&#39;s constructor.
Definition: IntrusiveList.hpp:233
ptrdiff_t difference_type
difference type
Definition: IntrusiveList.hpp:652
constexpr IntrusiveListConstIterator(const IntrusiveListNode *const node)
IntrusiveListConstIterator&#39;s constructor.
Definition: IntrusiveList.hpp:682
reference back()
Definition: IntrusiveList.hpp:968
constexpr IntrusiveListIterator(IntrusiveListNode *const node)
IntrusiveListIterator&#39;s constructor.
Definition: IntrusiveList.hpp:491
const_iterator end() const
Definition: IntrusiveList.hpp:1049
pointer operator->() const
IntrusiveListIterator&#39;s binary infix pointer member access operator.
Definition: IntrusiveList.hpp:515
void pop_back()
Unlinks the last element from the list.
Definition: IntrusiveList.hpp:1076
const MutexControlBlock & const_reference
const reference to value linked in the list
Definition: IntrusiveList.hpp:937
IntrusiveListConstIterator & operator++()
IntrusiveListConstIterator&#39;s unary prefix increment operator.
Definition: IntrusiveList.hpp:745
IntrusiveListIterator operator--(int)
IntrusiveListIterator&#39;s unary postfix decrement operator.
Definition: IntrusiveList.hpp:574
static iterator erase(const iterator position)
Unlinks the element at position from the list.
Definition: IntrusiveList.hpp:1133
void pop_front()
Unlinks the first element from the list.
Definition: IntrusiveList.hpp:1085
reference front()
Definition: IntrusiveList.hpp:1058
IntrusiveListNode rootNode_
root node of the intrusive list
Definition: IntrusiveList.hpp:427
bool operator==(const IntrusiveForwardListIterator< T, NodePointer, U > &left, const IntrusiveForwardListConstIterator< T, ConstNodePointer, U > &right)
"Equal to" comparison operator for IntrusiveForwardListIterator and IntrusiveForwardListConstIterator...
Definition: IntrusiveForwardList.hpp:785
const U * pointer
pointer to object "pointed to" by the iterator
Definition: IntrusiveList.hpp:658
IntrusiveListIterator & operator--()
IntrusiveListIterator&#39;s unary prefix decrement operator.
Definition: IntrusiveList.hpp:562
void clear()
Unlinks all nodes from the list.
Definition: IntrusiveList.hpp:290
static iterator insert(const iterator position, reference newElement)
Links the element in the list before position.
Definition: IntrusiveList.hpp:1151
std::reverse_iterator< iterator > reverse_iterator
reverse iterator of elements on the list
Definition: IntrusiveList.hpp:943
void swap(IntrusiveForwardListBase &left, IntrusiveForwardListBase &right)
Swaps contents of two lists.
Definition: IntrusiveForwardList.hpp:409
constexpr IntrusiveListConstIterator(const IntrusiveListIterator< T, NonConstNodePointer, U > &iterator)
IntrusiveListConstIterator&#39;s constructor.
Definition: IntrusiveList.hpp:711
ptrdiff_t difference_type
difference type
Definition: IntrusiveList.hpp:461
const U & reference
reference to object "pointed to" by the iterator
Definition: IntrusiveList.hpp:661
constexpr IntrusiveList()
IntrusiveList&#39;s constructor.
Definition: IntrusiveList.hpp:958
IntrusiveListIterator class is an iterator of elements on IntrusiveList.
Definition: IntrusiveList.hpp:456
const IntrusiveListNode & cend() const
Definition: IntrusiveList.hpp:281