4 template<class TYPE> class List;
12 int get_item_number() { return !list ? -1 : list->number_of(this); }
13 ListItem() { list = 0; previous = next = 0; }
14 ListItem(List<TYPE> &me) { list = me; previous = next = 0; }
15 virtual ~ListItem() { if( list ) list->remove_pointer(this); }
20 TYPE *split(int (*cmpr)(TYPE *a, TYPE *b),TYPE *l, TYPE *r);
21 static int cmpr(TYPE *a, TYPE *b) {
22 if( *a == *b ) return 0;
23 return *a > *b ? 1 : -1;
27 void remove(TYPE *item) { if(item) delete item; }
28 void remove_pointer(ListItem<TYPE> *item);
29 TYPE *append(TYPE *new_item);
30 TYPE *append() { return append(new TYPE()); }
31 TYPE *insert_before(TYPE *here, TYPE *item);
32 TYPE *insert_before(TYPE *here) { return insert_before(here, new TYPE()); }
33 TYPE *insert_after(TYPE *here, TYPE *item);
34 TYPE *insert_after(TYPE *here) { return insert_after(here, new TYPE()); }
35 int total() { TYPE *p=first; int n=0; while(p) { p=p->next; ++n; } return n; }
36 TYPE *get_item_number(int i) { TYPE *p=first;
37 while(p && i>0) { --i; p=p->next; }
40 TYPE &operator[](int i) { return *get_item_number(i); }
41 int number_of(TYPE *item) { TYPE *p=first; int i=0;
42 while(p && p!=item) { ++i; p=p->next; }
45 void swap(TYPE *item1, TYPE *item2);
46 void sort(TYPE *ap=0, TYPE *bp=0) { return sort(cmpr,ap,bp); }
47 void sort(int (*cmp)(TYPE *a, TYPE *b), TYPE *ap=0, TYPE *bp=0);
48 List() { first = last = 0; }
49 virtual ~List() { while(last) delete last; }
53 #define PREVIOUS current->previous
54 #define NEXT current->next
57 TYPE* List<TYPE>::append(TYPE *item)
59 item->list = this; item->next = 0;
60 if( !last ) { item->previous = 0; first = item; }
61 else { item->previous = last; last->next = item; }
66 TYPE* List<TYPE>::insert_before(TYPE *here, TYPE *item)
68 if( !here || !last ) return append(item);
69 item->list = this; item->next = here;
70 *( !(item->previous=here->previous) ? &first : &here->previous->next ) = item;
71 return here->previous = item;
75 TYPE* List<TYPE>::insert_after(TYPE *here, TYPE *item)
77 if( !here || !last ) return append(item);
78 item->list = this; item->previous = here;
79 *( !(item->next=here->next) ? &last : &here->next->previous ) = item;
80 return here->next = item;
85 void List<TYPE>::remove_pointer(ListItem<TYPE> *item)
88 TYPE *previous = item->previous, *next = item->next;
89 *( previous ? &previous->next : &first ) = next;
90 *( next ? &next->previous : &last ) = previous;
95 void List<TYPE>::swap(TYPE *item1, TYPE *item2)
97 if( item1 == item2 ) return;
98 TYPE *item1_previous = item1->previous, *item1_next = item1->next;
99 TYPE *item2_previous = item2->previous, *item2_next = item2->next;
100 *( item1_previous ? &item1_previous->next : &first ) = item2;
101 *( item1_next ? &item1_next->previous : &last ) = item2;
102 *( item2_previous ? &item2_previous->next : &first ) = item1;
103 *( item2_next ? &item2_next->previous : &last ) = item1;
104 item1->previous = item2_previous == item1 ? item2 : item2_previous;
105 item1->next = item2_next == item1 ? item2 : item2_next;
106 item2->previous = item1_previous == item2 ? item1 : item1_previous;
107 item2->next = item1_next == item2 ? item1 : item1_next;
111 TYPE *List<TYPE>::split(int (*cmpr)(TYPE *a, TYPE *b), TYPE *l, TYPE *r)
114 while( cmpr(r,l) >= 0 ) if( (l=l->next) == r ) return r;
116 while( cmpr(l,r) >= 0 ) if( r == (l=l->previous) ) return r;
122 void List<TYPE>::sort(int (*cmpr)(TYPE *a, TYPE *b), TYPE *ll, TYPE *rr)
125 TYPE *l = !ll ? first : ll->next;
126 if( l == rr ) return;
127 TYPE *r = !rr ? last : rr->previous;
129 TYPE *m = split(cmpr, l, r);