moved the Judy implementation to osrf_big_list and made osrf_list a
[Evergreen.git] / OpenSRF / src / libstack / osrf_big_list.c
1 #include "osrf_big_list.h"
2
3
4 osrfBigList* osrfNewBigList() {
5         osrfBigList* list = safe_malloc(sizeof(osrfBigList));
6         list->list = (Pvoid_t) NULL;
7         list->size = 0;
8         list->freeItem = NULL;
9         return list;
10 }
11
12
13 int osrfBigListPush( osrfBigList* list, void* item ) {
14         if(!(list && item)) return -1;
15         Word_t* value;
16         unsigned long index = -1;
17         JLL(value, list->list, index );
18         osrfBigListSet( list, item, index+1 );
19         return 0;
20 }
21
22
23 void* osrfBigListSet( osrfBigList* list, void* item, unsigned long position ) {
24         if(!list || position < 0) return NULL;
25
26         Word_t* value;
27         void* olditem = osrfBigListRemove( list, position );
28
29         JLI( value, list->list, position ); 
30         *value = (Word_t) item;
31         __osrfBigListSetSize( list );
32
33         return olditem;
34 }
35
36
37 void* osrfBigListGetIndex( osrfBigList* list, unsigned long position ) {
38         if(!list) return NULL;
39
40         Word_t* value;
41         JLG( value, list->list, position );
42         if(value) return (void*) *value;
43         return NULL;
44 }
45
46 void osrfBigListFree( osrfBigList* list ) {
47         if(!list) return;
48
49         Word_t* value;
50         unsigned long index = -1;
51         JLL(value, list->list, index );
52         int retcode;
53
54         while (value != NULL) {
55                 if(list->freeItem) 
56                         list->freeItem( (void*) *value );
57                 JLD(retcode, list->list, index);
58                 JLP(value, list->list, index);
59         }               
60
61         free(list);
62 }
63
64 void* osrfBigListRemove( osrfBigList* list, int position ) {
65         if(!list) return NULL;
66
67         int retcode;
68         Word_t* value;
69         JLG( value, list->list, position );
70         void* olditem = NULL;
71
72         if( value ) {
73
74                 olditem = (void*) *value;
75                 if( olditem ) {
76                         JLD(retcode, list->list, position );
77                         if(retcode == 1) {
78                                 if(list->freeItem) {
79                                         list->freeItem( olditem );
80                                         olditem = NULL;
81                                 }
82                                 __osrfBigListSetSize( list );
83                         }
84                 }
85         }
86
87         return olditem;
88 }
89
90
91 int osrfBigListFind( osrfBigList* list, void* addr ) {
92         if(!(list && addr)) return -1;
93
94         Word_t* value;
95         unsigned long index = -1;
96         JLL(value, list->list, index );
97
98         while (value != NULL) {
99                 if( (void*) *value == addr )
100                         return index;
101                 JLP(value, list->list, index);
102         }
103
104         return -1;
105 }
106
107
108
109 void __osrfBigListSetSize( osrfBigList* list ) {
110         if(!list) return;
111
112         Word_t* value;
113         unsigned long index = -1;
114         JLL(value, list->list, index );
115         list->size = index + 1;
116 }
117
118
119 unsigned long osrfBigListGetCount( osrfBigList* list ) {
120         if(!list) return -1;
121         unsigned long retcode = -1;
122         JLC( retcode, list->list, 0, -1 );
123         return retcode;
124 }
125
126
127 void* osrfBigListPop( osrfBigList* list ) {
128         if(!list) return NULL;
129         return osrfBigListRemove( list, list->size - 1 );
130 }
131
132
133 osrfBigBigListIterator* osrfNewBigListIterator( osrfBigList* list ) {
134         if(!list) return NULL;
135         osrfBigBigListIterator* itr = safe_malloc(sizeof(osrfBigBigListIterator));
136         itr->list = list;
137         itr->current = 0;
138         return itr;
139 }
140
141 void* osrfBigBigListIteratorNext( osrfBigBigListIterator* itr ) {
142         if(!(itr && itr->list)) return NULL;
143
144         Word_t* value;
145         if(itr->current >= itr->list->size) return NULL;
146         JLF( value, itr->list->list, itr->current );
147         if(value) {
148                 itr->current++;
149                 return (void*) *value;
150         }
151         return NULL;
152 }
153
154 void osrfBigBigListIteratorFree( osrfBigBigListIterator* itr ) {
155         if(!itr) return;
156         free(itr);
157 }
158
159
160
161 void osrfBigBigListIteratorReset( osrfBigBigListIterator* itr ) {
162         if(!itr) return;
163         itr->current = 0;
164 }
165
166
167 void osrfBigListVanillaFree( void* item ) {
168         free(item);
169 }
170
171 void osrfBigListSetDefaultFree( osrfBigList* list ) {
172         if(!list) return;
173         list->freeItem = osrfBigListVanillaFree;
174 }