added union function

adnelson · adnelson · commit fc71a94f97b2 · 2013-08-26T16:13:05.000-05:00
diff --git a/include/list.h b/include/list.h
@@ -6,6 +6,7 @@
 #include <stdbool.h>
 #include <string.h>
 #include <pthread.h>
+#include <assert.h>
 
 typedef struct ListNode_s {
    void *data;
@@ -18,8 +19,10 @@ typedef struct List_s {
    void (*del) (void *);
    pthread_mutex_t lock;
    char *(*toString) (void *);
-   int (*compare)(void *, void *);
+   int (*compare)(const void *, const void *);
    void (*print) (void *);
+   void *(*copy) (void *);
+   size_t elem_size;
    const char *name;
 } List_t;
 
@@ -29,6 +32,7 @@ List_t *list_initWithN(size_t n, ...);
 void list_destroy(List_t *l);
 
 void list_setPrintFunc(List_t *l, void (*print) (void *));
+void list_setCompFunc(List_t *l, int (*compare) (const void *, const void *));
 
 void *list_findByInt(List_t *l, int (*toInt) (void *), int i);
 void *list_findByString(List_t *l, void (*toString) (char *,void *), const char *str);
@@ -52,9 +56,15 @@ void list_filterDelete(List_t *l, bool (*pred) (void *));
 void list_map(List_t *l, void *(*f) (void *));
 /* same as above, but frees original. */
 void list_mapDelete(List_t *l, void *(*f) (void *));
+/* sorts based on provided compare function */
+void list_sort(List_t *l);
+/* performs a union of two lists using compare function */
+List_t list_union(List_t *l1, List_t *l2);
 
 ListNode_t *listNode_init(void *data, ListNode_t *next, ListNode_t *prev);
 
+List_t list_deepCopy(List_t *l);
+
 /* Threadsafe */
 bool list_addBack(List_t *l, void *data);
 void *list_removeBack(List_t *l);
diff --git a/src/list.c b/src/list.c
@@ -334,3 +334,76 @@ void list_mapDelete(List_t *l, void *(*f) (void *)) {
       node = node->next;
    }
 }
+
+void list_sort(List_t *l) {
+   if (!l->compare) {
+      fprintf(stderr, "Error: no compare function defined. Cannot sort.\n");
+      return;
+   }
+   if (!l->elem_size) {
+      fprintf(stderr, "Error: element size is not defined. Cannot sort.\n");
+      return;
+   }
+   if (l->size > 0) {
+      /* copy all elements into an array */
+      void **arr = calloc(l->size, sizeof(void *));
+      ListNode_t *node = l->front;
+      size_t idx = 0;
+      while (node) {
+         ListNode_t *next = node->next;
+         arr[idx++] = node->data;
+         list_removeNode(l, node); /* frees the node, not the data*/
+         node = next;
+      }
+
+      assert(l->size == 0 && "List is not empty for some reason");
+      /* use quicksort to sort the array */
+      qsort(arr, l->size, l->elem_size, l->compare);
+
+      /* copy the elements back */
+      for (idx = 0; idx < l->size; ++idx) {
+         list_addBack(l, arr[idx]);
+      }
+   }
+}
+
+List_t list_union(List_t *l1, List_t *l2) {
+   if (!l1->copy || !l2->copy) {
+      fprintf(stderr, "Error: copy function not defined. Can't perform union\n");
+      exit(1);
+   }
+   if (!l1->compare || (l1->compare != l2->compare)) {
+      fprintf(stderr, "Error: compare not defined, or not the same comparison"
+                      "function. Can't perform union\n");
+      exit(1);
+   } else if (l1->size == 0) {
+      return list_deepCopy(l2);
+   } else if (l2->size == 0) {
+      return list_deepCopy(l1);
+   } else {
+      List_t res;
+      list_init(&res, l1->del ? l1->del : l2->del);
+   }
+}
+
+List_t list_deepCopy(List_t *l) {
+   if (!l->copy) {
+      fprintf(stderr, "Error: no copy function defined. Can't deepCopy\n");
+      exit(1);
+   } else {
+      List_t res;
+      ListNode_t *node = l->front;
+      list_init(&res, l->del);
+      res.copy = l->copy;
+      res.toString = l->toString;
+      res.print = l->print;
+      res.elem_size = l->elem_size;
+      res.name = l->name;
+      while (node) {
+         list_addBack(&res, l->copy(node->data));
+         node = node->next;
+      }
+      assert(res.size == l->size && "Sizes don't match for some reason");
+      return res;
+   }
+}
