Use const where applicable to allow for const data structures.

include/ht.h

@@ -124,7 +124,17 @@ libds_result ht_put(ht* ht, const void* key, void* value);
  * @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, const 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.
@@ -144,6 +154,6 @@ void ht_remove(ht* ht, const 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/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

@@ -95,13 +95,23 @@ void sprs_free(sprs* sprs);
  * @param data the value to store.
  */
 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, size_t 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,
@@ -113,7 +123,7 @@ int sprs_contains(sprs* sprs, size_t 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, size_t index);
+void* sprs_get(const sprs* sprs, size_t index);
 
 /**
  * Runs through every element in the sparse set, and compares it against the
@@ -125,7 +135,7 @@ void* sprs_get(sprs* sprs, size_t 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
@@ -138,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

@@ -67,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
@@ -80,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.
@@ -88,7 +88,7 @@ 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, size_t index);
+void* vec_index(const vec* vec, size_t index);
 /**
  * Clears the vector, removing all elements from it
  * but not resizing it down.

src/ht.c

@@ -69,7 +69,7 @@ libds_result ht_put(ht* ht, const void* key, void* data) {
 
   return result;
 }
-void* ht_get(ht* ht, const void* key) {
+void* ht_get(const ht* ht, const void* key) {
   void* data = NULL;
   ht_node* search_node;
   unsigned long key_int = ht->hash_func(key) % LIBDS_HT_SIZE;
@@ -84,6 +84,21 @@ void* ht_get(ht* ht, const void* key) {
 
   return data;
 }
+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 long key_int = ht->hash_func(key) % LIBDS_HT_SIZE;
@@ -101,7 +116,7 @@ void ht_remove(ht* ht, const 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/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_tail(ll* ll) { return ll->tail ? ll->tail->data : NULL; }
+void* ll_head(const ll* ll) { return ll->head ? ll->head->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

@@ -297,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;
@@ -357,14 +377,14 @@ int run_test(char* test_name, int (*test_func)()) {
 }
 
 int main(int argc, char** argv) {
-  char* test_names[26] = {"vec_basic",   "vec_add",   "vec_remove", "vec_find",
+  char* test_names[27] = {"vec_basic",   "vec_add",   "vec_remove", "vec_find",
                           "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[26])() = {
+  int (*test_functions[27])() = {
       test_vec_basic,   test_vec_add,   test_vec_remove, test_vec_find,
       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;

src/sprs.c

@@ -32,22 +32,55 @@ void sprs_free(sprs* sprs){
 }
 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, size_t 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, size_t 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++){
@@ -57,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

@@ -61,7 +61,7 @@ void vec_remove(vec* v, void* data) {
   }
 }
 
-void* vec_find(vec* v, void* data, compare_func compare) {
+void* vec_find(const vec* v, void* data, compare_func compare) {
   size_t index = 0;
   void* found = NULL;
   void** data_array = v->data;
@@ -73,7 +73,7 @@ void* vec_find(vec* v, void* data, compare_func compare) {
   }
   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,
                 ...) {
   size_t index = 0;
   int return_code = 0;
@@ -90,7 +90,7 @@ int vec_foreach(vec* v, void* data, compare_func compare, foreach_func foreach,
   return return_code;
 }
 
-void* vec_index(vec* v, size_t index) {
+void* vec_index(const vec* v, size_t index) {
   void* to_return = NULL;
   if (index < v->capacity) {
     to_return = ((void**) v->data)[index];