Imagelibrary/Containers
1
0
Fork 0
mirror of https://github.com/bkthomps/Containers.git synced 2025-12-05 15:15:49 +00:00
Code Issues Packages Projects Releases Wiki Activity

Style change for null checking

Browse Source 
Now "if (var == NULL)" is "if (!var)" and "if (var != NULL)" is "if (var)".
This commit is contained in:
Bailey Thompson
2018-01-02 13:50:21 -05:00
committed by GitHub
parent 2dd0b78826
commit 1338cf3dcb
16 changed files with 272 additions and 273 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
src/array.c
View File

@@ -42,13 +42,13 @@ struct _array {
array array_init(const int element_count, const size_t data_size) array array_init(const int element_count, const size_t data_size)
{ {
struct _array *const init = malloc(sizeof(struct _array)); struct _array *const init = malloc(sizeof(struct _array));
if (init == NULL) { if (!init) {
return NULL; return NULL;
} }
init->data_size = data_size; init->data_size = data_size;
init->element_count = element_count; init->element_count = element_count;
init->data = calloc((size_t) element_count, data_size); init->data = calloc((size_t) element_count, data_size);
if (init->data == NULL) { if (!init->data) {
free(init); free(init);
return NULL; return NULL;
} }

24
src/deque.c
View File

@@ -51,7 +51,7 @@ struct node {
deque deque_init(const size_t data_size) deque deque_init(const size_t data_size)
{ {
struct _deque *const init = malloc(sizeof(struct _deque)); struct _deque *const init = malloc(sizeof(struct _deque));
if (init == NULL) { if (!init) {
return NULL; return NULL;
} }
init->data_size = data_size; init->data_size = data_size;
@@ -59,13 +59,13 @@ deque deque_init(const size_t data_size)
init->end_index = init->start_index + 1; init->end_index = init->start_index + 1;
init->block_count = 1; init->block_count = 1;
init->block = malloc(sizeof(struct node)); init->block = malloc(sizeof(struct node));
if (init->block == NULL) { if (!init->block) {
free(init); free(init);
return NULL; return NULL;
} }
struct node *const block = init->block; struct node *const block = init->block;
block->data = malloc(BLOCK_SIZE * init->data_size); block->data = malloc(BLOCK_SIZE * init->data_size);
if (block->data == NULL) { if (!block->data) {
free(init->block); free(init->block);
free(init); free(init);
return NULL; return NULL;
@@ -114,7 +114,7 @@ int deque_trim(deque me)
const int end_block = me->end_index / BLOCK_SIZE; const int end_block = me->end_index / BLOCK_SIZE;
const int new_block_count = end_block - start_block + 1; const int new_block_count = end_block - start_block + 1;
void *const new_block = malloc(new_block_count * sizeof(struct node)); void *const new_block = malloc(new_block_count * sizeof(struct node));
if (new_block == NULL) { if (!new_block) {
return -ENOMEM; return -ENOMEM;
} }
for (int i = 0; i < start_block; i++) { for (int i = 0; i < start_block; i++) {
@@ -172,7 +172,7 @@ int deque_push_front(deque me, void *const data)
const int added_blocks = new_block_count - old_block_count; const int added_blocks = new_block_count - old_block_count;
void *temp = realloc(me->block, void *temp = realloc(me->block,
new_block_count * sizeof(struct node)); new_block_count * sizeof(struct node));
if (temp == NULL) { if (!temp) {
return -ENOMEM; return -ENOMEM;
} }
me->block = temp; me->block = temp;
@@ -189,9 +189,9 @@ int deque_push_front(deque me, void *const data)
} }
} }
struct node *const block_item = &me->block[block_index]; struct node *const block_item = &me->block[block_index];
if (block_item->data == NULL) { if (!block_item->data) {
block_item->data = malloc(BLOCK_SIZE * me->data_size); block_item->data = malloc(BLOCK_SIZE * me->data_size);
if (block_item->data == NULL) { if (!block_item->data) {
return -ENOMEM; return -ENOMEM;
} }
} }
@@ -221,7 +221,7 @@ int deque_push_back(deque me, void *const data)
(int) ceil(RESIZE_RATIO * me->block_count); (int) ceil(RESIZE_RATIO * me->block_count);
void *temp = realloc(me->block, void *temp = realloc(me->block,
new_block_count * sizeof(struct node)); new_block_count * sizeof(struct node));
if (temp == NULL) { if (!temp) {
return -ENOMEM; return -ENOMEM;
} }
me->block = temp; me->block = temp;
@@ -232,9 +232,9 @@ int deque_push_back(deque me, void *const data)
} }
} }
struct node *const block_item = &me->block[block_index]; struct node *const block_item = &me->block[block_index];
if (block_item->data == NULL) { if (!block_item->data) {
block_item->data = malloc(BLOCK_SIZE * me->data_size); block_item->data = malloc(BLOCK_SIZE * me->data_size);
if (block_item->data == NULL) { if (!block_item->data) {
return -ENOMEM; return -ENOMEM;
} }
} }
@@ -402,11 +402,11 @@ int deque_get_last(void *const data, deque me)
int deque_clear(deque me) int deque_clear(deque me)
{ {
struct node *const temp_block = malloc(sizeof(struct node)); struct node *const temp_block = malloc(sizeof(struct node));
if (temp_block == NULL) { if (!temp_block) {
return -ENOMEM; return -ENOMEM;
} }
void *const temp_block_data = malloc(BLOCK_SIZE * me->data_size); void *const temp_block_data = malloc(BLOCK_SIZE * me->data_size);
if (temp_block_data == NULL) { if (!temp_block_data) {
free(temp_block); free(temp_block);
return -ENOMEM; return -ENOMEM;
} }

10
src/forward_list.c
View File

@@ -46,7 +46,7 @@ struct node {
forward_list forward_list_init(const size_t data_size) forward_list forward_list_init(const size_t data_size)
{ {
struct _forward_list *const init = malloc(sizeof(struct _forward_list)); struct _forward_list *const init = malloc(sizeof(struct _forward_list));
if (init == NULL) { if (!init) {
return NULL; return NULL;
} }
init->data_size = data_size; init->data_size = data_size;
@@ -89,7 +89,7 @@ void forward_list_copy_to_array(void *const arr, forward_list me)
{ {
struct node *traverse = me->head; struct node *traverse = me->head;
int offset = 0; int offset = 0;
while (traverse != NULL) { while (traverse) {
memcpy(arr + offset, traverse->data, me->data_size); memcpy(arr + offset, traverse->data, me->data_size);
offset += me->data_size; offset += me->data_size;
traverse = traverse->next; traverse = traverse->next;
@@ -139,11 +139,11 @@ int forward_list_add_at(forward_list me, const int index, void *const data)
return -EINVAL; return -EINVAL;
} }
struct node *const add = malloc(sizeof(struct node)); struct node *const add = malloc(sizeof(struct node));
if (add == NULL) { if (!add) {
return -ENOMEM; return -ENOMEM;
} }
add->data = malloc(me->data_size); add->data = malloc(me->data_size);
if (add->data == NULL) { if (!add->data) {
free(add); free(add);
return -ENOMEM; return -ENOMEM;
} }
@@ -347,7 +347,7 @@ int forward_list_get_last(void *const data, forward_list me)
void forward_list_clear(forward_list me) void forward_list_clear(forward_list me)
{ {
struct node *traverse = me->head; struct node *traverse = me->head;
while (traverse != NULL) { while (traverse) {
struct node *const temp = traverse; struct node *const temp = traverse;
traverse = traverse->next; traverse = traverse->next;
free(temp->data); free(temp->data);

24
src/list.c
View File

@@ -48,7 +48,7 @@ struct node {
list list_init(const size_t data_size) list list_init(const size_t data_size)
{ {
struct _list *const init = malloc(sizeof(struct _list)); struct _list *const init = malloc(sizeof(struct _list));
if (init == NULL) { if (!init) {
return NULL; return NULL;
} }
init->data_size = data_size; init->data_size = data_size;
@@ -92,7 +92,7 @@ void list_copy_to_array(void *const arr, list me)
{ {
struct node *traverse = me->head; struct node *traverse = me->head;
int offset = 0; int offset = 0;
while (traverse != NULL) { while (traverse) {
memcpy(arr + offset, traverse->data, me->data_size); memcpy(arr + offset, traverse->data, me->data_size);
offset += me->data_size; offset += me->data_size;
traverse = traverse->next; traverse = traverse->next;
@@ -148,22 +148,22 @@ int list_add_first(list me, void *const data)
{ {
struct node *const traverse = me->head; struct node *const traverse = me->head;
struct node *const add = malloc(sizeof(struct node)); struct node *const add = malloc(sizeof(struct node));
if (add == NULL) { if (!add) {
return -ENOMEM; return -ENOMEM;
} }
add->data = malloc(me->data_size); add->data = malloc(me->data_size);
if (add->data == NULL) { if (!add->data) {
free(add); free(add);
return -ENOMEM; return -ENOMEM;
} }
add->prev = NULL; add->prev = NULL;
memcpy(add->data, data, me->data_size); memcpy(add->data, data, me->data_size);
add->next = traverse; add->next = traverse;
if (traverse != NULL) { if (traverse) {
traverse->prev = add; traverse->prev = add;
} }
me->head = add; me->head = add;
if (me->tail == NULL) { if (!me->tail) {
me->tail = traverse; me->tail = traverse;
} }
me->space++; me->space++;
@@ -195,11 +195,11 @@ int list_add_at(list me, const int index, void *const data)
// The new node will go right before this node. // The new node will go right before this node.
struct node *const traverse = list_get_node_at(me, index); struct node *const traverse = list_get_node_at(me, index);
struct node *const add = malloc(sizeof(struct node)); struct node *const add = malloc(sizeof(struct node));
if (add == NULL) { if (!add) {
return -ENOMEM; return -ENOMEM;
} }
add->data = malloc(me->data_size); add->data = malloc(me->data_size);
if (add->data == NULL) { if (!add->data) {
free(add); free(add);
return -ENOMEM; return -ENOMEM;
} }
@@ -225,18 +225,18 @@ int list_add_last(list me, void *const data)
{ {
struct node *const traverse = me->tail; struct node *const traverse = me->tail;
struct node *const add = malloc(sizeof(struct node)); struct node *const add = malloc(sizeof(struct node));
if (add == NULL) { if (!add) {
return -ENOMEM; return -ENOMEM;
} }
add->data = malloc(me->data_size); add->data = malloc(me->data_size);
if (add->data == NULL) { if (!add->data) {
free(add); free(add);
return -ENOMEM; return -ENOMEM;
} }
add->prev = traverse; add->prev = traverse;
memcpy(add->data, data, me->data_size); memcpy(add->data, data, me->data_size);
add->next = NULL; add->next = NULL;
if (traverse != NULL) { if (traverse) {
traverse->next = add; traverse->next = add;
} }
me->tail = add; me->tail = add;
@@ -413,7 +413,7 @@ int list_get_last(void *const data, list me)
void list_clear(list me) void list_clear(list me)
{ {
struct node *traverse = me->head; struct node *traverse = me->head;
while (traverse != NULL) { while (traverse) {
struct node *const temp = traverse; struct node *const temp = traverse;
traverse = traverse->next; traverse = traverse->next;
free(temp->data); free(temp->data);

68
src/map.c
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2017 Bailey Thompson * Copyright (c) 2017-2018 Bailey Thompson
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal * of this software and associated documentation files (the "Software"), to deal
@@ -57,7 +57,7 @@ map map_init(const size_t key_size,
int (*const comparator)(const void *const, const void *const)) int (*const comparator)(const void *const, const void *const))
{ {
struct _map *const init = malloc(sizeof(struct _map)); struct _map *const init = malloc(sizeof(struct _map));
if (init == NULL) { if (!init) {
return NULL; return NULL;
} }
init->key_size = key_size; init->key_size = key_size;
@@ -100,7 +100,7 @@ static void map_reference_parent(map me,
struct node *const child) struct node *const child)
{ {
child->parent = parent->parent; child->parent = parent->parent;
if (parent->parent == NULL) { if (!parent->parent) {
me->root = child; me->root = child;
} else if (parent->parent->left == parent) { } else if (parent->parent->left == parent) {
parent->parent->left = child; parent->parent->left = child;
@@ -118,7 +118,7 @@ static void map_rotate_left(map me,
{ {
map_reference_parent(me, parent, child); map_reference_parent(me, parent, child);
struct node *const grand_child = child->left; struct node *const grand_child = child->left;
if (grand_child != NULL) { if (grand_child) {
grand_child->parent = parent; grand_child->parent = parent;
} }
parent->parent = child; parent->parent = child;
@@ -135,7 +135,7 @@ static void map_rotate_right(map me,
{ {
map_reference_parent(me, parent, child); map_reference_parent(me, parent, child);
struct node *const grand_child = child->right; struct node *const grand_child = child->right;
if (grand_child != NULL) { if (grand_child) {
grand_child->parent = parent; grand_child->parent = parent;
} }
parent->parent = child; parent->parent = child;
@@ -217,7 +217,7 @@ static void map_insert_balance(map me, struct node *const item)
struct node *grand_child = NULL; struct node *grand_child = NULL;
struct node *child = item; struct node *child = item;
struct node *parent = item->parent; struct node *parent = item->parent;
while (parent != NULL) { while (parent) {
if (parent->left == child) { if (parent->left == child) {
parent->balance--; parent->balance--;
} else { } else {
@@ -248,19 +248,19 @@ static struct node *map_create_node(map me,
struct node *const parent) struct node *const parent)
{ {
struct node *const insert = malloc(sizeof(struct node)); struct node *const insert = malloc(sizeof(struct node));
if (insert == NULL) { if (!insert) {
return NULL; return NULL;
} }
insert->parent = parent; insert->parent = parent;
insert->balance = 0; insert->balance = 0;
insert->key = malloc(me->key_size); insert->key = malloc(me->key_size);
if (insert->key == NULL) { if (!insert->key) {
free(insert); free(insert);
return NULL; return NULL;
} }
memcpy(insert->key, key, me->key_size); memcpy(insert->key, key, me->key_size);
insert->value = malloc(me->value_size); insert->value = malloc(me->value_size);
if (insert->value == NULL) { if (!insert->value) {
free(insert->key); free(insert->key);
free(insert); free(insert);
return NULL; return NULL;
@@ -285,9 +285,9 @@ static struct node *map_create_node(map me,
*/ */
int map_put(map me, void *const key, void *const value) int map_put(map me, void *const key, void *const value)
{ {
if (me->root == NULL) { if (!me->root) {
struct node *insert = map_create_node(me, key, value, NULL); struct node *insert = map_create_node(me, key, value, NULL);
if (insert == NULL) { if (!insert) {
return -ENOMEM; return -ENOMEM;
} }
me->root = insert; me->root = insert;
@@ -297,11 +297,11 @@ int map_put(map me, void *const key, void *const value)
while (true) { while (true) {
const int compare = me->comparator(key, traverse->key); const int compare = me->comparator(key, traverse->key);
if (compare < 0) { if (compare < 0) {
if (traverse->left != NULL) { if (traverse->left) {
traverse = traverse->left; traverse = traverse->left;
} else { } else {
struct node *insert = map_create_node(me, key, value, traverse); struct node *insert = map_create_node(me, key, value, traverse);
if (insert == NULL) { if (!insert) {
return -ENOMEM; return -ENOMEM;
} }
traverse->left = insert; traverse->left = insert;
@@ -309,11 +309,11 @@ int map_put(map me, void *const key, void *const value)
return 0; return 0;
} }
} else if (compare > 0) { } else if (compare > 0) {
if (traverse->right != NULL) { if (traverse->right) {
traverse = traverse->right; traverse = traverse->right;
} else { } else {
struct node *insert = map_create_node(me, key, value, traverse); struct node *insert = map_create_node(me, key, value, traverse);
if (insert == NULL) { if (!insert) {
return -ENOMEM; return -ENOMEM;
} }
traverse->right = insert; traverse->right = insert;
@@ -333,19 +333,19 @@ int map_put(map me, void *const key, void *const value)
static struct node *map_equal_match(map me, const void *const key) static struct node *map_equal_match(map me, const void *const key)
{ {
struct node *traverse = me->root; struct node *traverse = me->root;
if (traverse == NULL) { if (!traverse) {
return false; return false;
} }
while (true) { while (true) {
const int compare = me->comparator(key, traverse->key); const int compare = me->comparator(key, traverse->key);
if (compare < 0) { if (compare < 0) {
if (traverse->left != NULL) { if (traverse->left) {
traverse = traverse->left; traverse = traverse->left;
} else { } else {
return NULL; return NULL;
} }
} else if (compare > 0) { } else if (compare > 0) {
if (traverse->right != NULL) { if (traverse->right) {
traverse = traverse->right; traverse = traverse->right;
} else { } else {
return NULL; return NULL;
@@ -368,7 +368,7 @@ static struct node *map_equal_match(map me, const void *const key)
bool map_get(void *const value, map me, void *const key) bool map_get(void *const value, map me, void *const key)
{ {
struct node *const traverse = map_equal_match(me, key); struct node *const traverse = map_equal_match(me, key);
if (traverse == NULL) { if (!traverse) {
return false; return false;
} }
memcpy(value, traverse->value, me->value_size); memcpy(value, traverse->value, me->value_size);
@@ -420,13 +420,13 @@ static void map_delete_balance(map me,
// Must re-balance if not in {-1, 0, 1} // Must re-balance if not in {-1, 0, 1}
if (item->balance > 1 || item->balance < -1) { if (item->balance > 1 || item->balance < -1) {
item = map_repair_pivot(me, item, is_left_deleted); item = map_repair_pivot(me, item, is_left_deleted);
if (item->parent == NULL || item->balance == -1 || item->balance == 1) { if (!item->parent || item->balance == -1 || item->balance == 1) {
return; return;
} }
} }
struct node *child = item; struct node *child = item;
struct node *parent = item->parent; struct node *parent = item->parent;
while (parent != NULL) { while (parent) {
if (parent->left == child) { if (parent->left == child) {
parent->balance++; parent->balance++;
} else { } else {
@@ -442,7 +442,7 @@ static void map_delete_balance(map me,
parent = child->parent; parent = child->parent;
// If balance is -1 or +1 after modification or the parent is NULL, // If balance is -1 or +1 after modification or the parent is NULL,
// then the tree is balanced. // then the tree is balanced.
if (parent == NULL || child->balance == -1 || child->balance == 1) { if (!parent || child->balance == -1 || child->balance == 1) {
return; return;
} }
} else { } else {
@@ -459,7 +459,7 @@ static void map_remove_no_children(map me, const struct node *const traverse)
{ {
struct node *const parent = traverse->parent; struct node *const parent = traverse->parent;
// If no parent and no children, then the only node is traverse. // If no parent and no children, then the only node is traverse.
if (parent == NULL) { if (!parent) {
me->root = NULL; me->root = NULL;
return; return;
} }
@@ -480,8 +480,8 @@ static void map_remove_one_child(map me, const struct node *const traverse)
{ {
struct node *const parent = traverse->parent; struct node *const parent = traverse->parent;
// If no parent, make the child of traverse the new root. // If no parent, make the child of traverse the new root.
if (parent == NULL) { if (!parent) {
if (traverse->left != NULL) { if (traverse->left) {
traverse->left->parent = NULL; traverse->left->parent = NULL;
me->root = traverse->left; me->root = traverse->left;
} else { } else {
@@ -492,7 +492,7 @@ static void map_remove_one_child(map me, const struct node *const traverse)
} }
// The parent of traverse now references the child of traverse. // The parent of traverse now references the child of traverse.
if (parent->left == traverse) { if (parent->left == traverse) {
if (traverse->left != NULL) { if (traverse->left) {
parent->left = traverse->left; parent->left = traverse->left;
traverse->left->parent = parent; traverse->left->parent = parent;
} else { } else {
@@ -501,7 +501,7 @@ static void map_remove_one_child(map me, const struct node *const traverse)
} }
map_delete_balance(me, parent, true); map_delete_balance(me, parent, true);
} else { } else {
if (traverse->left != NULL) { if (traverse->left) {
parent->right = traverse->left; parent->right = traverse->left;
traverse->left->parent = parent; traverse->left->parent = parent;
} else { } else {
@@ -529,13 +529,13 @@ static void map_remove_two_children(map me, const struct node *const traverse)
item->left->parent = item; item->left->parent = item;
} else { } else {
item = traverse->right->left; item = traverse->right->left;
while (item->left != NULL) { while (item->left) {
item = item->left; item = item->left;
} }
parent = item->parent; parent = item->parent;
item->balance = traverse->balance; item->balance = traverse->balance;
item->parent->left = item->right; item->parent->left = item->right;
if (item->right != NULL) { if (item->right) {
item->right->parent = item->parent; item->right->parent = item->parent;
} }
item->left = traverse->left; item->left = traverse->left;
@@ -544,7 +544,7 @@ static void map_remove_two_children(map me, const struct node *const traverse)
item->right->parent = item; item->right->parent = item;
item->parent = traverse->parent; item->parent = traverse->parent;
} }
if (traverse->parent == NULL) { if (!traverse->parent) {
me->root = item; me->root = item;
} else if (traverse->parent->left == traverse) { } else if (traverse->parent->left == traverse) {
item->parent->left = item; item->parent->left = item;
@@ -559,9 +559,9 @@ static void map_remove_two_children(map me, const struct node *const traverse)
*/ */
static void map_remove_element(map me, struct node *const traverse) static void map_remove_element(map me, struct node *const traverse)
{ {
if (traverse->left == NULL && traverse->right == NULL) { if (!traverse->left && !traverse->right) {
map_remove_no_children(me, traverse); map_remove_no_children(me, traverse);
} else if (traverse->left == NULL || traverse->right == NULL) { } else if (!traverse->left || !traverse->right) {
map_remove_one_child(me, traverse); map_remove_one_child(me, traverse);
} else { } else {
map_remove_two_children(me, traverse); map_remove_two_children(me, traverse);
@@ -583,7 +583,7 @@ static void map_remove_element(map me, struct node *const traverse)
bool map_remove(map me, void *const key) bool map_remove(map me, void *const key)
{ {
struct node *const traverse = map_equal_match(me, key); struct node *const traverse = map_equal_match(me, key);
if (traverse == NULL) { if (!traverse) {
return false; return false;
} }
map_remove_element(me, traverse); map_remove_element(me, traverse);
@@ -597,7 +597,7 @@ bool map_remove(map me, void *const key)
*/ */
void map_clear(map me) void map_clear(map me)
{ {
while (me->root != NULL) { while (me->root) {
map_remove_element(me, me->root); map_remove_element(me, me->root);
} }
} }

87
src/multimap.c
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2017 Bailey Thompson * Copyright (c) 2017-2018 Bailey Thompson
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal * of this software and associated documentation files (the "Software"), to deal
@@ -69,7 +69,7 @@ multimap multimap_init(const size_t key_size,
const void *const)) const void *const))
{ {
struct _multimap *const init = malloc(sizeof(struct _multimap)); struct _multimap *const init = malloc(sizeof(struct _multimap));
if (init == NULL) { if (!init) {
return NULL; return NULL;
} }
init->key_size = key_size; init->key_size = key_size;
@@ -114,7 +114,7 @@ static void multimap_reference_parent(multimap me,
struct node *const child) struct node *const child)
{ {
child->parent = parent->parent; child->parent = parent->parent;
if (parent->parent == NULL) { if (!parent->parent) {
me->root = child; me->root = child;
} else if (parent->parent->left == parent) { } else if (parent->parent->left == parent) {
parent->parent->left = child; parent->parent->left = child;
@@ -132,7 +132,7 @@ static void multimap_rotate_left(multimap me,
{ {
multimap_reference_parent(me, parent, child); multimap_reference_parent(me, parent, child);
struct node *const grand_child = child->left; struct node *const grand_child = child->left;
if (grand_child != NULL) { if (grand_child) {
grand_child->parent = parent; grand_child->parent = parent;
} }
parent->parent = child; parent->parent = child;
@@ -149,7 +149,7 @@ static void multimap_rotate_right(multimap me,
{ {
multimap_reference_parent(me, parent, child); multimap_reference_parent(me, parent, child);
struct node *const grand_child = child->right; struct node *const grand_child = child->right;
if (grand_child != NULL) { if (grand_child) {
grand_child->parent = parent; grand_child->parent = parent;
} }
parent->parent = child; parent->parent = child;
@@ -231,7 +231,7 @@ static void multimap_insert_balance(multimap me, struct node *const item)
struct node *grand_child = NULL; struct node *grand_child = NULL;
struct node *child = item; struct node *child = item;
struct node *parent = item->parent; struct node *parent = item->parent;
while (parent != NULL) { while (parent) {
if (parent->left == child) { if (parent->left == child) {
parent->balance--; parent->balance--;
} else { } else {
@@ -260,11 +260,11 @@ static struct value_node *multimap_create_value_node(multimap me,
const void *const value) const void *const value)
{ {
struct value_node *const add = malloc(sizeof(struct value_node)); struct value_node *const add = malloc(sizeof(struct value_node));
if (add == NULL) { if (!add) {
return NULL; return NULL;
} }
add->value = malloc(me->value_size); add->value = malloc(me->value_size);
if (add->value == NULL) { if (!add->value) {
free(add); free(add);
return NULL; return NULL;
} }
@@ -282,20 +282,20 @@ static struct node *multimap_create_node(multimap me,
struct node *const parent) struct node *const parent)
{ {
struct node *const insert = malloc(sizeof(struct node)); struct node *const insert = malloc(sizeof(struct node));
if (insert == NULL) { if (!insert) {
return NULL; return NULL;
} }
insert->parent = parent; insert->parent = parent;
insert->balance = 0; insert->balance = 0;
insert->key = malloc(me->key_size); insert->key = malloc(me->key_size);
if (insert->key == NULL) { if (!insert->key) {
free(insert); free(insert);
return NULL; return NULL;
} }
memcpy(insert->key, key, me->key_size); memcpy(insert->key, key, me->key_size);
insert->value_count = 1; insert->value_count = 1;
insert->head = multimap_create_value_node(me, value); insert->head = multimap_create_value_node(me, value);
if (insert->head == NULL) { if (!insert->head) {
free(insert->key); free(insert->key);
free(insert); free(insert);
return NULL; return NULL;
@@ -318,9 +318,9 @@ static struct node *multimap_create_node(multimap me,
*/ */
int multimap_put(multimap me, void *const key, void *const value) int multimap_put(multimap me, void *const key, void *const value)
{ {
if (me->root == NULL) { if (!me->root) {
struct node *insert = multimap_create_node(me, key, value, NULL); struct node *insert = multimap_create_node(me, key, value, NULL);
if (insert == NULL) { if (!insert) {
return -ENOMEM; return -ENOMEM;
} }
me->root = insert; me->root = insert;
@@ -330,12 +330,12 @@ int multimap_put(multimap me, void *const key, void *const value)
while (true) { while (true) {
const int compare = me->key_comparator(key, traverse->key); const int compare = me->key_comparator(key, traverse->key);
if (compare < 0) { if (compare < 0) {
if (traverse->left != NULL) { if (traverse->left) {
traverse = traverse->left; traverse = traverse->left;
} else { } else {
struct node *insert = struct node *insert =
multimap_create_node(me, key, value, traverse); multimap_create_node(me, key, value, traverse);
if (insert == NULL) { if (!insert) {
return -ENOMEM; return -ENOMEM;
} }
traverse->left = insert; traverse->left = insert;
@@ -343,12 +343,12 @@ int multimap_put(multimap me, void *const key, void *const value)
return 0; return 0;
} }
} else if (compare > 0) { } else if (compare > 0) {
if (traverse->right != NULL) { if (traverse->right) {
traverse = traverse->right; traverse = traverse->right;
} else { } else {
struct node *insert = struct node *insert =
multimap_create_node(me, key, value, traverse); multimap_create_node(me, key, value, traverse);
if (insert == NULL) { if (!insert) {
return -ENOMEM; return -ENOMEM;
} }
traverse->right = insert; traverse->right = insert;
@@ -357,7 +357,7 @@ int multimap_put(multimap me, void *const key, void *const value)
} }
} else { } else {
struct value_node *value_traverse = traverse->head; struct value_node *value_traverse = traverse->head;
while (value_traverse->next != NULL) { while (value_traverse->next) {
value_traverse = value_traverse->next; value_traverse = value_traverse->next;
} }
value_traverse->next = multimap_create_value_node(me, value); value_traverse->next = multimap_create_value_node(me, value);
@@ -374,19 +374,19 @@ int multimap_put(multimap me, void *const key, void *const value)
static struct node *multimap_equal_match(multimap me, const void *const key) static struct node *multimap_equal_match(multimap me, const void *const key)
{ {
struct node *traverse = me->root; struct node *traverse = me->root;
if (traverse == NULL) { if (!traverse) {
return false; return false;
} }
while (true) { while (true) {
const int compare = me->key_comparator(key, traverse->key); const int compare = me->key_comparator(key, traverse->key);
if (compare < 0) { if (compare < 0) {
if (traverse->left != NULL) { if (traverse->left) {
traverse = traverse->left; traverse = traverse->left;
} else { } else {
return NULL; return NULL;
} }
} else if (compare > 0) { } else if (compare > 0) {
if (traverse->right != NULL) { if (traverse->right) {
traverse = traverse->right; traverse = traverse->right;
} else { } else {
return NULL; return NULL;
@@ -408,7 +408,7 @@ static struct node *multimap_equal_match(multimap me, const void *const key)
void multimap_get_start(multimap me, void *const key) void multimap_get_start(multimap me, void *const key)
{ {
const struct node *const traverse = multimap_equal_match(me, key); const struct node *const traverse = multimap_equal_match(me, key);
if (traverse != NULL) { if (traverse) {
me->iterate_get = traverse->head; me->iterate_get = traverse->head;
} }
} }
@@ -425,7 +425,7 @@ void multimap_get_start(multimap me, void *const key)
*/ */
bool multimap_get_next(void *const value, multimap me) bool multimap_get_next(void *const value, multimap me)
{ {
if (me->iterate_get == NULL) { if (!me->iterate_get) {
return false; return false;
} }
const struct value_node *const item = me->iterate_get; const struct value_node *const item = me->iterate_get;
@@ -445,7 +445,7 @@ bool multimap_get_next(void *const value, multimap me)
int multimap_count(multimap me, void *const key) int multimap_count(multimap me, void *const key)
{ {
struct node *const traverse = multimap_equal_match(me, key); struct node *const traverse = multimap_equal_match(me, key);
if (traverse == NULL) { if (!traverse) {
return 0; return 0;
} }
return traverse->value_count; return traverse->value_count;
@@ -496,13 +496,13 @@ static void multimap_delete_balance(multimap me,
// Must re-balance if not in {-1, 0, 1} // Must re-balance if not in {-1, 0, 1}
if (item->balance > 1 || item->balance < -1) { if (item->balance > 1 || item->balance < -1) {
item = multimap_repair_pivot(me, item, is_left_deleted); item = multimap_repair_pivot(me, item, is_left_deleted);
if (item->parent == NULL || item->balance == -1 || item->balance == 1) { if (!item->parent || item->balance == -1 || item->balance == 1) {
return; return;
} }
} }
struct node *child = item; struct node *child = item;
struct node *parent = item->parent; struct node *parent = item->parent;
while (parent != NULL) { while (parent) {
if (parent->left == child) { if (parent->left == child) {
parent->balance++; parent->balance++;
} else { } else {
@@ -518,7 +518,7 @@ static void multimap_delete_balance(multimap me,
parent = child->parent; parent = child->parent;
// If balance is -1 or +1 after modification or the parent is NULL, // If balance is -1 or +1 after modification or the parent is NULL,
// then the tree is balanced. // then the tree is balanced.
if (parent == NULL || child->balance == -1 || child->balance == 1) { if (!parent || child->balance == -1 || child->balance == 1) {
return; return;
} }
} else { } else {
@@ -536,7 +536,7 @@ static void multimap_remove_no_children(multimap me,
{ {
struct node *const parent = traverse->parent; struct node *const parent = traverse->parent;
// If no parent and no children, then the only node is traverse. // If no parent and no children, then the only node is traverse.
if (parent == NULL) { if (!parent) {
me->root = NULL; me->root = NULL;
return; return;
} }
@@ -558,8 +558,8 @@ static void multimap_remove_one_child(multimap me,
{ {
struct node *const parent = traverse->parent; struct node *const parent = traverse->parent;
// If no parent, make the child of traverse the new root. // If no parent, make the child of traverse the new root.
if (parent == NULL) { if (!parent) {
if (traverse->left != NULL) { if (traverse->left) {
traverse->left->parent = NULL; traverse->left->parent = NULL;
me->root = traverse->left; me->root = traverse->left;
} else { } else {
@@ -570,7 +570,7 @@ static void multimap_remove_one_child(multimap me,
} }
// The parent of traverse now references the child of traverse. // The parent of traverse now references the child of traverse.
if (parent->left == traverse) { if (parent->left == traverse) {
if (traverse->left != NULL) { if (traverse->left) {
parent->left = traverse->left; parent->left = traverse->left;
traverse->left->parent = parent; traverse->left->parent = parent;
} else { } else {
@@ -579,7 +579,7 @@ static void multimap_remove_one_child(multimap me,
} }
multimap_delete_balance(me, parent, true); multimap_delete_balance(me, parent, true);
} else { } else {
if (traverse->left != NULL) { if (traverse->left) {
parent->right = traverse->left; parent->right = traverse->left;
traverse->left->parent = parent; traverse->left->parent = parent;
} else { } else {
@@ -608,13 +608,13 @@ static void multimap_remove_two_children(multimap me,
item->left->parent = item; item->left->parent = item;
} else { } else {
item = traverse->right->left; item = traverse->right->left;
while (item->left != NULL) { while (item->left) {
item = item->left; item = item->left;
} }
parent = item->parent; parent = item->parent;
item->balance = traverse->balance; item->balance = traverse->balance;
item->parent->left = item->right; item->parent->left = item->right;
if (item->right != NULL) { if (item->right) {
item->right->parent = item->parent; item->right->parent = item->parent;
} }
item->left = traverse->left; item->left = traverse->left;
@@ -623,7 +623,7 @@ static void multimap_remove_two_children(multimap me,
item->right->parent = item; item->right->parent = item;
item->parent = traverse->parent; item->parent = traverse->parent;
} }
if (traverse->parent == NULL) { if (!traverse->parent) {
me->root = item; me->root = item;
} else if (traverse->parent->left == traverse) { } else if (traverse->parent->left == traverse) {
item->parent->left = item; item->parent->left = item;
@@ -638,9 +638,9 @@ static void multimap_remove_two_children(multimap me,
*/ */
static void multimap_remove_element(multimap me, struct node *const traverse) static void multimap_remove_element(multimap me, struct node *const traverse)
{ {
if (traverse->left == NULL && traverse->right == NULL) { if (!traverse->left && !traverse->right) {
multimap_remove_no_children(me, traverse); multimap_remove_no_children(me, traverse);
} else if (traverse->left == NULL || traverse->right == NULL) { } else if (!traverse->left || !traverse->right) {
multimap_remove_one_child(me, traverse); multimap_remove_one_child(me, traverse);
} else { } else {
multimap_remove_two_children(me, traverse); multimap_remove_two_children(me, traverse);
@@ -661,7 +661,7 @@ static void multimap_remove_element(multimap me, struct node *const traverse)
bool multimap_remove(multimap me, void *const key, void *const value) bool multimap_remove(multimap me, void *const key, void *const value)
{ {
struct node *const traverse = multimap_equal_match(me, key); struct node *const traverse = multimap_equal_match(me, key);
if (traverse == NULL) { if (!traverse) {
return false; return false;
} }
struct value_node *current = traverse->head; struct value_node *current = traverse->head;
@@ -670,12 +670,11 @@ bool multimap_remove(multimap me, void *const key, void *const value)
} else { } else {
struct value_node *previous = current; struct value_node *previous = current;
current = current->next; current = current->next;
while (current != NULL && while (current && me->value_comparator(current->value, value) != 0) {
me->value_comparator(current->value, value) != 0) {
previous = current; previous = current;
current = current->next; current = current->next;
} }
if (current == NULL) { if (!current) {
return false; return false;
} }
previous->next = current->next; previous->next = current->next;
@@ -697,7 +696,7 @@ static void multimap_remove_all_element(multimap me,
struct node *const traverse) struct node *const traverse)
{ {
struct value_node *value_traverse = traverse->head; struct value_node *value_traverse = traverse->head;
while (value_traverse != NULL) { while (value_traverse) {
struct value_node *temp = value_traverse; struct value_node *temp = value_traverse;
value_traverse = value_traverse->next; value_traverse = value_traverse->next;
free(temp->value); free(temp->value);
@@ -718,7 +717,7 @@ static void multimap_remove_all_element(multimap me,
bool multimap_remove_all(multimap me, void *const key) bool multimap_remove_all(multimap me, void *const key)
{ {
struct node *const traverse = multimap_equal_match(me, key); struct node *const traverse = multimap_equal_match(me, key);
if (traverse == NULL) { if (!traverse) {
return false; return false;
} }
multimap_remove_all_element(me, traverse); multimap_remove_all_element(me, traverse);
@@ -732,7 +731,7 @@ bool multimap_remove_all(multimap me, void *const key)
*/ */
void multimap_clear(multimap me) void multimap_clear(multimap me)
{ {
while (me->root != NULL) { while (me->root) {
multimap_remove_all_element(me, me->root); multimap_remove_all_element(me, me->root);
} }
} }

66
src/multiset.c
View File

@@ -55,7 +55,7 @@ multiset multiset_init(const size_t key_size,
const void *const)) const void *const))
{ {
struct _multiset *const init = malloc(sizeof(struct _multiset)); struct _multiset *const init = malloc(sizeof(struct _multiset));
if (init == NULL) { if (!init) {
return NULL; return NULL;
} }
init->key_size = key_size; init->key_size = key_size;
@@ -97,7 +97,7 @@ static void multiset_reference_parent(multiset me,
struct node *const child) struct node *const child)
{ {
child->parent = parent->parent; child->parent = parent->parent;
if (parent->parent == NULL) { if (!parent->parent) {
me->root = child; me->root = child;
} else if (parent->parent->left == parent) { } else if (parent->parent->left == parent) {
parent->parent->left = child; parent->parent->left = child;
@@ -115,7 +115,7 @@ static void multiset_rotate_left(multiset me,
{ {
multiset_reference_parent(me, parent, child); multiset_reference_parent(me, parent, child);
struct node *const grand_child = child->left; struct node *const grand_child = child->left;
if (grand_child != NULL) { if (grand_child) {
grand_child->parent = parent; grand_child->parent = parent;
} }
parent->parent = child; parent->parent = child;
@@ -132,7 +132,7 @@ static void multiset_rotate_right(multiset me,
{ {
multiset_reference_parent(me, parent, child); multiset_reference_parent(me, parent, child);
struct node *const grand_child = child->right; struct node *const grand_child = child->right;
if (grand_child != NULL) { if (grand_child) {
grand_child->parent = parent; grand_child->parent = parent;
} }
parent->parent = child; parent->parent = child;
@@ -214,7 +214,7 @@ static void multiset_insert_balance(multiset me, struct node *const item)
struct node *grand_child = NULL; struct node *grand_child = NULL;
struct node *child = item; struct node *child = item;
struct node *parent = item->parent; struct node *parent = item->parent;
while (parent != NULL) { while (parent) {
if (parent->left == child) { if (parent->left == child) {
parent->balance--; parent->balance--;
} else { } else {
@@ -244,14 +244,14 @@ static struct node *multiset_create_node(multiset me,
struct node *const parent) struct node *const parent)
{ {
struct node *const insert = malloc(sizeof(struct node)); struct node *const insert = malloc(sizeof(struct node));
if (insert == NULL) { if (!insert) {
return NULL; return NULL;
} }
insert->count = 1; insert->count = 1;
insert->parent = parent; insert->parent = parent;
insert->balance = 0; insert->balance = 0;
insert->key = malloc(me->key_size); insert->key = malloc(me->key_size);
if (insert->key == NULL) { if (!insert->key) {
free(insert); free(insert);
return NULL; return NULL;
} }
@@ -273,9 +273,9 @@ static struct node *multiset_create_node(multiset me,
*/ */
int multiset_put(multiset me, void *const key) int multiset_put(multiset me, void *const key)
{ {
if (me->root == NULL) { if (!me->root) {
struct node *insert = multiset_create_node(me, key, NULL); struct node *insert = multiset_create_node(me, key, NULL);
if (insert == NULL) { if (!insert) {
return -ENOMEM; return -ENOMEM;
} }
me->root = insert; me->root = insert;
@@ -285,11 +285,11 @@ int multiset_put(multiset me, void *const key)
while (true) { while (true) {
const int compare = me->comparator(key, traverse->key); const int compare = me->comparator(key, traverse->key);
if (compare < 0) { if (compare < 0) {
if (traverse->left != NULL) { if (traverse->left) {
traverse = traverse->left; traverse = traverse->left;
} else { } else {
struct node *insert = multiset_create_node(me, key, traverse); struct node *insert = multiset_create_node(me, key, traverse);
if (insert == NULL) { if (!insert) {
return -ENOMEM; return -ENOMEM;
} }
traverse->left = insert; traverse->left = insert;
@@ -297,11 +297,11 @@ int multiset_put(multiset me, void *const key)
return 0; return 0;
} }
} else if (compare > 0) { } else if (compare > 0) {
if (traverse->right != NULL) { if (traverse->right) {
traverse = traverse->right; traverse = traverse->right;
} else { } else {
struct node *insert = multiset_create_node(me, key, traverse); struct node *insert = multiset_create_node(me, key, traverse);
if (insert == NULL) { if (!insert) {
return -ENOMEM; return -ENOMEM;
} }
traverse->right = insert; traverse->right = insert;
@@ -322,19 +322,19 @@ int multiset_put(multiset me, void *const key)
static struct node *multiset_equal_match(multiset me, const void *const key) static struct node *multiset_equal_match(multiset me, const void *const key)
{ {
struct node *traverse = me->root; struct node *traverse = me->root;
if (traverse == NULL) { if (!traverse) {
return false; return false;
} }
while (true) { while (true) {
const int compare = me->comparator(key, traverse->key); const int compare = me->comparator(key, traverse->key);
if (compare < 0) { if (compare < 0) {
if (traverse->left != NULL) { if (traverse->left) {
traverse = traverse->left; traverse = traverse->left;
} else { } else {
return NULL; return NULL;
} }
} else if (compare > 0) { } else if (compare > 0) {
if (traverse->right != NULL) { if (traverse->right) {
traverse = traverse->right; traverse = traverse->right;
} else { } else {
return NULL; return NULL;
@@ -356,7 +356,7 @@ static struct node *multiset_equal_match(multiset me, const void *const key)
int multiset_count(multiset me, void *const key) int multiset_count(multiset me, void *const key)
{ {
const struct node *const item = multiset_equal_match(me, key); const struct node *const item = multiset_equal_match(me, key);
if (item == NULL) { if (!item) {
return 0; return 0;
} }
return item->count; return item->count;
@@ -407,13 +407,13 @@ static void multiset_delete_balance(multiset me,
// Must re-balance if not in {-1, 0, 1} // Must re-balance if not in {-1, 0, 1}
if (item->balance > 1 || item->balance < -1) { if (item->balance > 1 || item->balance < -1) {
item = multiset_repair_pivot(me, item, is_left_deleted); item = multiset_repair_pivot(me, item, is_left_deleted);
if (item->parent == NULL || item->balance == -1 || item->balance == 1) { if (!item->parent || item->balance == -1 || item->balance == 1) {
return; return;
} }
} }
struct node *child = item; struct node *child = item;
struct node *parent = item->parent; struct node *parent = item->parent;
while (parent != NULL) { while (parent) {
if (parent->left == child) { if (parent->left == child) {
parent->balance++; parent->balance++;
} else { } else {
@@ -429,7 +429,7 @@ static void multiset_delete_balance(multiset me,
parent = child->parent; parent = child->parent;
// If balance is -1 or +1 after modification or the parent is NULL, // If balance is -1 or +1 after modification or the parent is NULL,
// then the tree is balanced. // then the tree is balanced.
if (parent == NULL || child->balance == -1 || child->balance == 1) { if (!parent || child->balance == -1 || child->balance == 1) {
return; return;
} }
} else { } else {
@@ -447,7 +447,7 @@ static void multiset_remove_no_children(multiset me,
{ {
struct node *const parent = traverse->parent; struct node *const parent = traverse->parent;
// If no parent and no children, then the only node is traverse. // If no parent and no children, then the only node is traverse.
if (parent == NULL) { if (!parent) {
me->root = NULL; me->root = NULL;
return; return;
} }
@@ -469,8 +469,8 @@ static void multiset_remove_one_child(multiset me,
{ {
struct node *const parent = traverse->parent; struct node *const parent = traverse->parent;
// If no parent, make the child of traverse the new root. // If no parent, make the child of traverse the new root.
if (parent == NULL) { if (!parent) {
if (traverse->left != NULL) { if (traverse->left) {
traverse->left->parent = NULL; traverse->left->parent = NULL;
me->root = traverse->left; me->root = traverse->left;
} else { } else {
@@ -481,7 +481,7 @@ static void multiset_remove_one_child(multiset me,
} }
// The parent of traverse now references the child of traverse. // The parent of traverse now references the child of traverse.
if (parent->left == traverse) { if (parent->left == traverse) {
if (traverse->left != NULL) { if (traverse->left) {
parent->left = traverse->left; parent->left = traverse->left;
traverse->left->parent = parent; traverse->left->parent = parent;
} else { } else {
@@ -490,7 +490,7 @@ static void multiset_remove_one_child(multiset me,
} }
multiset_delete_balance(me, parent, true); multiset_delete_balance(me, parent, true);
} else { } else {
if (traverse->left != NULL) { if (traverse->left) {
parent->right = traverse->left; parent->right = traverse->left;
traverse->left->parent = parent; traverse->left->parent = parent;
} else { } else {
@@ -519,13 +519,13 @@ static void multiset_remove_two_children(multiset me,
item->left->parent = item; item->left->parent = item;
} else { } else {
item = traverse->right->left; item = traverse->right->left;
while (item->left != NULL) { while (item->left) {
item = item->left; item = item->left;
} }
parent = item->parent; parent = item->parent;
item->balance = traverse->balance; item->balance = traverse->balance;
item->parent->left = item->right; item->parent->left = item->right;
if (item->right != NULL) { if (item->right) {
item->right->parent = item->parent; item->right->parent = item->parent;
} }
item->left = traverse->left; item->left = traverse->left;
@@ -534,7 +534,7 @@ static void multiset_remove_two_children(multiset me,
item->right->parent = item; item->right->parent = item;
item->parent = traverse->parent; item->parent = traverse->parent;
} }
if (traverse->parent == NULL) { if (!traverse->parent) {
me->root = item; me->root = item;
} else if (traverse->parent->left == traverse) { } else if (traverse->parent->left == traverse) {
item->parent->left = item; item->parent->left = item;
@@ -549,9 +549,9 @@ static void multiset_remove_two_children(multiset me,
*/ */
static void multiset_remove_element(multiset me, struct node *const traverse) static void multiset_remove_element(multiset me, struct node *const traverse)
{ {
if (traverse->left == NULL && traverse->right == NULL) { if (!traverse->left && !traverse->right) {
multiset_remove_no_children(me, traverse); multiset_remove_no_children(me, traverse);
} else if (traverse->left == NULL || traverse->right == NULL) { } else if (!traverse->left || !traverse->right) {
multiset_remove_one_child(me, traverse); multiset_remove_one_child(me, traverse);
} else { } else {
multiset_remove_two_children(me, traverse); multiset_remove_two_children(me, traverse);
@@ -571,7 +571,7 @@ static void multiset_remove_element(multiset me, struct node *const traverse)
bool multiset_remove(multiset me, void *const key) bool multiset_remove(multiset me, void *const key)
{ {
struct node *const traverse = multiset_equal_match(me, key); struct node *const traverse = multiset_equal_match(me, key);
if (traverse == NULL) { if (!traverse) {
return false; return false;
} }
traverse->count--; traverse->count--;
@@ -593,7 +593,7 @@ bool multiset_remove(multiset me, void *const key)
bool multiset_remove_all(multiset me, void *const key) bool multiset_remove_all(multiset me, void *const key)
{ {
struct node *const traverse = multiset_equal_match(me, key); struct node *const traverse = multiset_equal_match(me, key);
if (traverse == NULL) { if (!traverse) {
return false; return false;
} }
me->size -= traverse->count; me->size -= traverse->count;
@@ -608,7 +608,7 @@ bool multiset_remove_all(multiset me, void *const key)
*/ */
void multiset_clear(multiset me) void multiset_clear(multiset me)
{ {
while (me->root != NULL) { while (me->root) {
multiset_remove_element(me, me->root); multiset_remove_element(me, me->root);
} }
me->size = 0; me->size = 0;

6
src/priority_queue.c
View File

@@ -47,12 +47,12 @@ priority_queue priority_queue_init(const size_t data_size,
const void *const)) const void *const))
{ {
struct _priority_queue *const init = malloc(sizeof(struct _priority_queue)); struct _priority_queue *const init = malloc(sizeof(struct _priority_queue));
if (init == NULL) { if (!init) {
return NULL; return NULL;
} }
init->data_size = data_size; init->data_size = data_size;
init->data = vector_init(data_size); init->data = vector_init(data_size);
if (init->data == NULL) { if (!init->data) {
free(init); free(init);
return NULL; return NULL;
} }
@@ -96,7 +96,7 @@ bool priority_queue_is_empty(priority_queue me)
int priority_queue_push(priority_queue me, void *const data) int priority_queue_push(priority_queue me, void *const data)
{ {
void *const temp = malloc(me->data_size); void *const temp = malloc(me->data_size);
if (temp == NULL) { if (!temp) {
return -ENOMEM; return -ENOMEM;
} }
const int rc = vector_add_last(me->data, data); const int rc = vector_add_last(me->data, data);

4
src/queue.c
View File

@@ -42,12 +42,12 @@ struct _queue {
queue queue_init(const size_t data_size) queue queue_init(const size_t data_size)
{ {
struct _queue *const init = malloc(sizeof(struct _queue)); struct _queue *const init = malloc(sizeof(struct _queue));
if (init == NULL) { if (!init) {
return NULL; return NULL;
} }
init->trim_count = 0; init->trim_count = 0;
init->deque_data = deque_init(data_size); init->deque_data = deque_init(data_size);
if (init->deque_data == NULL) { if (!init->deque_data) {
free(init); free(init);
return NULL; return NULL;
} }

64
src/set.c
View File

@@ -1,5 +1,5 @@
/* /*
* Copyright (c) 2017 Bailey Thompson * Copyright (c) 2017-2018 Bailey Thompson
* *
* Permission is hereby granted, free of charge, to any person obtaining a copy * Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal * of this software and associated documentation files (the "Software"), to deal
@@ -52,7 +52,7 @@ set set_init(const size_t key_size,
int (*const comparator)(const void *const, const void *const)) int (*const comparator)(const void *const, const void *const))
{ {
struct _set *const init = malloc(sizeof(struct _set)); struct _set *const init = malloc(sizeof(struct _set));
if (init == NULL) { if (!init) {
return NULL; return NULL;
} }
init->key_size = key_size; init->key_size = key_size;
@@ -94,7 +94,7 @@ static void set_reference_parent(set me,
struct node *const child) struct node *const child)
{ {
child->parent = parent->parent; child->parent = parent->parent;
if (parent->parent == NULL) { if (!parent->parent) {
me->root = child; me->root = child;
} else if (parent->parent->left == parent) { } else if (parent->parent->left == parent) {
parent->parent->left = child; parent->parent->left = child;
@@ -112,7 +112,7 @@ static void set_rotate_left(set me,
{ {
set_reference_parent(me, parent, child); set_reference_parent(me, parent, child);
struct node *const grand_child = child->left; struct node *const grand_child = child->left;
if (grand_child != NULL) { if (grand_child) {
grand_child->parent = parent; grand_child->parent = parent;
} }
parent->parent = child; parent->parent = child;
@@ -129,7 +129,7 @@ static void set_rotate_right(set me,
{ {
set_reference_parent(me, parent, child); set_reference_parent(me, parent, child);
struct node *const grand_child = child->right; struct node *const grand_child = child->right;
if (grand_child != NULL) { if (grand_child) {
grand_child->parent = parent; grand_child->parent = parent;
} }
parent->parent = child; parent->parent = child;
@@ -211,7 +211,7 @@ static void set_insert_balance(set me, struct node *const item)
struct node *grand_child = NULL; struct node *grand_child = NULL;
struct node *child = item; struct node *child = item;
struct node *parent = item->parent; struct node *parent = item->parent;
while (parent != NULL) { while (parent) {
if (parent->left == child) { if (parent->left == child) {
parent->balance--; parent->balance--;
} else { } else {
@@ -241,13 +241,13 @@ static struct node *set_create_node(set me,
struct node *const parent) struct node *const parent)
{ {
struct node *const insert = malloc(sizeof(struct node)); struct node *const insert = malloc(sizeof(struct node));
if (insert == NULL) { if (!insert) {
return NULL; return NULL;
} }
insert->parent = parent; insert->parent = parent;
insert->balance = 0; insert->balance = 0;
insert->key = malloc(me->key_size); insert->key = malloc(me->key_size);
if (insert->key == NULL) { if (!insert->key) {
free(insert); free(insert);
return NULL; return NULL;
} }
@@ -269,9 +269,9 @@ static struct node *set_create_node(set me,
*/ */
int set_put(set me, void *const key) int set_put(set me, void *const key)
{ {
if (me->root == NULL) { if (!me->root) {
struct node *insert = set_create_node(me, key, NULL); struct node *insert = set_create_node(me, key, NULL);
if (insert == NULL) { if (!insert) {
return -ENOMEM; return -ENOMEM;
} }
me->root = insert; me->root = insert;
@@ -281,11 +281,11 @@ int set_put(set me, void *const key)
while (true) { while (true) {
const int compare = me->comparator(key, traverse->key); const int compare = me->comparator(key, traverse->key);
if (compare < 0) { if (compare < 0) {
if (traverse->left != NULL) { if (traverse->left) {
traverse = traverse->left; traverse = traverse->left;
} else { } else {
struct node *insert = set_create_node(me, key, traverse); struct node *insert = set_create_node(me, key, traverse);
if (insert == NULL) { if (!insert) {
return -ENOMEM; return -ENOMEM;
} }
traverse->left = insert; traverse->left = insert;
@@ -293,11 +293,11 @@ int set_put(set me, void *const key)
return 0; return 0;
} }
} else if (compare > 0) { } else if (compare > 0) {
if (traverse->right != NULL) { if (traverse->right) {
traverse = traverse->right; traverse = traverse->right;
} else { } else {
struct node *insert = set_create_node(me, key, traverse); struct node *insert = set_create_node(me, key, traverse);
if (insert == NULL) { if (!insert) {
return -ENOMEM; return -ENOMEM;
} }
traverse->right = insert; traverse->right = insert;
@@ -316,19 +316,19 @@ int set_put(set me, void *const key)
static struct node *set_equal_match(set me, const void *const key) static struct node *set_equal_match(set me, const void *const key)
{ {
struct node *traverse = me->root; struct node *traverse = me->root;
if (traverse == NULL) { if (!traverse) {
return false; return false;
} }
while (true) { while (true) {
const int compare = me->comparator(key, traverse->key); const int compare = me->comparator(key, traverse->key);
if (compare < 0) { if (compare < 0) {
if (traverse->left != NULL) { if (traverse->left) {
traverse = traverse->left; traverse = traverse->left;
} else { } else {
return NULL; return NULL;
} }
} else if (compare > 0) { } else if (compare > 0) {
if (traverse->right != NULL) { if (traverse->right) {
traverse = traverse->right; traverse = traverse->right;
} else { } else {
return NULL; return NULL;
@@ -384,13 +384,13 @@ static void set_delete_balance(set me,
// Must re-balance if not in {-1, 0, 1} // Must re-balance if not in {-1, 0, 1}
if (item->balance > 1 || item->balance < -1) { if (item->balance > 1 || item->balance < -1) {
item = set_repair_pivot(me, item, is_left_deleted); item = set_repair_pivot(me, item, is_left_deleted);
if (item->parent == NULL || item->balance == -1 || item->balance == 1) { if (!item->parent || item->balance == -1 || item->balance == 1) {
return; return;
} }
} }
struct node *child = item; struct node *child = item;
struct node *parent = item->parent; struct node *parent = item->parent;
while (parent != NULL) { while (parent) {
if (parent->left == child) { if (parent->left == child) {
parent->balance++; parent->balance++;
} else { } else {
@@ -406,7 +406,7 @@ static void set_delete_balance(set me,
parent = child->parent; parent = child->parent;
// If balance is -1 or +1 after modification or the parent is NULL, // If balance is -1 or +1 after modification or the parent is NULL,
// then the tree is balanced. // then the tree is balanced.
if (parent == NULL || child->balance == -1 || child->balance == 1) { if (!parent || child->balance == -1 || child->balance == 1) {
return; return;
} }
} else { } else {
@@ -423,7 +423,7 @@ static void set_remove_no_children(set me, const struct node *const traverse)
{ {
struct node *const parent = traverse->parent; struct node *const parent = traverse->parent;
// If no parent and no children, then the only node is traverse. // If no parent and no children, then the only node is traverse.
if (parent == NULL) { if (!parent) {
me->root = NULL; me->root = NULL;
return; return;
} }
@@ -444,8 +444,8 @@ static void set_remove_one_child(set me, const struct node *const traverse)
{ {
struct node *const parent = traverse->parent; struct node *const parent = traverse->parent;
// If no parent, make the child of traverse the new root. // If no parent, make the child of traverse the new root.
if (parent == NULL) { if (!parent) {
if (traverse->left != NULL) { if (traverse->left) {
traverse->left->parent = NULL; traverse->left->parent = NULL;
me->root = traverse->left; me->root = traverse->left;
} else { } else {
@@ -456,7 +456,7 @@ static void set_remove_one_child(set me, const struct node *const traverse)
} }
// The parent of traverse now references the child of traverse. // The parent of traverse now references the child of traverse.
if (parent->left == traverse) { if (parent->left == traverse) {
if (traverse->left != NULL) { if (traverse->left) {
parent->left = traverse->left; parent->left = traverse->left;
traverse->left->parent = parent; traverse->left->parent = parent;
} else { } else {
@@ -465,7 +465,7 @@ static void set_remove_one_child(set me, const struct node *const traverse)
} }
set_delete_balance(me, parent, true); set_delete_balance(me, parent, true);
} else { } else {
if (traverse->left != NULL) { if (traverse->left) {
parent->right = traverse->left; parent->right = traverse->left;
traverse->left->parent = parent; traverse->left->parent = parent;
} else { } else {
@@ -493,13 +493,13 @@ static void set_remove_two_children(set me, const struct node *const traverse)
item->left->parent = item; item->left->parent = item;
} else { } else {
item = traverse->right->left; item = traverse->right->left;
while (item->left != NULL) { while (item->left) {
item = item->left; item = item->left;
} }
parent = item->parent; parent = item->parent;
item->balance = traverse->balance; item->balance = traverse->balance;
item->parent->left = item->right; item->parent->left = item->right;
if (item->right != NULL) { if (item->right) {
item->right->parent = item->parent; item->right->parent = item->parent;
} }
item->left = traverse->left; item->left = traverse->left;
@@ -508,7 +508,7 @@ static void set_remove_two_children(set me, const struct node *const traverse)
item->right->parent = item; item->right->parent = item;
item->parent = traverse->parent; item->parent = traverse->parent;
} }
if (traverse->parent == NULL) { if (!traverse->parent) {
me->root = item; me->root = item;
} else if (traverse->parent->left == traverse) { } else if (traverse->parent->left == traverse) {
item->parent->left = item; item->parent->left = item;
@@ -523,9 +523,9 @@ static void set_remove_two_children(set me, const struct node *const traverse)
*/ */
static void set_remove_element(set me, struct node *const traverse) static void set_remove_element(set me, struct node *const traverse)
{ {
if (traverse->left == NULL && traverse->right == NULL) { if (!traverse->left && !traverse->right) {
set_remove_no_children(me, traverse); set_remove_no_children(me, traverse);
} else if (traverse->left == NULL || traverse->right == NULL) { } else if (!traverse->left || !traverse->right) {
set_remove_one_child(me, traverse); set_remove_one_child(me, traverse);
} else { } else {
set_remove_two_children(me, traverse); set_remove_two_children(me, traverse);
@@ -546,7 +546,7 @@ static void set_remove_element(set me, struct node *const traverse)
bool set_remove(set me, void *const key) bool set_remove(set me, void *const key)
{ {
struct node *const traverse = set_equal_match(me, key); struct node *const traverse = set_equal_match(me, key);
if (traverse == NULL) { if (!traverse) {
return false; return false;
} }
set_remove_element(me, traverse); set_remove_element(me, traverse);
@@ -560,7 +560,7 @@ bool set_remove(set me, void *const key)
*/ */
void set_clear(set me) void set_clear(set me)
{ {
while (me->root != NULL) { while (me->root) {
set_remove_element(me, me->root); set_remove_element(me, me->root);
} }
} }

4
src/stack.c
View File

@@ -39,11 +39,11 @@ struct _stack {
stack stack_init(const size_t data_size) stack stack_init(const size_t data_size)
{ {
struct _stack *const init = malloc(sizeof(struct _stack)); struct _stack *const init = malloc(sizeof(struct _stack));
if (init == NULL) { if (!init) {
return NULL; return NULL;
} }
init->deque_data = deque_init(data_size); init->deque_data = deque_init(data_size);
if (init->deque_data == NULL) { if (!init->deque_data) {
free(init); free(init);
return NULL; return NULL;
} }

42
src/unordered_map.c
View File

@@ -65,7 +65,7 @@ unordered_map unordered_map_init(const size_t key_size,
const void *const)) const void *const))
{ {
struct _unordered_map *const init = malloc(sizeof(struct _unordered_map)); struct _unordered_map *const init = malloc(sizeof(struct _unordered_map));
if (init == NULL) { if (!init) {
return NULL; return NULL;
} }
init->key_size = key_size; init->key_size = key_size;
@@ -75,7 +75,7 @@ unordered_map unordered_map_init(const size_t key_size,
init->size = 0; init->size = 0;
init->capacity = STARTING_BUCKETS; init->capacity = STARTING_BUCKETS;
init->buckets = calloc(STARTING_BUCKETS, sizeof(struct node *)); init->buckets = calloc(STARTING_BUCKETS, sizeof(struct node *));
if (init->buckets == NULL) { if (!init->buckets) {
free(init); free(init);
return NULL; return NULL;
} }
@@ -89,12 +89,12 @@ static void unordered_map_add_item(unordered_map me, struct node *const add)
{ {
const int index = (int) (add->hash % me->capacity); const int index = (int) (add->hash % me->capacity);
add->next = NULL; add->next = NULL;
if (me->buckets[index] == NULL) { if (!me->buckets[index]) {
me->buckets[index] = add; me->buckets[index] = add;
return; return;
} }
struct node *traverse = me->buckets[index]; struct node *traverse = me->buckets[index];
while (traverse->next != NULL) { while (traverse->next) {
traverse = traverse->next; traverse = traverse->next;
} }
traverse->next = add; traverse->next = add;
@@ -113,13 +113,13 @@ int unordered_map_rehash(unordered_map me)
{ {
struct node **old_buckets = me->buckets; struct node **old_buckets = me->buckets;
me->buckets = calloc((size_t) me->capacity, sizeof(struct node *)); me->buckets = calloc((size_t) me->capacity, sizeof(struct node *));
if (me->buckets == NULL) { if (!me->buckets) {
me->buckets = old_buckets; me->buckets = old_buckets;
return -ENOMEM; return -ENOMEM;
} }
for (int i = 0; i < me->capacity; i++) { for (int i = 0; i < me->capacity; i++) {
struct node *traverse = old_buckets[i]; struct node *traverse = old_buckets[i];
while (traverse != NULL) { while (traverse) {
struct node *const backup = traverse->next; struct node *const backup = traverse->next;
traverse->hash = me->hash(traverse->key); traverse->hash = me->hash(traverse->key);
unordered_map_add_item(me, traverse); unordered_map_add_item(me, traverse);
@@ -163,14 +163,14 @@ static int unordered_map_resize(unordered_map me)
const int new_capacity = (int) (me->capacity * RESIZE_RATIO); const int new_capacity = (int) (me->capacity * RESIZE_RATIO);
struct node **old_buckets = me->buckets; struct node **old_buckets = me->buckets;
me->buckets = calloc((size_t) new_capacity, sizeof(struct node *)); me->buckets = calloc((size_t) new_capacity, sizeof(struct node *));
if (me->buckets == NULL) { if (!me->buckets) {
me->buckets = old_buckets; me->buckets = old_buckets;
return -ENOMEM; return -ENOMEM;
} }
me->capacity = new_capacity; me->capacity = new_capacity;
for (int i = 0; i < old_capacity; i++) { for (int i = 0; i < old_capacity; i++) {
struct node *traverse = old_buckets[i]; struct node *traverse = old_buckets[i];
while (traverse != NULL) { while (traverse) {
struct node *const backup = traverse->next; struct node *const backup = traverse->next;
unordered_map_add_item(me, traverse); unordered_map_add_item(me, traverse);
traverse = backup; traverse = backup;
@@ -200,17 +200,17 @@ static struct node *const unordered_map_create_element(unordered_map me,
const void *const value) const void *const value)
{ {
struct node *const init = malloc(sizeof(struct node)); struct node *const init = malloc(sizeof(struct node));
if (init == NULL) { if (!init) {
return NULL; return NULL;
} }
init->key = malloc(me->key_size); init->key = malloc(me->key_size);
if (init->key == NULL) { if (!init->key) {
free(init); free(init);
return NULL; return NULL;
} }
memcpy(init->key, key, me->key_size); memcpy(init->key, key, me->key_size);
init->value = malloc(me->value_size); init->value = malloc(me->value_size);
if (init->value == NULL) { if (!init->value) {
free(init->key); free(init->key);
free(init); free(init);
return NULL; return NULL;
@@ -237,9 +237,9 @@ int unordered_map_put(unordered_map me, void *const key, void *const value)
const unsigned long hash = me->hash(key); const unsigned long hash = me->hash(key);
const int index = (int) (hash % me->capacity); const int index = (int) (hash % me->capacity);
if (me->buckets[index] == NULL) { if (!me->buckets[index]) {
me->buckets[index] = unordered_map_create_element(me, hash, key, value); me->buckets[index] = unordered_map_create_element(me, hash, key, value);
if (me->buckets[index] == NULL) { if (!me->buckets[index]) {
return -ENOMEM; return -ENOMEM;
} }
} else { } else {
@@ -248,7 +248,7 @@ int unordered_map_put(unordered_map me, void *const key, void *const value)
memcpy(traverse->value, value, me->value_size); memcpy(traverse->value, value, me->value_size);
return 0; return 0;
} }
while (traverse->next != NULL) { while (traverse->next) {
traverse = traverse->next; traverse = traverse->next;
if (unordered_map_is_equal(me, traverse, hash, key)) { if (unordered_map_is_equal(me, traverse, hash, key)) {
memcpy(traverse->value, value, me->value_size); memcpy(traverse->value, value, me->value_size);
@@ -256,7 +256,7 @@ int unordered_map_put(unordered_map me, void *const key, void *const value)
} }
} }
traverse->next = unordered_map_create_element(me, hash, key, value); traverse->next = unordered_map_create_element(me, hash, key, value);
if (traverse->next == NULL) { if (!traverse->next) {
return -ENOMEM; return -ENOMEM;
} }
} }
@@ -281,7 +281,7 @@ bool unordered_map_get(void *const value, unordered_map me, void *const key)
const unsigned long hash = me->hash(key); const unsigned long hash = me->hash(key);
const int index = (int) (hash % me->capacity); const int index = (int) (hash % me->capacity);
struct node *traverse = me->buckets[index]; struct node *traverse = me->buckets[index];
while (traverse != NULL) { while (traverse) {
if (unordered_map_is_equal(me, traverse, hash, key)) { if (unordered_map_is_equal(me, traverse, hash, key)) {
memcpy(value, traverse->value, me->value_size); memcpy(value, traverse->value, me->value_size);
return true; return true;
@@ -304,7 +304,7 @@ bool unordered_map_contains(unordered_map me, void *const key)
const unsigned long hash = me->hash(key); const unsigned long hash = me->hash(key);
const int index = (int) (hash % me->capacity); const int index = (int) (hash % me->capacity);
const struct node *traverse = me->buckets[index]; const struct node *traverse = me->buckets[index];
while (traverse != NULL) { while (traverse) {
if (unordered_map_is_equal(me, traverse, hash, key)) { if (unordered_map_is_equal(me, traverse, hash, key)) {
return true; return true;
} }
@@ -325,7 +325,7 @@ bool unordered_map_remove(unordered_map me, void *const key)
{ {
const unsigned long hash = me->hash(key); const unsigned long hash = me->hash(key);
const int index = (int) (hash % me->capacity); const int index = (int) (hash % me->capacity);
if (me->buckets[index] == NULL) { if (!me->buckets[index]) {
return false; return false;
} }
struct node *traverse = me->buckets[index]; struct node *traverse = me->buckets[index];
@@ -337,7 +337,7 @@ bool unordered_map_remove(unordered_map me, void *const key)
me->size--; me->size--;
return true; return true;
} }
while (traverse->next != NULL) { while (traverse->next) {
if (unordered_map_is_equal(me, traverse->next, hash, key)) { if (unordered_map_is_equal(me, traverse->next, hash, key)) {
struct node *const backup = traverse->next; struct node *const backup = traverse->next;
traverse->next = traverse->next->next; traverse->next = traverse->next->next;
@@ -364,12 +364,12 @@ int unordered_map_clear(unordered_map me)
{ {
struct node **temp = struct node **temp =
calloc((size_t) STARTING_BUCKETS, sizeof(struct node *)); calloc((size_t) STARTING_BUCKETS, sizeof(struct node *));
if (temp == NULL) { if (!temp) {
return -ENOMEM; return -ENOMEM;
} }
for (int i = 0; i < me->capacity; i++) { for (int i = 0; i < me->capacity; i++) {
struct node *traverse = me->buckets[i]; struct node *traverse = me->buckets[i];
while (traverse != NULL) { while (traverse) {
struct node *const backup = traverse; struct node *const backup = traverse;
traverse = traverse->next; traverse = traverse->next;
free(backup->key); free(backup->key);

54
src/unordered_multimap.c
View File

@@ -74,7 +74,7 @@ unordered_multimap_init(const size_t key_size,
{ {
struct _unordered_multimap *const init = struct _unordered_multimap *const init =
malloc(sizeof(struct _unordered_multimap)); malloc(sizeof(struct _unordered_multimap));
if (init == NULL) { if (!init) {
return NULL; return NULL;
} }
init->key_size = key_size; init->key_size = key_size;
@@ -85,13 +85,13 @@ unordered_multimap_init(const size_t key_size,
init->size = 0; init->size = 0;
init->capacity = STARTING_BUCKETS; init->capacity = STARTING_BUCKETS;
init->buckets = calloc(STARTING_BUCKETS, sizeof(struct node *)); init->buckets = calloc(STARTING_BUCKETS, sizeof(struct node *));
if (init->buckets == NULL) { if (!init->buckets) {
free(init); free(init);
return NULL; return NULL;
} }
init->iterate_hash = 0; init->iterate_hash = 0;
init->iterate_key = calloc(1, init->key_size); init->iterate_key = calloc(1, init->key_size);
if (init->iterate_key == NULL) { if (!init->iterate_key) {
free(init->buckets); free(init->buckets);
free(init); free(init);
return NULL; return NULL;
@@ -108,12 +108,12 @@ static void unordered_multimap_add_item(unordered_multimap me,
{ {
const int index = (int) (add->hash % me->capacity); const int index = (int) (add->hash % me->capacity);
add->next = NULL; add->next = NULL;
if (me->buckets[index] == NULL) { if (!me->buckets[index]) {
me->buckets[index] = add; me->buckets[index] = add;
return; return;
} }
struct node *traverse = me->buckets[index]; struct node *traverse = me->buckets[index];
while (traverse->next != NULL) { while (traverse->next) {
traverse = traverse->next; traverse = traverse->next;
} }
traverse->next = add; traverse->next = add;
@@ -132,13 +132,13 @@ int unordered_multimap_rehash(unordered_multimap me)
{ {
struct node **old_buckets = me->buckets; struct node **old_buckets = me->buckets;
me->buckets = calloc((size_t) me->capacity, sizeof(struct node *)); me->buckets = calloc((size_t) me->capacity, sizeof(struct node *));
if (me->buckets == NULL) { if (!me->buckets) {
me->buckets = old_buckets; me->buckets = old_buckets;
return -ENOMEM; return -ENOMEM;
} }
for (int i = 0; i < me->capacity; i++) { for (int i = 0; i < me->capacity; i++) {
struct node *traverse = old_buckets[i]; struct node *traverse = old_buckets[i];
while (traverse != NULL) { while (traverse) {
struct node *const backup = traverse->next; struct node *const backup = traverse->next;
traverse->hash = me->hash(traverse->key); traverse->hash = me->hash(traverse->key);
unordered_multimap_add_item(me, traverse); unordered_multimap_add_item(me, traverse);
@@ -182,14 +182,14 @@ static int unordered_multimap_resize(unordered_multimap me)
const int new_capacity = (int) (me->capacity * RESIZE_RATIO); const int new_capacity = (int) (me->capacity * RESIZE_RATIO);
struct node **old_buckets = me->buckets; struct node **old_buckets = me->buckets;
me->buckets = calloc((size_t) new_capacity, sizeof(struct node *)); me->buckets = calloc((size_t) new_capacity, sizeof(struct node *));
if (me->buckets == NULL) { if (!me->buckets) {
me->buckets = old_buckets; me->buckets = old_buckets;
return -ENOMEM; return -ENOMEM;
} }
me->capacity = new_capacity; me->capacity = new_capacity;
for (int i = 0; i < old_capacity; i++) { for (int i = 0; i < old_capacity; i++) {
struct node *traverse = old_buckets[i]; struct node *traverse = old_buckets[i];
while (traverse != NULL) { while (traverse) {
struct node *const backup = traverse->next; struct node *const backup = traverse->next;
unordered_multimap_add_item(me, traverse); unordered_multimap_add_item(me, traverse);
traverse = backup; traverse = backup;
@@ -220,17 +220,17 @@ unordered_multimap_create_element(unordered_multimap me,
const void *const value) const void *const value)
{ {
struct node *const init = malloc(sizeof(struct node)); struct node *const init = malloc(sizeof(struct node));
if (init == NULL) { if (!init) {
return NULL; return NULL;
} }
init->key = malloc(me->key_size); init->key = malloc(me->key_size);
if (init->key == NULL) { if (!init->key) {
free(init); free(init);
return NULL; return NULL;
} }
memcpy(init->key, key, me->key_size); memcpy(init->key, key, me->key_size);
init->value = malloc(me->value_size); init->value = malloc(me->value_size);
if (init->value == NULL) { if (!init->value) {
free(init->key); free(init->key);
free(init); free(init);
return NULL; return NULL;
@@ -257,20 +257,20 @@ int unordered_multimap_put(unordered_multimap me,
{ {
const unsigned long hash = me->hash(key); const unsigned long hash = me->hash(key);
const int index = (int) (hash % me->capacity); const int index = (int) (hash % me->capacity);
if (me->buckets[index] == NULL) { if (!me->buckets[index]) {
me->buckets[index] = me->buckets[index] =
unordered_multimap_create_element(me, hash, key, value); unordered_multimap_create_element(me, hash, key, value);
if (me->buckets[index] == NULL) { if (!me->buckets[index]) {
return -ENOMEM; return -ENOMEM;
} }
} else { } else {
struct node *traverse = me->buckets[index]; struct node *traverse = me->buckets[index];
while (traverse->next != NULL) { while (traverse->next) {
traverse = traverse->next; traverse = traverse->next;
} }
traverse->next = traverse->next =
unordered_multimap_create_element(me, hash, key, value); unordered_multimap_create_element(me, hash, key, value);
if (traverse->next == NULL) { if (!traverse->next) {
return -ENOMEM; return -ENOMEM;
} }
} }
@@ -296,7 +296,7 @@ void unordered_multimap_get_start(unordered_multimap me, void *const key)
me->iterate_element = NULL; me->iterate_element = NULL;
const int index = (int) (me->iterate_hash % me->capacity); const int index = (int) (me->iterate_hash % me->capacity);
struct node *traverse = me->buckets[index]; struct node *traverse = me->buckets[index];
while (traverse != NULL) { while (traverse) {
if (unordered_multimap_is_equal(me, traverse, me->iterate_hash, key)) { if (unordered_multimap_is_equal(me, traverse, me->iterate_hash, key)) {
me->iterate_element = traverse; me->iterate_element = traverse;
return; return;
@@ -318,12 +318,12 @@ void unordered_multimap_get_start(unordered_multimap me, void *const key)
*/ */
bool unordered_multimap_get_next(void *const value, unordered_multimap me) bool unordered_multimap_get_next(void *const value, unordered_multimap me)
{ {
if (me->iterate_element == NULL) { if (!me->iterate_element) {
return false; return false;
} }
struct node *const item = me->iterate_element; struct node *const item = me->iterate_element;
struct node *traverse = item->next; struct node *traverse = item->next;
while (traverse != NULL) { while (traverse) {
if (unordered_multimap_is_equal(me, traverse, me->iterate_hash, if (unordered_multimap_is_equal(me, traverse, me->iterate_hash,
me->iterate_key)) { me->iterate_key)) {
me->iterate_element = traverse; me->iterate_element = traverse;
@@ -351,7 +351,7 @@ int unordered_multimap_count(unordered_multimap me, void *const key)
const unsigned long hash = me->hash(key); const unsigned long hash = me->hash(key);
const int index = (int) (hash % me->capacity); const int index = (int) (hash % me->capacity);
const struct node *traverse = me->buckets[index]; const struct node *traverse = me->buckets[index];
while (traverse != NULL) { while (traverse) {
if (unordered_multimap_is_equal(me, traverse, hash, key)) { if (unordered_multimap_is_equal(me, traverse, hash, key)) {
count++; count++;
} }
@@ -373,7 +373,7 @@ bool unordered_multimap_contains(unordered_multimap me, void *const key)
const unsigned long hash = me->hash(key); const unsigned long hash = me->hash(key);
const int index = (int) (hash % me->capacity); const int index = (int) (hash % me->capacity);
const struct node *traverse = me->buckets[index]; const struct node *traverse = me->buckets[index];
while (traverse != NULL) { while (traverse) {
if (unordered_multimap_is_equal(me, traverse, hash, key)) { if (unordered_multimap_is_equal(me, traverse, hash, key)) {
return true; return true;
} }
@@ -397,7 +397,7 @@ bool unordered_multimap_remove(unordered_multimap me,
{ {
const unsigned long hash = me->hash(key); const unsigned long hash = me->hash(key);
const int index = (int) (hash % me->capacity); const int index = (int) (hash % me->capacity);
if (me->buckets[index] == NULL) { if (!me->buckets[index]) {
return false; return false;
} }
struct node *traverse = me->buckets[index]; struct node *traverse = me->buckets[index];
@@ -410,7 +410,7 @@ bool unordered_multimap_remove(unordered_multimap me,
me->size--; me->size--;
return true; return true;
} }
while (traverse->next != NULL) { while (traverse->next) {
is_key_equal = is_key_equal =
unordered_multimap_is_equal(me, traverse->next, hash, key); unordered_multimap_is_equal(me, traverse->next, hash, key);
if (is_key_equal && me->value_comparator(traverse->value, value) == 0) { if (is_key_equal && me->value_comparator(traverse->value, value) == 0) {
@@ -443,7 +443,7 @@ bool unordered_multimap_remove_all(unordered_multimap me, void *const key)
bool was_modified = false; bool was_modified = false;
while (true) { while (true) {
struct node *traverse = me->buckets[index]; struct node *traverse = me->buckets[index];
if (traverse == NULL) { if (!traverse) {
break; break;
} }
if (unordered_multimap_is_equal(me, traverse, hash, key)) { if (unordered_multimap_is_equal(me, traverse, hash, key)) {
@@ -455,7 +455,7 @@ bool unordered_multimap_remove_all(unordered_multimap me, void *const key)
was_modified = true; was_modified = true;
continue; continue;
} }
while (traverse->next != NULL) { while (traverse->next) {
if (unordered_multimap_is_equal(me, traverse->next, hash, key)) { if (unordered_multimap_is_equal(me, traverse->next, hash, key)) {
struct node *const backup = traverse->next; struct node *const backup = traverse->next;
traverse->next = traverse->next->next; traverse->next = traverse->next->next;
@@ -485,12 +485,12 @@ int unordered_multimap_clear(unordered_multimap me)
{ {
struct node **temp = struct node **temp =
calloc((size_t) STARTING_BUCKETS, sizeof(struct node *)); calloc((size_t) STARTING_BUCKETS, sizeof(struct node *));
if (temp == NULL) { if (!temp) {
return -ENOMEM; return -ENOMEM;
} }
for (int i = 0; i < me->capacity; i++) { for (int i = 0; i < me->capacity; i++) {
struct node *traverse = me->buckets[i]; struct node *traverse = me->buckets[i];
while (traverse != NULL) { while (traverse) {
struct node *const backup = traverse; struct node *const backup = traverse;
traverse = traverse->next; traverse = traverse->next;
free(backup->key); free(backup->key);

42
src/unordered_multiset.c
View File

@@ -64,7 +64,7 @@ unordered_multiset_init(const size_t key_size,
{ {
struct _unordered_multiset *const init = struct _unordered_multiset *const init =
malloc(sizeof(struct _unordered_multiset)); malloc(sizeof(struct _unordered_multiset));
if (init == NULL) { if (!init) {
return NULL; return NULL;
} }
init->key_size = key_size; init->key_size = key_size;
@@ -74,7 +74,7 @@ unordered_multiset_init(const size_t key_size,
init->used = 0; init->used = 0;
init->capacity = STARTING_BUCKETS; init->capacity = STARTING_BUCKETS;
init->buckets = calloc(STARTING_BUCKETS, sizeof(struct node *)); init->buckets = calloc(STARTING_BUCKETS, sizeof(struct node *));
if (init->buckets == NULL) { if (!init->buckets) {
free(init); free(init);
return NULL; return NULL;
} }
@@ -89,12 +89,12 @@ static void unordered_multiset_add_item(unordered_multiset me,
{ {
const int index = (int) (add->hash % me->capacity); const int index = (int) (add->hash % me->capacity);
add->next = NULL; add->next = NULL;
if (me->buckets[index] == NULL) { if (!me->buckets[index]) {
me->buckets[index] = add; me->buckets[index] = add;
return; return;
} }
struct node *traverse = me->buckets[index]; struct node *traverse = me->buckets[index];
while (traverse->next != NULL) { while (traverse->next) {
traverse = traverse->next; traverse = traverse->next;
} }
traverse->next = add; traverse->next = add;
@@ -113,13 +113,13 @@ int unordered_multiset_rehash(unordered_multiset me)
{ {
struct node **old_buckets = me->buckets; struct node **old_buckets = me->buckets;
me->buckets = calloc((size_t) me->capacity, sizeof(struct node *)); me->buckets = calloc((size_t) me->capacity, sizeof(struct node *));
if (me->buckets == NULL) { if (!me->buckets) {
me->buckets = old_buckets; me->buckets = old_buckets;
return -ENOMEM; return -ENOMEM;
} }
for (int i = 0; i < me->capacity; i++) { for (int i = 0; i < me->capacity; i++) {
struct node *traverse = old_buckets[i]; struct node *traverse = old_buckets[i];
while (traverse != NULL) { while (traverse) {
struct node *const backup = traverse->next; struct node *const backup = traverse->next;
traverse->hash = me->hash(traverse->key); traverse->hash = me->hash(traverse->key);
unordered_multiset_add_item(me, traverse); unordered_multiset_add_item(me, traverse);
@@ -163,14 +163,14 @@ static int unordered_multiset_resize(unordered_multiset me)
const int new_capacity = (int) (me->capacity * RESIZE_RATIO); const int new_capacity = (int) (me->capacity * RESIZE_RATIO);
struct node **old_buckets = me->buckets; struct node **old_buckets = me->buckets;
me->buckets = calloc((size_t) new_capacity, sizeof(struct node *)); me->buckets = calloc((size_t) new_capacity, sizeof(struct node *));
if (me->buckets == NULL) { if (!me->buckets) {
me->buckets = old_buckets; me->buckets = old_buckets;
return -ENOMEM; return -ENOMEM;
} }
me->capacity = new_capacity; me->capacity = new_capacity;
for (int i = 0; i < old_capacity; i++) { for (int i = 0; i < old_capacity; i++) {
struct node *traverse = old_buckets[i]; struct node *traverse = old_buckets[i];
while (traverse != NULL) { while (traverse) {
struct node *const backup = traverse->next; struct node *const backup = traverse->next;
unordered_multiset_add_item(me, traverse); unordered_multiset_add_item(me, traverse);
traverse = backup; traverse = backup;
@@ -200,12 +200,12 @@ unordered_multiset_create_element(unordered_multiset me,
const void *const key) const void *const key)
{ {
struct node *const init = malloc(sizeof(struct node)); struct node *const init = malloc(sizeof(struct node));
if (init == NULL) { if (!init) {
return NULL; return NULL;
} }
init->count = 1; init->count = 1;
init->key = malloc(me->key_size); init->key = malloc(me->key_size);
if (init->key == NULL) { if (!init->key) {
free(init); free(init);
return NULL; return NULL;
} }
@@ -229,9 +229,9 @@ int unordered_multiset_put(unordered_multiset me, void *const key)
const unsigned long hash = me->hash(key); const unsigned long hash = me->hash(key);
const int index = (int) (hash % me->capacity); const int index = (int) (hash % me->capacity);
if (me->buckets[index] == NULL) { if (!me->buckets[index]) {
me->buckets[index] = unordered_multiset_create_element(me, hash, key); me->buckets[index] = unordered_multiset_create_element(me, hash, key);
if (me->buckets[index] == NULL) { if (!me->buckets[index]) {
return -ENOMEM; return -ENOMEM;
} }
} else { } else {
@@ -241,7 +241,7 @@ int unordered_multiset_put(unordered_multiset me, void *const key)
me->size++; me->size++;
return 0; return 0;
} }
while (traverse->next != NULL) { while (traverse->next) {
traverse = traverse->next; traverse = traverse->next;
if (unordered_multiset_is_equal(me, traverse, hash, key)) { if (unordered_multiset_is_equal(me, traverse, hash, key)) {
traverse->count++; traverse->count++;
@@ -250,7 +250,7 @@ int unordered_multiset_put(unordered_multiset me, void *const key)
} }
} }
traverse->next = unordered_multiset_create_element(me, hash, key); traverse->next = unordered_multiset_create_element(me, hash, key);
if (traverse->next == NULL) { if (!traverse->next) {
return -ENOMEM; return -ENOMEM;
} }
} }
@@ -275,7 +275,7 @@ int unordered_multiset_count(unordered_multiset me, void *const key)
const unsigned long hash = me->hash(key); const unsigned long hash = me->hash(key);
const int index = (int) (hash % me->capacity); const int index = (int) (hash % me->capacity);
const struct node *traverse = me->buckets[index]; const struct node *traverse = me->buckets[index];
while (traverse != NULL) { while (traverse) {
if (unordered_multiset_is_equal(me, traverse, hash, key)) { if (unordered_multiset_is_equal(me, traverse, hash, key)) {
return traverse->count; return traverse->count;
} }
@@ -309,7 +309,7 @@ bool unordered_multiset_remove(unordered_multiset me, void *const key)
{ {
const unsigned long hash = me->hash(key); const unsigned long hash = me->hash(key);
const int index = (int) (hash % me->capacity); const int index = (int) (hash % me->capacity);
if (me->buckets[index] == NULL) { if (!me->buckets[index]) {
return false; return false;
} }
struct node *traverse = me->buckets[index]; struct node *traverse = me->buckets[index];
@@ -324,7 +324,7 @@ bool unordered_multiset_remove(unordered_multiset me, void *const key)
me->size--; me->size--;
return true; return true;
} }
while (traverse->next != NULL) { while (traverse->next) {
if (unordered_multiset_is_equal(me, traverse->next, hash, key)) { if (unordered_multiset_is_equal(me, traverse->next, hash, key)) {
struct node *const backup = traverse->next; struct node *const backup = traverse->next;
backup->count--; backup->count--;
@@ -355,7 +355,7 @@ bool unordered_multiset_remove_all(unordered_multiset me, void *const key)
{ {
const unsigned long hash = me->hash(key); const unsigned long hash = me->hash(key);
const int index = (int) (hash % me->capacity); const int index = (int) (hash % me->capacity);
if (me->buckets[index] == NULL) { if (!me->buckets[index]) {
return false; return false;
} }
struct node *traverse = me->buckets[index]; struct node *traverse = me->buckets[index];
@@ -367,7 +367,7 @@ bool unordered_multiset_remove_all(unordered_multiset me, void *const key)
me->used--; me->used--;
return true; return true;
} }
while (traverse->next != NULL) { while (traverse->next) {
if (unordered_multiset_is_equal(me, traverse->next, hash, key)) { if (unordered_multiset_is_equal(me, traverse->next, hash, key)) {
struct node *const backup = traverse->next; struct node *const backup = traverse->next;
traverse->next = traverse->next->next; traverse->next = traverse->next->next;
@@ -394,12 +394,12 @@ int unordered_multiset_clear(unordered_multiset me)
{ {
struct node **temp = struct node **temp =
calloc((size_t) STARTING_BUCKETS, sizeof(struct node *)); calloc((size_t) STARTING_BUCKETS, sizeof(struct node *));
if (temp == NULL) { if (!temp) {
return -ENOMEM; return -ENOMEM;
} }
for (int i = 0; i < me->capacity; i++) { for (int i = 0; i < me->capacity; i++) {
struct node *traverse = me->buckets[i]; struct node *traverse = me->buckets[i];
while (traverse != NULL) { while (traverse) {
struct node *const backup = traverse; struct node *const backup = traverse;
traverse = traverse->next; traverse = traverse->next;
free(backup->key); free(backup->key);

38
src/unordered_set.c
View File

@@ -61,7 +61,7 @@ unordered_set unordered_set_init(const size_t key_size,
const void *const)) const void *const))
{ {
struct _unordered_set *const init = malloc(sizeof(struct _unordered_set)); struct _unordered_set *const init = malloc(sizeof(struct _unordered_set));
if (init == NULL) { if (!init) {
return NULL; return NULL;
} }
init->key_size = key_size; init->key_size = key_size;
@@ -70,7 +70,7 @@ unordered_set unordered_set_init(const size_t key_size,
init->size = 0; init->size = 0;
init->capacity = STARTING_BUCKETS; init->capacity = STARTING_BUCKETS;
init->buckets = calloc(STARTING_BUCKETS, sizeof(struct node *)); init->buckets = calloc(STARTING_BUCKETS, sizeof(struct node *));
if (init->buckets == NULL) { if (!init->buckets) {
free(init); free(init);
return NULL; return NULL;
} }
@@ -84,12 +84,12 @@ static void unordered_set_add_item(unordered_set me, struct node *const add)
{ {
const int index = (int) (add->hash % me->capacity); const int index = (int) (add->hash % me->capacity);
add->next = NULL; add->next = NULL;
if (me->buckets[index] == NULL) { if (!me->buckets[index]) {
me->buckets[index] = add; me->buckets[index] = add;
return; return;
} }
struct node *traverse = me->buckets[index]; struct node *traverse = me->buckets[index];
while (traverse->next != NULL) { while (traverse->next) {
traverse = traverse->next; traverse = traverse->next;
} }
traverse->next = add; traverse->next = add;
@@ -108,13 +108,13 @@ int unordered_set_rehash(unordered_set me)
{ {
struct node **old_buckets = me->buckets; struct node **old_buckets = me->buckets;
me->buckets = calloc((size_t) me->capacity, sizeof(struct node *)); me->buckets = calloc((size_t) me->capacity, sizeof(struct node *));
if (me->buckets == NULL) { if (!me->buckets) {
me->buckets = old_buckets; me->buckets = old_buckets;
return -ENOMEM; return -ENOMEM;
} }
for (int i = 0; i < me->capacity; i++) { for (int i = 0; i < me->capacity; i++) {
struct node *traverse = old_buckets[i]; struct node *traverse = old_buckets[i];
while (traverse != NULL) { while (traverse) {
struct node *const backup = traverse->next; struct node *const backup = traverse->next;
traverse->hash = me->hash(traverse->key); traverse->hash = me->hash(traverse->key);
unordered_set_add_item(me, traverse); unordered_set_add_item(me, traverse);
@@ -158,14 +158,14 @@ static int unordered_set_resize(unordered_set me)
const int new_capacity = (int) (me->capacity * RESIZE_RATIO); const int new_capacity = (int) (me->capacity * RESIZE_RATIO);
struct node **old_buckets = me->buckets; struct node **old_buckets = me->buckets;
me->buckets = calloc((size_t) new_capacity, sizeof(struct node *)); me->buckets = calloc((size_t) new_capacity, sizeof(struct node *));
if (me->buckets == NULL) { if (!me->buckets) {
me->buckets = old_buckets; me->buckets = old_buckets;
return -ENOMEM; return -ENOMEM;
} }
me->capacity = new_capacity; me->capacity = new_capacity;
for (int i = 0; i < old_capacity; i++) { for (int i = 0; i < old_capacity; i++) {
struct node *traverse = old_buckets[i]; struct node *traverse = old_buckets[i];
while (traverse != NULL) { while (traverse) {
struct node *const backup = traverse->next; struct node *const backup = traverse->next;
unordered_set_add_item(me, traverse); unordered_set_add_item(me, traverse);
traverse = backup; traverse = backup;
@@ -194,11 +194,11 @@ static struct node *const unordered_set_create_element(unordered_set me,
const void *const key) const void *const key)
{ {
struct node *const init = malloc(sizeof(struct node)); struct node *const init = malloc(sizeof(struct node));
if (init == NULL) { if (!init) {
return NULL; return NULL;
} }
init->key = malloc(me->key_size); init->key = malloc(me->key_size);
if (init->key == NULL) { if (!init->key) {
free(init); free(init);
return NULL; return NULL;
} }
@@ -223,9 +223,9 @@ int unordered_set_put(unordered_set me, void *const key)
const unsigned long hash = me->hash(key); const unsigned long hash = me->hash(key);
const int index = (int) (hash % me->capacity); const int index = (int) (hash % me->capacity);
if (me->buckets[index] == NULL) { if (!me->buckets[index]) {
me->buckets[index] = unordered_set_create_element(me, hash, key); me->buckets[index] = unordered_set_create_element(me, hash, key);
if (me->buckets[index] == NULL) { if (!me->buckets[index]) {
return -ENOMEM; return -ENOMEM;
} }
} else { } else {
@@ -233,14 +233,14 @@ int unordered_set_put(unordered_set me, void *const key)
if (unordered_set_is_equal(me, traverse, hash, key)) { if (unordered_set_is_equal(me, traverse, hash, key)) {
return 0; return 0;
} }
while (traverse->next != NULL) { while (traverse->next) {
traverse = traverse->next; traverse = traverse->next;
if (unordered_set_is_equal(me, traverse, hash, key)) { if (unordered_set_is_equal(me, traverse, hash, key)) {
return 0; return 0;
} }
} }
traverse->next = unordered_set_create_element(me, hash, key); traverse->next = unordered_set_create_element(me, hash, key);
if (traverse->next == NULL) { if (!traverse->next) {
return -ENOMEM; return -ENOMEM;
} }
} }
@@ -264,7 +264,7 @@ bool unordered_set_contains(unordered_set me, void *const key)
const unsigned long hash = me->hash(key); const unsigned long hash = me->hash(key);
const int index = (int) (hash % me->capacity); const int index = (int) (hash % me->capacity);
const struct node *traverse = me->buckets[index]; const struct node *traverse = me->buckets[index];
while (traverse != NULL) { while (traverse) {
if (unordered_set_is_equal(me, traverse, hash, key)) { if (unordered_set_is_equal(me, traverse, hash, key)) {
return true; return true;
} }
@@ -285,7 +285,7 @@ bool unordered_set_remove(unordered_set me, void *const key)
{ {
const unsigned long hash = me->hash(key); const unsigned long hash = me->hash(key);
const int index = (int) (hash % me->capacity); const int index = (int) (hash % me->capacity);
if (me->buckets[index] == NULL) { if (!me->buckets[index]) {
return false; return false;
} }
struct node *traverse = me->buckets[index]; struct node *traverse = me->buckets[index];
@@ -296,7 +296,7 @@ bool unordered_set_remove(unordered_set me, void *const key)
me->size--; me->size--;
return true; return true;
} }
while (traverse->next != NULL) { while (traverse->next) {
if (unordered_set_is_equal(me, traverse->next, hash, key)) { if (unordered_set_is_equal(me, traverse->next, hash, key)) {
struct node *const backup = traverse->next; struct node *const backup = traverse->next;
traverse->next = traverse->next->next; traverse->next = traverse->next->next;
@@ -322,12 +322,12 @@ int unordered_set_clear(unordered_set me)
{ {
struct node **temp = struct node **temp =
calloc((size_t) STARTING_BUCKETS, sizeof(struct node *)); calloc((size_t) STARTING_BUCKETS, sizeof(struct node *));
if (temp == NULL) { if (!temp) {
return -ENOMEM; return -ENOMEM;
} }
for (int i = 0; i < me->capacity; i++) { for (int i = 0; i < me->capacity; i++) {
struct node *traverse = me->buckets[i]; struct node *traverse = me->buckets[i];
while (traverse != NULL) { while (traverse) {
struct node *const backup = traverse; struct node *const backup = traverse;
traverse = traverse->next; traverse = traverse->next;
free(backup->key); free(backup->key);

8
src/vector.c
View File

@@ -45,14 +45,14 @@ struct _vector {
vector vector_init(const size_t data_size) vector vector_init(const size_t data_size)
{ {
struct _vector *const init = malloc(sizeof(struct _vector)); struct _vector *const init = malloc(sizeof(struct _vector));
if (init == NULL) { if (!init) {
return NULL; return NULL;
} }
init->data_size = data_size; init->data_size = data_size;
init->offset = 0; init->offset = 0;
init->space = START_SPACE; init->space = START_SPACE;
init->storage = malloc(init->space * init->data_size); init->storage = malloc(init->space * init->data_size);
if (init->storage == NULL) { if (!init->storage) {
free(init); free(init);
return NULL; return NULL;
} }
@@ -89,7 +89,7 @@ bool vector_is_empty(vector me)
static int vector_set_space(vector me, const int size) static int vector_set_space(vector me, const int size)
{ {
void *const temp = realloc(me->storage, size * me->data_size); void *const temp = realloc(me->storage, size * me->data_size);
if (temp == NULL) { if (!temp) {
return -ENOMEM; return -ENOMEM;
} }
me->storage = temp; me->storage = temp;
@@ -190,7 +190,7 @@ int vector_add_at(vector me, const int index, void *const data)
if (me->offset + 1 >= me->space) { if (me->offset + 1 >= me->space) {
const int new_space = (int) (me->space * RESIZE_RATIO); const int new_space = (int) (me->space * RESIZE_RATIO);
void *const temp = realloc(me->storage, new_space * me->data_size); void *const temp = realloc(me->storage, new_space * me->data_size);
if (temp == NULL) { if (!temp) {
return -ENOMEM; return -ENOMEM;
} }
me->storage = temp; me->storage = temp;