Extension to Vector API.

Signed-off-by: Timothy Rule (VM/EMT3) <[email protected]>

Author: timrulebosch

dse/clib/collections/vector.h

@@ -23,6 +23,7 @@ typedef struct Vector {
         VectorCompar compar;
     } vtable;
     size_t capacity;
+    size_t initial_capacity;
     size_t length;
     size_t item_size;
     void*  items;
@@ -35,6 +36,7 @@ static __inline__ int __vector_resize(Vector* v, size_t hint)
         free(v->items);
         v->items = NULL;
         v->capacity = 0;
+        v->length = 0;
     } else if (hint > v->length) {
         if (v->items == NULL) {
             v->items = calloc(hint, v->item_size);
@@ -58,6 +60,7 @@ static __inline__ Vector vector_make(
     Vector v = {
         .item_size = item_size,
         .capacity = capacity ? capacity : VECTOR_DEFAULT_CAPACITY,
+        .initial_capacity = capacity ? capacity : VECTOR_DEFAULT_CAPACITY,
         .vtable.compar = compar_func,
     };
     __vector_resize(&v, v.capacity);
@@ -72,7 +75,11 @@ static __inline__ size_t vector_len(Vector* v)
 static __inline__ int vector_push(Vector* v, void* item)
 {
     if (v == NULL) return -EINVAL;
-    if (v->length == v->capacity) __vector_resize(v, v->capacity * 2);
+    if (v->capacity == 0) {
+        __vector_resize(v, v->initial_capacity);
+    } else if (v->length == v->capacity) {
+        __vector_resize(v, v->capacity * 2);
+    }
     v->length += 1;
     if (item) {
         size_t offset = (v->length - 1) * v->item_size;
@@ -125,24 +132,24 @@ static __inline__ int vector_sort(Vector* v)
     return 0;
 }
 
-static __inline__ int vector_find(
+static __inline__ void* vector_find(
     Vector* v, void* key, size_t start, void* item)
 {
-    if (v == NULL) return -EINVAL;
-    if (key == NULL) return -EINVAL;
-    if (v->length == 0 || v->items == NULL) return -ENODATA;
-    if (v->vtable.compar == NULL) return -EINVAL;
-    if (start >= v->length) return -EINVAL;
+    if (v == NULL) return NULL;
+    if (key == NULL) return NULL;
+    if (v->length == 0 || v->items == NULL) return NULL;
+    if (v->vtable.compar == NULL) return NULL;
+    if (start >= v->length) return NULL;
     size_t offset = start * v->item_size;
     void*  result = bsearch(key, v->items + offset, v->length - start,
          v->item_size, v->vtable.compar);
     if (result) {
         if (item) {
             memcpy(item, result, v->item_size);
         }
-        return 0;
+        return result;
     } else {
-        return 1;
+        return NULL;
     }
 }
 
@@ -168,10 +175,18 @@ static __inline__ int vector_range(Vector* v, void* from_key, void* to_key,
     return 0;
 }
 
-static __inline__ void vector_clear(Vector* v, size_t capacity)
+static __inline__ void vector_clear(Vector* v)
+{
+    if (v == NULL) return;
+    if (v->items == NULL) return;
+    memset(v->items, 0, v->capacity * v->item_size);
+    v->length = 0;
+}
+
+static __inline__ void vector_reset(Vector* v)
 {
     if (v == NULL) return;
-    __vector_resize(v, capacity);
+    __vector_resize(v, 0);
 }
 
 

tests/collections/test_vector.c

@@ -8,7 +8,7 @@
 #include <dse/clib/collections/vector.h>
 
 
-#define UNUSED(x)     ((void)x)
+#define UNUSED(x) ((void)x)
 
 
 static int test_setup(void** state)
@@ -51,16 +51,17 @@ void test_vector__make_clear(void** state)
     assert_null(vector_at(NULL, 0, NULL));
     assert_int_equal(-EINVAL, vector_delete_at(NULL, 0));
     assert_int_equal(-EINVAL, vector_sort(NULL));
-    assert_int_equal(-EINVAL, vector_find(NULL, NULL, 0, NULL));
+    assert_null(vector_find(NULL, NULL, 0, NULL));
     assert_int_equal(-EINVAL, vector_range(NULL, NULL, NULL, NULL, NULL));
-    vector_clear(NULL, 0);
+    vector_clear(NULL);
+    vector_reset(NULL);
 
     // Make default capacity.
     v = vector_make(sizeof(VectorItem), 0, NULL);
     assert_int_equal(v.capacity, 64);
     assert_int_equal(v.item_size, sizeof(VectorItem));
     assert_non_null(v.items);
-    vector_clear(&v, 0);
+    vector_reset(&v);
     assert_int_equal(v.capacity, 0);
     assert_null(v.items);
 
@@ -69,7 +70,7 @@ void test_vector__make_clear(void** state)
     assert_int_equal(v.capacity, 4);
     assert_int_equal(v.item_size, sizeof(VectorItem));
     assert_non_null(v.items);
-    vector_clear(&v, 0);
+    vector_reset(&v);
     assert_int_equal(v.capacity, 0);
     assert_null(v.items);
 
@@ -81,13 +82,14 @@ void test_vector__make_clear(void** state)
     assert_int_equal(v.capacity, 0);
     assert_int_equal(v.item_size, sizeof(VectorItem));
     assert_null(v.items);
-    vector_clear(&v, 4);
-    assert_int_equal(v.capacity, 4);
-    assert_non_null(v.items);
-    vector_clear(&v, 2);
-    assert_int_equal(v.capacity, 2);
-    assert_non_null(v.items);
-    vector_clear(&v, 0);
+    vector_clear(&v);
+    assert_int_equal(v.capacity, 0);
+    assert_int_equal(v.length, 0);
+    assert_null(v.items);
+    vector_reset(&v);
+    assert_int_equal(v.capacity, 0);
+    assert_int_equal(v.length, 0);
+    assert_null(v.items);
 }
 
 void test_vector__push_pop(void** state)
@@ -121,7 +123,8 @@ void test_vector__push_pop(void** state)
     assert_int_equal(1, vi.key);  // Previous value, check returns!.
     assert_int_equal(0, vector_len(&v));
     assert_int_equal(4, v.capacity);
-    vector_clear(&v, 0);
+    vector_reset(&v);
+
 
     // NULL items.
     v = vector_make(sizeof(VectorItem), 2, NULL);
@@ -132,7 +135,30 @@ void test_vector__push_pop(void** state)
     assert_int_equal(0, vector_pop(&v, NULL));
     assert_int_equal(0, vector_len(&v));
     assert_int_equal(2, v.capacity);
-    vector_clear(&v, 0);
+    vector_reset(&v);
+
+
+    // PUSH and clear/reset.
+    v = vector_make(sizeof(VectorItem), 2, NULL);
+    assert_int_equal(2, v.capacity);
+    assert_int_equal(0, vector_len(&v));
+
+    // PUSH PULL with resize.
+    assert_int_equal(0, vector_push(&v, &(VectorItem){ .key = 1, .data = 11 }));
+    assert_int_equal(0, vector_push(&v, &(VectorItem){ .key = 2, .data = 22 }));
+    assert_int_equal(2, v.capacity);
+    assert_int_equal(2, vector_len(&v));
+    vector_clear(&v);
+    assert_int_equal(2, v.capacity);
+    assert_int_equal(0, vector_len(&v));
+    vector_reset(&v);
+    assert_int_equal(0, v.capacity);
+    assert_int_equal(0, vector_len(&v));
+    assert_int_equal(0, vector_push(&v, &(VectorItem){ .key = 1, .data = 11 }));
+    assert_int_equal(0, vector_push(&v, &(VectorItem){ .key = 2, .data = 22 }));
+    assert_int_equal(2, v.capacity);
+    assert_int_equal(2, vector_len(&v));
+    vector_reset(&v);
 }
 
 void test_vector__at(void** state)
@@ -164,7 +190,7 @@ void test_vector__at(void** state)
 
     assert_null(vector_at(&v, 3, NULL));
 
-    vector_clear(&v, 0);
+    vector_reset(&v);
 }
 
 void test_vector__sort_find(void** state)
@@ -192,20 +218,22 @@ void test_vector__sort_find(void** state)
     assert_null(vector_at(&v, 3, NULL));
 
     // Find.
-    assert_int_equal(0, vector_find(&v, &(VectorItem){ .key = 1 }, 0, &vi));
+    assert_non_null(vector_find(&v, &(VectorItem){ .key = 1 }, 0, &vi));
     assert_int_equal(1, vi.key);
-    assert_int_equal(0, vector_find(&v, &(VectorItem){ .key = 2 }, 0, &vi));
+    VectorItem* vi_p = vector_find(&v, &(VectorItem){ .key = 1 }, 0, NULL);
+    assert_non_null(vi_p);
+    assert_int_equal(1, vi_p->key);
+    assert_non_null(vector_find(&v, &(VectorItem){ .key = 2 }, 0, &vi));
     assert_int_equal(2, vi.key);
-    assert_int_equal(0, vector_find(&v, &(VectorItem){ .key = 3 }, 0, &vi));
+    assert_non_null(vector_find(&v, &(VectorItem){ .key = 3 }, 0, &vi));
     assert_int_equal(3, vi.key);
-    assert_int_equal(1, vector_find(&v, &(VectorItem){ .key = 4 }, 0, &vi));
+    assert_null(vector_find(&v, &(VectorItem){ .key = 4 }, 0, &vi));
     assert_int_equal(3, vi.key);
-    assert_int_equal(1, vector_find(&v, &(VectorItem){ .key = 1 }, 1, &vi));
-    assert_int_equal(1, vector_find(&v, &(VectorItem){ .key = 2 }, 2, &vi));
-    assert_int_equal(
-        -EINVAL, vector_find(&v, &(VectorItem){ .key = 3 }, 3, &vi));
+    assert_null(vector_find(&v, &(VectorItem){ .key = 1 }, 1, &vi));
+    assert_null(vector_find(&v, &(VectorItem){ .key = 2 }, 2, &vi));
+    assert_null(vector_find(&v, &(VectorItem){ .key = 3 }, 3, &vi));
 
-    vector_clear(&v, 0);
+    vector_reset(&v);
 }
 
 int RangeCallback(void* item, void* data)
@@ -271,7 +299,7 @@ void test_vector__range(void** state)
                &(VectorItem){ .key = 3 }, RangeCallbackv22, &range_counter));
     assert_int_equal(0, range_counter);
 
-    vector_clear(&v, 0);
+    vector_reset(&v);
 }
 
 void test_vector__delete_at(void** state)
@@ -307,7 +335,7 @@ void test_vector__delete_at(void** state)
     assert_int_equal(-ENODATA, vector_delete_at(&v, 0));
     assert_int_equal(0, vector_len(&v));
 
-    vector_clear(&v, 0);
+    vector_reset(&v);
 }