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