added size check to constructor
[OpenSRF.git] / src / libstack / osrf_list.c
1 #include "osrf_list.h"
2
3 osrfList* osrfNewList() {
4         osrfList* list;
5         OSRF_MALLOC(list, sizeof(osrfList));
6         list->arrsize   = OSRF_LIST_DEFAULT_SIZE;
7         OSRF_MALLOC(list->arrlist, list->arrsize * sizeof(void*));
8         return list;
9 }
10
11 osrfList* osrfNewListSize( unsigned int size ) {
12         osrfList* list;
13         OSRF_MALLOC(list, sizeof(osrfList));
14     if( size <= 0 ) size = 16;
15         list->arrsize   = size;
16         OSRF_MALLOC( list->arrlist, list->arrsize * sizeof(void*) );
17         return list;
18 }
19
20
21 int osrfListPush( osrfList* list, void* item ) {
22         if(!(list)) return -1;
23         osrfListSet( list, item, list->size );
24         return 0;
25 }
26
27 int osrfListPushFirst( osrfList* list, void* item ) {
28         if(!(list && item)) return -1;
29         int i;
30         for( i = 0; i < list->size; i++ ) 
31                 if(!list->arrlist[i]) break;
32         osrfListSet( list, item, i );
33         return list->size;
34 }
35
36 void* osrfListSet( osrfList* list, void* item, unsigned int position ) {
37         if(!list || position < 0) return NULL;
38
39         int i;
40         int newsize = list->arrsize;
41         void** newarr;
42
43         while( position >= newsize ) 
44                 newsize += OSRF_LIST_INC_SIZE;
45
46         if( newsize > list->arrsize ) { /* expand the list if necessary */
47                 OSRF_MALLOC(newarr, newsize * sizeof(void*));
48                 for( i = 0; i < list->arrsize; i++ ) 
49                         newarr[i] = list->arrlist[i];
50                 free(list->arrlist);
51                 list->arrlist = newarr;
52                 list->arrsize = newsize;
53         }
54
55         void* olditem = osrfListRemove( list, position );
56         list->arrlist[position] = item;
57         //if( list->size == 0 || list->size <= position )
58         if( list->size <= position ) list->size = position + 1;
59         return olditem;
60 }
61
62
63 void* osrfListGetIndex( osrfList* list, unsigned int position ) {
64         if(!list || position >= list->size) return NULL;
65         return list->arrlist[position];
66 }
67
68 void osrfListFree( osrfList* list ) {
69         if(!list) return;
70
71         if( list->freeItem ) {
72                 int i; void* val;
73                 for( i = 0; i < list->size; i++ ) {
74                         if( (val = list->arrlist[i]) ) 
75                                 list->freeItem(val);
76                 }
77         }
78
79         free(list->arrlist);
80         free(list);
81 }
82
83 void* osrfListRemove( osrfList* list, int position ) {
84         if(!list || position >= list->size) return NULL;
85
86         void* olditem = list->arrlist[position];
87         list->arrlist[position] = NULL;
88         if( list->freeItem ) {
89                 list->freeItem(olditem);
90                 olditem = NULL;
91         }
92
93         if( position == list->size - 1 ) list->size--;
94         return olditem;
95 }
96
97
98 int osrfListFind( osrfList* list, void* addr ) {
99         if(!(list && addr)) return -1;
100         int index;
101         for( index = 0; index < list->size; index++ ) {
102                 if( list->arrlist[index] == addr ) 
103                         return index;
104         }
105         return -1;
106 }
107
108
109 unsigned int osrfListGetCount( osrfList* list ) {
110         if(!list) return -1;
111         return list->size;
112 }
113
114
115 void* osrfListPop( osrfList* list ) {
116         if(!list) return NULL;
117         return osrfListRemove( list, list->size - 1 );
118 }
119
120
121 osrfListIterator* osrfNewListIterator( osrfList* list ) {
122         if(!list) return NULL;
123         //osrfListIterator* itr = safe_malloc(sizeof(osrfListIterator));
124         osrfListIterator* itr;
125         OSRF_MALLOC(itr, sizeof(osrfListIterator));
126         itr->list = list;
127         itr->current = 0;
128         return itr;
129 }
130
131 void* osrfListIteratorNext( osrfListIterator* itr ) {
132         if(!(itr && itr->list)) return NULL;
133         if(itr->current >= itr->list->size) return NULL;
134         return itr->list->arrlist[itr->current++];
135 }
136
137 void osrfListIteratorFree( osrfListIterator* itr ) {
138         if(!itr) return;
139         free(itr);
140 }
141
142
143 void osrfListIteratorReset( osrfListIterator* itr ) {
144         if(!itr) return;
145         itr->current = 0;
146 }
147
148
149 void osrfListVanillaFree( void* item ) {
150         free(item);
151 }
152
153 void osrfListSetDefaultFree( osrfList* list ) {
154         if(!list) return;
155         list->freeItem = osrfListVanillaFree;
156 }