OpenSRF/src/libstack/osrf_list.c

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