00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037
00038
00039
00040
00041
00042
00043
00044
00045
00046
00047
00048
00049
00050
00051
00052
00053
00054
00055
00056
00057
00058
00059
00060
00061
00062
00063
00064
00065
00066
00067
00068
00069
00070
00071
00072
00073
00074
00075
00076
00077
00078
00079
00080
00081
00082
00083
00084
00085
00086
00087
00088
00089
00090
00091 #ifndef _List_h_
00092 #define _List_h_
00093
00094 #ifndef NULL
00095 #define NULL 0
00096 #endif
00097
00098 #include <agent_pp/agent++.h>
00099 #include <agent_pp/avl_map.h>
00100
00101 #ifdef AGENTPP_NAMESPACE
00102 namespace Agentpp {
00103 #endif
00104
00105 template <class T> class List;
00106 template <class T> class ListCursor;
00107 template <class T> class OrderedList;
00108 template <class T> class OidListCursor;
00109
00117 template <class T> class ListItem {
00118 friend class List<T>;
00119 friend class ListCursor<T>;
00120 friend class OrderedList<T>;
00121 public:
00128 T* getItem() { return item; }
00129
00130 private:
00131 ListItem<T> *prev, *next;
00132 T* item;
00133 ListItem(ListItem<T> *p, ListItem<T> *n, T* i):
00134 prev(p), next(n), item(i) { }
00135 };
00136
00137 template <class T> class List {
00138 friend class ListCursor<T>;
00139 public:
00148 T* addFirst(T* t) {
00149 head = new ListItem<T>(NULL, head, t);
00150 if (head->next) head->next->prev = head;
00151 if (!tail)
00152 tail = head;
00153 return head->item;
00154 }
00155
00164 T* addLast(T* t) {
00165 if (!head)
00166 return addFirst(t);
00167 else {
00168 ListItem<T> *p = tail;
00169 p->next = new ListItem<T>(p, NULL, t);
00170 tail = p->next;
00171 return tail->item;
00172 }
00173 }
00174
00183 T* add(T* t) { return addLast(t); }
00184
00195 T* insertBefore(T* item, T* elem) {
00196 if ((!head) || (head->item == elem)) {
00197 return addFirst(item);
00198 }
00199 else {
00200 ListItem<T>* tmp;
00201 ListItem<T>* h;
00202 tmp = head;
00203 while ((tmp->next) && (elem != tmp->next->item))
00204 tmp = tmp->next;
00205 h = tmp->next;
00206 if (h) {
00207 tmp->next = new ListItem<T>(tmp, h, item);
00208 h->prev = tmp->next;
00209 }
00210 else {
00211 tmp->next = new ListItem<T>(tmp, NULL, item);
00212 tail = tmp->next;
00213 }
00214 return tmp->next->item;
00215 }
00216 }
00217
00228 T* insertAfter(T* item, T* elem) {
00229 if ((!tail) || (tail->item == elem)) {
00230 return addLast(item);
00231 }
00232 else {
00233 ListItem<T>* tmp;
00234 ListItem<T>* h;
00235 tmp = tail;
00236 while ((tmp->prev) && (elem != tmp->prev->item))
00237 tmp = tmp->prev;
00238 h = tmp->prev;
00239 if (h) {
00240 tmp->prev = new ListItem<T>(h, tmp, item);
00241 h->next = tmp->prev;
00242 }
00243 else {
00244 tmp->prev = new ListItem<T>(NULL, tmp, item);
00245 head = tmp->prev;
00246 }
00247 return tmp->prev->item;
00248 }
00249 }
00250
00257 T* removeFirst() {
00258 if (head) {
00259 T* retval = head->item;
00260 ListItem<T> *temp = head;
00261 head = head->next;
00262 if (!head)
00263 tail = 0;
00264 else
00265 head->prev = NULL;
00266 delete temp;
00267 return retval;
00268 }
00269 return 0;
00270 }
00271
00278 T* removeLast() {
00279 if (tail) {
00280 T* retval = tail->item;
00281 ListItem<T> *temp = tail;
00282 tail = tail->prev;
00283 if (!tail)
00284 head = 0;
00285 else
00286 tail->next = NULL;
00287 delete temp;
00288 return retval;
00289 }
00290 return 0;
00291 }
00292
00296 void clearAll() {
00297 ListItem<T>* tmp = head;
00298 ListItem<T>* del;
00299 while (tmp) {
00300 delete tmp->item;
00301 del = tmp;
00302 tmp = tmp->next;
00303 delete del;
00304 }
00305 head = 0;
00306 tail = 0;
00307 }
00308
00313 void clear() {
00314 ListItem<T>* tmp = head;
00315 ListItem<T>* del;
00316 while (tmp) {
00317 del = tmp;
00318 tmp = tmp->next;
00319 delete del;
00320 }
00321 head = 0;
00322 tail = 0;
00323 }
00324
00334 T* remove(T* i) {
00335
00336 ListItem<T> *tmp;
00337
00338 if (!head)
00339 return 0;
00340 tmp = head;
00341 do {
00342 if (tmp->item == i) {
00343 return remove(tmp);
00344 }
00345 }
00346 while ((tmp = tmp->next) != 0);
00347 return 0;
00348 }
00349
00359 T* remove(ListItem<T>* victim) {
00360 T* i = victim->item;
00361 if ((victim->prev) && (victim->next)) {
00362 victim->prev->next = victim->next;
00363 victim->next->prev = victim->prev;
00364 }
00365 else
00366 if (victim->next) {
00367 victim->next->prev = 0;
00368 head = victim->next;
00369 }
00370 else
00371 if (victim->prev) {
00372 victim->prev->next = 0;
00373 tail = victim->prev;
00374 }
00375 else {
00376 head = 0;
00377 tail = 0;
00378 }
00379 delete victim;
00380 return i;
00381 }
00382
00392 T* getNth(int n) const {
00393 if (!head)
00394 return NULL;
00395 else {
00396 ListItem<T> *p = head;
00397
00398 while ((n>0) && (p->next)) {
00399 n--;
00400 p = p->next;
00401 }
00402 if (n != 0)
00403 return NULL;
00404 return p->item;
00405 }
00406 }
00407
00417 ListItem<T>* position(T* t) const {
00418
00419 ListItem<T> *p = head;
00420
00421 while ((p) && (p->item != t))
00422 p = p->next;
00423 return p;
00424 }
00425
00435 int index(T* t) const {
00436
00437 ListItem<T> *p = head;
00438 int i=0;
00439 for (; (p) && (p->item != t); i++)
00440 p = p->next;
00441 return (p) ? i : -1;
00442 }
00443
00450 T* first() const { return (head) ? head->item : 0; }
00457 T* last() const { return (tail) ? tail->item : 0; }
00458
00470 T* overwriteNth(int n, T* t) {
00471 if (!head)
00472 return NULL;
00473 else {
00474 ListItem<T> *p = head;
00475
00476 while ((n>0) && (p->next)) {
00477 n--;
00478 p = p->next;
00479 }
00480 if (n == 0) {
00481 if (p->item)
00482 delete p->item;
00483 p->item = t;
00484 }
00485 return p->item;
00486 }
00487 }
00488
00497 int trim(int n) {
00498 T* t = 0;
00499 int i=0;
00500 for (; (i<n) && ((t = removeLast()) != 0); i++) {
00501 delete t;
00502 }
00503 return i;
00504 }
00505
00512 int size() const {
00513 int r = 0;
00514 ListItem<T> *p = head;
00515 while (p) {
00516 r++;
00517 p = p->next;
00518 }
00519 return r;
00520 }
00521
00529 int empty() const {
00530 return (head == 0);
00531 }
00532
00536 List(): head(0), tail(0) { }
00537
00541 ~List() { clearAll(); }
00542
00543 protected:
00544
00545 ListItem<T> *head;
00546 ListItem<T> *tail;
00547 };
00548
00549 template <class T> class ListCursor {
00550 public:
00551 void init(const List<T>* l) { cursor = l->head; }
00552 void initLast(const List<T>* l) { cursor = l->tail; }
00553 void init(ListItem<T>* t) { cursor = t; }
00554
00555 void init(const OrderedList<T>* l) { cursor = l->content.head; }
00556 void initLast(const OrderedList<T>* l) { cursor = l->content.tail; }
00557
00558 T* get() {
00559 if (cursor)
00560 return cursor->item;
00561 else
00562 return 0;
00563 }
00564
00565 int next() {
00566 if ((cursor) && (cursor->next)) {
00567 cursor = cursor->next;
00568 return 1;
00569 } else
00570 if (cursor)
00571 cursor = 0;
00572 return 0;
00573 }
00574
00575 int prev() {
00576 if ((cursor) && (cursor->prev)) {
00577 cursor = cursor->prev;
00578 return 1;
00579 } else
00580 if (cursor)
00581 cursor = 0;
00582 return 0;
00583 }
00584
00585 int isNext() {
00586 if ((cursor) && (cursor->next))
00587 return 1;
00588 return 0;
00589 }
00590
00591 int isPrev() {
00592 if ((cursor) && (cursor->prev))
00593 return 1;
00594 return 0;
00595 }
00596
00597 ListItem<T>* get_cursor() {
00598 return cursor;
00599 }
00600
00601 ListCursor(): cursor(0) { };
00602 ListCursor(const List<T>* l): cursor(l->head) { };
00603 ListCursor(const ListCursor<T>& c): cursor(c.cursor) { };
00604
00605 protected:
00606 ListItem<T> *cursor;
00607 };
00608
00609
00610
00611
00612
00613
00614
00615 template <class T> class OrderedList;
00616
00617 template <class T> class OrderedList {
00618 friend class ListCursor<T>;
00619 public:
00620 T* add(T* item) {
00621 if (!content.empty()) {
00622 ListCursor<T> cur;
00623 for (cur.init(&content); cur.get(); cur.next()) {
00624 if (*item < *cur.get())
00625 return content.insertBefore(item, cur.get());
00626 }
00627 return content.add(item);
00628 }
00629 else return content.add(item);
00630 }
00631
00632 T* addLast(T* item) {
00633 if (!content.empty()) {
00634 ListCursor<T> cur;
00635 for (cur.initLast(&content); cur.get(); cur.prev()) {
00636 if (*item > *cur.get())
00637 return content.insertAfter(item,
00638 cur.get());
00639 }
00640 return content.addFirst(item);
00641 }
00642 else return content.addFirst(item);
00643 }
00644
00645
00646
00647 T* addUnique(T* item) {
00648 if (!content.empty()) {
00649 ListCursor<T> cur;
00650 for (cur.init(&content); cur.get(); cur.next()) {
00651 if (*item == *cur.get()) {
00652 delete item;
00653 return 0;
00654 }
00655 if (*item < *cur.get())
00656 return content.insertBefore(item, cur.get());
00657 }
00658 return content.add(item);
00659 }
00660 else return content.add(item);
00661 }
00662
00663 T* remove(T* item) { return content.remove(item); }
00664 T* remove(ListItem<T>* item) { return content.remove(item); }
00665
00666 T* overwriteNth(int n, T* t) {
00667 return content.overwriteNth(n, t);
00668 }
00669
00670 int size() const { return content.size(); }
00671 T* first() const { return content.first(); }
00672 T* last() const { return content.last(); }
00673 T* getNth(int i) const { return content.getNth(i); }
00674
00675 ListItem<T>* position(T* t) const { return content.position(t); }
00676 int index(T* t) const { return content.index(t); }
00677
00678 int empty() const { return content.empty(); }
00679
00680 void clearAll() { content.clearAll(); }
00681 void clear() { content.clear(); }
00682
00683 protected:
00684
00685 List<T> content;
00686 };
00687
00688
00689 template <class T> class OrderedListCursor {
00690 public:
00691 void init(const OrderedList<T>* l) { cursor.init(l); }
00692 void initLast(const OrderedList<T>* l) { cursor.initLast(l); }
00693 void init(ListItem<T>* t) { cursor.init(t); }
00694
00695 T* get() { return cursor.get(); }
00696 int next() { return cursor.next(); }
00697 int isNext() { return cursor.isNext(); }
00698 int prev() { return cursor.prev(); }
00699 int isPrev() { return cursor.isPrev(); }
00700 ListItem<T>* get_cursor() { return cursor.get_cursor(); }
00701
00702 OrderedListCursor() { }
00703 OrderedListCursor(const OrderedList<T>* l):
00704 cursor((const List<T>*)l) { }
00705 OrderedListCursor(const OrderedListCursor<T>& c): cursor(c.cursor) { }
00706 protected:
00707 ListCursor<T> cursor;
00708 };
00709
00710
00711
00712
00713 template <class T> class OidList {
00714 friend class OidListCursor<T>;
00715 public:
00716 T* add(T* item) {
00717 (*content)[item->key()] = (void*)item;
00718 return item;
00719 }
00720
00721 T* remove(T* item) {
00722 content->del(item->key());
00723 return item;
00724 }
00725
00726 void remove(Oidx* oidptr) {
00727 T* t = find(oidptr);
00728 content->del(oidptr);
00729 if (t) delete t;
00730 }
00731
00732 T* find(Oidx* oidptr) const {
00733 Pix i = content->seek(oidptr);
00734 if (i) return (T*)content->contents(i);
00735 return 0;
00736 }
00737
00738 T* find_lower(Oidx* oidptr) const {
00739 Pix i = content->seek_inexact(oidptr);
00740 if (!i) return 0;
00741 while ((i) && (i != content->last()) &&
00742 (*content->key(i) < *oidptr))
00743 content->next(i);
00744 while ((i) && (*content->key(i) > *oidptr))
00745 content->prev(i);
00746
00747 if (i) return (T*)content->contents(i);
00748 return 0;
00749 }
00750
00751 T* find_upper(Oidx* oidptr) const {
00752 Pix i = content->seek_inexact(oidptr);
00753 if (!i) return 0;
00754 while ((i) && (i != content->first()) &&
00755 (*content->key(i) > *oidptr))
00756 content->prev(i);
00757 while ((i) && (*content->key(i) < *oidptr))
00758 content->next(i);
00759 if (i) return (T*)content->contents(i);
00760 return 0;
00761 }
00762
00763 T* find_next(Oidx* oidptr) const {
00764 Pix i = content->seek(oidptr);
00765 if (!i) return 0;
00766 content->next(i);
00767 if (i) return (T*)content->contents(i);
00768 return 0;
00769 }
00770
00771 T* find_prev(Oidx* oidptr) const {
00772 Pix i = content->seek(oidptr);
00773 if (!i) return 0;
00774 content->prev(i);
00775 if (i) return (T*)content->contents(i);
00776 return 0;
00777 }
00778
00779 T* seek(Oidx* oidptr) const {
00780 Pix i = content->seek_inexact(oidptr);
00781 if (i) return (T*)content->contents(i);
00782 return 0;
00783 }
00784
00785 int size() const { return content->length(); }
00786
00787 T* first() const {
00788 Pix i = content->first();
00789 if (i) return (T*)content->contents(i);
00790 return 0;
00791 }
00792
00793 T* last() const {
00794 Pix i = content->last();
00795 if (i) return (T*)content->contents(i);
00796 return 0;
00797 }
00798
00799 T* getNth(int i) const {
00800 Pix x = content->first();
00801 for (int n = 0; ((n<i) && (x)); n++) {
00802 content->next(x);
00803 }
00804 if (x) return (T*)content->contents(x);
00805 return 0;
00806 }
00807
00808 int index(T* t) const {
00809 Pix i = content->seek(t->key());
00810 int n = -1;
00811 while (i) {
00812 content->prev(i);
00813 n++;
00814 }
00815 return n;
00816 }
00817
00818 int empty() const { return content->empty(); }
00819
00820 void clear() {
00821 content->clear();
00822 }
00823 void clearAll() {
00824 Pix i = content->first();
00825 while (i) {
00826 T* t = (T*)content->contents(i);
00827 content->next(i);
00828 content->del(t->key());
00829 delete t;
00830 }
00831 content->clear();
00832 }
00833
00834 OidList() {
00835 content = new OidxPtrEntryPtrAVLMap(0);
00836 }
00837 ~OidList() { clearAll(); delete content; }
00838
00839 protected:
00840
00841 OidxPtrEntryPtrAVLMap* content;
00842 };
00843
00844
00845 template <class T> class OidListCursor {
00846 public:
00847 void init(OidList<T>* l) {
00848 list = l;
00849 cursor = l->content->first();
00850 }
00851
00852 void initLast(OidList<T>* l) {
00853 list = l;
00854 cursor = l->content->last();
00855 }
00856
00857 T* get() {
00858 if ((list) && (cursor))
00859 return (T*)list->content->contents(cursor);
00860 else
00861 return 0;
00862 }
00863
00864 T* get_next() {
00865 if ((list) && (cursor)) {
00866 Pix x = cursor;
00867 list->content->next(x);
00868 if (x)
00869 return (T*)list->content->contents(x);
00870 }
00871 return 0;
00872 }
00873
00874 T* get_prev() {
00875 if ((list) && (cursor)) {
00876 Pix x = cursor;
00877 list->content->prev(x);
00878 if (x)
00879 return (T*)list->content->contents(x);
00880 }
00881 return 0;
00882 }
00883
00884 int next() {
00885 if ((list) && (cursor)) {
00886 list->content->next(cursor);
00887 return (cursor) ? TRUE : FALSE;
00888 } else
00889 if (cursor)
00890 cursor = 0;
00891 return 0;
00892 }
00893
00894 int prev() {
00895 if ((list) && (cursor)) {
00896 list->content->prev(cursor);
00897 return (cursor) ? TRUE : FALSE;
00898 } else
00899 if (cursor)
00900 cursor = 0;
00901 return 0;
00902 }
00903
00904 int lookup(Oidx* oidptr) {
00905 if (list) {
00906 Pix i = list->content->seek_inexact(oidptr);
00907 if (!i) return FALSE;
00908 T* t;
00909 while ((i) && (t = (T*)list->content->contents(i)) &&
00910 (*t->key() > *oidptr)) {
00911 list->content->prev(i);
00912 }
00913 if ((i) && (t)) {
00914 cursor = i;
00915 return TRUE;
00916 }
00917 }
00918 return FALSE;
00919 }
00920
00921 OidListCursor(): cursor(0) { list = 0; }
00922 OidListCursor(OidList<T>* l):
00923 cursor(l->content->first()) { list = l; }
00924 OidListCursor(const OidListCursor<T>& c): cursor(c.cursor)
00925 { list = c.list; }
00926 protected:
00927 Pix cursor;
00928 OidList<T>* list;
00929 };
00930
00931
00938 template <class T> class Array {
00939 public:
00948 T* addFirst(T* t) {
00949 T** h = content;
00950 content = new T*[sz+1];
00951 memcpy(content+1, h, sz*sizeof(T*));
00952 content[0] = t;
00953 delete[] h;
00954 sz++;
00955 return t;
00956 }
00957
00966 T* addLast(T* t) {
00967 T** h = content;
00968 content = new T*[sz+1];
00969 memcpy(content, h, sz*sizeof(T*));
00970 content[sz++] = t;
00971 delete[] h;
00972 return t;
00973 }
00974
00983 T* add(T* t) { return addLast(t); }
00984
00995 T* insertBefore(T* item, T* elem) {
00996 for (unsigned int i=0; i<sz; i++) {
00997 if (content[i] == elem) {
00998 if (i == 0) return addFirst(item);
00999 T** h = content;
01000 content = new T*[sz+1];
01001 memcpy(content, h, i*sizeof(T*));
01002 memcpy(content+i+1, h+i,
01003 (sz-i)*sizeof(T*));
01004 content[i] = item;
01005 delete[] h;
01006 sz++;
01007 return item;
01008 }
01009 }
01010 return addLast(item);
01011 }
01012
01023 T* insertAfter(T* item, T* elem) {
01024 for (unsigned int i=0; i<sz; i++) {
01025 if (content[i] == elem) {
01026 if (i == sz-1) return addLast(item);
01027 T** h = content;
01028 content = new T*[sz+1];
01029 memcpy(content, h, (i+1)*sizeof(T*));
01030 if (i+1<sz)
01031 memcpy(content+i+2, h+i+1,
01032 (sz-i-1)*sizeof(T*));
01033 content[i+1] = item;
01034 delete[] h;
01035 sz++;
01036 return item;
01037 }
01038 }
01039 return addLast(item);
01040 }
01041
01048 T* removeFirst() {
01049 if (sz == 0) return 0;
01050 T* t = content[0];
01051 T** h = content;
01052 content = new T*[--sz];
01053 memcpy(content, h+1, sz*sizeof(T*));
01054 delete[] h;
01055 return t;
01056 }
01057
01064 T* removeLast() {
01065 if (sz > 0)
01066 return content[--sz];
01067 return 0;
01068 }
01069
01073 void clearAll() {
01074 for (unsigned int i=0; i<sz; i++) {
01075 delete content[i];
01076 }
01077 delete[] content;
01078 sz = 0;
01079 content = new T*[0];
01080 }
01081
01086 void clear() {
01087 delete[] content;
01088 sz = 0;
01089 content = new T*[0];
01090 }
01091
01099 void clear(int i) {
01100 content[i] = 0;
01101 }
01102
01112 T* remove(T* item) {
01113 for (unsigned int i=0; i<sz; i++) {
01114 if (item == content[i]) {
01115 return remove(i);
01116 }
01117 }
01118 return 0;
01119 }
01120
01130 T* remove(unsigned int i) {
01131 if (i >= sz) return 0;
01132 T* t = content[i];
01133 T** h = content;
01134 content = new T*[sz-1];
01135 if (i > 0)
01136 memcpy(content, h, i*sizeof(T*));
01137 if (i+1 < sz)
01138 memcpy(content+i, h+i+1,(sz-i-1)*sizeof(T*));
01139 delete[] h;
01140 sz--;
01141 return t;
01142 }
01143
01153 T* getNth(int n) const {
01154 if ((n < 0) || (((unsigned int)n) >= sz)) return 0;
01155 return content[n];
01156 }
01157
01167 int index(T* t) const {
01168 for (unsigned int i=0; i<sz; i++) {
01169 if (t == content[i])
01170 return i;
01171 }
01172 return -1;
01173 }
01174
01181 T* first() const { return (sz) ? content[0] : 0; }
01188 T* last() const { return (sz) ? content[sz-1] : 0; }
01189
01201 T* overwriteNth(int n, T* t) {
01202 if ((n < 0) || ((unsigned int)n >= sz)) return 0;
01203 if (content[n]) delete content[n];
01204 content[n] = t;
01205 return content[n];
01206 }
01207
01208 T& operator[](int n) const {
01209 return *(content[n]);
01210 }
01211
01220 int trim(int n) {
01221 int i=0;
01222 for (i=0; (i<n) && (sz > 0); i++) {
01223 T* t = removeLast();
01224 if (t) delete t;
01225 else break;
01226 }
01227 return i;
01228 }
01229
01236 int size() const {
01237 return sz;
01238 }
01239
01247 int empty() const {
01248 return (sz == 0);
01249 }
01250
01254 Array<T>* clone() {
01255 Array<T>* r = new Array<T>();
01256 if (sz == 0) return r;
01257 r->sz = sz;
01258 delete[] r->content;
01259 r->content = new T*[sz];
01260 for (unsigned int i=0; i<sz; i++) {
01261 r->content[i] = (T*)content[i]->clone();
01262 }
01263 return r;
01264 }
01265
01266 Array<T>& operator=(const Array<T>& o) {
01267 if (this == &o) return *this;
01268 clearAll();
01269 delete[] content;
01270 sz = o.sz;
01271 content = new T*[sz];
01272 for (unsigned int i=0; i<sz; i++) {
01273 content[i] = (T*)o.content[i]->clone();
01274 }
01275 return (*this);
01276 }
01277
01281 Array(): sz(0) { content = new T*[1]; }
01282
01286 ~Array() { clearAll(); delete[] content; }
01287
01288 protected:
01289
01290 T** content;
01291 unsigned int sz;
01292 };
01293
01294 template <class T> class OrderedArray;
01295
01296 template <class T> class ArrayCursor {
01297 public:
01298 void init(const Array<T>* l) {
01299 cursor = 0;
01300 list = l;
01301 }
01302
01303 void initLast(const Array<T>* l) {
01304 list = l;
01305 cursor = l->size()-1;
01306 }
01307
01308 T* get() {
01309 if ((cursor < 0) || (cursor >= list->size())) return 0;
01310 return list->getNth(cursor);
01311 }
01312
01313 int next() {
01314 if ((++cursor >= list->size())) return 0;
01315 return 1;
01316 }
01317
01318 int prev() {
01319 if (--cursor < 0) return 0;
01320 return 1;
01321 }
01322
01323 int isNext() {
01324 if ((cursor+1 >= list->size())) return 0;
01325 return 1;
01326 }
01327
01328 int isPrev() {
01329 if (cursor-1 < 0) return 0;
01330 return 1;
01331 }
01332
01333 int get_cursor() {
01334 return cursor;
01335 }
01336
01337 ArrayCursor(): cursor(0) { list = 0; };
01338 ArrayCursor(const List<T>* l): cursor(0) { list = l; };
01339 ArrayCursor(const ArrayCursor<T>& c): cursor(c.cursor)
01340 { list = c.list; };
01341
01342 protected:
01343 const Array<T>* list;
01344 int cursor;
01345 };
01346
01347
01348
01349
01350
01351
01352 template <class T> class OrderedArray;
01353
01354 template <class T> class OrderedArray: public Array<T> {
01355 friend class ArrayCursor<T>;
01356 public:
01357 T* addBegin(T* item) {
01358 if (!this->empty()) {
01359 for (unsigned int i=0; i<this->sz; i++) {
01360 if (*item < *(this->content[i]))
01361 return insertBefore(item,
01362 this->content[i]);
01363 }
01364 return Array<T>::add(item);
01365 }
01366 else return Array<T>::add(item);
01367 }
01368
01369 T* add(T* item) {
01370 return addEnd(item);
01371 }
01372
01373 T* addEnd(T* item) {
01374 if (!this->empty()) {
01375 for (int i=this->sz-1; i>=0; i--) {
01376 if (*item > *(this->content[i]))
01377 return insertAfter(item,
01378 this->content[i]);
01379 }
01380 return Array<T>::addFirst(item);
01381 }
01382 else return Array<T>::addFirst(item);
01383 }
01384
01385
01386
01387 T* addUnique(T* item) {
01388 if (!this->empty()) {
01389 for (unsigned int i=0; i<this->sz; i++) {
01390 if (*item == *(this->content[i])) {
01391 delete item;
01392 return 0;
01393 }
01394 if (*item < *(this->content[i]))
01395 return insertBefore(item,
01396 this->content[i]);
01397 }
01398 return Array<T>::add(item);
01399 }
01400 else return Array<T>::add(item);
01401 }
01402
01403
01404
01405
01406
01407
01408
01409
01410
01411
01412
01413
01414
01415 };
01416
01417 #ifdef AGENTPP_NAMESPACE
01418 }
01419 #endif
01420
01421 #endif