linklist.c

#include "linklist.h"
#include "dbug_mem.h"


//
// public methods
//


void
list_init(List *list, int (*match)(const void *key1, const void *key2), 
   void (*destroy)(void *data))
{
   //MSG_DEBUG("list_init() called");
   
   T_RDWR_INIT(&(list->rwlock), NULL);
   
   // Initialize the list.
   list->size = 0;
   
   if (destroy != NULL) {
      list->destroy = destroy;
   } else {
      list->destroy = stringFreeFunction;
   }
   
   if (match != NULL) {
      list->match = match;
   } else {
      list->match = stringMatchFunction;
   }
   
   list->head = NULL;
   list->tail = NULL;
}


void
list_destroy(List *list)
{
   void *data = NULL;
   
   //MSG_DEBUG("list_destroy() called");
   
   T_RDWR_WLOCK(&(list->rwlock));
   
   // Remove each element.
   while (list_size(list) > 0) {
      if (list_rem_next(list, NULL, (void **)&data) == 0 && 
            list->destroy != NULL) {
         // Call a user-defined function to free dynamically allocated data.
         list->destroy(data);
      }
   }
   
   // No operations are allowed now, but clear the structure as a precaution.
    memset(list, 0, sizeof(List));
   
    T_RDWR_WUNLOCK(&(list->rwlock));
   
   return;
}


int
list_getsize(List *list)
{
   int retval = 0;
   
   //MSG_DEBUG("list_getsize() called");
   
   T_RDWR_RLOCK(&(list->rwlock));
   
   retval = list_size(list);
   
   T_RDWR_RUNLOCK(&(list->rwlock));
   
   return retval;
}


int
list_insert(List *list, void *data)
{
   int retval = -1;
   void *temp = data;
   
   //MSG_DEBUG("list_insert() called");
   
   T_RDWR_WLOCK(&(list->rwlock));
   
   // check if already there
   if(list_internal_lookup(list, &temp)==0) {
      // element already there
      retval = 1;
   } else {
      // create element in list
      retval = list_ins_next(list, NULL, data);
   }
   
   T_RDWR_WUNLOCK(&(list->rwlock));
   
   return retval;
}


int
list_lookup(List *list, void **data)
{
   int retval = -1;
   
   //MSG_DEBUG("list_lookup() called");
   
   T_RDWR_RLOCK(&(list->rwlock));
   
   retval = list_internal_lookup(list, data);
   
   T_RDWR_RUNLOCK(&(list->rwlock));
   
   return retval;
}


int
list_for_each_call(List *list, int (*func)(void *data, void *userdata), 
   void *userdata)
{
   ListElmt *element;
   int retval = 0;
   void *data=NULL;
   
   //MSG_DEBUG("list_for_each_call() called");
   
   T_RDWR_RLOCK(&(list->rwlock));
   
   // Search for the data in list.
   for (element = list_head(list); element != NULL && retval==0; element = 
         list_next(element)) {
      data = (void *)element->data;
      retval = func(data, userdata);
   }
   
   T_RDWR_RUNLOCK(&(list->rwlock));
   
   return retval;
}


int
list_remove_each_if_func_eq_1(List *list, int (*func)(void *data, void *userdata), 
   void *userdata)
{
   ListElmt *element, *prev, *next;
   void *data = NULL;
   
   //MSG_DEBUG("list_remove_each_if_func_eq_1(): called");
   
   T_RDWR_WLOCK(&(list->rwlock));
   
   // Search for the data in list.
   prev = NULL;
   
   for (element = list_head(list); element != NULL;) {
      next = list_next(element);
      if (func(list_data(element), userdata) == 1) {
         // Remove the data from list.
         if (list_rem_next(list, prev, &data) == 0 &&
               list->destroy != NULL) {
            // Call a user-defined function to free dynamically allocated data.
            list->destroy(data);
         }
      } else {
         prev = element;
      }
      element = next;
   }
   
   T_RDWR_WUNLOCK(&(list->rwlock));
   
   return 0;
}

int
list_foreach_match(List *list, int (*matchfunc)(const void *key1, const void *key2), void (*callbackfunc)(const void *data), void **data)
{
   ListElmt *element;
    int retval = -1;
   
   //MSG_DEBUG("list_remove_each_if_func_eq_1(): called");
   
   T_RDWR_RLOCK(&(list->rwlock));
   
   
   for (element = list_head(list); element != NULL ; element = list_next(element)) {
      if (matchfunc(*data, list_data(element))) {
         callbackfunc(list_data(element));
            retval = 0;
      }
   }
   
   T_RDWR_RUNLOCK(&(list->rwlock));
   
   return retval;
}


