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 }