File: INCLUDE\UTILS\U_LISTS.H
1 //#############################################################################
2 // //
3 // U_LISTS.H //
4 // Subsystem: Utilities - verkettete Listen //
5 // Benutung durch andere Subsysteme erforderlich: JA //
6 // Implementation: U_LISTS.CPP //
7 //---------------------------------------------------------------------------//
8 // Autoren: Thomas Kullmann, Günther Reinecker //
9 // Stand: 02.04.2004 //
10 // //
11 //#############################################################################
12
13 #ifndef __U_LISTS_H
14 #define __U_LISTS_H
15
16 #include "u_values.h" // für _CURVECLASS, _FREEOBJ, Trace
17
18 //##############################################################################
19 // TLnkContainer
20 //##############################################################################
21
22 // Kontainer zum Verketten von void* -Elementen als doppelt verkettete Liste
23 // Zugriff nur durch dieses Subsystem
24 class TLnkContainer {
25 friend class TLnkList;
26 friend class TIndList;
27
28 private:
29 TLnkContainer(void *const aData, TLnkList &aList);
30
31 // ==> stimmen <aList> und <m_List> überein ?
32 bool IsElementOf(const TLnkList *const aList) const;
33
34 // ATTRIBUT(E)
35 private:
36 void *const m_Data;
37
38 TLnkList &m_List;
39
40 TLnkContainer *m_Prev;
41 TLnkContainer *m_Next;
42 };
43
44 //##############################################################################
45 // TLnkList
46 //##############################################################################
47
48 // doppelt verkettete Liste
49 // Zugriff nur über Container und dieses Subsystem
50 class _CURVECLASS TLnkList { // entfernen von Elementen bislang nur einmal in der Liste vorhandene Daten und <aData>!=0 getestet
51 private:
52 TLnkList(const TLnkList& aList) : m_FailIfNull(aList.m_FailIfNull), m_FailIfExists(aList.m_FailIfExists), m_AutoDelete(aList.m_AutoDelete), m_CheckOnDel(aList.m_CheckOnDel), m_First(0), m_Last(0) {}; // kein Copy-Konstruktor
53 TLnkList &operator= (const TLnkList&) { return *this; }; // kein Zuweisungsoperator
54
55 public:
56 TLnkList(const bool aFailIfNull= true, const bool aFailIfExists= true, const bool aAutoDelete= false, const bool aCheckOnDel= true);
57 virtual ~TLnkList();
58
59 // gibt das Element aus dem Container zurück
60 // (1) wenn <m_AutoDelete>==true darf das Element nicht selbst mit delete freigegeben werden!
61 // ==> das im Container verpackte Element
62 void *GetAt(TLnkContainer &aContainer) const;
63
64 // fügt <aData> am Anfang der Liste ein
65 // (1) wenn <m_FailIfExists>==true und <aData> bereits in der Liste, dann wird <aData> nicht eingefügt
66 // (2) wenn <m_FailIfNull>==true und <aData>==0 ist, wird <aData> nicht eingefügt
67 // ==> wurde <aData> eingefügt
68 // bei (1) und (2) ist der Rückgabewert false
69 bool Insert(void *const aData);
70
71 // fügt <aData> am Ende der Liste ein
72 // (1) wenn <m_FailIfExists>==true und <aData> bereits in der Liste, dann wird <aData> nicht eingefügt
73 // (2) wenn <m_FailIfNull>==true und <aData>==0 ist, wird <aData> nicht eingefügt
74 // ==> wurde <aData> eingefügt
75 // bei (1) und (2) ist der Rückgabewert false
76 bool Append(void *const aData);
77
78 // fügt <aData> VOR <aContainer> ein
79 // (0) wenn <aContainer>==0 wird am Anfang der Liste eingefügt - siehe Insert
80 // (1) wenn <m_FailIfExists>==true und <aData> bereits in der Liste, dann wird <aData> nicht eingefügt
81 // (2) wenn <m_FailIfNull>==true und <aData>==0 ist, wird <aData> nicht eingefügt
82 // ==> wurde <aData> eingefügt
83 // bei (1) und (2) ist der Rückgabewert false
84 bool InsBefore(TLnkContainer *aContainer, void *const aData);
85
86 // fügt <aData> NACH <aContainer> ein
87 // (0) wenn <aContainer>==0 wird am Ende der Liste eingefügt - siehe Append
88 // (1) wenn <m_FailIfExists>==true und <aData> bereits in der Liste, dann wird <aData> nicht eingefügt
89 // (2) wenn <m_FailIfNull>==true und <aData>==0 ist, wird <aData> nicht eingefügt
90 // ==> wurde <aData> eingefügt
91 // bei (1) und (2) ist der Rückgabewert false
92 bool AddAfter(TLnkContainer *aContainer, void *const aData);
93
94 // entfernt <aContainer>
95 // (1) wenn <m_AutoDelete>==true und das in <aContainer> liegende Non-Null-Element einzigartig in der Liste ist, wird das Element entfernt und mit delete freigegeben
96 // ==> das entfernte Element
97 // bei (1) ist der Rückgabewert 0
98 void *Remove(TLnkContainer &aContainer);
99
100 // sucht das erste Element, das <aData> verwaltet und entfernt dieses
101 void *RemoveData(void *aData);
102
103 // entfernt alle Element aus der Liste
104 // bei <m_AutoDelete>==true werden die Non-Null-Elemente mit delete freigegeben
105 virtual void Clear();
106
107 // entfernt <aContainer> und Folgeelemente
108 // bei <m_AutoDelete>==true werden einzigartige Non-Null-Elemente mit delete freigegeben
109 void CutList(TLnkContainer &aContainer);
110
111 protected:
112 virtual void FreeData(void *aData) const; // überschreiben, wenn in der Liste nur Objekte eines bestimmten Typs enthalten sind (dann <aData> auf diesen Typ casten und freigeben)
113
114 private:
115 // sucht nach dem nächsten Container, der <aData> beinhaltet - die Suche beginnt bei <aStart>
116 // ist <aStart>==0, beginnt die Suche am Anfang
117 // ==> der gefundene Container; ggf. 0
118 TLnkContainer *Find(void *aData, TLnkContainer *aStart=0);
119
120 // ATTRIBUT(E)
121 protected:
122 const bool m_FailIfNull; // Null-Elemente dürfen nicht eingefügt werden
123 const bool m_FailIfExists; // Elemente dürfen nicht mehrfach eingefügt werden
124 const bool m_AutoDelete; // Non-Null-Elemente mit delete freigeben, wenn letztes Vorkommen mit Remove bzw. Clear entfernt wird
125 const bool m_CheckOnDel; // bei automatischen Freigeben ( <m_AutoDelete>==true ) wird geprüft, ob weitere Vorkommen in der Liste verbleiben - ggf. wird das Objekt nicht freigegeben, sondern nur aus der Liste entfernt
126
127 TLnkContainer *m_First;
128 TLnkContainer *m_Last;
129 };
130
131 //##############################################################################
132 // TIndList
133 //##############################################################################
134
135 typedef unsigned long TIndex;
136
137 // Liste von void* -Elementen; Zugriff per Index, d.h. [0...GetCount()-1]
138 // ***In der DEBUG-Version wird zusätzlich eine TraceErr-Fehlermeldung ausgegeben!
139 class _CURVECLASS TIndList : protected TLnkList {
140 public:
141 TIndList(const bool aFailIfNull= true, const bool aFailIfExists= true, const bool aAutoDelete= false, const bool aCheckOnDel= true, const TIndex &aTemp= 32);
142
143 // (0) Bei einem zu großen Index wird das letzte Element zurückgegeben.***
144 // (E) Ist die Liste leer, wird 0 zurückgegeben.***
145 // <aValid> wird true gesetzt, wenn <aIndex> gültig ist und die Liste nicht leer ist; sonst false.
146 // ==> das Element an Position <aIndex>
147 void *GetAt(TIndex aIndex, bool &aValid) const;
148
149 // WIEVOR, jedoch ohne aValid - d.h. ein zu großer Index oder eine leere Liste sind für den Aufrufer nicht nachvollziehbar
150 void *GetAt(TIndex aIndex) const;
151 void *operator[] (TIndex aIndex) const;
152
153 // fügt <aData> am Anfang bzw. am Ende der Liste ein
154 // (1) und (2) und Rückgabewert gelten von TLnkList::Insert bzw. TLnkList::Append
155 bool Insert(void *const aData);
156 bool Append(void *const aData);
157
158 // fügt <aData> VOR dem Element an Position <aIndex> ein
159 // (E) Bei einem zu großen Index oder einer leeren Liste wird am Ende eingefügt.***
160 // (1) und (2) und Rückgabewert gelten von TLnkList::InsBefore
161 bool InsBefore(TIndex aIndex, void *const aData);
162
163 // fügt <aData> NACH dem Element an Position <aIndex> ein
164 // (E) Bei einem zu großen Index oder einer leeren Liste wird am Ende eingefügt.***
165 // (1) und (2) und Rückgabewert gelten von TLnkList::AddAfter
166 bool AddAfter(TIndex aIndex, void *const aData);
167
168 // entfernt das Element an Position <aIndex>
169 // (0) Bei einem zu großen Index wird das letzte Element entfernt.***
170 // (E) Ist die Liste leer, wird nur 0 zurückgegeben.***
171 // (1) und Rückgabewert gelten von TLnkList::Remove
172 void *Remove(TIndex aIndex);
173
174 // entfernt das erste Vorkommen, das <aData> beinhaltet
175 // (E) Ist die Liste leer oder wird <aData> nicht gefunden, wird nur 0 zurückgegeben.
176 void *RemoveData(void *aData);
177
178 // entfernt das Element an Position <aIndex> und alle Folgeelemente
179 // (E) Bei einem zu großen Index oder einer leeren Liste wird keine Aktion ausgeführt.***
180 void CutList(TIndex aCount);
181
182 // wie TLnkList::Clear
183 virtual void Clear();
184
185 // ==> Anzahl der Elemente
186 TIndex GetCount() const;
187
188 private:
189 void DoInvalidAccelerator();
190
191 // Hilfemethoden für Find
192 TLnkContainer *FindForward(TIndex, const TIndex, TLnkContainer *) const; // sucht vorwärts
193 TLnkContainer *FindBackward(TIndex, const TIndex, TLnkContainer *) const; // sucht rückwärts
194
195 // ==> der Container an Position <aIndex>
196 // (0) Bei einem zu großen Index wird in der RELEASE-Version das letzte Element zurückgegeben.***
197 // (E) Ist die Liste leer, wird 0 zurückgegeben.***
198 TLnkContainer *FindIdx(TIndex aIndex, bool aAdoptAccelerator= true) const;
199
200 // ATTRIBUT(E)
201 protected:
202 TIndex m_Count;
203
204 // zuletzt benutzer Index und der dazugehöriger Container
205 TIndex m_AccelIndex;
206 TLnkContainer *m_AccelContainer;
207 };
208
209 //##############################################################################
210 // TIdxContainer
211 //##############################################################################
212
213 const cDefaultSize= 16;
214
215 // Container der ein Array von void* -Elementen enthält
216 // Zugriff nur durch dieses Subsystem
217 // ***In der DEBUG-Version wird zusätzlich eine TraceErr-Fehlermeldung ausgegeben!
218 class TIdxContainer {
219 friend class TIdxList;
220
221 private:
222 TIdxContainer(const TIndex &aSize= cDefaultSize);
223 virtual ~TIdxContainer(); // die noch enthaltenen Elemente werden nicht automatisch freigegeben, nur die dymanische Liste <m_Data>
224
225 // ==> Größe des Arrays
226 TIndex GetSize() const;
227
228 // verschiebt alle Elemente ab incl. <aStartIdx> bis zum Ende um eine Position nach hinten
229 // (E) Bei einem zu großen Index wird dieser auf den Anfang der Liste gesetzt, d.h. die gesamte Liste wird geshiftet.***
230 // ==> das dabei nach hinten rausgeshiftete (ehemalig letzte) Element
231 void *ShiftRight(TIndex aStartIdx);
232
233 // verschiebt alle Elemente an incl. <aStartIdx> bis zum Ende um eine Position nach vorn
234 // (E) Bei einem zu großen Index wird dieser auf den Anfang der Liste gesetzt, d.h. die gesamte Liste wird geshiftet.***
235 // ==> das dabei nach vorn rausgeshiftete Element (ehemalig an Position <aEndIdx>)
236 void *ShiftLeft(TIndex aStartIdx);
237
238 // ATTRIBUT(E)
239 private:
240 void **m_Data; // dynamisch erzeugte void* -Liste, Größe ist pro Container unveränderlich
241
242 const TIndex m_Size; // Größe der Liste
243
244 TIdxContainer *m_Prev;
245 TIdxContainer *m_Next;
246 };
247
248 //##############################################################################
249 // TIdxList
250 //##############################################################################
251
252 // Liste von void* -Elementen; Zugriff per Index, d.h. [0...GetCount()-1]
253 // ***In der DEBUG-Version wird zusätzlich eine TraceErr-Fehlermeldung ausgegeben!
254 class _CURVECLASS TIdxList { // entfernen von Elementen bislang nur einmal in der Liste vorhandene Daten und <aData>!=0 getestet
255 private:
256 TIdxList(const TIdxList& aList) : m_FailIfNull(aList.m_FailIfNull), m_FailIfExists(aList.m_FailIfExists), m_AutoDelete(aList.m_AutoDelete), m_CheckOnDel(aList.m_CheckOnDel), m_First(0), m_Last(0), m_Count(0), m_Used(0), m_Size(aList,m_Size) {}; // kein Copy-Konstruktor
257 TIdxList &operator= (const TIdxList&) { return *this; }; // kein Zuweisungsoperator
258
259 public:
260 TIdxList(const bool aFailIfNull= true, const bool aFailIfExists= true, const bool aAutoDelete= false, const bool aCheckOnDel= true, const TIndex &aSize= cDefaultSize);
261 virtual ~TIdxList();
262
263 // (0) Bei einem zu großen Index wird das letzte Element zurückgegeben.***
264 // (E) Ist die Liste leer, wird 0 zurückgegeben.***
265 // <aValid> wird true gesetzt, wenn <aIndex> gültig ist und die Liste nicht leer ist; sonst false.
266 // ==> das Element an Position <aIndex>
267 void *GetAt(TIndex aIndex, bool &aValid) const;
268
269 // WIEVOR, jedoch ohne aValid - d.h. ein zu großer Index oder eine leere Liste sind für den Aufrufer nicht nachvollziehbar
270 void *GetAt(TIndex aIndex) const;
271 void *operator[] (TIndex aIndex) const;
272
273 // fügt <aData> am Anfang bzw. am Ende der Liste ein
274 // (1) wenn <m_FailIfExists>==true und <aData> bereits in der Liste, dann wird <aData> nicht eingefügt
275 // (2) wenn <m_FailIfNull>==true und <aData>==0 ist, wird <aData> nicht eingefügt
276 // ==> wurde <aData> eingefügt
277 // bei (1) und (2) ist der Rückgabewert false
278 bool Insert(void *const aData);
279 bool Append(void *const aData);
280
281 // fügt <aData> VOR dem Element an Position <aIndex> ein
282 // (E) Bei einem zu großen Index oder einer leeren Liste vor dem Ende eingefügt.***
283 // (1) wenn <m_FailIfExists>==true und <aData> bereits in der Liste, dann wird <aData> nicht eingefügt
284 // (2) wenn <m_FailIfNull>==true und <aData>==0 ist, wird <aData> nicht eingefügt
285 // ==> wurde <aData> eingefügt
286 // bei (1) und (2) ist der Rückgabewert false
287 bool InsBefore(TIndex aIndex, void *const aData);
288
289 // fügt <aData> NACH dem Element an Position <aIndex> ein
290 // (E) Bei einem zu großen Index oder einer leeren Liste wird am Ende eingefügt.***
291 // (1) wenn <m_FailIfExists>==true und <aData> bereits in der Liste, dann wird <aData> nicht eingefügt
292 // (2) wenn <m_FailIfNull>==true und <aData>==0 ist, wird <aData> nicht eingefügt
293 // ==> wurde <aData> eingefügt
294 // bei (1) und (2) ist der Rückgabewert false
295 bool AddAfter(TIndex aIndex, void *const aData);
296
297 // entfernt das Element an Position <aIndex>
298 // (0) Bei einem zu großen Index wird das letzte Element entfernt.***
299 // (E) Ist die Liste leer, wird nur 0 zurückgegeben.***
300 // (1) und Rückgabewert gelten von TLnkList::Remove
301 void *Remove(TIndex aIndex);
302
303 // entfernt das Element an Position <aCount> und alle Folgeelemente
304 // (E) Bei einem zu großen Index oder einer leeren Liste wird keine Aktion ausgeführt.***
305 void CutList(const TIndex &aCount);
306
307 // entfernt alle Elemente
308 virtual void Clear();
309
310 // ==> Anzahl der Elemente
311 TIndex GetCount() const;
312
313 protected:
314 virtual void FreeData(void *aData) const; // überschreiben, wenn in der Liste nur Objekte eines bestimmten Typs enthalten sind (dann <aData> auf diesen Typ casten und freigeben)
315
316 // sucht Container und Index für das Element an Position <aIndex>
317 // der Container ist der Rückgabewert, <aIndex> entspricht nach dem Aufruf der Position in diesem Container
318 // (E) Bei einem zu großen <aIndex> wird das letzte Element zurückgegeben.
319 // (0) Ist die Liste leer, wird 0 zurückgegeben.
320 TIdxContainer *FindIdx(TIndex &aIndex) const;
321
322 // sucht den ersten Container der <aData> enthält
323 // der Container ist der Rückgabewert, <aIndex> entspricht nach dem Aufruf der Position in diesem Container
324 // (0) Ist die Liste leer oder das Element nicht enthalten, wird 0 zurückgegeben.
325 TIdxContainer *Find(void *aData, TIndex &aIndex) const;
326
327 // ATTRIBUT(E)
328 protected:
329 const bool m_FailIfNull; // Null-Elemente dürfen nicht eingefügt werden
330 const bool m_FailIfExists; // Elemente dürfen nicht mehrfach eingefügt werden
331 const bool m_AutoDelete; // Non-Null-Elemente mit delete freigeben, wenn letztes Vorkommen mit Remove bzw. Clear entfernt wird
332 const bool m_CheckOnDel; // bei automatischen Freigeben ( <m_AutoDelete>==true ) wird geprüft, ob weitere Vorkommen in der Liste verbleiben - ggf. wird das Objekt nicht freigegeben, sondern nur aus der Liste entfernt
333
334 TIdxContainer *m_First;
335 TIdxContainer *m_Last;
336
337 TIndex m_Count; // Anzahl der verwalteten Elemente insgesamt
338 TIndex m_Used; // Anzahl der Elemente im letzten Container
339 TIndex m_Size; // Größe der Arrays in den Containern
340 };
341
342 typedef TIdxList TBaseList;
343
344 //##############################################################################
345 // TIntList
346 //##############################################################################
347
348 // Liste von int -Elementen; Zugriff per Index, d.h. [0...GetCount()-1]
349 // ***In der DEBUG-Version wird zusätzlich eine TraceErr-Fehlermeldung ausgegeben!
350 class _CURVECLASS TIntList : protected TBaseList {
351 public:
352 // erzeugt eine Liste mit <aCount> leeren Elementen, deren Wert <aDefaultValue> entspricht
353 // <aSize> regelt die Größe der Container, in denen die Werte verpackt werden - siehe TIdxContainer
354 TIntList(const TIndex &aCount= 0, const int &aDefaultValue= 0, const TIndex &aSize= cDefaultSize);
355 TIntList(const TIntList &aList); // Copy-Konstruktor, die eine neue Liste mit den gleichen Elementen erzeugt
356 TIntList &operator= (const TIntList &aList); // Zuweisungsoperator, der eine neue Liste mit den gleichen Elementen erzeugt
357
358 // (E) Bei einem zu großen Index oder wenn die Liste leer ist, wird <m_DefaultValue> zurückgegeben.***
359 // <aValid> wird true gesetzt, wenn <aIndex> gültig ist und die Liste nicht leer ist; sonst false.
360 // ==> das Element an Position <aIndex>
361 int GetAt(const TIndex &aIndex, bool &aValid) const;
362
363 // WIEVOR, jedoch ohne aValid - d.h. es ein zu großer Index oder eine leere Liste sind für den Aufrufer nicht nachvollziehbar, es wird nur <m_DefaultValue> zurückgegeben
364 int GetAt(const TIndex &aIndex) const;
365
366 // Lesezugriff:
367 // wie GetAt(...)
368 // Schreibzugriff:
369 // (E) Bei einem zu großen Index oder wenn die Liste leer ist, wird kein Wert gesetzt.***
370 // Dazu wird eine Kopie von <m_DefaultValue> zurückgegeben. Diese kann geändert werden, hat aber keine Wirkung auf andere Elemente der Liste oder <m_DefaultValue> selbst.
371 int &operator[] (const TIndex &aIndex);
372
373 // setzt <aValue> als Element an Position <aIndex>
374 // (E) Bei einem zu großen Index oder wenn die Liste leer ist, wird kein Wert gesetzt.***
375 // ==> wurde der Wert gesetzt
376 bool SetAt(const TIndex &aIndex, const int &aValue);
377
378 // fügt <aValue> am Anfang bzw. am Ende der Liste ein
379 bool Insert(const int &aValue);
380 bool Append(const int &aValue);
381
382 // fügt <aValue> VOR bzw. NACH dem Element an Position <aIndex> ein
383 bool InsBefore(const TIndex &aIndex, const int &aValue);
384 bool AddAfter(const TIndex &aIndex, const int &aValue);
385
386 // ändert die Größe der Liste auf <aSize>, indem entweder <aDefaultValue> am Ende eingefügt werden ODER die letzten Elemente entfernt werden
387 void SetCount(const TIndex &aCount, const int &aDefaultValue);
388
389 // wie SetCount(aCount, m_DefaultValue)
390 void SetCount(const TIndex &aCount);
391
392 // Element entfernen; Größe ermitteln
393 TBaseList::Remove;
394 TBaseList::CutList;
395 TBaseList::Clear;
396 TBaseList::GetCount;
397
398 private:
399 int m_DefaultValue;
400 };
401
402 //##############################################################################
403 // TFloatList
404 //##############################################################################
405
406 // Liste von float -Elementen; Zugriff per Index, d.h. [0...GetCount()-1]
407 // Beschreibung siehe TIntList
408 class _CURVECLASS TFloatList : protected TBaseList {
409 public:
410 TFloatList(const TIndex &aCount= 0, const float &aDefaultValue= 0.0, const TIndex &aSize= cDefaultSize);
411 TFloatList(const TFloatList &aList);
412 TFloatList &operator= (const TFloatList &aList);
413
414 float GetAt(const TIndex &aIndex, bool &aValid) const;
415 float GetAt(const TIndex &aIndex) const;
416 float &operator[] (const TIndex &aIndex);
417 bool SetAt(const TIndex &aIndex, const float &aValue);
418
419 bool Insert(const float &aValue);
420 bool Append(const float &aValue);
421
422 bool InsBefore(const TIndex &aIndex, const float &aValue);
423 bool AddAfter(const TIndex &aIndex, const float &aValue);
424
425 void SetCount(const TIndex &aCount, const float &aDefaultValue);
426 void SetCount(const TIndex &aCount);
427
428 // Element entfernen; Größe ermitteln
429 TBaseList::Remove;
430 TBaseList::CutList;
431 TBaseList::Clear;
432 TBaseList::GetCount;
433
434 private:
435 float m_DefaultValue;
436 };
437
438 //##############################################################################
439 // TPoint
440 //##############################################################################
441
442 //! Struktur eines Elements der Kurve
443 class _CURVECLASS TPoint { // aus Speicherspargründen ist Pt nun ein Array statt TFloatList
444 public:
445 TPoint();
446 virtual ~TPoint();
447 TPoint(const TPoint &aPoint);
448 TPoint &operator= (const TPoint &aPoint);
449
450 // Direktzugriff auf <m_Pt>
451 float GetAt(const TIndex &aIndex, bool &aValid) const;
452 float GetAt(const TIndex &aIndex) const;
453 float &operator[] (const TIndex &aIndex);
454 bool SetAt(const TIndex &aIndex, const float &aValue);
455
456 BOOL Valid;
457
458 private:
459 enum { s_Size= 3 }; // Anzahl der Elemente in <m_Pt>
460 float *m_Pt;
461 };
462
463 //##############################################################################
464 // TPointList
465 //##############################################################################
466
467 // Liste von TPoint -Elementen; Zugriff per Index, d.h. [0...GetCount()-1]
468 // Beschreibung siehe TIntList
469 class _CURVECLASS TPointList : protected TBaseList {
470 public:
471 TPointList(const TIndex &aCount= 0, const TIndex &aSize= 128);
472 virtual ~TPointList();
473 TPointList(const TPointList &aList);
474 TPointList &operator= (const TPointList &aList);
475
476 TPoint &GetAt(const TIndex &aIndex, bool &aValid) const;
477 TPoint &GetAt(const TIndex &aIndex) const;
478 TPoint &operator[] (const TIndex &aIndex) const;
479
480 bool Insert(const TPoint &aValue);
481 bool Append(const TPoint &aValue);
482
483 bool InsBefore(const TIndex &aIndex, const TPoint &aValue);
484 bool AddAfter(const TIndex &aIndex, const TPoint &aValue);
485
486 void SetCount(const TIndex &aCount, const TPoint &aDefaultValue);
487 void SetCount(const TIndex &aCount);
488
489 // Element entfernen; Größe ermitteln
490 TBaseList::Remove;
491 TBaseList::CutList;
492 TBaseList::Clear;
493 TBaseList::GetCount;
494
495 protected:
496 virtual void FreeData(void *aData) const;
497
498 private:
499 TPoint m_DefaultValue;
500 };
501
502 #endif // __U_LISTS_H
503