Use const where applicable to allow for const data structures.

This is to prevent the re-use of this library in multiple projects.

CMakeLists.txt

@@ -1,12 +1,18 @@
 cmake_minimum_required(VERSION 2.7)
+
+if(TARGET ds)
+  return()
+endif(TARGET ds)
+
 project(libds)
 
-set_property(GLOBAL PROPERTY C_STANDARD 90)
+add_compile_options(-pedantic -Wall)
-ADD_COMPILE_OPTIONS(-pedantic -Wall)
 
 add_library(ds STATIC src/libds.c src/vec.c src/ht.c src/ll.c src/sprs.c)
 add_executable(libds src/main.c)
 
+set_property(TARGET ds PROPERTY C_STANDARD 90)
+set_property(TARGET libds PROPERTY C_STANDARD 90)
 target_include_directories(ds PUBLIC include)
 target_include_directories(libds PUBLIC include)
 

include/ht.h

@@ -45,21 +45,21 @@ struct ht_s {
    * @param input the data being hashed.
    * @return the data's hash.
    */
-  unsigned int (*hash_func)(void* input);
+  unsigned long (*hash_func)(const void* input);
   /**
    * Function to compare two keys.
    * @param given_key the key being used to retrieve data
    * @param current_key the key of a hash table node
    * @return nonzero value if the keys match.
    */
-  int (*cmp_func)(void* given_key, void* current_key);
+  int (*cmp_func)(const void* given_key, const void* current_key);
   /**
    * Function used to duplicate the given key and
    * store it in a node.
    * @param key the key to copy
    * @return pointer to a new key.
    */
-  void* (*copy_func)(void* key);
+  void* (*copy_func)(const void* key);
   /**
    * Function used to free a previously copied key.
    * @param key the key to free.
@@ -76,7 +76,7 @@ typedef struct ht_s ht;
  * @param key the data to hash.
  * @return the produced hashed integer.
  */
-unsigned int ht_default_hash_func(void* key);
+unsigned long ht_default_hash_func(const void* key);
 /**
  * The default key comparison function.
  * Assumes both keys are strings and uses strcmp.
@@ -84,13 +84,13 @@ unsigned int ht_default_hash_func(void* key);
  * @param b the key compared against
  * @return true if the keys represent the same string.
  */
-int ht_default_cmp_func(void* a, void* b);
+int ht_default_cmp_func(const void* a, const void* b);
 /**
  * The default key copy function.
  * @param key the key being copied
  * @return a pointer to the copy of the key.
  */
-void* ht_default_copy_func(void* key);
+void* ht_default_copy_func(const void* key);
 /**
  * The default key free function. Simply calls free()
  * @param key the key to free.
@@ -117,20 +117,30 @@ void ht_free(ht* ht);
  * @param value the value to store.
  * @return LIBDS_SUCCESS if all goes well, LIBDS_MALLOC if an allocation fails.
  */
-libds_result ht_put(ht* ht, void* key, void* value);
+libds_result ht_put(ht* ht, const void* key, void* value);
 /**
  * Retrieves a value from the hash table.
  * @param ht the hash table to retrieve a value from.
  * @param key the key to use to find the data.
  * @return the data, or NULL if it is not found.
  */
-void* ht_get(ht* ht, void* key);
+void* ht_get(const ht* ht, const void* key);
+/**
+ * Retreives the first value from the hash table
+ * that's stored with the given key and passes the compare function.
+ * @param ht the hash table to retreive the value from.
+ * @param key the key to use to find the data.
+ * @param data the data to compare the candidate value to.
+ * @param compare the comparison function used to compare adta.
+ * @return the data, or NULL if it is not found.
+ */
+void* ht_find(const ht* ht, const void* key, void* data, compare_func compare);
 /**
  * Removes a value from the hash table.
  * @param ht the hash table to remove a value from.
  * @param key the key to use to find the data.
  */
-void ht_remove(ht* ht, void* key);
+void ht_remove(ht* ht, const void* key);
 
 /**
  * Runs through every element in the hash table, and compares it against the
@@ -144,6 +154,6 @@ void ht_remove(ht* ht, void* key);
  * @param ... variable arguments to be passed to the foreach function.
  * @return the code returned by the foreach functions.
  */
-int ht_foreach(ht* ht, void* data, compare_func compare, foreach_func foreach, ...);
+int ht_foreach(const ht* ht, void* data, compare_func compare, foreach_func foreach, ...);
 
 #endif

include/libds.h

@@ -15,7 +15,7 @@ typedef enum libds_result_e libds_result;
  * The function should take two elements, and, if they match, return 1. Otherwise, it should
  * return 0.
  */
-typedef int (*compare_func)(void*, void*);
+typedef int (*compare_func)(const void*, const void*);
 /**
  * Foreach function type.
  * Foreach functions are passed to _foreach calls.
@@ -29,13 +29,13 @@ typedef int (*foreach_func)(void*, va_list);
  * @param b The second piece of data being compared
  * @return always true, i.e 1
  */
-int compare_always(void* a, void* b);
+int compare_always(const void* a, const void* b);
 /**
  * A compare_func implementation that compares two pointers using ==.
  * @param a the first piece of data being compared
  * @param b the second piece of data being compared
  * @return true if a and b are the same value.
  */
-int compare_pointer(void* a, void* b);
+int compare_pointer(const void* a, const void* b);
 
 #endif

include/ll.h

@@ -82,7 +82,7 @@ void ll_remove(ll* ll, void* data);
  * @param compare the comparison function
  * @return the first element that is matched by the comparison function, or NULL if none are matched.
  */
-void* ll_find(ll* ll, void* data, compare_func compare);
+void* ll_find(const ll* ll, void* data, compare_func compare);
 /**
  * Runs through every element in the linked list, and compares it against the
  * given data using the given comparison function. If the comparison function returns
@@ -95,20 +95,20 @@ void* ll_find(ll* ll, void* data, compare_func compare);
  * @param ... variable arguments to be passed on to the foreach function
  * @return 0 if all goes well, or the first nonzero code returned by foreach.
  */
-int ll_foreach(ll* ll, void* data, compare_func compare, foreach_func foreach, ...);
+int ll_foreach(const ll* ll, void* data, compare_func compare, foreach_func foreach, ...);
 
 /**
  * Gets the element at the beginning of the linked list.
  * @param ll the linked list to get the data from.
  * @return the element at the beginning of the element, or NULL if there is none.
  */
-void* ll_head(ll* ll);
+void* ll_head(const ll* ll);
 /**
 * Gets the element at the end of the linked list.
 * @param ll the linked list to get the data from.
 * @return the element at the end of the element, or NULL if there is none.
 */
-void* ll_tail(ll* ll);
+void* ll_tail(const ll* ll);
 /**
  * Removes the element at the beginning of the linked list,
  * and returns it.

include/sprs.h

@@ -1,6 +1,7 @@
 #ifndef LIBDS_SPRS_HEADER
 #define LIBDS_SPRS_HEADER
 
+#include <stddef.h>
 #include "libds.h"
 
 /**
@@ -33,7 +34,7 @@ struct sprs_element_s {
   /**
    * The index of this element in the dense array.
    */
-  int index;
+  size_t index;
   /**
    * A piece of data (optional) associated with this index.
    */
@@ -47,17 +48,17 @@ struct sprs_s {
   /**
    * The maximum size of the set. This is the limit for integer indices.
    */
-  int capacity;
+  size_t capacity;
   /**
    * The current size of the sparse set, and the next available index in the dense array.
    */
-  int size;
+  size_t size;
 
   /**
    * The dense array.
    * This is a pointer so that an array of a certain size can be allocated as needed.
    */
-  int* dense;
+  size_t* dense;
   /**
    * The sparse array.
    * This is a pointer so that an array of a certain size can be allocated as needed.
@@ -80,7 +81,7 @@ void sprs_init(sprs* sprs);
  * @param size the maximum capacity of the sparse set to use.
  * @return LIBDS_SUCCESS if all goes well, or LIBDS_MALLOC if an allocation failed.
  */
-libds_result sprs_setup(sprs* sprs, int size);
+libds_result sprs_setup(sprs* sprs, size_t size);
 /**
  * Frees memory allocated by the sparse set, and resets its capacity and size.
  * @param sprs the sparse set to free.
@@ -93,14 +94,24 @@ void sprs_free(sprs* sprs);
  * @param index the index at which to store the value
  * @param data the value to store.
  */
-void sprs_put(sprs* sprs, int index, void* data);
+void sprs_put(sprs* sprs, size_t index, void* data);
+/**
+ * Stores a value in the sparse set under a given index.
+ * If the capacity of the sparse set is smaller than the given index,
+ * this grows the sparse set by doubling its size.
+ * @param sprs the sparse set into which to store the value.
+ * @param index the index at which to store the value.
+ * @param data the value to store.
+ * @return LIBDS_SUCCESS if all goes well, or LIBDS_MALLOC if the growing failed.
+ */
+libds_result sprs_put_grow(sprs* sprs, size_t index, void* data);
 /**
  * Checks if the sparse set contains data under a given index.
  * @param sprs the sparse set to check.
  * @param index the index for which to check.
  * @return 1 if the index exists, 0 if not.
  */
-int sprs_contains(sprs* sprs, int index);
+int sprs_contains(const sprs* sprs, size_t index);
 /**
  * Gets the value stored under the given sparse set index.
  * This will check for whether the index is in the sparse set first,
@@ -112,7 +123,7 @@ int sprs_contains(sprs* sprs, int index);
  * @param index the index from under which to retrieve the value.
  * @return the value stored under the index, or NULL if there is nothing there.
  */
-void* sprs_get(sprs* sprs, int index);
+void* sprs_get(const sprs* sprs, size_t index);
 
 /**
  * Runs through every element in the sparse set, and compares it against the
@@ -124,7 +135,7 @@ void* sprs_get(sprs* sprs, int index);
  * @param compare the comparison function
  * @return the first element that is matched by the comparison function, or NULL if none are matched.
  */
-void* sprs_find(sprs* sprs, void* data, compare_func compare);
+void* sprs_find(const sprs* sprs, void* data, compare_func compare);
 /**
  * Runs through every element in the sparse set, and compares it against the
  * given data using the given comparison function. If the comparison function returns
@@ -137,6 +148,6 @@ void* sprs_find(sprs* sprs, void* data, compare_func compare);
  * @param ... variable arguments to be passed on to the foreach function
  * @return 0 if all goes well, or the first nonzero code returned by foreach.
  */
-int sprs_foreach(sprs* sprs, void* data, compare_func compare, foreach_func foreach, ...);
+int sprs_foreach(const sprs* sprs, void* data, compare_func compare, foreach_func foreach, ...);
 
 #endif

include/vec.h

@@ -3,6 +3,7 @@
 
 #define LIBDS_VEC_CAPACITY 4
 
+#include <stddef.h>
 #include "libds.h"
 
 /**
@@ -18,11 +19,11 @@ struct vec_s {
   /**
    * The maximum size of the vector.
    */
-  int capacity;
+  size_t capacity;
   /**
    * The current number of items in the vector.
    */
-  int size;
+  size_t size;
 };
 
 typedef struct vec_s vec;
@@ -66,7 +67,7 @@ void vec_remove(vec* vec, void* val);
  * @param compare the comparison function
  * @return the first element that is matched by the comparison function, or NULL if none are matched.
  */
-void* vec_find(vec* vec, void* data, compare_func compare);
+void* vec_find(const vec* vec, void* data, compare_func compare);
 /**
  * Runs through every element in the vector, and compares it against the
  * given data using the given comparison function. If the comparison function returns
@@ -79,7 +80,7 @@ void* vec_find(vec* vec, void* data, compare_func compare);
  * @param ... variable arguments to be passed on to the foreach function
  * @return 0 if all goes well, or the first nonzero code returned by foreach.
  */
-int vec_foreach(vec* vec, void* data, compare_func compare, foreach_func foreach, ...);
+int vec_foreach(const vec* vec, void* data, compare_func compare, foreach_func foreach, ...);
 
 /**
  * Gets the value at the given index of the vector.
@@ -87,6 +88,12 @@ int vec_foreach(vec* vec, void* data, compare_func compare, foreach_func foreach
  * @param index the index to retreive a value from
  * @return pointer to the value, or, if the index is out of bounds (or there is nothing there) NULL.
  */
-void* vec_index(vec* vec, int index);
+void* vec_index(const vec* vec, size_t index);
+/**
+ * Clears the vector, removing all elements from it
+ * but not resizing it down.
+ * @param vec the vector to clear.
+ */
+void vec_clear(vec* vec);
 
 #endif

src/ht.c

@@ -2,11 +2,11 @@
 #include <stdlib.h>
 #include <string.h>
 
-unsigned int ht_default_hash_func(void* data) {
+unsigned long ht_default_hash_func(const void* data) {
-  const unsigned int fnv_prime = 16777619;
+  const unsigned long fnv_prime = 16777619;
-  const unsigned int fnv_offset_basis = 2166136261;
+  const unsigned long fnv_offset_basis = 2166136261;
-  unsigned int hash;
+  unsigned long hash;
-  char* string;
+  const char* string;
   hash = fnv_offset_basis;
   string = data;
   while (*string) {
@@ -15,8 +15,8 @@ unsigned int ht_default_hash_func(void* data) {
   }
   return hash;
 }
-int ht_default_cmp_func(void* a, void* b) { return strcmp(a, b) == 0; }
+int ht_default_cmp_func(const void* a, const void* b) { return strcmp(a, b) == 0; }
-void* ht_default_copy_func(void* from) {
+void* ht_default_copy_func(const void* from) {
   void* copy = malloc(sizeof(char) * (strlen(from) + 1));
   if (copy) {
     strcpy(copy, from);
@@ -35,48 +35,44 @@ void ht_init(ht* ht) {
 void ht_free(ht* ht) {
   int index = 0;
   for (; index < LIBDS_HT_SIZE; index++) {
-    ht_node* head = ht->data[index];
+    while (ht->data[index]) {
-    while (head) {
+      ht_node* to_delete = ht->data[index];
-      ht_node* to_delete = head;
+      ht->data[index] = to_delete->next;
-      head = head->next;
       ht->free_func(to_delete->key);
       free(to_delete);
     }
   }
+  ht->cmp_func = NULL;
+  ht->copy_func = NULL;
+  ht->free_func = NULL;
+  ht->hash_func = NULL;
 }
 
-libds_result ht_put(ht* ht, void* key, void* data) {
+libds_result ht_put(ht* ht, const void* key, void* data) {
   libds_result result = LIBDS_SUCCESS;
   ht_node* new_node = NULL;
-  unsigned int key_int = ht->hash_func(key) % LIBDS_HT_SIZE;
+  void* new_key = NULL;
+  unsigned long key_int = ht->hash_func(key) % LIBDS_HT_SIZE;
 
   new_node = malloc(sizeof(*new_node));
-  if (new_node) {
+  new_key = ht->copy_func(key);
+  if (new_node && new_key) {
     new_node->data = data;
-    new_node->key = ht->copy_func(key);
+    new_node->key = new_key;
-    if (new_node->key == NULL) {
-      result = LIBDS_MALLOC;
-    }
-  } else {
-    result = LIBDS_MALLOC;
-  }
-
-  if (result != LIBDS_SUCCESS) {
-    if (new_node) {
-      free(new_node);
-      new_node = NULL;
-    }
-  } else {
     new_node->next = ht->data[key_int];
     ht->data[key_int] = new_node;
+  } else {
+    free(new_node);
+    free(new_key);
+    result = LIBDS_MALLOC;
   }
 
   return result;
 }
-void* ht_get(ht* ht, void* key) {
+void* ht_get(const ht* ht, const void* key) {
   void* data = NULL;
   ht_node* search_node;
-  unsigned int key_int = ht->hash_func(key) % LIBDS_HT_SIZE;
+  unsigned long key_int = ht->hash_func(key) % LIBDS_HT_SIZE;
 
   search_node = ht->data[key_int];
   while (search_node && data == NULL) {
@@ -88,9 +84,24 @@ void* ht_get(ht* ht, void* key) {
 
   return data;
 }
-void ht_remove(ht* ht, void* key) {
+void* ht_find(const ht* ht, const void* key, void* data, compare_func compare) {
+  void* found = NULL;
+  ht_node* search_node;
+  unsigned long key_int = ht->hash_func(key) % LIBDS_HT_SIZE;
+
+  search_node = ht->data[key_int];
+  while (search_node && found == NULL) {
+    if (ht->cmp_func(search_node->key, key) &&
+        compare(data, search_node->data)) {
+      found = search_node->data;
+    }
+    search_node = search_node->next;
+  }
+  return found;
+}
+void ht_remove(ht* ht, const void* key) {
   ht_node** search_ptr;
-  unsigned int key_int = ht->hash_func(key) % LIBDS_HT_SIZE;
+  unsigned long key_int = ht->hash_func(key) % LIBDS_HT_SIZE;
 
   search_ptr = &ht->data[key_int];
   while (*search_ptr) {
@@ -105,7 +116,7 @@ void ht_remove(ht* ht, void* key) {
   }
 }
 
-int ht_foreach(ht* ht, void* data, compare_func compare, foreach_func foreach,
+int ht_foreach(const ht* ht, void* data, compare_func compare, foreach_func foreach,
                ...) {
   int index = 0;
   int return_code = 0;

src/libds.c

@@ -1,4 +1,4 @@
 #include "libds.h"
 
-int compare_always(void* a, void* b) { return 1; }
+int compare_always(const void* a, const void* b) { return 1; }
-int compare_pointer(void* a, void* b) { return a == b; }
+int compare_pointer(const void* a, const void* b) { return a == b; }

src/ll.c

@@ -62,7 +62,7 @@ void ll_remove(ll* ll, void* data) {
   }
 }
 
-void* ll_find(ll* ll, void* data, compare_func compare) {
+void* ll_find(const ll* ll, void* data, compare_func compare) {
   void* to_return = NULL;
   ll_node* head = ll->head;
   while (head && to_return == NULL) {
@@ -73,7 +73,7 @@ void* ll_find(ll* ll, void* data, compare_func compare) {
   }
   return to_return;
 }
-int ll_foreach(ll* ll, void* data, compare_func compare, foreach_func foreach,
+int ll_foreach(const ll* ll, void* data, compare_func compare, foreach_func foreach,
                ...) {
   int return_code = 0;
   ll_node* head = ll->head;
@@ -89,8 +89,8 @@ int ll_foreach(ll* ll, void* data, compare_func compare, foreach_func foreach,
   return return_code;
 }
 
-void* ll_head(ll* ll) { return ll->head ? ll->head->data : NULL; }
+void* ll_head(const ll* ll) { return ll->head ? ll->head->data : NULL; }
-void* ll_tail(ll* ll) { return ll->tail ? ll->tail->data : NULL; }
+void* ll_tail(const ll* ll) { return ll->tail ? ll->tail->data : NULL; }
 void* ll_pophead(ll* ll) {
   void* to_return = NULL;
   if (ll->head) {

src/main.c

@@ -14,7 +14,7 @@ int _test_vec_foreach_func(void* data, va_list args) {
   *sum += *real_data;
   return 0;
 }
-int _test_vec_find_string(void* a, void* b) { return strcmp(a, b) == 0; }
+int _test_vec_find_string(const void* a, const void* b) { return strcmp(a, b) == 0; }
 
 int test_vec_basic() {
   vec test_vec;
@@ -38,12 +38,16 @@ int test_vec_add() {
 int test_vec_remove() {
   vec test_vec;
   char* test_string = "test";
+  char* second_test_string = "test2";
   int return_code;
 
   vec_init(&test_vec);
   vec_add(&test_vec, test_string);
+  vec_add(&test_vec, test_string);
+  vec_add(&test_vec, test_string);
+  vec_add(&test_vec, second_test_string);
   vec_remove(&test_vec, test_string);
-  return_code = *((void**)test_vec.data) == NULL;
+  return_code = ((void**)test_vec.data)[0] == second_test_string;
   vec_free(&test_vec);
 
   return return_code;
@@ -89,6 +93,22 @@ int test_vec_index() {
   vec_free(&test_vec);
   return return_code;
 }
+int test_vec_clear(){
+  vec test_vec;
+  char* test_string = "test";
+  void** vec_data = NULL;
+  int return_code;
+  vec_init(&test_vec);
+  vec_data = test_vec.data;
+  vec_add(&test_vec, test_string);
+  vec_add(&test_vec, test_string);
+  vec_add(&test_vec, test_string);
+  vec_add(&test_vec, test_string);
+  vec_clear(&test_vec);
+  return_code = (vec_data[0] == vec_data[1]) && (vec_data[1] == vec_data[2]) && (vec_data[2] == vec_data[3]) && (test_vec.size == 0);
+  vec_free(&test_vec);
+  return return_code;
+}
 
 int _test_ht_foreach_func(void* data, va_list args) {
   char* real_data = data;
@@ -277,6 +297,26 @@ int test_sprs_put(){
   return return_code;
 }
 
+int test_sprs_put_grow(){
+  char* test_string_one = "test 1";
+  char* test_string_two = "test 2";
+  int return_code = 1;
+  sprs sprs;
+  sprs_init(&sprs);
+  sprs_setup(&sprs, 2);
+  sprs_put_grow(&sprs, 1, test_string_one);
+  return_code &= sprs.dense[0] == 1 && sprs.sparse[1].index == 0 && sprs.sparse[1].data == test_string_one;
+  return_code &= sprs.capacity == 2;
+  sprs_put_grow(&sprs, 3, test_string_two);
+  return_code &= sprs.dense[1] == 3 && sprs.sparse[3].index == 1 && sprs.sparse[3].data == test_string_two;
+  return_code &= sprs.capacity == 4;
+  sprs_put_grow(&sprs, 12, test_string_one);
+  return_code &= sprs.dense[2] == 12 && sprs.sparse[12].index == 2 && sprs.sparse[12].data == test_string_one;
+  return_code &= sprs.capacity == 16;
+  sprs_free(&sprs);
+  return return_code;
+}
+
 int test_sprs_contains(){
   int return_code;
   sprs sprs;
@@ -337,18 +377,18 @@ int run_test(char* test_name, int (*test_func)()) {
 }
 
 int main(int argc, char** argv) {
-  char* test_names[25] = {"vec_basic",   "vec_add",   "vec_remove", "vec_find",
+  char* test_names[27] = {"vec_basic",   "vec_add",   "vec_remove", "vec_find",
-                          "vec_foreach", "vec_index", "ht_basic",   "ht_put",
+                          "vec_foreach", "vec_index", "vec_clear", "ht_basic",   "ht_put",
-                          "ht_get",      "ht_remove", "ht_foreach", "ll_basic", "ll_append", "ll_prepend", "ll_remove", "ll_find" , "ll_foreach", "ll_pophead", "ll_poptail", "sprs_basic", "sprs_put", "sprs_contains", "sprs_get", "sprs_find", "sprs_foreach"};
+                          "ht_get",      "ht_remove", "ht_foreach", "ll_basic", "ll_append", "ll_prepend", "ll_remove", "ll_find" , "ll_foreach", "ll_pophead", "ll_poptail", "sprs_basic", "sprs_put", "sprs_put_grow", "sprs_contains", "sprs_get", "sprs_find", "sprs_foreach"};
 
-  int (*test_functions[25])() = {
+  int (*test_functions[27])() = {
       test_vec_basic,   test_vec_add,   test_vec_remove, test_vec_find,
-      test_vec_foreach, test_vec_index, test_ht_basic,   test_ht_put,
+      test_vec_foreach, test_vec_index, test_vec_clear, test_ht_basic,   test_ht_put,
-      test_ht_get,      test_ht_remove, test_ht_foreach, test_ll_basic, test_ll_append, test_ll_prepend, test_ll_remove, test_ll_find, test_ll_foreach, test_ll_pophead, test_ll_poptail, test_sprs_basic, test_sprs_put, test_sprs_contains, test_sprs_get, test_sprs_find, test_sprs_foreach};
+      test_ht_get,      test_ht_remove, test_ht_foreach, test_ll_basic, test_ll_append, test_ll_prepend, test_ll_remove, test_ll_find, test_ll_foreach, test_ll_pophead, test_ll_poptail, test_sprs_basic, test_sprs_put, test_sprs_put_grow, test_sprs_contains, test_sprs_get, test_sprs_find, test_sprs_foreach};
 
   int test_index = 0;
   int result = 1;
-  for (; test_index < 25 && result; test_index++) {
+  for (; test_index < 26 && result; test_index++) {
     result = run_test(test_names[test_index], test_functions[test_index]);
   }
   return result ? EXIT_SUCCESS : EXIT_FAILURE;

src/sprs.c

@@ -7,13 +7,15 @@ void sprs_init(sprs* sprs){
   sprs->dense = NULL;
   sprs->sparse = NULL;
 }
-libds_result sprs_setup(sprs* sprs, int size){
+libds_result sprs_setup(sprs* sprs, size_t size){
   libds_result result = LIBDS_SUCCESS;
   sprs->sparse = malloc(sizeof(*(sprs->sparse)) * size);
   sprs->dense = malloc(sizeof(*(sprs->dense)) * size);
   if(sprs->sparse == NULL || sprs->dense == NULL){
     free(sprs->sparse);
     free(sprs->dense);
+    sprs->sparse = NULL;
+    sprs->dense = NULL;
     result = LIBDS_MALLOC;
   } else {
     sprs->capacity = size;
@@ -28,24 +30,57 @@ void sprs_free(sprs* sprs){
   sprs->dense = NULL;
   sprs->sparse = NULL;
 }
-void sprs_put(sprs* sprs, int index, void* data){
+void sprs_put(sprs* sprs, size_t index, void* data){
   if(index < sprs->capacity && sprs->size < sprs->capacity){
+    if(!sprs_contains(sprs, index)){
       sprs->dense[sprs->size++] = index;
       sprs->sparse[index].index = sprs->size - 1;
       sprs->sparse[index].data = data;
+    } else {
+      sprs->sparse[index].data = data;
+    }
   }
 }
-int sprs_contains(sprs* sprs, int index){
+libds_result sprs_put_grow(sprs* sprs, size_t index, void* data) {
+  libds_result result = LIBDS_SUCCESS;
+  if(!sprs_contains(sprs, index) && (index >= sprs->capacity || sprs->size >= sprs->capacity)) {
+    int increase_required = 0;
+    size_t ratio = index / sprs->capacity;
+    size_t new_size;
+    void* new_sparse;
+    void* new_dense;
+    while(ratio >>= 1) {
+      increase_required++;
+    }
+    new_size = sprs->capacity * (1 << (increase_required + 1));
+    new_sparse = realloc(sprs->sparse, sizeof(*(sprs->sparse)) * new_size);
+    new_dense = realloc(sprs->dense, sizeof(*(sprs->dense)) * new_size);
+    if(new_sparse == NULL || new_dense == NULL){
+      free(new_sparse);
+      free(new_dense);
+      result = LIBDS_MALLOC;
+    } else {
+      sprs->sparse = new_sparse;
+      sprs->dense = new_dense;
+      sprs->capacity = new_size;
+    }
+  }
+  if(result == LIBDS_SUCCESS) {
+    sprs_put(sprs, index, data);
+  }
+  return result;
+}
+int sprs_contains(const sprs* sprs, size_t index){
   return sprs->sparse[index].index < sprs->size && sprs->dense[sprs->sparse[index].index] == index;
 }
-void* sprs_get(sprs* sprs, int index){
+void* sprs_get(const sprs* sprs, size_t index){
   void* data = NULL;
   if(sprs_contains(sprs, index)){
     data = sprs->sparse[index].data;
   }
   return data;
 }
-void* sprs_find(sprs* sprs, void* data, compare_func compare){
+void* sprs_find(const sprs* sprs, void* data, compare_func compare){
   int index = 0;
   void* to_return = NULL;
   for(; index < sprs->size && to_return == NULL; index++){
@@ -55,7 +90,7 @@ void* sprs_find(sprs* sprs, void* data, compare_func compare){
   }
   return to_return;
 }
-int sprs_foreach(sprs* sprs, void* data, compare_func compare, foreach_func foreach, ...){
+int sprs_foreach(const sprs* sprs, void* data, compare_func compare, foreach_func foreach, ...){
   int index = 0;
   int return_code = 0;
   va_list args;

src/vec.c

@@ -8,7 +8,7 @@ libds_result vec_init(vec* v) {
 
   v->size = 0;
   v->capacity = LIBDS_VEC_CAPACITY;
-  v->data = calloc(LIBDS_VEC_CAPACITY, sizeof(void*));
+  v->data = malloc(LIBDS_VEC_CAPACITY * sizeof(void*));
   if (v->data == NULL) {
     result = LIBDS_MALLOC;
   }
@@ -27,7 +27,7 @@ void vec_free(vec* v) {
 libds_result vec_add(vec* v, void* data) {
   libds_result result = LIBDS_SUCCESS;
   if (v->size >= v->capacity) {
-    void* new_mem = calloc(v->capacity *= 2, sizeof(void*));
+    void* new_mem = malloc((v->capacity *= 2) * sizeof(void*));
     if (new_mem) {
       memcpy(new_mem, v->data, sizeof(void*) * v->capacity / 2);
       free(v->data);
@@ -38,78 +38,65 @@ libds_result vec_add(vec* v, void* data) {
   }
 
   if (result == LIBDS_SUCCESS) {
-    int index = 0;
+    ((void**) v->data)[v->size++] = data;
-    while (index < v->capacity) {
-      void** data_array = v->data;
-      if (data_array[index] == NULL) {
-        data_array[index] = data;
-        v->size++;
-        break;
-      }
-      index++;
-    }
   }
 
   return result;
 }
 void vec_remove(vec* v, void* data) {
-  int elements = v->size;
+  size_t index = 0;
-  int index = 0;
   void** data_array = v->data;
-  while (elements > 0) {
+  while (index < v->size && data_array[index]) {
-    if (data_array[index]) {
+    size_t search_ahead = 0;
-      elements--;
+    while(data_array[index + search_ahead] == data){
-      if (data_array[index] == data) {
+      search_ahead++;
-        data_array[index] = NULL;
-        v->size--;
     }
+
+    if(search_ahead){
+      size_t remaining_elements = v->size - (index + search_ahead);
+      memmove(data_array + index, data_array + index + search_ahead, remaining_elements);
+      v->size -= search_ahead;
     }
     index++;
   }
 }
 
-void* vec_find(vec* v, void* data, compare_func compare) {
+void* vec_find(const vec* v, void* data, compare_func compare) {
-  int elements = v->size;
+  size_t index = 0;
-  int index = 0;
   void* found = NULL;
   void** data_array = v->data;
-  while (elements > 0 && found == NULL) {
+  while (index < v->size && found == NULL) {
-    if (data_array[index]) {
+    if (data_array[index] && compare(data, data_array[index])) {
-      if (compare(data, data_array[index])) {
       found = data_array[index];
     }
-      elements--;
-    }
     index++;
   }
   return found;
 }
-int vec_foreach(vec* v, void* data, compare_func compare, foreach_func foreach,
+int vec_foreach(const vec* v, void* data, compare_func compare, foreach_func foreach,
                 ...) {
-  int elements = v->size;
+  size_t index = 0;
-  int index = 0;
   int return_code = 0;
   void** data_array = v->data;
   va_list args;
-  while (elements > 0 && return_code == 0) {
+  while (index < v->size && return_code == 0) {
-    if (data_array[index]) {
+    if (data_array[index] && compare(data, data_array[index])) {
-      if (compare(data, data_array[index])) {
       va_start(args, foreach);
       return_code = foreach (data_array[index], args);
       va_end(args);
     }
-      elements--;
-    }
     index++;
   }
   return return_code;
 }
 
-void* vec_index(vec* v, int index) {
+void* vec_index(const vec* v, size_t index) {
   void* to_return = NULL;
-  if (index < v->capacity && index >= 0) {
+  if (index < v->capacity) {
-    void** data_array = v->data;
+    to_return = ((void**) v->data)[index];
-    to_return = data_array[index];
   }
   return to_return;
 }
+void vec_clear(vec* vec) {
+  vec->size = 0;
+}