int
list_remove(List *list, void **data)
{
   ListElmt *element, *prev;
   
   //MSG_DEBUG("list_remove() called");
   
   T_RDWR_WLOCK(&(list->rwlock));
   
   // Search for the data in list.
   prev = NULL;
   
   for (element = list_head(list); element != NULL; element = 
         list_next(element)) {
      if (list->match(*data, list_data(element))) {
         // Remove the data from list.
         if (list_rem_next(list, prev, data) == 0) {
            T_RDWR_WUNLOCK(&(list->rwlock));
            return 0;
         } else {
            T_RDWR_WUNLOCK(&(list->rwlock));
            return -1;
         }
        }
      prev = element;
   }
   
   T_RDWR_WUNLOCK(&(list->rwlock));
   
   // Return that the data was not found.
   return -1;
}


//
// private methods
//


// INTERNAL => NOT PROTECTED AGAINST THREADING ==> DO NOT USE FROM OUTSIDE
int
list_ins_next(List *list, ListElmt *element, const void *data)
{
   ListElmt *new_element = NULL;
   
   //MSG_DEBUG("list_ins_next() called");
   
   // Allocate storage for the element.
   if ((new_element = (ListElmt *)malloc(sizeof(ListElmt))) == NULL) {
      return -1;
   }
   
   // Insert the element into the list.
   new_element->data = (void *)data;
   
   if (element == NULL) {
      // Handle insertion at the head of the list.
      if (list_size(list) == 0) {
         list->tail = new_element;
      }
      
      new_element->next = list->head;
      list->head = new_element;
   } else {
      // Handle insertion somewhere other than at the head.
      if (element->next == NULL) {
         list->tail = new_element;
      }
   
      new_element->next = element->next;
      element->next = new_element;
   }
   
   // Adjust the size of the list to account for the inserted element.
   list->size++;
   
   return 0;
}


// INTERNAL => NOT PROTECTED AGAINST THREADING ==> DO NOT USE FROM OUTSIDE
int
list_rem_next(List *list, ListElmt *element, void **data)
{
   ListElmt *old_element = NULL;
   
   //MSG_DEBUG("list_rem_next() called");
   
   // Do not allow removal from an empty list.
   if (list_size(list) == 0) {
      return -1;
   }
   
   // Remove the element from the list.
   if (element == NULL) {
      // Handle removal from the head of the list.
      *data = list->head->data;
      old_element = list->head;
      list->head = list->head->next;
      
      if (list_size(list) == 1) {
         list->tail = NULL;
      }
   } else {
      // Handle removal from somewhere other than the head.
      if (element->next == NULL) {
         return -1;
      }
      
      *data = element->next->data;
      old_element = element->next;
      element->next = element->next->next;
      
      if (element->next == NULL) {
         list->tail = element;
      }
   }
   
   // Free the storage allocated by the abstract data type.
   free(old_element);
   
   // Adjust the size of the list to account for the removed element.
   list->size--;
   
    return 0;
}


// INTERNAL => NOT PROTECTED AGAINST THREADING ==> DO NOT USE FROM OUTSIDE
int
stringMatchFunction(const void *key1, const void *key2)
{
   int res = 0;
   
   res = strcmp(key1, key2);
   
   return res == 0 ? 1 : 0;
}


// INTERNAL => NOT PROTECTED AGAINST THREADING ==> DO NOT USE FROM OUTSIDE
void
stringFreeFunction(void *ptr)
{
   if (ptr != NULL) free(ptr);
}


// INTERNAL => NOT PROTECTED AGAINST THREADING ==> DO NOT USE FROM OUTSIDE
int
list_internal_lookup(List *list, void **data)
{
   ListElmt *element;
   int retval = -1;
   
   //MSG_DEBUG("list_internal_lookup() called");
   
   // Search for the data in the bucket.
   for (element = list_head(list); element != NULL && retval!=0; element =
         list_next(element)) {
      if (list->match(*data, list_data(element))) {
         // Pass back the data from the table.
         *data = list_data(element);
         retval = 0;
      }
   }
   
   // Return that the data was not found.
   return retval;
}

---