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 osrfListIterator* osrfNewListIterator( osrfList* list ) {
 132         if(!list) return NULL;
 133         osrfListIterator* itr = safe_malloc(sizeof(osrfListIterator));
 134         itr->list = list;
 135         itr->current = 0;
 136         return itr;
 137 }
 138
 139 void* osrfListIteratorNext( osrfListIterator* itr ) {
 140         if(!(itr && itr->list)) return NULL;
 141
 142         Word_t* value;
 143         if(itr->current >= itr->list->size) return NULL;
 144         JLF( value, itr->list->list, itr->current );
 145         if(value) {
 146                 itr->current++;
 147                 return (void*) *value;
 148         }
 149         return NULL;
 150 }
 151
 152 void osrfListIteratorFree( osrfListIterator* itr ) {
 153         if(!itr) return;
 154         free(itr);
 155 }
 156
 157
 158
 159 void osrfListIteratorReset( osrfListIterator* itr ) {
 160         if(!itr) return;
 161         itr->current = 0;
 162 }
 163
 164