DCL 4.0
Loading...
Searching...
No Matches
__ListT-GCC.h
Go to the documentation of this file.
1#ifndef __DCL_LIST_T_H__
2#error "Never include <dcl/__ListT-GCC.h> directly; use <dcl/ListT.h> instead."
3#endif
4
5__DCL_BEGIN_NAMESPACE
6
7#if __DCL_HAVE_THIS_FILE__
8 static const char_t __szListT_h__[] = __T("dcl/__ListT-GCC.h");
9 #undef __THIS_FILE__
10 #define __THIS_FILE__ __szListT_h__
11#endif
12
13template<typename ELEMENT>
14class List : public Object
15{
16 DECLARE_CLASSINFO(List)
17public:
18 struct ListNode : public NodeBase
19 {
20 ELEMENT data;
21 };
22
23 class ConstIterator;
24 class Iterator : public ListIteratorBase
25 {
26 public:
27 Iterator();
28 Iterator(NodeBase* _pNode);
29 Iterator(const Iterator& _it);
30 Iterator& operator=(const Iterator& _it);
31 Iterator& operator++();
32 Iterator operator++(int);
33 Iterator& operator--();
34 Iterator operator--(int);
35 ELEMENT& operator*();
36
37 protected:
38 friend class List<ELEMENT>;
39 friend class ConstIterator;
40 };
41
42 class ConstIterator : public ConstListIteratorBase
43 {
44 public:
45 ConstIterator();
46 ConstIterator(const NodeBase* _pNode);
47 ConstIterator(const ConstIterator& _it);
48 ConstIterator(const Iterator& _it);
49 ConstIterator& operator=(const ConstIterator& _it);
50 ConstIterator& operator++();
51 ConstIterator operator++(int);
52 ConstIterator& operator--();
53 ConstIterator operator--(int);
54 const ELEMENT& operator*();
55 };
56
57 class ReverseConstIterator;
58 class ReverseIterator : public ListIteratorBase
59 {
60 public:
61 ReverseIterator();
62 ReverseIterator(NodeBase* _pNode);
63 ReverseIterator(const ReverseIterator& _it);
64 ReverseIterator& operator=(const ReverseIterator& _it);
65 ReverseIterator& operator++();
66 ReverseIterator operator++(int);
67 ReverseIterator& operator--();
68 ReverseIterator operator--(int);
69 ELEMENT& operator*();
70
71 protected:
72 friend class List<ELEMENT>;
73 friend class ReverseConstIterator;
74 };
75
76 class ReverseConstIterator : public ConstListIteratorBase
77 {
78 public:
79 ReverseConstIterator();
80 ReverseConstIterator(const NodeBase* _pNode);
81 ReverseConstIterator(const ReverseConstIterator& _it);
82 ReverseConstIterator(const ReverseIterator& _it);
83 ReverseConstIterator& operator=(const ReverseConstIterator& _it);
84 ReverseConstIterator& operator++();
85 ReverseConstIterator operator++(int);
86 ReverseConstIterator& operator--();
87 ReverseConstIterator operator--(int);
88 const ELEMENT& operator*();
89 };
90
91public:
92 virtual ~List();
93 List();
94 List(const List<ELEMENT>& _src);
95 const List<ELEMENT>& operator=(const List<ELEMENT>& _src);
96
97 ConstIterator begin() const;
98 ConstIterator end() const;
99 Iterator begin();
100 Iterator end();
101
102 ReverseConstIterator rbegin() const;
103 ReverseConstIterator rend() const;
104 ReverseIterator rbegin();
105 ReverseIterator rend();
106
107 // @return is inserted element Iterator
108 Iterator insert(Iterator _pos, const ELEMENT& _element);
109 void insert(Iterator _pos, ConstIterator _first, ConstIterator _last);
110
111 // return is next Iterator
112 Iterator erase(Iterator _pos);
113 void splice(Iterator _pos,
114 List<ELEMENT>& _other, Iterator _otherFirst, Iterator _otherLast);
115
116 List<ELEMENT>& addHead(const ELEMENT& _element);
117 List<ELEMENT>& addTail(const ELEMENT& _element);
118 List<ELEMENT>& add(const ELEMENT& _element);
119
120 ELEMENT removeHead();
121 ELEMENT removeTail();
122
123 void clear();
124 bool isEmpty() const;
125 size_t size() const;
126
127protected:
128 NodeBase* __pMasterNode;
129 size_t __size;
130
131 size_t size(ConstIterator _first, ConstIterator _last) const;
132 // _first ~ _last to posTo
133 void move(Iterator posTo, Iterator _first, Iterator _last);
134
135 ListNode* createNode(const ELEMENT& _element);
136 void destroyNode(ListNode* _pNode);
137};
138
140
141template<typename ELEMENT>
142inline
143List<ELEMENT>::Iterator::Iterator()
144{
145 __pNode = NULL;
146}
147
148template<typename ELEMENT>
149inline
150List<ELEMENT>::Iterator::Iterator(NodeBase* _pNode)
151{
152 __DCL_ASSERT(_pNode != NULL);
153 __pNode = _pNode;
154}
155
156template<typename ELEMENT>
157inline
158List<ELEMENT>::Iterator::Iterator(const Iterator& _it)
159{
160 __DCL_ASSERT(_it.__pNode != NULL);
161 __pNode = _it.__pNode;
162}
163
164template<typename ELEMENT>
165inline
166typename List<ELEMENT>::Iterator&
167List<ELEMENT>::Iterator::operator=(const Iterator& _it)
168{
169 __DCL_ASSERT(_it.__pNode != NULL);
170 __pNode = _it.__pNode;
171 return *this;
172}
173
174template<typename ELEMENT>
175inline
176typename List<ELEMENT>::Iterator&
177List<ELEMENT>::Iterator::operator++()
178{
179 __DCL_ASSERT(__pNode != NULL);
180 __pNode = __pNode->pNext;
181 return *this;
182}
183
184template<typename ELEMENT>
185inline
186typename List<ELEMENT>::Iterator
187List<ELEMENT>::Iterator::operator++(int)
188{
189 __DCL_ASSERT(__pNode != NULL);
190 NodeBase* pSaveNode = __pNode;
191 __pNode = __pNode->pNext;
192 return Iterator(pSaveNode);
193}
194
195template<typename ELEMENT>
196inline
197typename List<ELEMENT>::Iterator&
198List<ELEMENT>::Iterator::operator--()
199{
200 __DCL_ASSERT(__pNode != NULL);
201 __pNode = __pNode->pPrev;
202 return *this;
203}
204
205template<typename ELEMENT>
206inline
207typename List<ELEMENT>::Iterator
208List<ELEMENT>::Iterator::operator--(int)
209{
210 __DCL_ASSERT(__pNode != NULL);
211 NodeBase* pSaveNode = __pNode;
212 __pNode = __pNode->pPrev;
213 return Iterator(pSaveNode);
214}
215
216template<typename ELEMENT>
217inline
218ELEMENT&
219List<ELEMENT>::Iterator::operator * ()
220{
221 __DCL_ASSERT(__pNode != NULL);
222 return ((ListNode*)__pNode)->data;
223}
224
226
227template<typename ELEMENT>
228inline
229List<ELEMENT>::ConstIterator::ConstIterator()
230{
231 __pNode = NULL;
232}
233
234template<typename ELEMENT>
235inline
236List<ELEMENT>::ConstIterator::ConstIterator(const NodeBase* _pNode)
237{
238 __DCL_ASSERT(_pNode != NULL);
239 __pNode = _pNode;
240}
241
242template<typename ELEMENT>
243inline
244List<ELEMENT>::ConstIterator::ConstIterator(const ConstIterator& _it)
245{
246 __DCL_ASSERT(_it.__pNode != NULL);
247 __pNode = _it.__pNode;
248}
249
250template<typename ELEMENT>
251inline
252List<ELEMENT>::ConstIterator::ConstIterator(const Iterator& _it)
253{
254 __DCL_ASSERT(_it.__pNode != NULL);
255 __pNode = _it.__pNode;
256}
257
258template<typename ELEMENT>
259inline
260typename List<ELEMENT>::ConstIterator&
261List<ELEMENT>::ConstIterator::operator=(const ConstIterator& _it)
262{
263 __DCL_ASSERT(_it.__pNode != NULL);
264 __pNode = _it.__pNode;
265 return *this;
266}
267
268template<typename ELEMENT>
269inline
270typename List<ELEMENT>::ConstIterator&
271List<ELEMENT>::ConstIterator::operator++()
272{
273 __DCL_ASSERT(__pNode != NULL);
274 __pNode = __pNode->pNext;
275 return *this;
276}
277
278template<typename ELEMENT>
279inline
280typename List<ELEMENT>::ConstIterator
281List<ELEMENT>::ConstIterator::operator++(int)
282{
283 __DCL_ASSERT(__pNode != NULL);
284 const NodeBase* pSaveNode = __pNode;
285 __pNode = __pNode->pNext;
286 return ConstIterator(pSaveNode);
287}
288
289template<typename ELEMENT>
290inline
291typename List<ELEMENT>::ConstIterator&
292List<ELEMENT>::ConstIterator::operator--()
293{
294 __DCL_ASSERT(__pNode != NULL);
295 __pNode = __pNode->pPrev;
296 return *this;
297}
298
299template<typename ELEMENT>
300inline
301typename List<ELEMENT>::ConstIterator
302List<ELEMENT>::ConstIterator::operator--(int)
303{
304 __DCL_ASSERT(__pNode != NULL);
305 const NodeBase* pSaveNode = __pNode;
306 __pNode = __pNode->pPrev;
307 return ConstIterator(pSaveNode);
308}
309
310template<typename ELEMENT>
311inline
312const ELEMENT&
313List<ELEMENT>::ConstIterator::operator * ()
314{
315 __DCL_ASSERT(__pNode != NULL);
316 return ((ListNode*)__pNode)->data;
317}
318
320
321template<typename ELEMENT>
322inline
323List<ELEMENT>::ReverseIterator::ReverseIterator()
324{
325 __pNode = NULL;
326}
327
328template<typename ELEMENT>
329inline
330List<ELEMENT>::ReverseIterator::ReverseIterator(NodeBase* _pNode)
331{
332 __DCL_ASSERT(_pNode != NULL);
333 __pNode = _pNode;
334}
335
336template<typename ELEMENT>
337inline
338List<ELEMENT>::ReverseIterator::ReverseIterator(const ReverseIterator& _it)
339{
340 __DCL_ASSERT(_it.__pNode != NULL);
341 __pNode = _it.__pNode;
342}
343
344template<typename ELEMENT>
345inline
346typename List<ELEMENT>::ReverseIterator&
347List<ELEMENT>::ReverseIterator::operator=(const ReverseIterator& _it)
348{
349 __DCL_ASSERT(_it.__pNode != NULL);
350 __pNode = _it.__pNode;
351 return *this;
352}
353
354template<typename ELEMENT>
355inline
356typename List<ELEMENT>::ReverseIterator&
357List<ELEMENT>::ReverseIterator::operator++()
358{
359 __DCL_ASSERT(__pNode != NULL);
360 __pNode = __pNode->pPrev;
361 return *this;
362}
363
364template<typename ELEMENT>
365inline
366typename List<ELEMENT>::ReverseIterator
367List<ELEMENT>::ReverseIterator::operator++(int)
368{
369 __DCL_ASSERT(__pNode != NULL);
370 NodeBase* pSaveNode = __pNode;
371 __pNode = __pNode->pPrev;
372 return ReverseIterator(pSaveNode);
373}
374
375template<typename ELEMENT>
376inline
377typename List<ELEMENT>::ReverseIterator&
378List<ELEMENT>::ReverseIterator::operator--()
379{
380 __DCL_ASSERT(__pNode != NULL);
381 __pNode = __pNode->pNext;
382 return *this;
383}
384
385template<typename ELEMENT>
386inline
387typename List<ELEMENT>::ReverseIterator
388List<ELEMENT>::ReverseIterator::operator--(int)
389{
390 __DCL_ASSERT(__pNode != NULL);
391 NodeBase* pSaveNode = __pNode;
392 __pNode = __pNode->pNext;
393 return ReverseIterator(pSaveNode);
394}
395
396template<typename ELEMENT>
397inline
398ELEMENT&
399List<ELEMENT>::ReverseIterator::operator * ()
400{
401 __DCL_ASSERT(__pNode != NULL);
402 return ((ListNode*)__pNode)->data;
403}
404
406
407template<typename ELEMENT>
408inline
409List<ELEMENT>::ReverseConstIterator::ReverseConstIterator()
410{
411 __pNode = NULL;
412}
413
414template<typename ELEMENT>
415inline
416List<ELEMENT>::ReverseConstIterator::ReverseConstIterator(const NodeBase* _pNode)
417{
418 __DCL_ASSERT(_pNode != NULL);
419 __pNode = _pNode;
420}
421
422template<typename ELEMENT>
423inline
424List<ELEMENT>::ReverseConstIterator::ReverseConstIterator(const ReverseConstIterator& _it)
425{
426 __DCL_ASSERT(_it.__pNode != NULL);
427 __pNode = _it.__pNode;
428}
429
430template<typename ELEMENT>
431inline
432List<ELEMENT>::ReverseConstIterator::ReverseConstIterator(const ReverseIterator& _it)
433{
434 __DCL_ASSERT(_it.__pNode != NULL);
435 __pNode = _it.__pNode;
436}
437
438template<typename ELEMENT>
439inline
440typename List<ELEMENT>::ReverseConstIterator&
441List<ELEMENT>::ReverseConstIterator::operator=(const ReverseConstIterator& _it)
442{
443 __DCL_ASSERT(_it.__pNode != NULL);
444 __pNode = _it.__pNode;
445 return *this;
446}
447
448template<typename ELEMENT>
449inline
450typename List<ELEMENT>::ReverseConstIterator&
451List<ELEMENT>::ReverseConstIterator::operator++()
452{
453 __DCL_ASSERT(__pNode != NULL);
454 __pNode = __pNode->pPrev;
455 return *this;
456}
457
458template<typename ELEMENT>
459inline
460typename List<ELEMENT>::ReverseConstIterator
461List<ELEMENT>::ReverseConstIterator::operator++(int)
462{
463 __DCL_ASSERT(__pNode != NULL);
464 const NodeBase* pSaveNode = __pNode;
465 __pNode = __pNode->pPrev;
466 return ReverseConstIterator(pSaveNode);
467}
468
469template<typename ELEMENT>
470inline
471typename List<ELEMENT>::ReverseConstIterator&
472List<ELEMENT>::ReverseConstIterator::operator--()
473{
474 __DCL_ASSERT(__pNode != NULL);
475 __pNode = __pNode->pNext;
476 return *this;
477}
478
479template<typename ELEMENT>
480inline
481typename List<ELEMENT>::ReverseConstIterator
482List<ELEMENT>::ReverseConstIterator::operator--(int)
483{
484 __DCL_ASSERT(__pNode != NULL);
485 const NodeBase* pSaveNode = __pNode;
486 __pNode = __pNode->pNext;
487 return ReverseConstIterator(pSaveNode);
488}
489
490template<typename ELEMENT>
491inline
492const ELEMENT&
493List<ELEMENT>::ReverseConstIterator::operator * ()
494{
495 __DCL_ASSERT(__pNode != NULL);
496 return ((ListNode*)__pNode)->data;
497}
498
500
501template<typename ELEMENT>
502inline
503typename List<ELEMENT>::ConstIterator
504List<ELEMENT>::begin() const
505{
506 return __pMasterNode->pNext;
507}
508
509template<typename ELEMENT>
510inline
511typename List<ELEMENT>::ConstIterator
512List<ELEMENT>::end() const
513{
514 return __pMasterNode;
515}
516
517template<typename ELEMENT>
518inline
519typename List<ELEMENT>::Iterator
520List<ELEMENT>::begin()
521{
522 return __pMasterNode->pNext;
523}
524
525template<typename ELEMENT>
526inline
527typename List<ELEMENT>::Iterator
528List<ELEMENT>::end()
529{
530 return __pMasterNode;
531}
532
533template<typename ELEMENT>
534inline
535typename List<ELEMENT>::ReverseConstIterator
536List<ELEMENT>::rbegin() const
537{
538 return __pMasterNode->pPrev;
539}
540
541template<typename ELEMENT>
542inline
543typename List<ELEMENT>::ReverseConstIterator
544List<ELEMENT>::rend() const
545{
546 return __pMasterNode;
547}
548
549template<typename ELEMENT>
550inline
551typename List<ELEMENT>::ReverseIterator
552List<ELEMENT>::rbegin()
553{
554 return __pMasterNode->pPrev;
555}
556
557template<typename ELEMENT>
558inline
559typename List<ELEMENT>::ReverseIterator
560List<ELEMENT>::rend()
561{
562 return __pMasterNode;
563}
564
565template<typename ELEMENT>
566inline
567bool
568List<ELEMENT>::isEmpty() const
569{
570 return __pMasterNode->pNext == __pMasterNode;
571}
572
573template<typename ELEMENT>
574inline
575size_t
576List<ELEMENT>::size() const
577{
578 return __size;
579}
580
581template<typename ELEMENT>
582inline
583List<ELEMENT>&
584List<ELEMENT>::addHead(const ELEMENT& _element)
585{
586 insert(begin(), _element);
587 return *this;
588}
589
590template<typename ELEMENT>
591inline
592List<ELEMENT>&
593List<ELEMENT>::addTail(const ELEMENT& _element)
594{
595 insert(end(), _element);
596 return *this;
597}
598
599template<typename ELEMENT>
600inline
601List<ELEMENT>&
602List<ELEMENT>::add(const ELEMENT& _element)
603{
604 insert(end(), _element);
605 return *this;
606}
607
609
610// IMPLEMENT_CLASSINFO(List<ELEMENT>, Object)
611#ifdef __DCL_NO_RTTI
612template<typename ELEMENT>
613const Object::ClassInfo List<ELEMENT>::m_classInfo =
614{
615 __DCL_NAMESPACE_STRING __S(List),
616 sizeof(class List),
617 &Object::m_classInfo
618};
619
620template<typename ELEMENT>
621const Object::ClassInfo* List<ELEMENT>::classInfo() const
622{
623 return CLASSINFO(class_name);
624}
625#else
626template<typename ELEMENT>
627const std::type_info& List<ELEMENT>::typeInfo() const
628{
629 return typeid(List);
630}
631#endif
632
633template<typename ELEMENT>
634List<ELEMENT>::~List()
635{
636 if (!isEmpty())
637 clear();
638 free(__pMasterNode);
639}
640
641template<typename ELEMENT>
642List<ELEMENT>::List()
643{
644 __pMasterNode = (NodeBase*) malloc(sizeof(NodeBase));
645 // FIXME!
646 // if (pNode == NULL)
647 // throw new BadAllocException(sizeof(HashNode), __THIS_FILE__, __LINE__);
648 __DCL_ASSERT(__pMasterNode != NULL);
649
650 __pMasterNode->pPrev = __pMasterNode;
651 __pMasterNode->pNext = __pMasterNode;
652 __size = 0;
653}
654
655template<typename ELEMENT>
656List<ELEMENT>::List(const List<ELEMENT>& _src)
657{
658 __pMasterNode = (NodeBase*) malloc(sizeof(NodeBase));
659 // FIXME!
660 // if (pNode == NULL)
661 // throw new BadAllocException(sizeof(HashNode), __THIS_FILE__, __LINE__);
662 __DCL_ASSERT(__pMasterNode != NULL);
663
664 __pMasterNode->pPrev = __pMasterNode;
665 __pMasterNode->pNext = __pMasterNode;
666 __size = 0;
667
668 insert(end(), _src.begin(), _src.end());
669}
670
671template<typename ELEMENT>
672const List<ELEMENT>&
673List<ELEMENT>::operator=(const List<ELEMENT>& _src)
674{
675 if (&_src != this)
676 {
677 if (!isEmpty())
678 clear();
679 insert(end(), _src.begin(), _src.end());
680 }
681 return *this;
682}
683
684template<typename ELEMENT>
685typename List<ELEMENT>::ListNode*
686List<ELEMENT>::createNode(const ELEMENT& _element)
687{
688 ListNode* pNode = (ListNode*) malloc(sizeof(ListNode));
689 // FIXME!
690 // if (pNode == NULL)
691 // throw new BadAllocException(sizeof(HashNode), __THIS_FILE__, __LINE__);
692
693#if __DCL_HAVE_ALLOC_DEBUG
694#undef new
695#endif
696
697 new(&(pNode->data)) ELEMENT;
698
699#if __DCL_HAVE_ALLOC_DEBUG
700#define new __DCL_DEBUG_NEW
701#endif
702
703 pNode->data = _element;
704 return pNode;
705}
706
707template<typename ELEMENT>
708void
709List<ELEMENT>::destroyNode(ListNode* _pNode)
710{
711 _pNode->data.~ELEMENT();
712 free(_pNode);
713}
714
715template<typename ELEMENT>
716typename List<ELEMENT>::Iterator
717List<ELEMENT>::insert(Iterator _pos, const ELEMENT& _element)
718{
719 ListNode* pNewNode = createNode(_element);
720 pNewNode->pPrev = _pos.__pNode->pPrev;
721 pNewNode->pNext = _pos.__pNode;
722 _pos.__pNode->pPrev->pNext = pNewNode;
723 _pos.__pNode->pPrev = pNewNode;
724
725 __size++;
726
727 return (ListNode*)pNewNode;
728}
729
730template<typename ELEMENT>
731void
732List<ELEMENT>::insert(Iterator _pos, ConstIterator _first, ConstIterator _last)
733{
734 for(; _first != _last; _first++)
735 {
736 insert(_pos, *_first);
737 }
738}
739
740template<typename ELEMENT>
741void
742List<ELEMENT>::clear()
743{
744 ListNode* pNodeTemp = NULL;
745 NodeBase* pNode = __pMasterNode->pNext;
746 while(pNode != __pMasterNode)
747 {
748 pNodeTemp = (ListNode*)pNode;
749 pNode = pNode->pNext;
750 destroyNode(pNodeTemp);
751 }
752 __pMasterNode->pNext = __pMasterNode;
753 __pMasterNode->pPrev = __pMasterNode;
754 __size = 0;
755}
756
757template<typename ELEMENT>
758typename List<ELEMENT>::Iterator
759List<ELEMENT>::erase(Iterator _pos)
760{
761 __DCL_ASSERT(_pos != end());
762 ListNode* pNodeTemp = (ListNode*)_pos.__pNode;
763 NodeBase* pNext = pNodeTemp->pNext;
764 pNodeTemp->pPrev->pNext = pNodeTemp->pNext;
765 pNodeTemp->pNext->pPrev = pNodeTemp->pPrev;
766 destroyNode(pNodeTemp);
767 __size--;
768 return (ListNode*)pNext;
769}
770
771template<typename ELEMENT>
772ELEMENT
773List<ELEMENT>::removeHead()
774{
775 __DCL_ASSERT(!isEmpty());
776 ELEMENT result = *begin();
777 erase(begin());
778 return result;
779}
780
781template<typename ELEMENT>
782ELEMENT
783List<ELEMENT>::removeTail()
784{
785 __DCL_ASSERT(!isEmpty());
786 Iterator it = end();
787 ELEMENT result = *(--it);
788 erase(it);
789 return result;
790}
791
792template<typename ELEMENT>
793void
794List<ELEMENT>::move(Iterator _pos, Iterator _first, Iterator _last)
795{
796 if (_pos != _last)
797 {
798 _last.__pNode->pPrev->pNext = _pos.__pNode;
799 _first.__pNode->pPrev->pNext = _last.__pNode;
800 _pos.__pNode->pPrev->pNext = _first.__pNode;
801
802 NodeBase* pTemp = _pos.__pNode->pPrev;
803 _pos.__pNode->pPrev = _last.__pNode->pPrev;
804 _last.__pNode->pPrev = _first.__pNode->pPrev;
805 _first.__pNode->pPrev = pTemp;
806 }
807}
808
809template<typename ELEMENT>
810void
811List<ELEMENT>::splice(Iterator _pos,
812 List<ELEMENT>& _other, Iterator _otherFirst, Iterator _otherLast)
813{
814 size_t nMoveCount = size((ListNode*)(_otherFirst.__pNode),
815 (ListNode*)(_otherLast.__pNode));
816 __size += nMoveCount;
817 _other.__size -= nMoveCount;
818
819 move(_pos, _otherFirst, _otherLast);
820}
821
822template<typename ELEMENT>
823size_t
824List<ELEMENT>::size(ConstIterator _first, ConstIterator _last) const
825{
826 size_t nCount = 0;
827 for(; _first != _last; _first++)
828 nCount++;
829 return nCount;
830}
831
832#if __DCL_HAVE_THIS_FILE__
833 #undef __THIS_FILE__
834 #define __THIS_FILE__ __T(__FILE__)
835#endif
836
837__DCL_END_NAMESPACE
NULL
#define NULL
Definition Config.h:340
char_t
wchar_t char_t
Definition Config.h:275
DECLARE_CLASSINFO
#define DECLARE_CLASSINFO(class_name)
Definition Object.h:210
CLASSINFO
#define CLASSINFO(class_name)
Definition Object.h:209
__DCL_ASSERT
#define __DCL_ASSERT(expr)
Definition Object.h:371
__T
#define __T(str)
Definition Object.h:44
result
return result
Definition SQLField.cpp:1152
List::removeHead
ELEMENT removeHead()
Definition __ListT-GCC.h:773
List::addHead
List< ELEMENT > & addHead(const ELEMENT &_element)
Definition __ListT-GCC.h:584
List::clear
void clear()
Definition __ListT-GCC.h:742
List::end
ConstIterator end() const
Definition __ListT-GCC.h:512
List::destroyNode
void destroyNode(ListNode *_pNode)
Definition __ListT-GCC.h:709
List::size
size_t size(ConstIterator _first, ConstIterator _last) const
Definition __ListT-GCC.h:824
List::insert
void insert(Iterator _pos, ConstIterator _first, ConstIterator _last)
Definition __ListT-GCC.h:732
List::removeTail
ELEMENT removeTail()
Definition __ListT-GCC.h:783
List::createNode
ListNode * createNode(const ELEMENT &_element)
Definition __ListT-GCC.h:686
List::rbegin
ReverseIterator rbegin()
Definition __ListT-GCC.h:552
List::~List
virtual ~List()
Definition __ListT-GCC.h:634
List::move
void move(Iterator posTo, Iterator _first, Iterator _last)
Definition __ListT-GCC.h:794
List::List
List(const List< ELEMENT > &_src)
Definition __ListT-GCC.h:656
List::begin
Iterator begin()
Definition __ListT-GCC.h:520
List::size
size_t size() const
Definition __ListT-GCC.h:576
List::splice
void splice(Iterator _pos, List< ELEMENT > &_other, Iterator _otherFirst, Iterator _otherLast)
Definition __ListT-GCC.h:811
List::rend
ReverseConstIterator rend() const
Definition __ListT-GCC.h:544
List::insert
Iterator insert(Iterator _pos, const ELEMENT &_element)
Definition __ListT-GCC.h:717
List::operator=
const List< ELEMENT > & operator=(const List< ELEMENT > &_src)
Definition __ListT-GCC.h:673
List::rend
ReverseIterator rend()
Definition __ListT-GCC.h:560
List::add
List< ELEMENT > & add(const ELEMENT &_element)
Definition __ListT-GCC.h:602
List::end
Iterator end()
Definition __ListT-GCC.h:528
List::erase
Iterator erase(Iterator _pos)
Definition __ListT-GCC.h:759
List< Update >::__pMasterNode
NodeBase * __pMasterNode
Definition __ListT-GCC.h:128
List::isEmpty
bool isEmpty() const
Definition __ListT-GCC.h:568
List::begin
ConstIterator begin() const
Definition __ListT-GCC.h:504
List::rbegin
ReverseConstIterator rbegin() const
Definition __ListT-GCC.h:536
List::addTail
List< ELEMENT > & addTail(const ELEMENT &_element)
Definition __ListT-GCC.h:593
ListIteratorBase::__pNode
NodeBase * __pNode
Definition ListBase.h:30
Object::Object
Object()
Definition Object.cpp:183
Object::typeInfo
virtual const std::type_info & typeInfo() const
Definition Object.cpp:126
NodeBase::pPrev
NodeBase * pPrev
Definition ListBase.h:18
NodeBase::pNext
NodeBase * pNext
Definition ListBase.h:19