git.sur5r.net Git - ngadmin/blob - lib/src/list.c

   1
   2 #include "list.h"
   3
   4
   5
   6
   7 // -------------------------
   8 List* createEmptyList (void) {
   9
  10  List *l;
  11
  12
  13  l=malloc(sizeof(List));
  14  l->first=NULL;
  15  l->last=NULL;
  16  l->count=0;
  17
  18  #ifdef MT_SAFE_LIST
  19  pthread_cond_init(&l->cond, NULL);
  20  pthread_mutex_init(&l->mutex, NULL);
  21  #endif
  22
  23
  24  return l;
  25
  26 }
  27
  28
  29
  30 // ------------------------------------------------
  31 void destroyList (List *l, void (*freefunc)(void*)) {
  32
  33  ListNode *pr, *ln;
  34
  35
  36
  37  if ( l==NULL ) {
  38   return;
  39  }
  40
  41
  42  #ifdef MT_SAFE_LIST
  43  pthread_mutex_destroy(&l->mutex);
  44  pthread_cond_destroy(&l->cond);
  45  #endif
  46
  47  for (ln=l->first; ln!=NULL; ) {
  48
  49   pr=ln;
  50
  51   if ( freefunc!=NULL ) {
  52    freefunc(pr->data);
  53   }
  54
  55   ln=pr->next;
  56   free(pr);
  57
  58  }
  59
  60
  61  free(l);
  62
  63 }
  64
  65
  66
  67 // -------------------------------------
  68 void pushFrontList (List *l, void* data) {
  69
  70  ListNode *ln;
  71
  72
  73  if ( l==NULL ) {
  74   return;
  75  }
  76
  77
  78  #ifdef MT_SAFE_LIST
  79  pthread_mutex_lock(&l->mutex);
  80  #endif
  81
  82  ln=malloc(sizeof(ListNode));
  83  ln->data=data;
  84  ln->prev=NULL;
  85  ln->next=l->first;
  86
  87  if ( l->first==NULL ) {
  88   l->last=ln;
  89  } else {
  90   l->first->prev=ln;
  91  }
  92
  93  l->first=ln;
  94  l->count++;
  95
  96  #ifdef MT_SAFE_LIST
  97  pthread_mutex_unlock(&l->mutex);
  98  pthread_cond_broadcast(&l->cond);
  99  #endif
 100
 101 }
 102
 103
 104
 105 // ------------------------------------
 106 void pushBackList (List *l, void* data) {
 107
 108  ListNode *ln;
 109
 110
 111  if ( l==NULL ) {
 112   return;
 113  }
 114
 115
 116  #ifdef MT_SAFE_LIST
 117  pthread_mutex_lock(&l->mutex);
 118  #endif
 119
 120  ln=malloc(sizeof(ListNode));
 121  ln->data=data;
 122  ln->prev=l->last;
 123  ln->next=NULL;
 124
 125  if ( l->last==NULL ) {
 126   l->first=ln;
 127  } else {
 128   l->last->next=ln;
 129  }
 130
 131  l->last=ln;
 132  l->count++;
 133
 134  #ifdef MT_SAFE_LIST
 135  pthread_mutex_unlock(&l->mutex);
 136  pthread_cond_broadcast(&l->cond);
 137  #endif
 138
 139 }
 140
 141
 142
 143 // -------------------------
 144 void* popFrontList (List *l) {
 145
 146  ListNode *ln;
 147  void* data;
 148
 149
 150  if ( l==NULL ) {
 151   return NULL;
 152  }
 153
 154
 155  #ifdef MT_SAFE_LIST
 156  pthread_mutex_lock(&l->mutex);
 157  #endif
 158
 159  if ( (ln=l->first)==NULL ) {
 160   #ifdef MT_SAFE_LIST
 161   pthread_mutex_unlock(&l->mutex);
 162   #endif
 163   return NULL;
 164  }
 165
 166  data=ln->data;
 167  l->first=ln->next;
 168
 169  if ( ln->next==NULL ) {
 170   l->last=NULL;
 171  } else {
 172   ln->next->prev=NULL;
 173  }
 174
 175  l->count--;
 176  free(ln);
 177
 178  #ifdef MT_SAFE_LIST
 179  pthread_mutex_unlock(&l->mutex);
 180  pthread_cond_broadcast(&l->cond);
 181  #endif
 182
 183
 184  return data;
 185
 186 }
 187
 188
 189
 190 // ------------------------
 191 void* popBackList (List *l) {
 192
 193  ListNode *ln;
 194  void* data;
 195
 196
 197
 198  if ( l==NULL ) {
 199   return NULL;
 200  }
 201
 202
 203  #ifdef MT_SAFE_LIST
 204  pthread_mutex_lock(&l->mutex);
 205  #endif
 206
 207  if ( (ln=l->last)==NULL ) {
 208   #ifdef MT_SAFE_LIST
 209   pthread_mutex_unlock(&l->mutex);
 210   #endif
 211   return NULL;
 212  }
 213
 214  data=ln->data;
 215  l->last=ln->prev;
 216
 217  if ( ln->prev==NULL ) {
 218   l->first=NULL;
 219  } else {
 220   ln->prev->next=NULL;
 221  }
 222
 223  l->count--;
 224  free(ln);
 225
 226  #ifdef MT_SAFE_LIST
 227  pthread_mutex_unlock(&l->mutex);
 228  pthread_cond_broadcast(&l->cond);
 229  #endif
 230
 231
 232  return data;
 233
 234 }
 235
 236
 237
 238 // ----------------------------------------------
 239 void clearList (List *l, void (*freefunc)(void*)) {
 240
 241  ListNode *ln, *pr;
 242
 243
 244  if ( l==NULL ) {
 245   return;
 246  }
 247
 248
 249  #ifdef MT_SAFE_LIST
 250  pthread_mutex_lock(&l->mutex);
 251  #endif
 252
 253  for (ln=l->first; ln!=NULL; ) {
 254
 255   pr=ln;
 256
 257   if ( freefunc!=NULL ) {
 258    freefunc(pr->data);
 259   }
 260
 261   ln=pr->next;
 262   free(pr);
 263
 264  }
 265
 266  l->first=NULL;
 267  l->last=NULL;
 268  l->count=0;
 269
 270  #ifdef MT_SAFE_LIST
 271  pthread_mutex_unlock(&l->mutex);
 272  pthread_cond_broadcast(&l->cond);
 273  #endif
 274
 275 }
 276
 277
 278
 279 // ---------------------------------------------------------------
 280 bool findAndDestroy (List *l, void* data, void (*freefunc)(void*)) {
 281
 282  ListNode *ln;
 283
 284
 285
 286  if ( l==NULL ) {
 287   return false;
 288  }
 289
 290
 291  #ifdef MT_SAFE_LIST
 292  pthread_mutex_lock(&l->mutex);
 293  #endif
 294
 295  for (ln=l->first; ln!=NULL && ln->data!=data; ln=ln->next);
 296
 297  if ( ln==NULL ) {
 298
 299   #ifdef MT_SAFE_LIST
 300   pthread_mutex_unlock(&l->mutex);
 301   #endif
 302
 303  } else {
 304
 305   if ( ln->prev==NULL ) {
 306    l->first=ln->next;
 307   } else {
 308    ln->prev->next=ln->next;
 309   }
 310
 311   if ( ln->next==NULL ) {
 312    l->last=ln->prev;
 313   } else {
 314    ln->next->prev=ln->prev;
 315   }
 316
 317
 318   if ( freefunc!=NULL ) {
 319    freefunc(data);
 320   }
 321
 322   l->count--;
 323
 324   #ifdef MT_SAFE_LIST
 325   pthread_mutex_unlock(&l->mutex);
 326   pthread_cond_broadcast(&l->cond);
 327   #endif
 328
 329  }
 330
 331
 332
 333  return true;
 334
 335 }
 336
 337
 338
 339 // -------------------------------------------------
 340 void browseList (List *l, void (*browsefunc)(void*)) {
 341
 342  ListNode *ln;
 343
 344
 345
 346  if ( l==NULL || browsefunc==NULL ) {
 347   return;
 348  }
 349
 350
 351  #ifdef MT_SAFE_LIST
 352  pthread_mutex_lock(&l->mutex);
 353  #endif
 354
 355  for (ln=l->first; ln!=NULL; ln=ln->next) {
 356   browsefunc(ln->data);
 357  }
 358
 359  #ifdef MT_SAFE_LIST
 360  pthread_mutex_unlock(&l->mutex);
 361  #endif
 362
 363 }
 364
 365
 366 // --------------------------------------
 367 void* convertToArray (List *l, size_t sz) {
 368
 369  ListNode *ln;
 370  void *tab=NULL, *p;
 371
 372
 373
 374  if ( l==NULL || sz==0 ) {
 375   return NULL;
 376  }
 377
 378
 379  #ifdef MT_SAFE_LIST
 380  pthread_mutex_lock(&l->mutex);
 381  #endif
 382
 383  if ( l->count>0 ) {
 384
 385   tab=malloc(l->count*sz);
 386   p=tab;
 387
 388   for (ln=l->first; ln!=NULL; ln=ln->next) {
 389    memcpy(p, ln->data, sz);
 390    p+=sz;
 391   }
 392
 393  }
 394
 395  #ifdef MT_SAFE_LIST
 396  pthread_mutex_unlock(&l->mutex);
 397  #endif
 398
 399
 400  return tab;
 401
 402 }
 403
 404
 405
 406