char *test_set()
{
	DArray_set(array, 0, val1);
	DArray_set(array, 1, val2);
	
	return NULL;
}
예제 #2
0
DArray DArray_group_by(DArray array, DArray_group_by_fn *group_by_fn)
{
  if (DArray_is_empty(array) || !group_by_fn) return NULL;

  DArray groups = DArray_create(sizeof(DArray), 10);
  DArray group;
  int idx;
  void *el;

  size_t count = (size_t) DArray_count(array);
  for (size_t i = 0; i < count; i++) {
    el = DArray_remove(array, i);
    if (!el) continue;
    idx = group_by_fn(el);
    if (idx == -1) continue;

    group = DArray_get(groups, idx);

    if (!group) {
      group = DArray_create(array->element_size, DArray_count(array) + 1);
      DArray_ensure_capacity(groups, idx + 1);
      DArray_set(groups, idx, group);
    }

    DArray_push(group, el);
  }

  return groups;
}
예제 #3
0
파일: hashmap.c 프로젝트: bane138/lcthw
void *Hashmap_delete(Hashmap *map, void *key)
{
    uint32_t hash = 0;
    DArray *bucket = Hashmap_find_bucket(map, key, 0, &hash);
    if(!bucket) {
        return NULL;
    }

    int i = Hashmap_get_node(map, hash, bucket, key);
    if(i == -1) {
        return NULL;
    }

    HashmapNode *node = DArray_get(bucket, i);
    void *data = node->data;
    free(node);

    HashmapNode *ending = DArray_pop(bucket);

    if(ending != node) {
        // alright looks like it's not the last one, swap it.
        DArray_set(bucket, i, ending);
    }

    return data;
}
예제 #4
0
static inline DArray *Hashmap_find_bucket(Hashmap * map, void *key,
        int create,
        uint32_t * hash_out)
{
    uint32_t hash = map->hash(key);
    int bucket_n = hash % DEFAULT_NUMBER_OF_BUCKETS;
    check(bucket_n >= 0, "Invalid bucket found: %d", bucket_n);
    // store it for the return so the caller can use it
    *hash_out = hash;

    DArray *bucket = DArray_get(map->buckets, bucket_n);

    if (!bucket && create) {
        // new bucket, set it up
        bucket = DArray_create(
                sizeof(void *), DEFAULT_NUMBER_OF_BUCKETS);
        check_mem(bucket);
        DArray_set(map->buckets, bucket_n, bucket);
    }

    return bucket;

error:
    return NULL;
}
예제 #5
0
파일: close.c 프로젝트: polysome/amok
int 
CloseNodes_Add(CloseNodes *close, Node *node)
{
    assert(close != NULL && "NULL CloseNodes pointer");
    assert(node != NULL && "NULL Node pointer");

    Distance distance = Hash_Distance(&close->id, &node->id);
    int i = FindIndex(close->close_nodes, &distance);

    if (i < 0)
        return 0;

    struct CloseNode *close_node = malloc(sizeof(struct CloseNode));
    check_mem(close_node);

    close_node->node = node;
    close_node->distance = distance;

    if (DArray_count(close->close_nodes) < BUCKET_K)
        DArray_push(close->close_nodes, NULL);

    ShiftFrom(close->close_nodes, i);
    DArray_set(close->close_nodes, i, close_node);

    return 0;
error:
    return -1;
}
예제 #6
0
int DArray_mergesort(DArray *array, DArray_compare cmp)
{
  int count = array->end;

  if (count > 1) {
    int pivot = count / 2;
    int after_pivot = count - pivot;
    DArray *left = DArray_create(array->element_size, pivot);
    DArray *right = DArray_create(array->element_size, after_pivot);

    for (int i = 0; i < pivot; i++) {
      DArray_push(left, DArray_get(array, i));
    }

    for (int i = pivot; i < count; i++) {
      DArray_push(right, DArray_get(array, i));
    }

    DArray_mergesort(left, cmp);
    DArray_mergesort(left, cmp);

    int i = 0;
    int l_ptr = 0;
    int r_ptr = 0;

    for (i = 0; i < count; i++) {
      if (l_ptr >= pivot) {
        DArray_set(array, i, DArray_get(right, r_ptr));
        r_ptr++;
      } else if (r_ptr >= after_pivot) {
        DArray_set(array, i, DArray_get(left, l_ptr));
        l_ptr++;
      } else if (cmp(DArray_get(left, l_ptr), DArray_get(right, r_ptr)) < 0) {
        DArray_set(array, i, DArray_get(left, l_ptr));
        l_ptr++;
      } else {
        DArray_set(array, i, DArray_get(right, r_ptr));
        r_ptr++;
      }
    }

    DArray_destroy(left);
    DArray_destroy(right);
  }
  return 0;
}
char *test_get_set()
{
    DArray *array = DArray_create(sizeof(intptr_t), 5);

    intptr_t value;

    DArray_set(array, 1, (void *) (intptr_t) 15);
    value = (intptr_t) DArray_get(array, 1);
    assert(value == 15 && "Did not get expected value at index 1.");
    assert(array->size == 1 && "Unexpected array size after adding one element at index 1.");

    DArray_set(array, 4, (void *) (intptr_t) 9789);
    value = (intptr_t) DArray_get(array, 4);
    assert(value == 9789 && "Did not get expected value at index 4.");
    assert(array->size == 2 && "Unexpected array size after adding one element at index 4.");

    DArray_destroy(array);

    return NULL;
}
예제 #8
0
파일: darray.c 프로젝트: fbmnds/lcthw
int DArray_push(DArray *array, void *el)
{
    check(array, "received darray null pointer");
    assert(array->count <= array->max && "inconsistent darray capacity");

    if (array->count == array->max)
        check(!DArray_expand(&array), "expand of darray failed");

    return DArray_set(array, array->count, el);
error:
    return 1;
}
char *test_iterationBackward_arrayContainingHoles_1()
{
    DArray *array = DArray_create(sizeof(intptr_t), 3);

    DArray_set(array, 0, (void *) (intptr_t) 10);
    DArray_set(array, 2, (void *) (intptr_t) 30);

    int index = -1;

    assert(DArray_iterator_prev(array, &index) == 1 && "Expected to continue to prev element.");
    assert(index == 2 && "Expected index was not set by iteration.");

    assert(DArray_iterator_prev(array, &index) == 1 && "Expected to continue to prev element.");
    assert(index == 0 && "Expected index was not set by iteration.");

    assert(DArray_iterator_prev(array, &index) == 0 && "Expected to end interation.");

    DArray_destroy(array);

    return NULL;
}
char *test_expand_setUndefinedIndexExpandsArray()
{
    int initial_capacity = 2;
    DArray *array = DArray_create(sizeof(intptr_t), initial_capacity);

    DArray_set(array, 0, (void *) (intptr_t) 9789);
    DArray_set(array, 1, (void *) (intptr_t) 747);
    assert(array->size == 2 && "Unexpected array size after adding 2 elements");
    assert(array->capacity == initial_capacity && "Unexpected array capacity - should match initial capacity.");

    DArray_set(array, 2, (void *) (intptr_t) 8776);
    assert(array->size == 3 && "Unexpected array size - after adding one more element.");
    assert(array->capacity == (initial_capacity + DARRAY_DEFAULT_EXPAND_RATE) && "Unexpected array capacity after expanding.");

    intptr_t value = (intptr_t) DArray_get(array, 0);
    assert(value == 9789 && "Did not get expected value at index 0.");

    value = (intptr_t) DArray_get(array, 1);
    assert(value == 747 && "Did not get expected value at index 1.");

    value = (intptr_t) DArray_get(array, 2);
    assert(value == 8776 && "Did not get expected value at index 2.");

    // index 0 1 2 are set, all others should be NULL
    for (int i = initial_capacity + 1;
         i < initial_capacity + DARRAY_DEFAULT_EXPAND_RATE;
         i++) {
        void *null_value = DArray_get(array, i);

        assert(null_value == NULL && "Expected remaining indexes to be NULL");
    }

    DArray_destroy(array);

    return NULL;
}
char *test_remove()
{
    DArray *array = DArray_create(sizeof(intptr_t), 100);
    DArray_remove(array, 66);
    assert(array->size == 0 && "Unexpected array size - must be 0 as no elements were added.");

    DArray_set(array, 20, (void *) (intptr_t) 9789);
    DArray_remove(array, 20);
    assert(array->size == 0 && "Unexpected array size - must be 0 again after removing element.");

    void *value = DArray_get(array, 20);
    assert(value == NULL && "Value at index 20 was not removed.");

    DArray_destroy(array);

    return NULL;
}
예제 #12
0
파일: close.c 프로젝트: polysome/amok
void 
ShiftFrom(DArray *close, int from)
{
    assert(close != NULL && "NULL DArray pointer");
    assert(BUCKET_K - 1 < DArray_max(close) && "Too small DArray");
    assert(0 <= from && from <= DArray_end(close) && "Bad shift index");

    if (DArray_end(close) == BUCKET_K)
        free(DArray_last(close));

    int i;
    for (i = DArray_end(close) - 1; i > from; i--)
    {
        struct CloseNode *tmp = DArray_get(close, i - 1);
        DArray_set(close, i, tmp);
    }
}
예제 #13
0
static inline DArray *Hashmap_find_bucket(Hashmap *map, void *key, int create, uint32_t *hash_out)
{
    uint32_t hash = map->hash(key);
    int bucket_n = hash % DEFAULT_NUMBER_OF_BUCKETS;
    check(bucket_n >= 0, "Invalid bucket number found %d", bucket_n);
    *hash_out = hash;

    DArray *bucket = DArray_get(map->buckets, bucket_n);

    if(!bucket && create) {
        bucket = DArray_create(sizeof(void *), DEFAULT_NUMBER_OF_BUCKETS);
        check_mem(bucket);
        DArray_set(map->buckets, bucket_n, bucket);
    }
    return bucket;

error:
    return NULL;
}
예제 #14
0
void* Hashmap_delete(Hashmap* map, void* key) {
    uint32_t hash = 9;
    DArray* bucket = Hashmap_find_bucket(map, key, 0, &hash);
    if(!bucket) return NULL;

    int i = Hashmap_get_node(map, hash, bucket, key);
    if(i == -1) return NULL;

    HashmapNode* node = DArray_get(bucket, i);
    void* data = node->data;
    free(node);

    HashmapNode* ending = DArray_pop(bucket);

    if(ending != node) {
        DArray_set(bucket, i, ending);
    }

    return data;
}
예제 #15
0
static inline DArray *Hashmap_find_bucket(Hashmap *map, void *key, int create, uint32_t *hash_out)
{//caller fn will include 1 or 0 for int create true or false
    uint32_t hash = map->hash(key);
    int bucket_n = hash % DEFAULT_NUMBER_OF_BUCKETS;//finds bucket, will always find a bucket no matter how big
    check(bucket_n >= 0, "Invalid bucket found: %d", bucket_n);
    *hash_out = hash; //store it for the return so caller can use it. I forget how caller is supposed to use this

    DArray *bucket = DArray_get(map->buckets, bucket_n);

    if(!bucket && create) {//creates bucket if none found
        //new bucket, set it up
        bucket = DArray_create(sizeof(void *), DEFAULT_NUMBER_OF_BUCKETS);
        check_mem(bucket);
        DArray_set(map->buckets, bucket_n, bucket);
    }

    return bucket;

error:
    return NULL;
}
char *test_contract()
{
    int initial_size = 2;
    DArray *array = DArray_create(sizeof(intptr_t), initial_size);

    DArray_set(array, 0, (void *) (intptr_t) 1);
    DArray_set(array, 1, (void *) (intptr_t) 2);

    // start expanding, first time
    DArray_set(array, 2, (void *) (intptr_t) 3);
    DArray_set(array, 3, (void *) (intptr_t) 4);
    DArray_set(array, 4, (void *) (intptr_t) 5);
    DArray_set(array, 5, (void *) (intptr_t) 6);
    DArray_set(array, 6, (void *) (intptr_t) 7);
    DArray_set(array, 7, (void *) (intptr_t) 8);
    DArray_set(array, 8, (void *) (intptr_t) 9);
    DArray_set(array, 9, (void *) (intptr_t) 10);
    DArray_set(array, 10, (void *) (intptr_t) 11);
    DArray_set(array, 11, (void *) (intptr_t) 12);

    assert(array->size == 12 && "Unexpected array size - expected initial size + one time expansion.");

    // start expanding, second time
    DArray_set(array, 12, (void *) (intptr_t) 13);
    DArray_set(array, 13, (void *) (intptr_t) 14);
    DArray_set(array, 14, (void *) (intptr_t) 15);
    DArray_set(array, 15, (void *) (intptr_t) 16);
    DArray_set(array, 16, (void *) (intptr_t) 17);
    DArray_set(array, 17, (void *) (intptr_t) 18);
    DArray_set(array, 18, (void *) (intptr_t) 19);
    DArray_set(array, 19, (void *) (intptr_t) 20);
    DArray_set(array, 20, (void *) (intptr_t) 21);
    DArray_set(array, 21, (void *) (intptr_t) 22);

    assert(array->size == 22 && "Unexpected array size - expected initial size + one time expansion.");

    DArray_destroy(array);

    return NULL;
}
예제 #17
0
void swap(DArray *array, int i, int j)
{
  void *tmp = DArray_get(array, i);
  DArray_set(array, i, DArray_get(array, j));
  DArray_set(array, j, tmp);
}