8 #ifndef Navigation_SharedPoolList_H
9 #define Navigation_SharedPoolList_H
26 typedef Pool<SPListNode<T> > NodePool;
27 typedef typename NodePool::Key NodeKey;
56 explicit SPL_Iterator(Node* listNode) : m_node(listNode) {}
57 SPL_Iterator(
const SPL_Iterator& rhs) : m_node(rhs.m_node) {}
59 KY_INLINE
const SPL_Iterator& operator=(
const SPL_Iterator& rhs) { m_node = rhs.m_node;
return *
this; }
61 KY_INLINE
bool operator==(
const SPL_Iterator& rhs)
const {
return m_node == rhs.m_node; }
62 KY_INLINE
bool operator!=(
const SPL_Iterator& rhs)
const {
return m_node != rhs.m_node; }
64 KY_INLINE SPL_Iterator& operator++() { m_node = m_node->m_next;
return *
this; }
65 KY_INLINE SPL_Iterator& operator--() { m_node = m_node->m_prev;
return *
this; }
67 KY_INLINE SPL_Iterator operator++(
int) { SPL_Iterator old = *
this; m_node = m_node->m_next;
return old; }
68 KY_INLINE SPL_Iterator operator--(
int) { SPL_Iterator old = *
this; m_node = m_node->m_prev;
return old; }
70 KY_INLINE T& operator*()
const {
return m_node->m_data; }
71 KY_INLINE T* operator->()
const {
return &m_node->m_data; }
73 KY_INLINE SPL_Iterator GetNext()
const {
return SPL_Iterator(m_node->m_next); }
74 KY_INLINE SPL_Iterator GetPrev()
const {
return SPL_Iterator(m_node->m_prev); }
76 KY_INLINE
bool IsNull()
const {
return m_node ==
KY_NULL; }
77 KY_INLINE
bool IsNotNull()
const {
return m_node !=
KY_NULL; }
86 class SPL_ConstIterator
93 typedef SPListNode<T> Node;
98 SPL_ConstIterator() : m_node(
KY_NULL) {}
99 SPL_ConstIterator(
const SPL_Iterator<T>& it) : m_node(it.m_node) {}
100 SPL_ConstIterator(
const SPL_ConstIterator& it) : m_node(it.m_node) {}
101 explicit SPL_ConstIterator(
const Node* listNode) : m_node(listNode) {}
105 KY_INLINE
bool operator==(
const SPL_ConstIterator& rhs)
const {
return m_node == rhs.m_node; }
106 KY_INLINE
bool operator!=(
const SPL_ConstIterator& rhs)
const {
return m_node != rhs.m_node; }
108 KY_INLINE SPL_ConstIterator& operator++() { m_node = m_node->m_next;
return *
this; }
109 KY_INLINE SPL_ConstIterator& operator--() { m_node = m_node->m_prev;
return *
this; }
111 KY_INLINE SPL_ConstIterator operator++(
int) { SPL_ConstIterator old = *
this; m_node = m_node->m_next;
return old; }
112 KY_INLINE SPL_ConstIterator operator--(
int) { SPL_ConstIterator old = *
this; m_node = m_node->m_prev;
return old; }
114 KY_INLINE
const T& operator*()
const {
return m_node->m_data; }
115 KY_INLINE
const T* operator->()
const {
return &m_node->m_data; }
117 KY_INLINE SPL_ConstIterator GetNext()
const {
return SPL_ConstIterator(m_node->m_next); }
118 KY_INLINE SPL_ConstIterator GetPrev()
const {
return SPL_ConstIterator(m_node->m_prev); }
120 KY_INLINE
bool IsNull()
const {
return m_node ==
KY_NULL; }
121 KY_INLINE
bool IsNotNull()
const {
return m_node !=
KY_NULL; }
152 template <
typename T>
161 typedef SPListNode<T> Node;
162 typedef SPL_Iterator<T> Iterator;
163 typedef SPL_ConstIterator<T> ConstIterator;
164 typedef Pool<SPListNode<T> > NodePool;
165 typedef typename NodePool::Key NodeKey;
170 explicit SharedPoolList(NodePool* nodePool =
KY_NULL) : m_nodePool(nodePool), m_count(0)
171 { m_root.m_next = m_root.m_prev = RootAsNode(); }
173 void SetNodePool(NodePool* nodePool) { m_nodePool = nodePool; }
175 ~SharedPoolList() { Clear(); }
179 KyUInt32 GetCount()
const {
return m_count; }
185 ConstIterator GetLast()
const {
return ConstIterator(m_root.m_prev); }
186 Iterator GetFirst() {
return Iterator(m_root.m_next); }
187 Iterator GetLast () {
return Iterator(m_root.m_prev); }
189 ConstIterator Begin()
const {
return ConstIterator(m_root.m_next); }
190 ConstIterator End()
const {
return ConstIterator(RootAsNode()); }
191 Iterator Begin() {
return Iterator(m_root.m_next); }
192 Iterator End() {
return Iterator(RootAsNode()); }
201 bool IsEmpty()
const {
return m_root.m_next == RootAsNode(); }
203 bool IsFirst(ConstIterator it)
const {
return it.m_node == m_root.m_next; }
204 bool IsFirst(Iterator it)
const {
return it.m_node == m_root.m_next; }
206 bool IsLast (ConstIterator it)
const {
return it.m_node == m_root.m_prev; }
207 bool IsLast (Iterator it)
const {
return it.m_node == m_root.m_prev; }
209 bool IsNull (ConstIterator it)
const {
return it.m_node == RootAsNode(); }
210 bool IsNull (Iterator it)
const {
return it.m_node == RootAsNode(); }
212 bool IsValid(ConstIterator it)
const {
return it.m_node != RootAsNode(); }
213 bool IsValid(Iterator it)
const {
return it.m_node != RootAsNode(); }
215 ConstIterator Find(
const T& data)
const;
216 Iterator Find(
const T& data);
221 Iterator InsertBefore(
const T& data, Iterator nextNodeIt) { Node* newNode = NewNode(data); InsertNodeBefore(newNode, nextNodeIt.m_node);
return Iterator(newNode); }
222 Iterator InsertAfter(Iterator prevNodeIt,
const T& data) { Node* newNode = NewNode(data); InsertNodeAfter(prevNodeIt.m_node, newNode);
return Iterator(newNode); }
224 Iterator InsertBefore(Iterator nextNodeIt) { Node* newNode = NewNode(); InsertNodeBefore(newNode, nextNodeIt.m_node);
return Iterator(newNode); }
225 Iterator InsertAfter(Iterator prevNodeIt) { Node* newNode = NewNode(); InsertNodeAfter(prevNodeIt.m_node, newNode);
return Iterator(newNode); }
227 Iterator PushFront(
const T& data) { Node* newNode = NewNode(data); InsertNodeBefore(newNode, m_root.m_next);
return Iterator(newNode); }
228 Iterator PushBack(
const T& data) { Node* newNode = NewNode(data); InsertNodeAfter(m_root.m_prev, newNode);
return Iterator(newNode); }
230 Iterator PushFront() { Node* newNode = NewNode(); InsertNodeBefore(newNode, m_root.m_next);
return Iterator(newNode); }
231 Iterator PushBack() { Node* newNode = NewNode(); InsertNodeAfter(m_root.m_prev, newNode);
return Iterator(newNode); }
236 Iterator Erase(Iterator it);
238 Iterator RemoveFirstOccurrence(Iterator begin,
const T& data);
240 KyUInt32 RemoveAllOccurrences(
const T& data);
242 template<
class Predicate>
243 KyUInt32 Remove_If(Predicate predicate)
246 for (Iterator it = Begin(); it != End(); )
260 void InsertNodeBefore(Node* newNode, Node* nextNode) { InsertNodeBetween(nextNode->m_prev, newNode, nextNode); }
261 void InsertNodeAfter(Node* prevNode, Node* newNode) { InsertNodeBetween(prevNode, newNode, prevNode->m_next); }
262 void InsertNodeBetween(Node* prevNode, Node* newNode, Node* nextNode);
263 Node* NewNode(
const T& data);
265 void RemoveNode(Node* node) { node->m_prev->m_next = node->m_next; node->m_next->m_prev = node->m_prev; }
266 Node* RootAsNode() {
return &m_root; }
267 const Node* RootAsNode()
const {
return &m_root; }
270 NodePool* m_nodePool;
276 template <
typename T>
277 typename SharedPoolList<T>::Node* SharedPoolList<T>::NewNode(
const T& data)
281 m_nodePool->New_CompactKeyAndPtr(key, node);
284 node->m_nodeKey = key;
291 template <
typename T>
292 typename SharedPoolList<T>::Node* SharedPoolList<T>::NewNode()
294 NodeKey nodeKey = m_nodePool->New_CompactKey();
295 Node* node = &m_nodePool->Get(nodeKey);
297 node->m_nodeKey = nodeKey;
302 template <
typename T>
303 void SharedPoolList<T>::InsertNodeBetween(Node* prevNode, Node* newNode, Node* nextNode)
305 prevNode->m_next = newNode;
306 newNode->m_prev = prevNode;
308 newNode->m_next = nextNode;
309 nextNode->m_prev = newNode;
313 template <
typename T>
314 typename SharedPoolList<T>::Iterator SharedPoolList<T>::Erase(Iterator it)
316 Node* node = it.m_node;
317 Node* nextNode = node->m_next;
319 m_nodePool->Delete(node->m_nodeKey);
321 return Iterator(nextNode);
325 template <
typename T>
326 void SharedPoolList<T>::Clear()
328 for (Iterator it = Begin(); it != End(); ++it)
329 m_nodePool->Delete(it.m_node->m_nodeKey);
332 m_root.m_next = m_root.m_prev = RootAsNode();
336 template <
typename T>
337 typename SharedPoolList<T>::ConstIterator SharedPoolList<T>::Find(
const T& data)
const
339 for (ConstIterator it = Begin(); it != End(); ++it)
347 template <
typename T>
348 typename SharedPoolList<T>::Iterator SharedPoolList<T>::Find(
const T& data)
350 for (Iterator it = Begin(); it != End(); ++it)
359 template <
typename T>
360 typename SharedPoolList<T>::Iterator SharedPoolList<T>::RemoveFirstOccurrence(Iterator begin,
const T& data)
363 for (; it != End(); ++it)
372 template <
typename T>
373 KyUInt32 SharedPoolList<T>::RemoveAllOccurrences(
const T& data)
376 for (Iterator it = Begin(); it != End(); )
392 #endif // Navigation_SharedPoolList_H
Const iterator on SharedPoolList nodes (SPL stands for SharedPoolList).
Definition: sharedpoollist.h:103
#define KY_NULL
Null value.
Definition: types.h:247
#define KY_CLASS_WITHOUT_COPY(ClassName)
Define to forbid copy constructor and copy assignment.
Definition: types.h:387
This is the list node used in SharedPoolList implementation (SP stands for SharedPool).
Definition: sharedpoollist.h:20
Definition: gamekitcrowddispersion.h:20
Iterator on SharedPoolList nodes (SPL stands for SharedPoolList).
Definition: sharedpoollist.h:48
#define KY_DEFINE_NEW_DELETE_OPERATORS(MemStat)
This macro defines new and delete operators.
Definition: memory.h:137
unsigned int KyUInt32
Type used internally to represent an unsigned 32-bit integer.
Definition: types.h:36