libUTL++
ListIt.h
1 #pragma once
2 
4 
5 #include <libutl/BidIt.h>
6 
8 
9 UTL_NS_BEGIN;
10 
12 
20 
22 class ListIt : public BidIt
23 {
25 
26 public:
32  ListIt(const List* list, ListNode* node)
33  : _list(const_cast<List*>(list))
34  , _node(node)
35  {
36  IFDEBUG(FwdIt::setOwner(list));
37  }
38 
40  virtual int compare(const Object& rhs) const;
41 
43  virtual void copy(const Object& rhs);
44 
45  virtual void forward(size_t dist = 1);
46 
47  virtual Object* get() const;
48 
50  List*
51  getList() const
52  {
53  return _list;
54  }
55 
57  ListNode*
58  getNode() const
59  {
60  return _node;
61  }
62 
63  virtual void reverse(size_t dist = 1);
64 
65  virtual void set(const Object* object);
66 
72  void
73  set(const List* list, ListNode* node)
74  {
75  _list = const_cast<List*>(list);
76  _node = node;
77  IFDEBUG(FwdIt::setOwner(list));
78  }
79 
81  void
83  {
84  _node = node;
85  }
86 
87  ListIt& operator++()
88  {
89  forward();
90  return *this;
91  }
92 
93  ListIt operator++(int)
94  {
95  ListIt res = *this;
96  forward();
97  return res;
98  }
99 
100  ListIt& operator--()
101  {
102  reverse();
103  return *this;
104  }
105 
106  ListIt operator--(int)
107  {
108  ListIt res = *this;
109  reverse();
110  return res;
111  }
112 
113 private:
114  void
115  init()
116  {
117  _list = nullptr;
118  _node = nullptr;
119  }
120  void
121  deInit()
122  {
123  }
124 
125 private:
126  List* _list;
127  ListNode* _node;
128 };
129 
131 
133 List::begin() const
134 {
135  iterator it(this, _front);
136  IFDEBUG(it.setConst(true));
137  return it;
138 }
139 
141 
143 List::begin()
144 {
145  return iterator(this, _front);
146 }
147 
149 
150 BidIt*
151 List::beginNew() const
152 {
153  BidIt* it = new iterator(this, _front);
154  IFDEBUG(it->setConst(true));
155  return it;
156 }
157 
159 
160 BidIt*
161 List::beginNew()
162 {
163  return new iterator(this, _front);
164 }
165 
167 
169 List::end() const
170 {
171  iterator it(this, _back);
172  IFDEBUG(it.setConst(true));
173  return it;
174 }
175 
177 
179 List::end()
180 {
181  return iterator(this, _back);
182 }
183 
185 
186 BidIt*
187 List::endNew() const
188 {
189  BidIt* it = new iterator(this, _back);
190  IFDEBUG(it->setConst(true));
191  return it;
192 }
193 
195 
196 BidIt*
197 List::endNew()
198 {
199  return new iterator(this, _back);
200 }
201 
203 
204 UTL_NS_END;
List node.
Definition: ListNode.h:28
List * getList() const
Get the associated List.
Definition: ListIt.h:51
Doubly-linked list.
Definition: List.h:80
Bi-directional List iterator.
Definition: ListIt.h:22
void deInit()
De-initialize UTL++.
#define UTL_CLASS_DECL(DC, BC)
Declaration of standard UTL++ functionality for a non-template class.
Definition: macros.h:688
void reverse(const BidIt &begin, const BidIt &end)
Reverse a sequence.
Templated proxy for BidIt.
Definition: TBidIt.h:19
#define IFDEBUG(x)
Do x in DEBUG mode only.
void copy(T *dest, const T *src, size_t len)
Copy one array of objects to another.
Definition: util_inl.h:690
ListNode * getNode() const
Get the list node.
Definition: ListIt.h:58
void setConst(bool p_const)
Set the const flag.
Definition: FwdIt.h:68
Bi-directional iterator abstraction.
Definition: BidIt.h:25
ListIt(const List *list, ListNode *node)
Constructor.
Definition: ListIt.h:32
Root of UTL++ class hierarchy.
Definition: Object.h:52
int compare(bool lhs, bool rhs)
Compare two boolean values.
void setNode(ListNode *node)
Set the list node.
Definition: ListIt.h:82
void init()
Initialize UTL++.