KVIrc 5.2.6
Developer APIs
KviPointerList.h
Go to the documentation of this file.
1#ifndef _KVI_POINTERLIST_H_
2#define _KVI_POINTERLIST_H_
3//=============================================================================
4//
5// File : KviPointerList.h
6// Creation date : Tue Jul 6 1999 14:52:20 by Szymon Stefanek
7//
8// This file is part of the KVIrc IRC client distribution
9// Copyright (C) 1999-2010 Szymon Stefanek (pragma at kvirc dot net)
10//
11// This program is FREE software. You can redistribute it and/or
12// modify it under the terms of the GNU General Public License
13// as published by the Free Software Foundation; either version 2
14// of the License, or (at your option) any later version.
15//
16// This program is distributed in the HOPE that it will be USEFUL,
17// but WITHOUT ANY WARRANTY; without even the implied warranty of
18// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
19// See the GNU General Public License for more details.
20//
21// You should have received a copy of the GNU General Public License
22// along with this program. If not, write to the Free Software Foundation,
23// Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
24//
25//=============================================================================
26
27//
28// C++ Template based double linked pointer list class
29// Original ss_list.h Created on 10 Dec 2001
30// Copyright (C) 2001-2010 Szymon Stefanek (pragma at kvirc dot net)
31// Added to KVIrc on 02 Jan 2008.
32//
33
50
51#include "kvi_settings.h"
52
53template <typename T>
54class KviPointerList;
55template <typename T>
57
69
140template <typename T>
142{
143protected:
146
147public:
156 {
157 m_pList = src.m_pList;
158 m_pNode = src.m_pNode;
159 }
160
173
187
196 {
197 m_pList = src.m_pList;
198 m_pNode = src.m_pNode;
199 }
200
201public:
209 {
210 m_pNode = m_pList->m_pHead;
211 return m_pNode != nullptr;
212 }
213
220 bool moveLast()
221 {
222 m_pNode = m_pList->m_pTail;
223 return m_pNode != nullptr;
224 }
225
233 bool moveNext()
234 {
235 if(!m_pNode)
236 return false;
237 m_pNode = m_pNode->m_pNext;
238 return m_pNode != nullptr;
239 }
240
250 {
251 if(!m_pNode)
252 return false;
253 m_pNode = m_pNode->m_pNext;
254 return m_pNode != nullptr;
255 }
256
265 bool movePrev()
266 {
267 if(!m_pNode)
268 return false;
269 m_pNode = m_pNode->m_pPrev;
270 return m_pNode != nullptr;
271 }
272
283 {
284 if(!m_pNode)
285 return false;
286 m_pNode = m_pNode->m_pPrev;
287 return m_pNode != nullptr;
288 }
289
297 {
298 return m_pNode ? (T *)(m_pNode->m_pData) : nullptr;
299 }
300
309 {
310 return m_pNode ? (T *)(m_pNode->m_pData) : nullptr;
311 }
312
319 bool isValid()
320 {
321 return m_pNode != nullptr;
322 }
323};
324
369template <typename T>
371{
372 friend class KviPointerListIterator<T>;
373
374protected:
375 bool m_bAutoDelete; //< do we automatically delete items when they are removed ?
376
377 KviPointerListNode * m_pHead; //< our list head pointer (nullptr if there are no items in the list)
378 KviPointerListNode * m_pTail; //< our list tail
379 KviPointerListNode * m_pAux; //< our iteration pointer
380
381 unsigned int m_uCount; //< the count of items in the list
382protected:
393 void insertBeforeSafe(KviPointerListNode * ref, const T * d)
394 {
395 m_pAux = ref;
397 n->m_pPrev = m_pAux->m_pPrev;
398 n->m_pNext = m_pAux;
399 if(m_pAux->m_pPrev)
400 {
401 m_pAux->m_pPrev->m_pNext = n;
402 }
403 else
404 {
405 m_pHead = n;
406 }
407 m_pAux->m_pPrev = n;
408 n->m_pData = (void *)d;
409 m_uCount++;
410 }
411
418 {
419 KviPointerListNode * pNewHead = src->m_pHead;
420 if(!pNewHead)
421 return;
422
423 if(pNewHead->m_pNext)
424 {
425 src->m_pHead = pNewHead->m_pNext;
426 src->m_pHead->m_pPrev = nullptr;
427 }
428 else
429 {
430 src->m_pHead = nullptr;
431 src->m_pTail = nullptr;
432 }
433
434 if(m_pHead)
435 {
436 m_pHead->m_pPrev = pNewHead;
437 pNewHead->m_pNext = m_pHead;
438 m_pHead = pNewHead;
439 }
440 else
441 {
442 m_pHead = pNewHead;
443 m_pTail = pNewHead;
444 m_pHead->m_pNext = nullptr;
445 }
446 m_uCount++;
447 src->m_uCount--;
448 }
449
455 {
456 if(m_pAux->m_pPrev)
457 m_pAux->m_pPrev->m_pNext = m_pAux->m_pNext;
458 else
459 m_pHead = m_pAux->m_pNext;
460 if(m_pAux->m_pNext)
461 m_pAux->m_pNext->m_pPrev = m_pAux->m_pPrev;
462 else
463 m_pTail = m_pAux->m_pPrev;
464 const T * pAuxData = (const T *)(m_pAux->m_pData);
465 delete m_pAux;
466 m_pAux = nullptr;
467 m_uCount--;
468 if(m_bAutoDelete)
469 delete pAuxData; // this can cause recursion, so do it at the end
470 }
471
472public:
482 {
483 m_pAux = m_pHead;
485 m_uCount += src->m_uCount;
486 while(m_pAux && n)
487 {
488 if(kvi_compare((const T *)(m_pAux->m_pData), (const T *)(n->m_pData)) > 0)
489 {
490 // our element is greater, n->m_pData goes first
491 KviPointerListNode * pNext = n->m_pNext;
492 n->m_pPrev = m_pAux->m_pPrev; // his prev becomes
493 n->m_pNext = m_pAux;
494 if(m_pAux->m_pPrev)
495 m_pAux->m_pPrev->m_pNext = n;
496 else
497 m_pHead = n;
498 m_pAux->m_pPrev = n;
499 n = pNext;
500 }
501 else
502 {
503 // that element is greater
504 m_pAux = m_pAux->m_pNext;
505 }
506 }
507 if(n)
508 {
509 // last items to append
510 if(m_pTail)
511 {
512 m_pTail->m_pNext = n;
513 n->m_pPrev = m_pTail;
514 }
515 else
516 {
517 m_pHead = n;
518 m_pTail = n;
519 n->m_pPrev = nullptr;
520 }
521 m_pTail = src->m_pTail;
522 }
523
524 src->m_pHead = nullptr;
525 src->m_pTail = nullptr;
526 src->m_uCount = 0;
527 }
528
535 {
537 m_pHead = src->m_pHead;
538 src->m_pHead = n;
539 n = m_pTail;
540 m_pTail = src->m_pTail;
541 src->m_pTail = n;
542 unsigned int uCount = m_uCount;
543 m_uCount = src->m_uCount;
544 src->m_uCount = uCount;
545 }
546
556 void sort()
557 {
558 if(m_uCount < 2)
559 return;
560
561 KviPointerList<T> carry;
562 KviPointerList<T> tmp[64];
563 KviPointerList * fill = &tmp[0];
564 KviPointerList * counter;
565
566 do
567 {
568 carry.grabFirstAndPrepend(this);
569
570 for(counter = &tmp[0]; counter != fill && !counter->isEmpty(); ++counter)
571 {
572 counter->merge(&carry);
573 carry.swap(counter);
574 }
575 carry.swap(counter);
576 if(counter == fill)
577 ++fill;
578 } while(m_uCount > 0);
579
580 for(counter = &tmp[1]; counter != fill; ++counter)
581 counter->merge(counter - 1);
582 swap(fill - 1);
583 }
584
596 void inSort(T * t)
597 {
599 while(x && (kvi_compare(((T *)x->m_pData), t) > 0))
600 x = x->m_pNext;
601 if(!x)
602 append(t);
603 else
605 }
606
611 bool isEmpty() const
612 {
613 return (m_pHead == nullptr);
614 }
615
620 unsigned int count() const
621 {
622 return m_uCount;
623 }
624
632 T * first()
633 {
634 if(!m_pHead)
635 {
636 m_pAux = nullptr;
637 return nullptr;
638 }
639 m_pAux = m_pHead;
640 return (T *)(m_pAux->m_pData);
641 }
642
651 {
652 if(!m_pHead)
653 return nullptr;
654 T * pData = (T *)m_pHead->m_pData;
655 if(m_pHead->m_pNext)
656 {
657 m_pHead = m_pHead->m_pNext;
658 delete m_pHead->m_pPrev;
659 m_pHead->m_pPrev = nullptr;
660 }
661 else
662 {
663 delete m_pHead;
664 m_pHead = nullptr;
665 m_pTail = nullptr;
666 }
667 m_pAux = nullptr;
668 m_uCount--;
669 return pData;
670 }
671
677 {
678 if(!m_pTail)
679 return nullptr;
680 T * pData = (T *)m_pTail->m_pData;
681 if(m_pTail->m_pPrev)
682 {
683 m_pTail = m_pTail->m_pPrev;
684 delete m_pTail->m_pNext;
685 m_pTail->m_pNext = nullptr;
686 }
687 else
688 {
689 delete m_pTail;
690 m_pHead = nullptr;
691 m_pTail = nullptr;
692 }
693 m_pAux = nullptr;
694 m_uCount--;
695 return pData;
696 }
697
706
714 T * last()
715 {
716 if(!m_pTail)
717 {
718 m_pAux = nullptr;
719 return nullptr;
720 }
721 m_pAux = m_pTail;
722 return (T *)(m_pAux->m_pData);
723 }
724
733
742 {
743 return (T *)(m_pAux->m_pData);
744 }
745
756 {
757 return m_pAux ? (T *)(m_pAux->m_pData) : nullptr;
758 }
759
771
781 T * next()
782 {
783 if(!m_pAux)
784 return nullptr;
785 m_pAux = m_pAux->m_pNext;
786 if(m_pAux)
787 return (T *)(m_pAux->m_pData);
788 return nullptr;
789 }
790
801 T * prev()
802 {
803 if(!m_pAux)
804 return nullptr;
805 m_pAux = m_pAux->m_pPrev;
806 if(m_pAux)
807 return (T *)(m_pAux->m_pData);
808 return nullptr;
809 }
810
819 T * at(int idx)
820 {
821 T * t = first();
822 int cnt = 0;
823 while(t)
824 {
825 if(idx == cnt)
826 return t;
827 t = next();
828 cnt++;
829 }
830 return nullptr;
831 }
832
839 {
841 int cnt = 0;
842 while(n)
843 {
844 if(idx == cnt)
845 return KviPointerListIterator<T>(*this, n);
846 n = n->m_pNext;
847 cnt++;
848 }
849 return KviPointerListIterator<T>(*this, nullptr);
850 }
851
861 int findRef(const T * d)
862 {
863 int ret = 0;
864 for(T * t = first(); t; t = next())
865 {
866 if(t == d)
867 return ret;
868 ret++;
869 }
870 return -1;
871 }
872
879 {
881 while(n)
882 {
883 if(n->m_pData == d)
884 return KviPointerListIterator<T>(*this, n);
885 n = n->m_pNext;
886 }
887 return KviPointerListIterator<T>(*this, nullptr);
888 }
889
895 void append(const T * d)
896 {
897 if(!m_pHead)
898 {
900 m_pHead->m_pPrev = nullptr;
901 m_pHead->m_pNext = nullptr;
902 m_pHead->m_pData = (void *)d;
904 }
905 else
906 {
907 m_pTail->m_pNext = new KviPointerListNode;
908 m_pTail->m_pNext->m_pPrev = m_pTail;
909 m_pTail->m_pNext->m_pNext = nullptr;
910 m_pTail->m_pNext->m_pData = (void *)d;
911 m_pTail = m_pTail->m_pNext;
912 }
913 m_uCount++;
914 }
915
922 {
923 for(T * t = l->first(); t; t = l->next())
924 append(t);
925 }
926
933 {
934 for(T * t = l->last(); t; t = l->prev())
935 prepend(t);
936 }
937
943 void prepend(const T * d)
944 {
945 if(!m_pHead)
946 {
948 m_pHead->m_pPrev = nullptr;
949 m_pHead->m_pNext = nullptr;
950 m_pHead->m_pData = (void *)d;
952 }
953 else
954 {
955 m_pHead->m_pPrev = new KviPointerListNode;
956 m_pHead->m_pPrev->m_pNext = m_pHead;
957 m_pHead->m_pPrev->m_pPrev = nullptr;
958 m_pHead->m_pPrev->m_pData = (void *)d;
959 m_pHead = m_pHead->m_pPrev;
960 m_uCount++;
961 }
962 }
963
976 void insert(int iIndex, const T * d)
977 {
978 m_pAux = m_pHead;
979 while(m_pAux && iIndex > 0)
980 {
981 iIndex--;
982 m_pAux = m_pAux->m_pNext;
983 }
984 if(m_pAux)
986 else
987 append(d);
988 }
989
997 {
998 if(!m_pHead)
999 return false;
1000 const T * pAuxData;
1001 if(m_pHead->m_pNext)
1002 {
1003 m_pHead = m_pHead->m_pNext;
1004 pAuxData = (const T *)(m_pHead->m_pPrev->m_pData);
1005 delete m_pHead->m_pPrev;
1006 m_pHead->m_pPrev = nullptr;
1007 }
1008 else
1009 {
1010 pAuxData = (const T *)(m_pHead->m_pData);
1011 delete m_pHead;
1012 m_pHead = nullptr;
1013 m_pTail = nullptr;
1014 }
1015 m_pAux = nullptr;
1016 m_uCount--;
1017 if(m_bAutoDelete)
1018 delete pAuxData;
1019 return true;
1020 }
1021
1029 {
1030 if(!m_pTail)
1031 return false;
1032 const T * pAuxData;
1033 if(m_pTail->m_pPrev)
1034 {
1035 m_pTail = m_pTail->m_pPrev;
1036 pAuxData = (const T *)(m_pTail->m_pNext->m_pData);
1037 delete m_pTail->m_pNext;
1038 m_pTail->m_pNext = nullptr;
1039 }
1040 else
1041 {
1042 pAuxData = (const T *)(m_pTail->m_pData);
1043 delete m_pTail;
1044 m_pHead = nullptr;
1045 m_pTail = nullptr;
1046 }
1047 m_pAux = nullptr;
1048 m_uCount--;
1049 if(m_bAutoDelete)
1050 delete pAuxData;
1051 return true;
1052 }
1053
1062 bool remove(int iIndex)
1063 {
1064 m_pAux = m_pHead;
1065 while(m_pAux && iIndex > 0)
1066 {
1067 iIndex--;
1068 m_pAux = m_pAux->m_pNext;
1069 }
1070 if(!m_pAux)
1071 return false;
1073 return true;
1074 }
1075
1085 void setAutoDelete(bool bAutoDelete)
1086 {
1087 m_bAutoDelete = bAutoDelete;
1088 }
1089
1095 {
1096 return m_bAutoDelete;
1097 };
1098
1105 void clear()
1106 {
1107 while(m_pHead)
1108 removeFirst();
1109 }
1110
1119 {
1120 if(!m_pAux)
1121 return false;
1123 return true;
1124 }
1125
1134 bool removeRef(const T * d)
1135 {
1136 if(findRef(d) == -1)
1137 return false;
1139 return true;
1140 }
1141
1152 void insertAfter(const T * ref, const T * d)
1153 {
1154 if(findRef(ref) == -1)
1155 {
1156 append(d);
1157 return;
1158 }
1160 n->m_pPrev = m_pAux;
1161 n->m_pNext = m_pAux->m_pNext;
1162 if(m_pAux->m_pNext)
1163 m_pAux->m_pNext->m_pPrev = n;
1164 else
1165 m_pTail = n;
1166 m_pAux->m_pNext = n;
1167 n->m_pData = (void *)d;
1168 m_uCount++;
1169 }
1170
1182 void insertBefore(const T * ref, const T * d)
1183 {
1184 if(findRef(ref) == -1)
1185 {
1186 prepend(d);
1187 return;
1188 }
1190 n->m_pPrev = m_pAux->m_pPrev;
1191 n->m_pNext = m_pAux;
1192 if(m_pAux->m_pPrev)
1193 m_pAux->m_pPrev->m_pNext = n;
1194 else
1195 m_pHead = n;
1196 m_pAux->m_pPrev = n;
1197 n->m_pData = (void *)d;
1198 m_uCount++;
1199 }
1200
1205 void invert()
1206 {
1207 if(!m_pHead)
1208 return;
1209 KviPointerListNode * oldHead = m_pHead;
1210 KviPointerListNode * oldTail = m_pTail;
1212 while(n)
1213 {
1214 KviPointerListNode * next = n->m_pNext;
1215 n->m_pNext = n->m_pPrev;
1216 n->m_pPrev = next;
1217 n = next;
1218 }
1219 m_pTail = oldHead;
1220 m_pHead = oldTail;
1221 }
1222
1229 {
1230 clear();
1231 for(T * t = l->first(); t; t = l->next())
1232 append(t);
1233 }
1234
1243 {
1244 copyFrom(&l);
1245 return *this;
1246 }
1247
1253 KviPointerList<T>(bool bAutoDelete = true)
1254 {
1255 m_bAutoDelete = bAutoDelete;
1256 m_pHead = nullptr;
1257 m_pTail = nullptr;
1258 m_uCount = 0;
1259 m_pAux = nullptr;
1260 };
1261
1267 virtual ~KviPointerList<T>()
1268 {
1269 clear();
1270 };
1271};
1272
1273#define KviPointerListBase KviPointerList
1274
1275// BROKEN MSVC LINKER
1276#ifdef COMPILE_ON_WINDOWS
1277#include "KviCString.h"
1279#endif
1280
1281// Provide a default implementation of kvi_compare()
1282template <typename T>
1283int kvi_compare(const T * p1, const T * p2)
1284{
1285 return p1 > p2; // just compare pointers
1286}
1287
1288#endif //_KVI_POINTERLIST_H_
int kvi_compare(const T *p1, const T *p2)
Definition KviPointerList.h:1283
A fast KviPointerList iterator.
Definition KviPointerList.h:142
KviPointerListNode * m_pNode
Definition KviPointerList.h:145
T * current()
Returns the value pointed by the iterator.
Definition KviPointerList.h:296
KviPointerListIterator(KviPointerList< T > &l)
Creates an iterator for the list l.
Definition KviPointerList.h:168
bool moveNext()
Moves the iterator to the next element of the list.
Definition KviPointerList.h:233
bool operator++()
Moves the iterator to the next element of the list.
Definition KviPointerList.h:249
bool movePrev()
Moves the iterator to the previous element of the list.
Definition KviPointerList.h:265
bool operator--()
Moves the iterator to the previous element of the list.
Definition KviPointerList.h:282
KviPointerList< KviKvsObjectConnection > * m_pList
Definition KviPointerList.h:144
bool isValid()
Returns true if this iterator points to a valid element.
Definition KviPointerList.h:319
KviPointerListIterator(KviPointerList< T > &l, KviPointerListNode *pNode)
Creates an iterator for the list l.
Definition KviPointerList.h:182
void operator=(const KviPointerListIterator< T > &src)
Creates an iterator copy.
Definition KviPointerList.h:195
KviPointerListIterator(const KviPointerListIterator< T > &src)
Creates an iterator copy.
Definition KviPointerList.h:155
bool moveFirst()
Moves the iterator to the first element of the list.
Definition KviPointerList.h:208
bool moveLast()
Moves the iterator to the last element of the list.
Definition KviPointerList.h:220
T * operator*()
Returns the value pointed by the iterator.
Definition KviPointerList.h:308
A KviPointerList node pointers.
Definition KviPointerList.h:63
void * m_pData
Definition KviPointerList.h:66
KviPointerListNode * m_pNext
Definition KviPointerList.h:67
KviPointerListNode * m_pPrev
Definition KviPointerList.h:65
A template double linked list of pointers.
Definition KviPointerList.h:371
void insertAfter(const T *ref, const T *d)
Inserts the item d after the item ref.
Definition KviPointerList.h:1152
void copyFrom(KviPointerList< T > *l)
Clears the list and inserts all the items from the list l.
Definition KviPointerList.h:1228
bool remove(int iIndex)
Removes the item at zero-based position iIndex.
Definition KviPointerList.h:1062
void grabFirstAndPrepend(KviPointerList< T > *src)
Grabs the first element from the list src and puts it as the first element of this list.
Definition KviPointerList.h:417
friend class KviPointerListIterator< T >
Definition KviPointerList.h:372
T * at(int idx)
Returns the item at index position.
Definition KviPointerList.h:819
void append(const T *d)
Appends an item at the end of the list.
Definition KviPointerList.h:895
T * last()
Returns the last item in the list.
Definition KviPointerList.h:714
KviPointerListIterator< T > iteratorAtFirst()
Returns an iterator pointing to the first item of the list.
Definition KviPointerList.h:702
KviPointerListIterator< T > iteratorAtCurrent()
Returns an iterator pointing to the current item in the list.
Definition KviPointerList.h:767
void removeCurrentSafe()
Removes the current iteration item assuming that it is valid.
Definition KviPointerList.h:454
void insertBeforeSafe(KviPointerListNode *ref, const T *d)
Inserts the item d before the item ref.
Definition KviPointerList.h:393
void append(KviPointerList< T > *l)
Appends all the items from the list l to this list.
Definition KviPointerList.h:921
virtual ~KviPointerList()
Destroys the list.
Definition KviPointerList.h:1267
KviPointerListNode * m_pTail
Definition KviPointerList.h:378
bool autoDelete()
Returns the autodelete flag.
Definition KviPointerList.h:1094
void invert()
Inverts the elements in the list.
Definition KviPointerList.h:1205
KviPointerList(bool bAutoDelete=true)
Creates a template list.
Definition KviPointerList.h:1253
void setAutoDelete(bool bAutoDelete)
Sets the autodelete flag.
Definition KviPointerList.h:1085
void insertBefore(const T *ref, const T *d)
Inserts the item d before the item ref.
Definition KviPointerList.h:1182
KviPointerListIterator< T > iteratorAt(int idx)
Returns an iterator pointing to the item at the specified index.
Definition KviPointerList.h:838
int findRef(const T *d)
Returns the position of an item.
Definition KviPointerList.h:861
bool removeFirst()
Removes the first item (if any)
Definition KviPointerList.h:996
void merge(KviPointerList< T > *src)
Inserts the list src inside this list.
Definition KviPointerList.h:481
T * prev()
Returns the previous item in the list.
Definition KviPointerList.h:801
bool m_bAutoDelete
Definition KviPointerList.h:375
void prepend(KviPointerList< T > *l)
Prepends all the items from the list l to this list.
Definition KviPointerList.h:932
T * current()
Returns the current iteration item.
Definition KviPointerList.h:741
bool isEmpty() const
Returns true if the list is empty.
Definition KviPointerList.h:611
unsigned int m_uCount
Definition KviPointerList.h:381
void insert(int iIndex, const T *d)
Inserts the item d at the position specified by iIndex.
Definition KviPointerList.h:976
void prepend(const T *d)
Inserts the item d in the head position.
Definition KviPointerList.h:943
KviPointerListNode * m_pHead
Definition KviPointerList.h:377
KviPointerList< T > & operator=(KviPointerList< T > &l)
Clears the list and inserts all the items from the list l.
Definition KviPointerList.h:1242
T * takeLast()
Removes the last item (if any) and returns it. This function obviously never deletes the item (regadl...
Definition KviPointerList.h:676
bool removeCurrent()
Removes the current iteration item.
Definition KviPointerList.h:1118
void inSort(T *t)
Inserts the item respecting the sorting order inside the list.
Definition KviPointerList.h:596
T * takeFirst()
Removes the first element from the list.
Definition KviPointerList.h:650
void swap(KviPointerList< T > *src)
Swap the lists.
Definition KviPointerList.h:534
KviPointerListIterator< T > iteratorAtRef(const T *d)
Returns an iterator pointing to the item with pointer d.
Definition KviPointerList.h:878
T * safeCurrent()
Returns the current iteration item.
Definition KviPointerList.h:755
unsigned int count() const
Returns the count of the items in the list.
Definition KviPointerList.h:620
void clear()
Removes all the items from the list.
Definition KviPointerList.h:1105
T * first()
Returns the first item in the list.
Definition KviPointerList.h:632
KviPointerListNode * m_pAux
Definition KviPointerList.h:379
bool removeRef(const T *d)
Removes the item pointed by d (if found in the list)
Definition KviPointerList.h:1134
KviPointerListIterator< T > iteratorAtLast()
Returns an iterator pointing to the first item of the list.
Definition KviPointerList.h:729
bool removeLast()
Removes the firstitem (if any)
Definition KviPointerList.h:1028
void sort()
Sorts this list in ascending order.
Definition KviPointerList.h:556
T * next()
Returns the next item in the list.
Definition KviPointerList.h:781
#define t
Definition detector.cpp:85
#define d
Definition detector.cpp:69
#define l
Definition detector.cpp:77
#define x
Definition detector.cpp:89
#define n
Definition detector.cpp:79
This file contains compile time settings.
#define KVILIB_API
Definition kvi_settings.h:124