added pop method to osrf_list
[working/Evergreen.git] / OpenSRF / src / libstack / osrf_list.c
1 #include "osrf_list.h"
2
3
4 osrfList* osrfNewList() {
5         osrfList* list = safe_malloc(sizeof(osrfList));
6         list->list = (Pvoid_t) NULL;
7         list->size = 0;
8         list->freeItem = NULL;
9         return list;
10 }
11
12
13 int osrfListPush( osrfList* 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         osrfListSet( list, item, index+1 );
19         return 0;
20 }
21
22
23 void* osrfListSet( osrfList* list, void* item, unsigned long position ) {
24         if(!list || position < 0) return NULL;
25
26         Word_t* value;
27         void* olditem = osrfListRemove( list, position );
28
29         JLI( value, list->list, position ); 
30         *value = (Word_t) item;
31         __osrfListSetSize( list );
32
33         return olditem;
34 }
35
36
37 void* osrfListGetIndex( osrfList* 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 osrfListFree( osrfList* 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                 JLD(retcode, list->list, index);
56
57                 if(list->freeItem) {
58                         list->freeItem( (void*) *value );
59                         *value = (Word_t) NULL;
60                 }
61
62                 JLP(value, list->list, index);
63         }               
64
65         free(list);
66 }
67
68 void* osrfListRemove( osrfList* list, int position ) {
69         if(!list) return NULL;
70
71         int retcode;
72         Word_t* value;
73         JLG( value, list->list, position );
74         void* olditem = NULL;
75
76         if( value ) {
77
78                 olditem = (void*) *value;
79                 if( olditem ) {
80                         JLD(retcode, list->list, position );
81                         if(retcode == 1) {
82                                 if(list->freeItem) {
83                                         list->freeItem( olditem );
84                                         olditem = NULL;
85                                 }
86                                 __osrfListSetSize( list );
87                         }
88                 }
89         }
90
91         return olditem;
92 }
93
94
95 int osrfListFind( osrfList* list, void* addr ) {
96         if(!(list && addr)) return -1;
97
98         Word_t* value;
99         unsigned long index = -1;
100         JLL(value, list->list, index );
101
102         while (value != NULL) {
103                 if( (void*) *value == addr )
104                         return index;
105                 JLP(value, list->list, index);
106         }
107
108         return -1;
109 }
110
111
112
113 void __osrfListSetSize( osrfList* list ) {
114         if(!list) return;
115
116         Word_t* value;
117         unsigned long index = -1;
118         JLL(value, list->list, index );
119         list->size = index + 1;
120 }
121
122
123 unsigned long osrfListGetCount( osrfList* list ) {
124         if(!list) return -1;
125         unsigned long retcode = -1;
126         JLC( retcode, list->list, 0, -1 );
127         return retcode;
128 }
129
130
131 void* osrfListPop( osrfList* list ) {
132         if(!list) return NULL;
133         return osrfListRemove( list, list->size - 1 );
134 }
135
136
137 osrfListIterator* osrfNewListIterator( osrfList* list ) {
138         if(!list) return NULL;
139         osrfListIterator* itr = safe_malloc(sizeof(osrfListIterator));
140         itr->list = list;
141         itr->current = 0;
142         return itr;
143 }
144
145 void* osrfListIteratorNext( osrfListIterator* itr ) {
146         if(!(itr && itr->list)) return NULL;
147
148         Word_t* value;
149         if(itr->current >= itr->list->size) return NULL;
150         JLF( value, itr->list->list, itr->current );
151         if(value) {
152                 itr->current++;
153                 return (void*) *value;
154         }
155         return NULL;
156 }
157
158 void osrfListIteratorFree( osrfListIterator* itr ) {
159         if(!itr) return;
160         free(itr);
161 }
162
163
164
165 void osrfListIteratorReset( osrfListIterator* itr ) {
166         if(!itr) return;
167         itr->current = 0;
168 }
169
170