AGENT++  4.0.3
List.h
Go to the documentation of this file.
1 /*_############################################################################
2  _##
3  _## AGENT++ 4.0 - List.h
4  _##
5  _## Copyright (C) 2000-2013 Frank Fock and Jochen Katz (agentpp.com)
6  _##
7  _## Licensed under the Apache License, Version 2.0 (the "License");
8  _## you may not use this file except in compliance with the License.
9  _## You may obtain a copy of the License at
10  _##
11  _## http://www.apache.org/licenses/LICENSE-2.0
12  _##
13  _## Unless required by applicable law or agreed to in writing, software
14  _## distributed under the License is distributed on an "AS IS" BASIS,
15  _## WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  _## See the License for the specific language governing permissions and
17  _## limitations under the License.
18  _##
19  _##########################################################################*/
20 
21 #ifndef _List_h_
22 #define _List_h_
23 
24 #ifndef NULL
25 #define NULL 0
26 #endif
27 
28 #include <agent_pp/agent++.h>
29 #include <agent_pp/avl_map.h>
30 
31 #ifdef AGENTPP_NAMESPACE
32 namespace Agentpp {
33 #endif
34 
35 template <class T> class List;
36 template <class T> class ListCursor;
37 template <class T> class OrderedList;
38 template <class T> class OidListCursor;
39 
47 template <class T> class ListItem {
48 friend class List<T>;
49 friend class ListCursor<T>;
50 friend class OrderedList<T>;
51 public:
58  T* getItem() { return item; }
59 
60 private:
61  ListItem<T> *prev, *next;
62  T* item;
63  ListItem(ListItem<T> *p, ListItem<T> *n, T* i):
64  prev(p), next(n), item(i) { }
65 };
66 
67 template <class T> class List {
68 friend class ListCursor<T>;
69 public:
78  T* addFirst(T* t) {
79  head = new ListItem<T>(NULL, head, t);
80  if (head->next) head->next->prev = head;
81  if (!tail)
82  tail = head;
83  return head->item;
84  }
85 
94  T* addLast(T* t) {
95  if (!head)
96  return addFirst(t);
97  else {
98  ListItem<T> *p = tail;
99  p->next = new ListItem<T>(p, NULL, t);
100  tail = p->next;
101  return tail->item;
102  }
103  }
104 
113  T* add(T* t) { return addLast(t); }
114 
125  T* insertBefore(T* item, T* elem) {
126  if ((!head) || (head->item == elem)) {
127  return addFirst(item);
128  }
129  else {
130  ListItem<T>* tmp;
131  ListItem<T>* h;
132  tmp = head;
133  while ((tmp->next) && (elem != tmp->next->item))
134  tmp = tmp->next;
135  h = tmp->next;
136  if (h) {
137  tmp->next = new ListItem<T>(tmp, h, item);
138  h->prev = tmp->next;
139  }
140  else {
141  tmp->next = new ListItem<T>(tmp, NULL, item);
142  tail = tmp->next;
143  }
144  return tmp->next->item;
145  }
146  }
147 
158  T* insertAfter(T* item, T* elem) {
159  if ((!tail) || (tail->item == elem)) {
160  return addLast(item);
161  }
162  else {
163  ListItem<T>* tmp;
164  ListItem<T>* h;
165  tmp = tail;
166  while ((tmp->prev) && (elem != tmp->prev->item))
167  tmp = tmp->prev;
168  h = tmp->prev;
169  if (h) {
170  tmp->prev = new ListItem<T>(h, tmp, item);
171  h->next = tmp->prev;
172  }
173  else {
174  tmp->prev = new ListItem<T>(NULL, tmp, item);
175  head = tmp->prev;
176  }
177  return tmp->prev->item;
178  }
179  }
180 
187  T* removeFirst() {
188  if (head) {
189  T* retval = head->item;
190  ListItem<T> *temp = head;
191  head = head->next;
192  if (!head)
193  tail = 0;
194  else
195  head->prev = NULL;
196  delete temp;
197  return retval;
198  }
199  return 0;
200  }
201 
208  T* removeLast() {
209  if (tail) {
210  T* retval = tail->item;
211  ListItem<T> *temp = tail;
212  tail = tail->prev;
213  if (!tail)
214  head = 0;
215  else
216  tail->next = NULL;
217  delete temp;
218  return retval;
219  }
220  return 0;
221  }
222 
226  void clearAll() {
227  ListItem<T>* tmp = head;
228  ListItem<T>* del;
229  while (tmp) {
230  delete tmp->item;
231  del = tmp;
232  tmp = tmp->next;
233  delete del;
234  }
235  head = 0;
236  tail = 0;
237  }
238 
243  void clear() {
244  ListItem<T>* tmp = head;
245  ListItem<T>* del;
246  while (tmp) {
247  del = tmp;
248  tmp = tmp->next;
249  delete del;
250  }
251  head = 0;
252  tail = 0;
253  }
254 
264  T* remove(T* i) {
265 
266  ListItem<T> *tmp;
267 
268  if (!head)
269  return 0;
270  tmp = head;
271  do {
272  if (tmp->item == i) {
273  return remove(tmp);
274  }
275  }
276  while ((tmp = tmp->next) != 0);
277  return 0;
278  }
279 
289  T* remove(ListItem<T>* victim) {
290  T* i = victim->item;
291  if ((victim->prev) && (victim->next)) {
292  victim->prev->next = victim->next;
293  victim->next->prev = victim->prev;
294  }
295  else
296  if (victim->next) {
297  victim->next->prev = 0;
298  head = victim->next;
299  }
300  else
301  if (victim->prev) {
302  victim->prev->next = 0;
303  tail = victim->prev;
304  }
305  else {
306  head = 0;
307  tail = 0;
308  }
309  delete victim;
310  return i;
311  }
312 
322  T* getNth(int n) const {
323  if (!head)
324  return NULL;
325  else {
326  ListItem<T> *p = head;
327 
328  while ((n>0) && (p->next)) {
329  n--;
330  p = p->next;
331  }
332  if (n != 0)
333  return NULL;
334  return p->item;
335  }
336  }
337 
347  ListItem<T>* position(T* t) const {
348 
349  ListItem<T> *p = head;
350 
351  while ((p) && (p->item != t))
352  p = p->next;
353  return p;
354  }
355 
365  int index(T* t) const {
366 
367  ListItem<T> *p = head;
368  int i=0;
369  for (; (p) && (p->item != t); i++)
370  p = p->next;
371  return (p) ? i : -1;
372  }
373 
380  T* first() const { return (head) ? head->item : 0; }
387  T* last() const { return (tail) ? tail->item : 0; }
388 
400  T* overwriteNth(int n, T* t) {
401  if (!head)
402  return NULL;
403  else {
404  ListItem<T> *p = head;
405 
406  while ((n>0) && (p->next)) {
407  n--;
408  p = p->next;
409  }
410  if (n == 0) {
411  if (p->item)
412  delete p->item;
413  p->item = t;
414  }
415  return p->item;
416  }
417  }
418 
427  int trim(int n) {
428  T* t = 0;
429  int i=0;
430  for (; (i<n) && ((t = removeLast()) != 0); i++) {
431  delete t;
432  }
433  return i;
434  }
435 
442  int size() const {
443  int r = 0;
444  ListItem<T> *p = head;
445  while (p) {
446  r++;
447  p = p->next;
448  }
449  return r;
450  }
451 
459  bool empty() const {
460  return (head == 0);
461  }
462 
466  List(): head(0), tail(0) { }
467 
471  ~List() { clearAll(); }
472 
473 protected:
474 
475  ListItem<T> *head;
476  ListItem<T> *tail;
477 };
478 
479 template <class T> class ListCursor {
480 public:
481  void init(const List<T>* l) { cursor = l->head; }
482  void initLast(const List<T>* l) { cursor = l->tail; }
483  void init(ListItem<T>* t) { cursor = t; }
484 
485  void init(const OrderedList<T>* l) { cursor = l->content.head; }
486  void initLast(const OrderedList<T>* l) { cursor = l->content.tail; }
487 
488  T* get() {
489  if (cursor)
490  return cursor->item;
491  else
492  return 0;
493  }
494 
495  int next() {
496  if ((cursor) && (cursor->next)) {
497  cursor = cursor->next;
498  return 1;
499  } else
500  if (cursor)
501  cursor = 0;
502  return 0;
503  }
504 
505  int prev() {
506  if ((cursor) && (cursor->prev)) {
507  cursor = cursor->prev;
508  return 1;
509  } else
510  if (cursor)
511  cursor = 0;
512  return 0;
513  }
514 
515  int isNext() {
516  if ((cursor) && (cursor->next))
517  return 1;
518  return 0;
519  }
520 
521  int isPrev() {
522  if ((cursor) && (cursor->prev))
523  return 1;
524  return 0;
525  }
526 
527  ListItem<T>* get_cursor() {
528  return cursor;
529  }
530 
531  ListCursor(): cursor(0) { };
532  ListCursor(const List<T>* l): cursor(l->head) { };
533  ListCursor(const ListCursor<T>& c): cursor(c.cursor) { };
534 
535 protected:
536  ListItem<T> *cursor;
537 };
538 
539 
540 //
541 // OrderedList is implemented as a wrapper of List to avoid corrupting
542 // the order by using directly methods of List
543 //
544 
545 template <class T> class OrderedList;
546 
547 template <class T> class OrderedList {
548 friend class ListCursor<T>;
549 public:
550  T* add(T* item) {
551  if (!content.empty()) {
552  ListCursor<T> cur;
553  for (cur.init(&content); cur.get(); cur.next()) {
554  if (*item < *cur.get())
555  return content.insertBefore(item, cur.get());
556  }
557  return content.add(item);
558  }
559  else return content.add(item);
560  }
561 
562  T* addLast(T* item) {
563  if (!content.empty()) {
564  ListCursor<T> cur;
565  for (cur.initLast(&content); cur.get(); cur.prev()) {
566  if (*item > *cur.get())
567  return content.insertAfter(item,
568  cur.get());
569  }
570  return content.addFirst(item);
571  }
572  else return content.addFirst(item);
573  }
574 
575  // add a new item, but if an equal item already exists:
576  // do not change the list, delete the new item and return 0
577  T* addUnique(T* item) {
578  if (!content.empty()) {
579  ListCursor<T> cur;
580  for (cur.init(&content); cur.get(); cur.next()) {
581  if (*item == *cur.get()) {
582  delete item;
583  return 0;
584  }
585  if (*item < *cur.get())
586  return content.insertBefore(item, cur.get());
587  }
588  return content.add(item);
589  }
590  else return content.add(item);
591  }
592 
593  T* remove(T* item) { return content.remove(item); }
594  T* remove(ListItem<T>* item) { return content.remove(item); }
595 
596  T* overwriteNth(int n, T* t) {
597  return content.overwriteNth(n, t);
598  }
599 
600  int size() const { return content.size(); }
601  T* first() const { return content.first(); }
602  T* last() const { return content.last(); }
603  T* getNth(int i) const { return content.getNth(i); }
604 
605  ListItem<T>* position(T* t) const { return content.position(t); }
606  int index(T* t) const { return content.index(t); }
607 
608  int empty() const { return content.empty(); }
609 
610  void clearAll() { content.clearAll(); }
611  void clear() { content.clear(); }
612 
613 protected:
614 
615  List<T> content;
616 };
617 
618 
619 template <class T> class OrderedListCursor {
620 public:
621  void init(const OrderedList<T>* l) { cursor.init(l); }
622  void initLast(const OrderedList<T>* l) { cursor.initLast(l); }
623  void init(ListItem<T>* t) { cursor.init(t); }
624 
625  T* get() { return cursor.get(); }
626  int next() { return cursor.next(); }
627  int isNext() { return cursor.isNext(); }
628  int prev() { return cursor.prev(); }
629  int isPrev() { return cursor.isPrev(); }
630  ListItem<T>* get_cursor() { return cursor.get_cursor(); }
631 
632  OrderedListCursor() { }
633  OrderedListCursor(const OrderedList<T>* l):
634  cursor((const List<T>*)l) { }
635  OrderedListCursor(const OrderedListCursor<T>& c): cursor(c.cursor) { }
636 protected:
637  ListCursor<T> cursor;
638 };
639 
640 
641 
642 
643 template <class T> class OidList {
644 friend class OidListCursor<T>;
645 public:
646  T* add(T* item) {
647  (*content)[item->key()] = (void*)item;
648  return item;
649  }
650 
651  T* remove(T* item) {
652  content->del(item->key());
653  return item;
654  }
655 
656  void remove(Oidx* oidptr) {
657  T* t = find(oidptr);
658  content->del(oidptr);
659  if (t) delete t;
660  }
661 
662  T* find(Oidx* oidptr) const {
663  Pix i = content->seek(oidptr);
664  if (i) return (T*)content->contents(i);
665  return 0;
666  }
667 
668  T* find_lower(Oidx* oidptr) const {
669  Pix i = content->seek_inexact(oidptr);
670  if (!i) return 0;
671  while ((i) && (i != content->last()) &&
672  (*content->key(i) < *oidptr))
673  content->next(i);
674  while ((i) && (*content->key(i) > *oidptr))
675  content->prev(i);
676 
677  if (i) return (T*)content->contents(i);
678  return 0;
679  }
680 
681  T* find_upper(Oidx* oidptr) const {
682  Pix i = content->seek_inexact(oidptr);
683  if (!i) return 0;
684  while ((i) && (i != content->first()) &&
685  (*content->key(i) > *oidptr))
686  content->prev(i);
687  while ((i) && (*content->key(i) < *oidptr))
688  content->next(i);
689  if (i) return (T*)content->contents(i);
690  return 0;
691  }
692 
693  T* find_next(Oidx* oidptr) const {
694  Pix i = content->seek(oidptr);
695  if (!i) return 0;
696  content->next(i);
697  if (i) return (T*)content->contents(i);
698  return 0;
699  }
700 
701  T* find_prev(Oidx* oidptr) const {
702  Pix i = content->seek(oidptr);
703  if (!i) return 0;
704  content->prev(i);
705  if (i) return (T*)content->contents(i);
706  return 0;
707  }
708 
709  T* seek(Oidx* oidptr) const {
710  Pix i = content->seek_inexact(oidptr);
711  if (i) return (T*)content->contents(i);
712  return 0;
713  }
714 
715  int size() const { return content->length(); }
716 
717  T* first() const {
718  Pix i = content->first();
719  if (i) return (T*)content->contents(i);
720  return 0;
721  }
722 
723  T* last() const {
724  Pix i = content->last();
725  if (i) return (T*)content->contents(i);
726  return 0;
727  }
728 
729  T* getNth(int i) const {
730  Pix x = content->first();
731  for (int n = 0; ((n<i) && (x)); n++) {
732  content->next(x);
733  }
734  if (x) return (T*)content->contents(x);
735  return 0;
736  }
737 
738  int index(T* t) const {
739  Pix i = content->seek(t->key());
740  int n = -1;
741  while (i) {
742  content->prev(i);
743  n++;
744  }
745  return n;
746  }
747 
748  bool empty() const { return content->empty(); }
749 
750  void clear() {
751  content->clear();
752  }
753  void clearAll() {
754  Pix i = content->first();
755  while (i) {
756  T* t = (T*)content->contents(i);
757  content->next(i);
758  content->del(t->key());
759  delete t;
760  }
761  content->clear();
762  }
763 
764  OidList() {
765  content = new OidxPtrEntryPtrAVLMap(0);
766  }
767  ~OidList() { clearAll(); delete content; }
768 
769 protected:
770 
771  OidxPtrEntryPtrAVLMap* content;
772 };
773 
774 
775 template <class T> class OidListCursor {
776 public:
777  void init(OidList<T>* l) {
778  list = l;
779  cursor = l->content->first();
780  }
781 
782  void initLast(OidList<T>* l) {
783  list = l;
784  cursor = l->content->last();
785  }
786 
787  T* get() {
788  if ((list) && (cursor))
789  return (T*)list->content->contents(cursor);
790  else
791  return 0;
792  }
793 
794  T* get_next() {
795  if ((list) && (cursor)) {
796  Pix x = cursor;
797  list->content->next(x);
798  if (x)
799  return (T*)list->content->contents(x);
800  }
801  return 0;
802  }
803 
804  T* get_prev() {
805  if ((list) && (cursor)) {
806  Pix x = cursor;
807  list->content->prev(x);
808  if (x)
809  return (T*)list->content->contents(x);
810  }
811  return 0;
812  }
813 
814  int next() {
815  if ((list) && (cursor)) {
816  list->content->next(cursor);
817  return (cursor) ? TRUE : FALSE;
818  } else
819  if (cursor)
820  cursor = 0;
821  return 0;
822  }
823 
824  int prev() {
825  if ((list) && (cursor)) {
826  list->content->prev(cursor);
827  return (cursor) ? TRUE : FALSE;
828  } else
829  if (cursor)
830  cursor = 0;
831  return 0;
832  }
833 
834  int lookup(Oidx* oidptr) {
835  if (list) {
836  Pix i = list->content->seek_inexact(oidptr);
837  if (!i) return FALSE;
838  T* t = 0;
839  while ((i) && (t = (T*)list->content->contents(i)) &&
840  (*t->key() > *oidptr)) {
841  list->content->prev(i);
842  }
843  if ((i) && (t)) {
844  cursor = i;
845  return TRUE;
846  }
847  }
848  return FALSE;
849  }
850 
851  OidListCursor(): cursor(0) { list = 0; }
852  OidListCursor(OidList<T>* l):
853  cursor(l->content->first()) { list = l; }
854  OidListCursor(const OidListCursor<T>& c): cursor(c.cursor)
855  { list = c.list; }
856 protected:
857  Pix cursor;
858  OidList<T>* list;
859 };
860 
861 
868 template <class T> class Array {
869 public:
878  T* addFirst(T* t) {
879  T** h = content;
880  content = new T*[sz+1];
881  memcpy(content+1, h, sz*sizeof(T*));
882  content[0] = t;
883  if (h) {
884  delete[] h;
885  }
886  sz++;
887  return t;
888  }
889 
898  T* addLast(T* t) {
899  T** h = content;
900  content = new T*[sz+1];
901  memcpy(content, h, sz*sizeof(T*));
902  content[sz++] = t;
903  if (h) {
904  delete[] h;
905  }
906  return t;
907  }
908 
917  T* add(T* t) { return addLast(t); }
918 
929  T* insertBefore(T* item, T* elem) {
930  for (unsigned int i=0; i<sz; i++) {
931  if (content[i] == elem) {
932  if (i == 0) return addFirst(item);
933  T** h = content;
934  content = new T*[sz+1];
935  memcpy(content, h, i*sizeof(T*));
936  memcpy(content+i+1, h+i,
937  (sz-i)*sizeof(T*));
938  content[i] = item;
939  if (h) {
940  delete[] h;
941  }
942  sz++;
943  return item;
944  }
945  }
946  return addLast(item);
947  }
948 
959  T* insertAfter(T* item, T* elem) {
960  for (unsigned int i=0; i<sz; i++) {
961  if (content[i] == elem) {
962  if (i == sz-1) return addLast(item);
963  T** h = content;
964  content = new T*[sz+1];
965  memcpy(content, h, (i+1)*sizeof(T*));
966  if (i+1<sz)
967  memcpy(content+i+2, h+i+1,
968  (sz-i-1)*sizeof(T*));
969  content[i+1] = item;
970  if (h) {
971  delete[] h;
972  }
973  sz++;
974  return item;
975  }
976  }
977  return addLast(item);
978  }
979 
986  T* removeFirst() {
987  if (sz == 0) return 0;
988  T* t = content[0];
989  T** h = content;
990  content = new T*[--sz];
991  memcpy(content, h+1, sz*sizeof(T*));
992  if (h) {
993  delete[] h;
994  }
995  return t;
996  }
997 
1004  T* removeLast() {
1005  if (sz > 0)
1006  return content[--sz];
1007  return 0;
1008  }
1009 
1013  void clearAll() {
1014  for (unsigned int i=0; i<sz; i++) {
1015  delete content[i];
1016  }
1017  delete[] content;
1018  sz = 0;
1019  content = 0;
1020  }
1021 
1026  void clear() {
1027  delete[] content;
1028  sz = 0;
1029  content = 0;
1030  }
1031 
1039  void clear(int i) {
1040  content[i] = 0;
1041  }
1042 
1052  T* remove(T* item) {
1053  for (unsigned int i=0; i<sz; i++) {
1054  if (item == content[i]) {
1055  return remove(i);
1056  }
1057  }
1058  return 0;
1059  }
1060 
1070  T* remove(unsigned int i) {
1071  if (i >= sz) return 0;
1072  T* t = content[i];
1073  T** h = content;
1074  content = new T*[sz-1];
1075  if (i > 0)
1076  memcpy(content, h, i*sizeof(T*));
1077  if (i+1 < sz)
1078  memcpy(content+i, h+i+1,(sz-i-1)*sizeof(T*));
1079  if (h) {
1080  delete[] h;
1081  }
1082  sz--;
1083  return t;
1084  }
1085 
1095  T* getNth(int n) const {
1096  if ((n < 0) || (((unsigned int)n) >= sz)) return 0;
1097  return content[n];
1098  }
1099 
1109  int index(T* t) const {
1110  for (unsigned int i=0; i<sz; i++) {
1111  if (t == content[i])
1112  return i;
1113  }
1114  return -1;
1115  }
1116 
1123  T* first() const { return (sz) ? content[0] : 0; }
1130  T* last() const { return (sz) ? content[sz-1] : 0; }
1131 
1143  T* overwriteNth(int n, T* t) {
1144  if ((n < 0) || ((unsigned int)n >= sz)) return 0;
1145  if (content[n]) delete content[n];
1146  content[n] = t;
1147  return content[n];
1148  }
1149 
1150  T& operator[](int n) const {
1151  return *(content[n]);
1152  }
1153 
1162  int trim(int n) {
1163  int i=0;
1164  for (i=0; (i<n) && (sz > 0); i++) {
1165  T* t = removeLast();
1166  if (t) delete t;
1167  else break;
1168  }
1169  return i;
1170  }
1171 
1178  int size() const {
1179  return sz;
1180  }
1181 
1189  int empty() const {
1190  return (sz == 0);
1191  }
1192 
1196  Array<T>* clone() {
1197  Array<T>* r = new Array<T>();
1198  if (sz == 0) return r;
1199  r->sz = sz;
1200  delete[] r->content;
1201  r->content = new T*[sz];
1202  for (unsigned int i=0; i<sz; i++) {
1203  r->content[i] = (T*)content[i]->clone();
1204  }
1205  return r;
1206  }
1207 
1208  Array<T>& operator=(const Array<T>& o) {
1209  if (this == &o) return *this;
1210  clearAll();
1211  sz = o.sz;
1212  content = new T*[sz];
1213  for (unsigned int i=0; i<sz; i++) {
1214  content[i] = (T*)o.content[i]->clone();
1215  }
1216  return (*this);
1217  }
1218 
1222  Array(): sz(0) { content = 0; }
1223 
1227  ~Array() { clearAll(); }
1228 
1229 protected:
1230 
1231  T** content;
1232  unsigned int sz;
1233 };
1234 
1235 template <class T> class OrderedArray;
1236 
1237 template <class T> class ArrayCursor {
1238 public:
1239  void init(const Array<T>* l) {
1240  cursor = 0;
1241  list = l;
1242  }
1243 
1244  void initLast(const Array<T>* l) {
1245  list = l;
1246  cursor = l->size()-1;
1247  }
1248 
1249  T* get() {
1250  if ((cursor < 0) || !list || (cursor >= list->size())) return 0;
1251  return list->getNth(cursor);
1252  }
1253 
1254  int next() {
1255  if ((++cursor >= list->size())) return 0;
1256  return 1;
1257  }
1258 
1259  int prev() {
1260  if (--cursor < 0) return 0;
1261  return 1;
1262  }
1263 
1264  int isNext() {
1265  if ((cursor+1 >= list->size())) return 0;
1266  return 1;
1267  }
1268 
1269  int isPrev() {
1270  if (cursor-1 < 0) return 0;
1271  return 1;
1272  }
1273 
1274  int get_cursor() {
1275  return cursor;
1276  }
1277 
1278  ArrayCursor(): cursor(0) { list = 0; };
1279  ArrayCursor(const List<T>* l): cursor(0) { list = l; };
1280  ArrayCursor(const ArrayCursor<T>& c): cursor(c.cursor)
1281  { list = c.list; };
1282 
1283 protected:
1284  const Array<T>* list;
1285  int cursor;
1286 };
1287 
1288 //
1289 // OrderedList is implemented as a wrapper of List to avoid corrupting
1290 // the order by using directly methods of List
1291 //
1292 
1293 template <class T> class OrderedArray;
1294 
1295 template <class T> class OrderedArray: public Array<T> {
1296 friend class ArrayCursor<T>;
1297 public:
1298  T* addBegin(T* item) {
1299  if (!this->empty()) {
1300  for (unsigned int i=0; i<this->sz; i++) {
1301  if (*item < *(this->content[i]))
1302  return this->insertBefore(item,
1303  this->content[i]);
1304  }
1305  return Array<T>::add(item);
1306  }
1307  else return Array<T>::add(item);
1308  }
1309 
1310  T* add(T* item) {
1311  return addEnd(item);
1312  }
1313 
1314  T* addEnd(T* item) {
1315  if (!this->empty()) {
1316  for (int i=this->sz-1; i>=0; i--) {
1317  if (*item > *(this->content[i]))
1318  return this->insertAfter(item,
1319  this->content[i]);
1320  }
1321  return Array<T>::addFirst(item);
1322  }
1323  else return Array<T>::addFirst(item);
1324  }
1325 
1326  // add a new item, but if an equal item already exists:
1327  // do not change the list, delete the new item and return 0
1328  T* addUnique(T* item) {
1329  if (!this->empty()) {
1330  for (unsigned int i=0; i<this->sz; i++) {
1331  if (*item == *(this->content[i])) {
1332  delete item;
1333  return 0;
1334  }
1335  if (*item < *(this->content[i]))
1336  return this->insertBefore(item,
1337  this->content[i]);
1338  }
1339  return Array<T>::add(item);
1340  }
1341  else return Array<T>::add(item);
1342  }
1343 
1344 };
1345 
1346 #ifdef AGENTPP_NAMESPACE
1347 }
1348 #endif
1349 
1350 #endif
Generated by   doxygen 1.8.2