From e3bc87298f08f9443a56895f905c41f4807bd6cf Mon Sep 17 00:00:00 2001 From: Bailey Thompson Date: Mon, 17 Aug 2020 16:55:29 -0400 Subject: [PATCH] Simplify return values (#114) Introduce bk_err and bk_bool rather than using int for both of these. This means that the function definition now specifies whether 0 means no error, or whether it means false. --- compile_headers.py | 6 +- containers.h | 304 +++++++++++++++---------------- documentation.md | 7 +- src/array.c | 23 ++- src/deque.c | 115 ++++++------ src/forward_list.c | 100 +++++----- src/include/all.h | 43 +++++ src/include/array.h | 6 +- src/include/deque.h | 28 +-- src/include/forward_list.h | 28 +-- src/include/list.h | 28 +-- src/include/map.h | 12 +- src/include/multimap.h | 14 +- src/include/multiset.h | 12 +- src/include/priority_queue.h | 12 +- src/include/queue.h | 16 +- src/include/set.h | 10 +- src/include/stack.h | 14 +- src/include/unordered_map.h | 16 +- src/include/unordered_multimap.h | 21 ++- src/include/unordered_multiset.h | 16 +- src/include/unordered_set.h | 14 +- src/include/vector.h | 34 ++-- src/list.c | 97 +++++----- src/map.c | 45 +++-- src/multimap.c | 57 +++--- src/multiset.c | 45 +++-- src/priority_queue.c | 41 ++--- src/queue.c | 34 ++-- src/set.c | 37 ++-- src/stack.c | 30 +-- src/unordered_map.c | 88 ++++----- src/unordered_multimap.c | 115 ++++++------ src/unordered_multiset.c | 93 +++++----- src/unordered_set.c | 74 ++++---- src/vector.c | 130 ++++++------- tst/test.h | 2 + tst/test_array.c | 1 - tst/test_deque.c | 1 - tst/test_forward_list.c | 1 - tst/test_list.c | 1 - tst/test_map.c | 2 - tst/test_multimap.c | 2 - tst/test_multiset.c | 2 - tst/test_priority_queue.c | 1 - tst/test_queue.c | 1 - tst/test_set.c | 2 - tst/test_stack.c | 1 - tst/test_unordered_map.c | 1 - tst/test_unordered_multimap.c | 1 - tst/test_unordered_multiset.c | 1 - tst/test_unordered_set.c | 1 - tst/test_vector.c | 2 - 53 files changed, 904 insertions(+), 884 deletions(-) create mode 100644 src/include/all.h diff --git a/compile_headers.py b/compile_headers.py index fdb6b97..232541b 100644 --- a/compile_headers.py +++ b/compile_headers.py @@ -50,7 +50,11 @@ folder_path = 'src/include' for filename in sorted(glob.glob(os.path.join(folder_path, '*.h'))): with open(filename, 'r') as file: text = file.read() - header += text.split("*/", 1)[1] + entire_file = text.split("*/", 1)[1] + split_around_include = entire_file.split('#include "all.h"\n\n', 1) + header += split_around_include[0] + if len(split_around_include) == 2: + header += split_around_include[1] containers_header_file = open("containers.h", "w+") containers_header_file.write(header) diff --git a/containers.h b/containers.h index b4649d5..7fe3103 100644 --- a/containers.h +++ b/containers.h @@ -27,11 +27,32 @@ */ -#ifndef BKTHOMPS_CONTAINERS_ARRAY_H -#define BKTHOMPS_CONTAINERS_ARRAY_H +#ifndef BKTHOMPS_CONTAINERS_ALL_H +#define BKTHOMPS_CONTAINERS_ALL_H #include +/* + * Cannot use because the C89 standard does not guarantee all + * of these. These are the same values as the regular linux error codes. + */ +#define BK_OK 0 +#define BK_ENOMEM 12 +#define BK_EINVAL 22 + +/* Cannot use because it is C99 not C89. */ +#define BK_FALSE 0 +#define BK_TRUE (!BK_FALSE) + +typedef int bk_err; +typedef int bk_bool; + +#endif /* BKTHOMPS_CONTAINERS_ALL_H */ + + +#ifndef BKTHOMPS_CONTAINERS_ARRAY_H +#define BKTHOMPS_CONTAINERS_ARRAY_H + /** * The array data structure, which is a static contiguous array. */ @@ -46,8 +67,8 @@ void array_copy_to_array(void *arr, array me); void *array_get_data(array me); /* Accessing */ -int array_set(array me, size_t index, void *data); -int array_get(void *data, array me, size_t index); +bk_err array_set(array me, size_t index, void *data); +bk_err array_get(void *data, array me, size_t index); /* Ending */ array array_destroy(array me); @@ -58,8 +79,6 @@ array array_destroy(array me); #ifndef BKTHOMPS_CONTAINERS_DEQUE_H #define BKTHOMPS_CONTAINERS_DEQUE_H -#include - /** * The deque data structure, which is a doubly-ended queue. */ @@ -70,30 +89,30 @@ deque deque_init(size_t data_size); /* Utility */ size_t deque_size(deque me); -int deque_is_empty(deque me); -int deque_trim(deque me); +bk_bool deque_is_empty(deque me); +bk_err deque_trim(deque me); void deque_copy_to_array(void *arr, deque me); /* Adding */ -int deque_push_front(deque me, void *data); -int deque_push_back(deque me, void *data); +bk_err deque_push_front(deque me, void *data); +bk_err deque_push_back(deque me, void *data); /* Removing */ -int deque_pop_front(void *data, deque me); -int deque_pop_back(void *data, deque me); +bk_err deque_pop_front(void *data, deque me); +bk_err deque_pop_back(void *data, deque me); /* Setting */ -int deque_set_first(deque me, void *data); -int deque_set_at(deque me, size_t index, void *data); -int deque_set_last(deque me, void *data); +bk_err deque_set_first(deque me, void *data); +bk_err deque_set_at(deque me, size_t index, void *data); +bk_err deque_set_last(deque me, void *data); /* Getting */ -int deque_get_first(void *data, deque me); -int deque_get_at(void *data, deque me, size_t index); -int deque_get_last(void *data, deque me); +bk_err deque_get_first(void *data, deque me); +bk_err deque_get_at(void *data, deque me, size_t index); +bk_err deque_get_last(void *data, deque me); /* Ending */ -int deque_clear(deque me); +bk_err deque_clear(deque me); deque deque_destroy(deque me); #endif /* BKTHOMPS_CONTAINERS_DEQUE_H */ @@ -102,8 +121,6 @@ deque deque_destroy(deque me); #ifndef BKTHOMPS_CONTAINERS_FORWARD_LIST_H #define BKTHOMPS_CONTAINERS_FORWARD_LIST_H -#include - /** * The forward_list data structure, which is a singly-linked list. */ @@ -114,28 +131,28 @@ forward_list forward_list_init(size_t data_size); /* Utility */ size_t forward_list_size(forward_list me); -int forward_list_is_empty(forward_list me); +bk_bool forward_list_is_empty(forward_list me); void forward_list_copy_to_array(void *arr, forward_list me); /* Adding */ -int forward_list_add_first(forward_list me, void *data); -int forward_list_add_at(forward_list me, size_t index, void *data); -int forward_list_add_last(forward_list me, void *data); +bk_err forward_list_add_first(forward_list me, void *data); +bk_err forward_list_add_at(forward_list me, size_t index, void *data); +bk_err forward_list_add_last(forward_list me, void *data); /* Removing */ -int forward_list_remove_first(forward_list me); -int forward_list_remove_at(forward_list me, size_t index); -int forward_list_remove_last(forward_list me); +bk_err forward_list_remove_first(forward_list me); +bk_err forward_list_remove_at(forward_list me, size_t index); +bk_err forward_list_remove_last(forward_list me); /* Setting */ -int forward_list_set_first(forward_list me, void *data); -int forward_list_set_at(forward_list me, size_t index, void *data); -int forward_list_set_last(forward_list me, void *data); +bk_err forward_list_set_first(forward_list me, void *data); +bk_err forward_list_set_at(forward_list me, size_t index, void *data); +bk_err forward_list_set_last(forward_list me, void *data); /* Getting */ -int forward_list_get_first(void *data, forward_list me); -int forward_list_get_at(void *data, forward_list me, size_t index); -int forward_list_get_last(void *data, forward_list me); +bk_err forward_list_get_first(void *data, forward_list me); +bk_err forward_list_get_at(void *data, forward_list me, size_t index); +bk_err forward_list_get_last(void *data, forward_list me); /* Ending */ void forward_list_clear(forward_list me); @@ -147,8 +164,6 @@ forward_list forward_list_destroy(forward_list me); #ifndef BKTHOMPS_CONTAINERS_LIST_H #define BKTHOMPS_CONTAINERS_LIST_H -#include - /** * The list data structure, which is a doubly-linked list. */ @@ -159,28 +174,28 @@ list list_init(size_t data_size); /* Utility */ size_t list_size(list me); -int list_is_empty(list me); +bk_bool list_is_empty(list me); void list_copy_to_array(void *arr, list me); /* Adding */ -int list_add_first(list me, void *data); -int list_add_at(list me, size_t index, void *data); -int list_add_last(list me, void *data); +bk_err list_add_first(list me, void *data); +bk_err list_add_at(list me, size_t index, void *data); +bk_err list_add_last(list me, void *data); /* Removing */ -int list_remove_first(list me); -int list_remove_at(list me, size_t index); -int list_remove_last(list me); +bk_err list_remove_first(list me); +bk_err list_remove_at(list me, size_t index); +bk_err list_remove_last(list me); /* Setting */ -int list_set_first(list me, void *data); -int list_set_at(list me, size_t index, void *data); -int list_set_last(list me, void *data); +bk_err list_set_first(list me, void *data); +bk_err list_set_at(list me, size_t index, void *data); +bk_err list_set_last(list me, void *data); /* Getting */ -int list_get_first(void *data, list me); -int list_get_at(void *data, list me, size_t index); -int list_get_last(void *data, list me); +bk_err list_get_first(void *data, list me); +bk_err list_get_at(void *data, list me, size_t index); +bk_err list_get_last(void *data, list me); /* Ending */ void list_clear(list me); @@ -192,8 +207,6 @@ list list_destroy(list me); #ifndef BKTHOMPS_CONTAINERS_MAP_H #define BKTHOMPS_CONTAINERS_MAP_H -#include - /** * The map data structure, which is a collection of key-value pairs, sorted by * keys, keys are unique. @@ -206,13 +219,13 @@ map map_init(size_t key_size, size_t value_size, /* Capacity */ size_t map_size(map me); -int map_is_empty(map me); +bk_bool map_is_empty(map me); /* Accessing */ -int map_put(map me, void *key, void *value); -int map_get(void *value, map me, void *key); -int map_contains(map me, void *key); -int map_remove(map me, void *key); +bk_err map_put(map me, void *key, void *value); +bk_bool map_get(void *value, map me, void *key); +bk_bool map_contains(map me, void *key); +bk_bool map_remove(map me, void *key); /* Ending */ void map_clear(map me); @@ -224,8 +237,6 @@ map map_destroy(map me); #ifndef BKTHOMPS_CONTAINERS_MULTIMAP_H #define BKTHOMPS_CONTAINERS_MULTIMAP_H -#include - /** * The multimap data structure, which is a collection of key-value pairs, sorted * by keys. @@ -241,16 +252,16 @@ multimap multimap_init(size_t key_size, size_t value_size, /* Capacity */ size_t multimap_size(multimap me); -int multimap_is_empty(multimap me); +bk_bool multimap_is_empty(multimap me); /* Accessing */ -int multimap_put(multimap me, void *key, void *value); +bk_err multimap_put(multimap me, void *key, void *value); void multimap_get_start(multimap me, void *key); -int multimap_get_next(void *value, multimap me); +bk_bool multimap_get_next(void *value, multimap me); size_t multimap_count(multimap me, void *key); -int multimap_contains(multimap me, void *key); -int multimap_remove(multimap me, void *key, void *value); -int multimap_remove_all(multimap me, void *key); +bk_bool multimap_contains(multimap me, void *key); +bk_bool multimap_remove(multimap me, void *key, void *value); +bk_bool multimap_remove_all(multimap me, void *key); /* Ending */ void multimap_clear(multimap me); @@ -262,8 +273,6 @@ multimap multimap_destroy(multimap me); #ifndef BKTHOMPS_CONTAINERS_MULTISET_H #define BKTHOMPS_CONTAINERS_MULTISET_H -#include - /** * The multiset data structure, which is a collection of key-value pairs, sorted * by keys, keys are unique @@ -277,14 +286,14 @@ multiset multiset_init(size_t key_size, /* Capacity */ size_t multiset_size(multiset me); -int multiset_is_empty(multiset me); +bk_bool multiset_is_empty(multiset me); /* Accessing */ -int multiset_put(multiset me, void *key); +bk_err multiset_put(multiset me, void *key); size_t multiset_count(multiset me, void *key); -int multiset_contains(multiset me, void *key); -int multiset_remove(multiset me, void *key); -int multiset_remove_all(multiset me, void *key); +bk_bool multiset_contains(multiset me, void *key); +bk_bool multiset_remove(multiset me, void *key); +bk_bool multiset_remove_all(multiset me, void *key); /* Ending */ void multiset_clear(multiset me); @@ -296,8 +305,6 @@ multiset multiset_destroy(multiset me); #ifndef BKTHOMPS_CONTAINERS_PRIORITY_QUEUE_H #define BKTHOMPS_CONTAINERS_PRIORITY_QUEUE_H -#include - /** * The priority_queue data structure, which adapts a container to provide a * priority queue. Adapts the vector container. @@ -311,19 +318,19 @@ priority_queue priority_queue_init(size_t data_size, /* Utility */ size_t priority_queue_size(priority_queue me); -int priority_queue_is_empty(priority_queue me); +bk_bool priority_queue_is_empty(priority_queue me); /* Adding */ -int priority_queue_push(priority_queue me, void *data); +bk_err priority_queue_push(priority_queue me, void *data); /* Removing */ -int priority_queue_pop(void *data, priority_queue me); +bk_bool priority_queue_pop(void *data, priority_queue me); /* Getting */ -int priority_queue_front(void *data, priority_queue me); +bk_bool priority_queue_front(void *data, priority_queue me); /* Ending */ -int priority_queue_clear(priority_queue me); +bk_err priority_queue_clear(priority_queue me); priority_queue priority_queue_destroy(priority_queue me); #endif /* BKTHOMPS_CONTAINERS_PRIORITY_QUEUE_H */ @@ -332,8 +339,6 @@ priority_queue priority_queue_destroy(priority_queue me); #ifndef BKTHOMPS_CONTAINERS_QUEUE_H #define BKTHOMPS_CONTAINERS_QUEUE_H -#include - /** * The queue data structure, which adapts a container to provide a queue * (first-in first-out). Adapts the deque container. @@ -345,22 +350,22 @@ queue queue_init(size_t data_size); /* Utility */ size_t queue_size(queue me); -int queue_is_empty(queue me); -int queue_trim(queue me); +bk_bool queue_is_empty(queue me); +bk_err queue_trim(queue me); void queue_copy_to_array(void *arr, queue me); /* Adding */ -int queue_push(queue me, void *data); +bk_err queue_push(queue me, void *data); /* Removing */ -int queue_pop(void *data, queue me); +bk_bool queue_pop(void *data, queue me); /* Getting */ -int queue_front(void *data, queue me); -int queue_back(void *data, queue me); +bk_bool queue_front(void *data, queue me); +bk_bool queue_back(void *data, queue me); /* Ending */ -int queue_clear(queue me); +bk_err queue_clear(queue me); queue queue_destroy(queue me); #endif /* BKTHOMPS_CONTAINERS_QUEUE_H */ @@ -369,8 +374,6 @@ queue queue_destroy(queue me); #ifndef BKTHOMPS_CONTAINERS_SET_H #define BKTHOMPS_CONTAINERS_SET_H -#include - /** * The set data structure, which is a collection of unique keys, sorted by keys. */ @@ -382,12 +385,12 @@ set set_init(size_t key_size, /* Capacity */ size_t set_size(set me); -int set_is_empty(set me); +bk_bool set_is_empty(set me); /* Accessing */ -int set_put(set me, void *key); -int set_contains(set me, void *key); -int set_remove(set me, void *key); +bk_err set_put(set me, void *key); +bk_bool set_contains(set me, void *key); +bk_bool set_remove(set me, void *key); /* Ending */ void set_clear(set me); @@ -399,8 +402,6 @@ set set_destroy(set me); #ifndef BKTHOMPS_CONTAINERS_STACK_H #define BKTHOMPS_CONTAINERS_STACK_H -#include - /** * The stack data structure, which adapts a container to provide a stack * (last-in first-out). Adapts the deque container. @@ -412,21 +413,21 @@ stack stack_init(size_t data_size); /* Utility */ size_t stack_size(stack me); -int stack_is_empty(stack me); -int stack_trim(stack me); +bk_bool stack_is_empty(stack me); +bk_err stack_trim(stack me); void stack_copy_to_array(void *arr, stack me); /* Adding */ -int stack_push(stack me, void *data); +bk_err stack_push(stack me, void *data); /* Removing */ -int stack_pop(void *data, stack me); +bk_bool stack_pop(void *data, stack me); /* Getting */ -int stack_top(void *data, stack me); +bk_bool stack_top(void *data, stack me); /* Ending */ -int stack_clear(stack me); +bk_err stack_clear(stack me); stack stack_destroy(stack me); #endif /* BKTHOMPS_CONTAINERS_STACK_H */ @@ -435,8 +436,6 @@ stack stack_destroy(stack me); #ifndef BKTHOMPS_CONTAINERS_UNORDERED_MAP_H #define BKTHOMPS_CONTAINERS_UNORDERED_MAP_H -#include - /** * The unordered_map data structure, which is a collection of key-value pairs, * hashed by keys, keys are unique @@ -451,18 +450,18 @@ unordered_map unordered_map_init(size_t key_size, const void *const two)); /* Utility */ -int unordered_map_rehash(unordered_map me); +bk_err unordered_map_rehash(unordered_map me); size_t unordered_map_size(unordered_map me); -int unordered_map_is_empty(unordered_map me); +bk_bool unordered_map_is_empty(unordered_map me); /* Accessing */ -int unordered_map_put(unordered_map me, void *key, void *value); -int unordered_map_get(void *value, unordered_map me, void *key); -int unordered_map_contains(unordered_map me, void *key); -int unordered_map_remove(unordered_map me, void *key); +bk_err unordered_map_put(unordered_map me, void *key, void *value); +bk_bool unordered_map_get(void *value, unordered_map me, void *key); +bk_bool unordered_map_contains(unordered_map me, void *key); +bk_bool unordered_map_remove(unordered_map me, void *key); /* Ending */ -int unordered_map_clear(unordered_map me); +bk_err unordered_map_clear(unordered_map me); unordered_map unordered_map_destroy(unordered_map me); #endif /* BKTHOMPS_CONTAINERS_UNORDERED_MAP_H */ @@ -471,8 +470,6 @@ unordered_map unordered_map_destroy(unordered_map me); #ifndef BKTHOMPS_CONTAINERS_UNORDERED_MULTIMAP_H #define BKTHOMPS_CONTAINERS_UNORDERED_MULTIMAP_H -#include - /** * The unordered_multimap data structure, which is a collection of key-value * pairs, hashed by keys. @@ -490,21 +487,22 @@ unordered_multimap_init(size_t key_size, const void *const two)); /* Utility */ -int unordered_multimap_rehash(unordered_multimap me); +bk_err unordered_multimap_rehash(unordered_multimap me); size_t unordered_multimap_size(unordered_multimap me); -int unordered_multimap_is_empty(unordered_multimap me); +bk_bool unordered_multimap_is_empty(unordered_multimap me); /* Accessing */ -int unordered_multimap_put(unordered_multimap me, void *key, void *value); +bk_err unordered_multimap_put(unordered_multimap me, void *key, void *value); void unordered_multimap_get_start(unordered_multimap me, void *key); -int unordered_multimap_get_next(void *value, unordered_multimap me); -int unordered_multimap_count(unordered_multimap me, void *key); -int unordered_multimap_contains(unordered_multimap me, void *key); -int unordered_multimap_remove(unordered_multimap me, void *key, void *value); -int unordered_multimap_remove_all(unordered_multimap me, void *key); +bk_bool unordered_multimap_get_next(void *value, unordered_multimap me); +size_t unordered_multimap_count(unordered_multimap me, void *key); +bk_bool unordered_multimap_contains(unordered_multimap me, void *key); +bk_bool unordered_multimap_remove(unordered_multimap me, + void *key, void *value); +bk_bool unordered_multimap_remove_all(unordered_multimap me, void *key); /* Ending */ -int unordered_multimap_clear(unordered_multimap me); +bk_err unordered_multimap_clear(unordered_multimap me); unordered_multimap unordered_multimap_destroy(unordered_multimap me); #endif /* BKTHOMPS_CONTAINERS_UNORDERED_MULTIMAP_H */ @@ -513,8 +511,6 @@ unordered_multimap unordered_multimap_destroy(unordered_multimap me); #ifndef BKTHOMPS_CONTAINERS_UNORDERED_MULTISET_H #define BKTHOMPS_CONTAINERS_UNORDERED_MULTISET_H -#include - /** * The unordered_multiset data structure, which is a collection of keys, hashed * by keys. @@ -529,19 +525,19 @@ unordered_multiset_init(size_t key_size, const void *const two)); /* Utility */ -int unordered_multiset_rehash(unordered_multiset me); +bk_err unordered_multiset_rehash(unordered_multiset me); size_t unordered_multiset_size(unordered_multiset me); -int unordered_multiset_is_empty(unordered_multiset me); +bk_bool unordered_multiset_is_empty(unordered_multiset me); /* Accessing */ -int unordered_multiset_put(unordered_multiset me, void *key); +bk_err unordered_multiset_put(unordered_multiset me, void *key); size_t unordered_multiset_count(unordered_multiset me, void *key); -int unordered_multiset_contains(unordered_multiset me, void *key); -int unordered_multiset_remove(unordered_multiset me, void *key); -int unordered_multiset_remove_all(unordered_multiset me, void *key); +bk_bool unordered_multiset_contains(unordered_multiset me, void *key); +bk_bool unordered_multiset_remove(unordered_multiset me, void *key); +bk_bool unordered_multiset_remove_all(unordered_multiset me, void *key); /* Ending */ -int unordered_multiset_clear(unordered_multiset me); +bk_err unordered_multiset_clear(unordered_multiset me); unordered_multiset unordered_multiset_destroy(unordered_multiset me); #endif /* BKTHOMPS_CONTAINERS_UNORDERED_MULTISET_H */ @@ -550,8 +546,6 @@ unordered_multiset unordered_multiset_destroy(unordered_multiset me); #ifndef BKTHOMPS_CONTAINERS_UNORDERED_SET_H #define BKTHOMPS_CONTAINERS_UNORDERED_SET_H -#include - /** * The unordered_set data structure, which is a collection of unique keys, * hashed by keys. @@ -565,17 +559,17 @@ unordered_set unordered_set_init(size_t key_size, const void *const two)); /* Utility */ -int unordered_set_rehash(unordered_set me); +bk_err unordered_set_rehash(unordered_set me); size_t unordered_set_size(unordered_set me); -int unordered_set_is_empty(unordered_set me); +bk_bool unordered_set_is_empty(unordered_set me); /* Accessing */ -int unordered_set_put(unordered_set me, void *key); -int unordered_set_contains(unordered_set me, void *key); -int unordered_set_remove(unordered_set me, void *key); +bk_err unordered_set_put(unordered_set me, void *key); +bk_bool unordered_set_contains(unordered_set me, void *key); +bk_bool unordered_set_remove(unordered_set me, void *key); /* Ending */ -int unordered_set_clear(unordered_set me); +bk_err unordered_set_clear(unordered_set me); unordered_set unordered_set_destroy(unordered_set me); #endif /* BKTHOMPS_CONTAINERS_UNORDERED_SET_H */ @@ -584,8 +578,6 @@ unordered_set unordered_set_destroy(unordered_set me); #ifndef BKTHOMPS_CONTAINERS_VECTOR_H #define BKTHOMPS_CONTAINERS_VECTOR_H -#include - /** * The vector data structure, which is a dynamic contiguous array. */ @@ -597,34 +589,34 @@ vector vector_init(size_t data_size); /* Utility */ size_t vector_size(vector me); size_t vector_capacity(vector me); -int vector_is_empty(vector me); -int vector_reserve(vector me, size_t size); -int vector_trim(vector me); +bk_bool vector_is_empty(vector me); +bk_err vector_reserve(vector me, size_t size); +bk_err vector_trim(vector me); void vector_copy_to_array(void *arr, vector me); void *vector_get_data(vector me); /* Adding */ -int vector_add_first(vector me, void *data); -int vector_add_at(vector me, size_t index, void *data); -int vector_add_last(vector me, void *data); +bk_err vector_add_first(vector me, void *data); +bk_err vector_add_at(vector me, size_t index, void *data); +bk_err vector_add_last(vector me, void *data); /* Removing */ -int vector_remove_first(vector me); -int vector_remove_at(vector me, size_t index); -int vector_remove_last(vector me); +bk_err vector_remove_first(vector me); +bk_err vector_remove_at(vector me, size_t index); +bk_err vector_remove_last(vector me); /* Setting */ -int vector_set_first(vector me, void *data); -int vector_set_at(vector me, size_t index, void *data); -int vector_set_last(vector me, void *data); +bk_err vector_set_first(vector me, void *data); +bk_err vector_set_at(vector me, size_t index, void *data); +bk_err vector_set_last(vector me, void *data); /* Getting */ -int vector_get_first(void *data, vector me); -int vector_get_at(void *data, vector me, size_t index); -int vector_get_last(void *data, vector me); +bk_err vector_get_first(void *data, vector me); +bk_err vector_get_at(void *data, vector me, size_t index); +bk_err vector_get_last(void *data, vector me); /* Ending */ -int vector_clear(vector me); +bk_err vector_clear(vector me); vector vector_destroy(vector me); #endif /* BKTHOMPS_CONTAINERS_VECTOR_H */ diff --git a/documentation.md b/documentation.md index f73e16d..0e1e0bf 100644 --- a/documentation.md +++ b/documentation.md @@ -61,10 +61,10 @@ int): deque d = deque_init(sizeof(int)); ... int add = 5; -int rc = deque_push_back(d, &add); /* 5 has been added to the back of the deque */ +bk_err rc = deque_push_back(d, &add); /* 5 has been added to the back of the deque */ ... int retrieve; -int rc = deque_pop_back(&retrieve, d); /* retrieve now is equal to 5 */ +bk_err rc = deque_pop_back(&retrieve, d); /* retrieve now is equal to 5 */ ... ``` @@ -72,7 +72,8 @@ Functions can fail for various reasons, such as the provided index argument being out of bounds, or the system running out of memory. The in-depth documentation linked above provides the exhaustive list of return codes for each function, which are present in the `errno.h` header file. For example, an -invalid argument would return `-EINVAL`, and on success 0 would be returned. +invalid argument would return `-BK_EINVAL`, and on success `BK_OK` would be +returned. # Comparators and Hash Functions The associative containers and the priority queue require the user to initialize diff --git a/src/array.c b/src/array.c index 6d0ee75..1110153 100644 --- a/src/array.c +++ b/src/array.c @@ -21,7 +21,6 @@ */ #include -#include #include "include/array.h" static const size_t book_keeping_size = sizeof(size_t); @@ -105,7 +104,7 @@ void array_copy_to_array(void *const arr, array me) * raw array. This pointer is not a copy, thus any modification to the data will * cause the array structure data to be modified. Operations using the array * functions may invalidate this pointer. The array owns this memory, thus it - * should not be freed. + * should not be freed. If the array size if 0, this should not be used. * * @param me the array to get the storage element from * @@ -132,20 +131,20 @@ void *array_get_data(array me) * @param index the location to set data at in the array * @param data the data to set at the location in the array * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int array_set(array me, const size_t index, void *const data) +bk_err array_set(array me, const size_t index, void *const data) { size_t element_count; size_t data_size; memcpy(&element_count, me + arr_size_offset, book_keeping_size); if (index >= element_count) { - return -EINVAL; + return -BK_EINVAL; } memcpy(&data_size, me + data_size_offset, book_keeping_size); memcpy(me + data_ptr_offset + index * data_size, data, data_size); - return 0; + return BK_OK; } /** @@ -160,20 +159,20 @@ int array_set(array me, const size_t index, void *const data) * @param me the array to copy from * @param index the index to copy from in the array * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int array_get(void *const data, array me, const size_t index) +bk_err array_get(void *const data, array me, const size_t index) { size_t element_count; size_t data_size; memcpy(&element_count, me + arr_size_offset, book_keeping_size); if (index >= element_count) { - return -EINVAL; + return -BK_EINVAL; } memcpy(&data_size, me + data_size_offset, book_keeping_size); memcpy(data, me + data_ptr_offset + index * data_size, data_size); - return 0; + return BK_OK; } /** diff --git a/src/deque.c b/src/deque.c index add77bb..d689dec 100644 --- a/src/deque.c +++ b/src/deque.c @@ -21,7 +21,6 @@ */ #include -#include #include "include/deque.h" #define BKTHOMPS_DEQUE_MAX_BLOCK_BYTE_SIZE 4096 @@ -102,9 +101,9 @@ size_t deque_size(deque me) * * @param me the deque to check if empty * - * @return 1 if the deque is empty, otherwise 0 + * @return BK_TRUE if the deque is empty, otherwise BK_FALSE */ -int deque_is_empty(deque me) +bk_bool deque_is_empty(deque me) { return deque_size(me) == 0; } @@ -115,10 +114,10 @@ int deque_is_empty(deque me) * * @param me the deque to trim * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int deque_trim(deque me) +bk_err deque_trim(deque me) { size_t i; const size_t start_block_index = me->start_index / me->block_size; @@ -127,7 +126,7 @@ int deque_trim(deque me) const size_t updated_block_count = end_block_index - start_block_index + 1; char **updated_data = malloc(updated_block_count * sizeof(char *)); if (!updated_data) { - return -ENOMEM; + return -BK_ENOMEM; } memcpy(updated_data, me->data + start_block_index, updated_block_count * sizeof(char *)); @@ -146,7 +145,7 @@ int deque_trim(deque me) me->end_index -= start_block_index * me->block_size; me->block_count = updated_block_count; me->data = updated_data; - return 0; + return BK_OK; } /** @@ -201,10 +200,10 @@ void deque_copy_to_array(void *const arr, deque me) * @param me the deque to add an element to * @param data the element to add * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int deque_push_front(deque me, void *const data) +bk_err deque_push_front(deque me, void *const data) { if (me->start_index == 0) { const size_t updated_block_count = @@ -212,7 +211,7 @@ int deque_push_front(deque me, void *const data) const size_t added_blocks = updated_block_count - me->block_count; char **temp = realloc(me->data, updated_block_count * sizeof(char *)); if (!temp) { - return -ENOMEM; + return -BK_ENOMEM; } memmove(temp + added_blocks, temp, me->block_count * sizeof(char *)); memset(temp, 0, added_blocks * sizeof(char *)); @@ -229,7 +228,7 @@ int deque_push_front(deque me, void *const data) if (!block) { block = malloc(me->block_size * me->data_size); if (!block) { - return -ENOMEM; + return -BK_ENOMEM; } memcpy(me->data + previous_block_index, &block, sizeof(char *)); } @@ -242,7 +241,7 @@ int deque_push_front(deque me, void *const data) memcpy(&block, me->data + block_index, sizeof(char *)); memcpy(block + inner_index * me->data_size, data, me->data_size); } - return 0; + return BK_OK; } /** @@ -255,10 +254,10 @@ int deque_push_front(deque me, void *const data) * @param me the deque to add an element to * @param data the element to add * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int deque_push_back(deque me, void *const data) +bk_err deque_push_back(deque me, void *const data) { if (me->end_index == me->block_count * me->block_size) { const size_t updated_block_count = @@ -266,7 +265,7 @@ int deque_push_back(deque me, void *const data) const size_t added_blocks = updated_block_count - me->block_count; char **temp = realloc(me->data, updated_block_count * sizeof(char *)); if (!temp) { - return -ENOMEM; + return -BK_ENOMEM; } memset(temp + me->block_count, 0, added_blocks * sizeof(char *)); me->data = temp; @@ -279,7 +278,7 @@ int deque_push_back(deque me, void *const data) if (!block) { block = malloc(me->block_size * me->data_size); if (!block) { - return -ENOMEM; + return -BK_ENOMEM; } memcpy(me->data + tentative_block_index, &block, sizeof(char *)); } @@ -292,7 +291,7 @@ int deque_push_back(deque me, void *const data) memcpy(block + inner_index * me->data_size, data, me->data_size); } me->end_index++; - return 0; + return BK_OK; } /** @@ -306,21 +305,21 @@ int deque_push_back(deque me, void *const data) * @param data the value to copy to * @param me the deque to remove from * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int deque_pop_front(void *const data, deque me) +bk_err deque_pop_front(void *const data, deque me) { char *block; const size_t block_index = me->start_index / me->block_size; const size_t inner_index = me->start_index % me->block_size; if (deque_is_empty(me)) { - return -EINVAL; + return -BK_EINVAL; } memcpy(&block, me->data + block_index, sizeof(char *)); memcpy(data, block + inner_index * me->data_size, me->data_size); me->start_index++; - return 0; + return BK_OK; } /** @@ -334,21 +333,21 @@ int deque_pop_front(void *const data, deque me) * @param data the value to copy to * @param me the deque to remove from * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int deque_pop_back(void *const data, deque me) +bk_err deque_pop_back(void *const data, deque me) { char *block; const size_t block_index = (me->end_index - 1) / me->block_size; const size_t inner_index = (me->end_index - 1) % me->block_size; if (deque_is_empty(me)) { - return -EINVAL; + return -BK_EINVAL; } memcpy(&block, me->data + block_index, sizeof(char *)); memcpy(data, block + inner_index * me->data_size, me->data_size); me->end_index--; - return 0; + return BK_OK; } /** @@ -361,10 +360,10 @@ int deque_pop_back(void *const data, deque me) * @param me the deque to set the value of * @param data the data to set * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int deque_set_first(deque me, void *const data) +bk_err deque_set_first(deque me, void *const data) { return deque_set_at(me, 0, data); } @@ -380,20 +379,20 @@ int deque_set_first(deque me, void *const data) * @param index the index to set at * @param data the data to set * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int deque_set_at(deque me, size_t index, void *const data) +bk_err deque_set_at(deque me, size_t index, void *const data) { char *block; const size_t block_index = (index + me->start_index) / me->block_size; const size_t inner_index = (index + me->start_index) % me->block_size; if (index >= deque_size(me)) { - return -EINVAL; + return -BK_EINVAL; } memcpy(&block, me->data + block_index, sizeof(char *)); memcpy(block + inner_index * me->data_size, data, me->data_size); - return 0; + return BK_OK; } /** @@ -406,10 +405,10 @@ int deque_set_at(deque me, size_t index, void *const data) * @param me the deque to set the value of * @param data the data to set * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int deque_set_last(deque me, void *const data) +bk_err deque_set_last(deque me, void *const data) { return deque_set_at(me, deque_size(me) - 1, data); } @@ -424,10 +423,10 @@ int deque_set_last(deque me, void *const data) * @param data the data to set * @param me the deque to set the value of * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int deque_get_first(void *const data, deque me) +bk_err deque_get_first(void *const data, deque me) { return deque_get_at(data, me, 0); } @@ -443,20 +442,20 @@ int deque_get_first(void *const data, deque me) * @param me the deque to set the value of * @param index the index to set at * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int deque_get_at(void *const data, deque me, size_t index) +bk_err deque_get_at(void *const data, deque me, size_t index) { char *block; const size_t block_index = (index + me->start_index) / me->block_size; const size_t inner_index = (index + me->start_index) % me->block_size; if (index >= deque_size(me)) { - return -EINVAL; + return -BK_EINVAL; } memcpy(&block, me->data + block_index, sizeof(char *)); memcpy(data, block + inner_index * me->data_size, me->data_size); - return 0; + return BK_OK; } /** @@ -469,10 +468,10 @@ int deque_get_at(void *const data, deque me, size_t index) * @param data the data to set * @param me the deque to set the value of * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int deque_get_last(void *const data, deque me) +bk_err deque_get_last(void *const data, deque me) { return deque_get_at(data, me, deque_size(me) - 1); } @@ -482,22 +481,22 @@ int deque_get_last(void *const data, deque me) * * @param me the deque to clear * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int deque_clear(deque me) +bk_err deque_clear(deque me) { size_t i; char *updated_block; char **updated_data = calloc(BKTHOMPS_DEQUE_INITIAL_BLOCK_COUNT, sizeof(char *)); if (!updated_data) { - return -ENOMEM; + return -BK_ENOMEM; } updated_block = malloc(me->block_size * me->data_size); if (!updated_block) { free(updated_data); - return -ENOMEM; + return -BK_ENOMEM; } for (i = 0; i < me->block_count; i++) { char *block; @@ -511,7 +510,7 @@ int deque_clear(deque me) me->data = updated_data; memcpy(me->data + me->start_index / me->block_size, &updated_block, sizeof(char *)); - return 0; + return BK_OK; } /** diff --git a/src/forward_list.c b/src/forward_list.c index 692408a..4070ec4 100644 --- a/src/forward_list.c +++ b/src/forward_list.c @@ -21,7 +21,6 @@ */ #include -#include #include "include/forward_list.h" struct internal_forward_list { @@ -78,9 +77,9 @@ size_t forward_list_size(forward_list me) * * @param me the singly-linked list to check * - * @return 1 if the singly-linked list is empty, otherwise 0 + * @return BK_TRUE if the singly-linked list is empty, otherwise BK_FALSE */ -int forward_list_is_empty(forward_list me) +bk_bool forward_list_is_empty(forward_list me) { return forward_list_size(me) == 0; } @@ -139,10 +138,10 @@ static char *forward_list_get_node_at(forward_list me, const size_t index) * @param me the singly-linked list to add data to * @param data the data to add to the singly-linked list * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int forward_list_add_first(forward_list me, void *const data) +bk_err forward_list_add_first(forward_list me, void *const data) { return forward_list_add_at(me, 0, data); } @@ -158,19 +157,20 @@ int forward_list_add_first(forward_list me, void *const data) * @param index the index to add the data at * @param data the data to add to the singly-linked list * - * @return 0 if no error - * @return -ENOMEM if out of memory - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory + * @return -BK_EINVAL if invalid argument */ -int forward_list_add_at(forward_list me, const size_t index, void *const data) +bk_err forward_list_add_at(forward_list me, const size_t index, + void *const data) { char *node; if (index > me->item_count) { - return -EINVAL; + return -BK_EINVAL; } node = malloc(ptr_size + me->bytes_per_item); if (!node) { - return -ENOMEM; + return -BK_ENOMEM; } memcpy(node + node_data_ptr_offset, data, me->bytes_per_item); if (index == 0) { @@ -188,7 +188,7 @@ int forward_list_add_at(forward_list me, const size_t index, void *const data) } } me->item_count++; - return 0; + return BK_OK; } /** @@ -201,10 +201,10 @@ int forward_list_add_at(forward_list me, const size_t index, void *const data) * @param me the singly-linked list to add data to * @param data the data to add to the singly-linked list * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int forward_list_add_last(forward_list me, void *const data) +bk_err forward_list_add_last(forward_list me, void *const data) { return forward_list_add_at(me, me->item_count, data); } @@ -214,10 +214,10 @@ int forward_list_add_last(forward_list me, void *const data) * * @param me the singly-linked list to remove data from * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int forward_list_remove_first(forward_list me) +bk_err forward_list_remove_first(forward_list me) { return forward_list_remove_at(me, 0); } @@ -228,13 +228,13 @@ int forward_list_remove_first(forward_list me) * @param me the singly-linked list to remove data from * @param index the index to remove from * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int forward_list_remove_at(forward_list me, const size_t index) +bk_err forward_list_remove_at(forward_list me, const size_t index) { if (index >= me->item_count) { - return -EINVAL; + return -BK_EINVAL; } if (index == 0) { char *temp = me->head; @@ -257,7 +257,7 @@ int forward_list_remove_at(forward_list me, const size_t index) free(backup); } me->item_count--; - return 0; + return BK_OK; } /** @@ -265,10 +265,10 @@ int forward_list_remove_at(forward_list me, const size_t index) * * @param me the singly-linked list to remove data from * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int forward_list_remove_last(forward_list me) +bk_err forward_list_remove_last(forward_list me) { return forward_list_remove_at(me, me->item_count - 1); } @@ -283,10 +283,10 @@ int forward_list_remove_last(forward_list me) * @param me the singly-linked list to set data for * @param data the data to set in the singly-linked list * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int forward_list_set_first(forward_list me, void *const data) +bk_err forward_list_set_first(forward_list me, void *const data) { return forward_list_set_at(me, 0, data); } @@ -302,18 +302,19 @@ int forward_list_set_first(forward_list me, void *const data) * @param index the index to set data in the singly-linked list * @param data the data to set in the singly-linked list * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int forward_list_set_at(forward_list me, const size_t index, void *const data) +bk_err forward_list_set_at(forward_list me, const size_t index, + void *const data) { char *traverse; if (index >= me->item_count) { - return -EINVAL; + return -BK_EINVAL; } traverse = forward_list_get_node_at(me, index); memcpy(traverse + node_data_ptr_offset, data, me->bytes_per_item); - return 0; + return BK_OK; } /** @@ -326,10 +327,10 @@ int forward_list_set_at(forward_list me, const size_t index, void *const data) * @param me the singly-linked list to set data for * @param data the data to set in the singly-linked list * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int forward_list_set_last(forward_list me, void *const data) +bk_err forward_list_set_last(forward_list me, void *const data) { return forward_list_set_at(me, me->item_count - 1, data); } @@ -345,10 +346,10 @@ int forward_list_set_last(forward_list me, void *const data) * @param data the data to get * @param me the singly-linked list to get data from * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int forward_list_get_first(void *const data, forward_list me) +bk_err forward_list_get_first(void *const data, forward_list me) { return forward_list_get_at(data, me, 0); } @@ -365,18 +366,19 @@ int forward_list_get_first(void *const data, forward_list me) * @param me the singly-linked list to get data from * @param index the index to get data from * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int forward_list_get_at(void *const data, forward_list me, const size_t index) +bk_err forward_list_get_at(void *const data, forward_list me, + const size_t index) { char *traverse; if (index >= me->item_count) { - return -EINVAL; + return -BK_EINVAL; } traverse = forward_list_get_node_at(me, index); memcpy(data, traverse + node_data_ptr_offset, me->bytes_per_item); - return 0; + return BK_OK; } /** @@ -390,10 +392,10 @@ int forward_list_get_at(void *const data, forward_list me, const size_t index) * @param data the data to get * @param me the singly-linked list to get data from * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int forward_list_get_last(void *const data, forward_list me) +bk_err forward_list_get_last(void *const data, forward_list me) { return forward_list_get_at(data, me, me->item_count - 1); } diff --git a/src/include/all.h b/src/include/all.h new file mode 100644 index 0000000..1b734b6 --- /dev/null +++ b/src/include/all.h @@ -0,0 +1,43 @@ +/* + * Copyright (c) 2017-2020 Bailey Thompson + * + * Permission is hereby granted, free of charge, to any person obtaining a copy + * of this software and associated documentation files (the "Software"), to deal + * in the Software without restriction, including without limitation the rights + * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell + * copies of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be included in + * all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR + * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, + * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE + * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER + * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE + * SOFTWARE. + */ + +#ifndef BKTHOMPS_CONTAINERS_ALL_H +#define BKTHOMPS_CONTAINERS_ALL_H + +#include + +/* + * Cannot use because the C89 standard does not guarantee all + * of these. These are the same values as the regular linux error codes. + */ +#define BK_OK 0 +#define BK_ENOMEM 12 +#define BK_EINVAL 22 + +/* Cannot use because it is C99 not C89. */ +#define BK_FALSE 0 +#define BK_TRUE (!BK_FALSE) + +typedef int bk_err; +typedef int bk_bool; + +#endif /* BKTHOMPS_CONTAINERS_ALL_H */ diff --git a/src/include/array.h b/src/include/array.h index 7d853d0..ce0f072 100644 --- a/src/include/array.h +++ b/src/include/array.h @@ -23,7 +23,7 @@ #ifndef BKTHOMPS_CONTAINERS_ARRAY_H #define BKTHOMPS_CONTAINERS_ARRAY_H -#include +#include "all.h" /** * The array data structure, which is a static contiguous array. @@ -39,8 +39,8 @@ void array_copy_to_array(void *arr, array me); void *array_get_data(array me); /* Accessing */ -int array_set(array me, size_t index, void *data); -int array_get(void *data, array me, size_t index); +bk_err array_set(array me, size_t index, void *data); +bk_err array_get(void *data, array me, size_t index); /* Ending */ array array_destroy(array me); diff --git a/src/include/deque.h b/src/include/deque.h index 91ddd1f..e7e3e41 100644 --- a/src/include/deque.h +++ b/src/include/deque.h @@ -23,7 +23,7 @@ #ifndef BKTHOMPS_CONTAINERS_DEQUE_H #define BKTHOMPS_CONTAINERS_DEQUE_H -#include +#include "all.h" /** * The deque data structure, which is a doubly-ended queue. @@ -35,30 +35,30 @@ deque deque_init(size_t data_size); /* Utility */ size_t deque_size(deque me); -int deque_is_empty(deque me); -int deque_trim(deque me); +bk_bool deque_is_empty(deque me); +bk_err deque_trim(deque me); void deque_copy_to_array(void *arr, deque me); /* Adding */ -int deque_push_front(deque me, void *data); -int deque_push_back(deque me, void *data); +bk_err deque_push_front(deque me, void *data); +bk_err deque_push_back(deque me, void *data); /* Removing */ -int deque_pop_front(void *data, deque me); -int deque_pop_back(void *data, deque me); +bk_err deque_pop_front(void *data, deque me); +bk_err deque_pop_back(void *data, deque me); /* Setting */ -int deque_set_first(deque me, void *data); -int deque_set_at(deque me, size_t index, void *data); -int deque_set_last(deque me, void *data); +bk_err deque_set_first(deque me, void *data); +bk_err deque_set_at(deque me, size_t index, void *data); +bk_err deque_set_last(deque me, void *data); /* Getting */ -int deque_get_first(void *data, deque me); -int deque_get_at(void *data, deque me, size_t index); -int deque_get_last(void *data, deque me); +bk_err deque_get_first(void *data, deque me); +bk_err deque_get_at(void *data, deque me, size_t index); +bk_err deque_get_last(void *data, deque me); /* Ending */ -int deque_clear(deque me); +bk_err deque_clear(deque me); deque deque_destroy(deque me); #endif /* BKTHOMPS_CONTAINERS_DEQUE_H */ diff --git a/src/include/forward_list.h b/src/include/forward_list.h index c30f62d..1ad86d8 100644 --- a/src/include/forward_list.h +++ b/src/include/forward_list.h @@ -23,7 +23,7 @@ #ifndef BKTHOMPS_CONTAINERS_FORWARD_LIST_H #define BKTHOMPS_CONTAINERS_FORWARD_LIST_H -#include +#include "all.h" /** * The forward_list data structure, which is a singly-linked list. @@ -35,28 +35,28 @@ forward_list forward_list_init(size_t data_size); /* Utility */ size_t forward_list_size(forward_list me); -int forward_list_is_empty(forward_list me); +bk_bool forward_list_is_empty(forward_list me); void forward_list_copy_to_array(void *arr, forward_list me); /* Adding */ -int forward_list_add_first(forward_list me, void *data); -int forward_list_add_at(forward_list me, size_t index, void *data); -int forward_list_add_last(forward_list me, void *data); +bk_err forward_list_add_first(forward_list me, void *data); +bk_err forward_list_add_at(forward_list me, size_t index, void *data); +bk_err forward_list_add_last(forward_list me, void *data); /* Removing */ -int forward_list_remove_first(forward_list me); -int forward_list_remove_at(forward_list me, size_t index); -int forward_list_remove_last(forward_list me); +bk_err forward_list_remove_first(forward_list me); +bk_err forward_list_remove_at(forward_list me, size_t index); +bk_err forward_list_remove_last(forward_list me); /* Setting */ -int forward_list_set_first(forward_list me, void *data); -int forward_list_set_at(forward_list me, size_t index, void *data); -int forward_list_set_last(forward_list me, void *data); +bk_err forward_list_set_first(forward_list me, void *data); +bk_err forward_list_set_at(forward_list me, size_t index, void *data); +bk_err forward_list_set_last(forward_list me, void *data); /* Getting */ -int forward_list_get_first(void *data, forward_list me); -int forward_list_get_at(void *data, forward_list me, size_t index); -int forward_list_get_last(void *data, forward_list me); +bk_err forward_list_get_first(void *data, forward_list me); +bk_err forward_list_get_at(void *data, forward_list me, size_t index); +bk_err forward_list_get_last(void *data, forward_list me); /* Ending */ void forward_list_clear(forward_list me); diff --git a/src/include/list.h b/src/include/list.h index c6728e5..060240b 100644 --- a/src/include/list.h +++ b/src/include/list.h @@ -23,7 +23,7 @@ #ifndef BKTHOMPS_CONTAINERS_LIST_H #define BKTHOMPS_CONTAINERS_LIST_H -#include +#include "all.h" /** * The list data structure, which is a doubly-linked list. @@ -35,28 +35,28 @@ list list_init(size_t data_size); /* Utility */ size_t list_size(list me); -int list_is_empty(list me); +bk_bool list_is_empty(list me); void list_copy_to_array(void *arr, list me); /* Adding */ -int list_add_first(list me, void *data); -int list_add_at(list me, size_t index, void *data); -int list_add_last(list me, void *data); +bk_err list_add_first(list me, void *data); +bk_err list_add_at(list me, size_t index, void *data); +bk_err list_add_last(list me, void *data); /* Removing */ -int list_remove_first(list me); -int list_remove_at(list me, size_t index); -int list_remove_last(list me); +bk_err list_remove_first(list me); +bk_err list_remove_at(list me, size_t index); +bk_err list_remove_last(list me); /* Setting */ -int list_set_first(list me, void *data); -int list_set_at(list me, size_t index, void *data); -int list_set_last(list me, void *data); +bk_err list_set_first(list me, void *data); +bk_err list_set_at(list me, size_t index, void *data); +bk_err list_set_last(list me, void *data); /* Getting */ -int list_get_first(void *data, list me); -int list_get_at(void *data, list me, size_t index); -int list_get_last(void *data, list me); +bk_err list_get_first(void *data, list me); +bk_err list_get_at(void *data, list me, size_t index); +bk_err list_get_last(void *data, list me); /* Ending */ void list_clear(list me); diff --git a/src/include/map.h b/src/include/map.h index 471814d..0734efd 100644 --- a/src/include/map.h +++ b/src/include/map.h @@ -23,7 +23,7 @@ #ifndef BKTHOMPS_CONTAINERS_MAP_H #define BKTHOMPS_CONTAINERS_MAP_H -#include +#include "all.h" /** * The map data structure, which is a collection of key-value pairs, sorted by @@ -37,13 +37,13 @@ map map_init(size_t key_size, size_t value_size, /* Capacity */ size_t map_size(map me); -int map_is_empty(map me); +bk_bool map_is_empty(map me); /* Accessing */ -int map_put(map me, void *key, void *value); -int map_get(void *value, map me, void *key); -int map_contains(map me, void *key); -int map_remove(map me, void *key); +bk_err map_put(map me, void *key, void *value); +bk_bool map_get(void *value, map me, void *key); +bk_bool map_contains(map me, void *key); +bk_bool map_remove(map me, void *key); /* Ending */ void map_clear(map me); diff --git a/src/include/multimap.h b/src/include/multimap.h index d2078b4..f233f4f 100644 --- a/src/include/multimap.h +++ b/src/include/multimap.h @@ -23,7 +23,7 @@ #ifndef BKTHOMPS_CONTAINERS_MULTIMAP_H #define BKTHOMPS_CONTAINERS_MULTIMAP_H -#include +#include "all.h" /** * The multimap data structure, which is a collection of key-value pairs, sorted @@ -40,16 +40,16 @@ multimap multimap_init(size_t key_size, size_t value_size, /* Capacity */ size_t multimap_size(multimap me); -int multimap_is_empty(multimap me); +bk_bool multimap_is_empty(multimap me); /* Accessing */ -int multimap_put(multimap me, void *key, void *value); +bk_err multimap_put(multimap me, void *key, void *value); void multimap_get_start(multimap me, void *key); -int multimap_get_next(void *value, multimap me); +bk_bool multimap_get_next(void *value, multimap me); size_t multimap_count(multimap me, void *key); -int multimap_contains(multimap me, void *key); -int multimap_remove(multimap me, void *key, void *value); -int multimap_remove_all(multimap me, void *key); +bk_bool multimap_contains(multimap me, void *key); +bk_bool multimap_remove(multimap me, void *key, void *value); +bk_bool multimap_remove_all(multimap me, void *key); /* Ending */ void multimap_clear(multimap me); diff --git a/src/include/multiset.h b/src/include/multiset.h index eb35042..c6bf006 100644 --- a/src/include/multiset.h +++ b/src/include/multiset.h @@ -23,7 +23,7 @@ #ifndef BKTHOMPS_CONTAINERS_MULTISET_H #define BKTHOMPS_CONTAINERS_MULTISET_H -#include +#include "all.h" /** * The multiset data structure, which is a collection of key-value pairs, sorted @@ -38,14 +38,14 @@ multiset multiset_init(size_t key_size, /* Capacity */ size_t multiset_size(multiset me); -int multiset_is_empty(multiset me); +bk_bool multiset_is_empty(multiset me); /* Accessing */ -int multiset_put(multiset me, void *key); +bk_err multiset_put(multiset me, void *key); size_t multiset_count(multiset me, void *key); -int multiset_contains(multiset me, void *key); -int multiset_remove(multiset me, void *key); -int multiset_remove_all(multiset me, void *key); +bk_bool multiset_contains(multiset me, void *key); +bk_bool multiset_remove(multiset me, void *key); +bk_bool multiset_remove_all(multiset me, void *key); /* Ending */ void multiset_clear(multiset me); diff --git a/src/include/priority_queue.h b/src/include/priority_queue.h index ea67915..be08547 100644 --- a/src/include/priority_queue.h +++ b/src/include/priority_queue.h @@ -23,7 +23,7 @@ #ifndef BKTHOMPS_CONTAINERS_PRIORITY_QUEUE_H #define BKTHOMPS_CONTAINERS_PRIORITY_QUEUE_H -#include +#include "all.h" /** * The priority_queue data structure, which adapts a container to provide a @@ -38,19 +38,19 @@ priority_queue priority_queue_init(size_t data_size, /* Utility */ size_t priority_queue_size(priority_queue me); -int priority_queue_is_empty(priority_queue me); +bk_bool priority_queue_is_empty(priority_queue me); /* Adding */ -int priority_queue_push(priority_queue me, void *data); +bk_err priority_queue_push(priority_queue me, void *data); /* Removing */ -int priority_queue_pop(void *data, priority_queue me); +bk_bool priority_queue_pop(void *data, priority_queue me); /* Getting */ -int priority_queue_front(void *data, priority_queue me); +bk_bool priority_queue_front(void *data, priority_queue me); /* Ending */ -int priority_queue_clear(priority_queue me); +bk_err priority_queue_clear(priority_queue me); priority_queue priority_queue_destroy(priority_queue me); #endif /* BKTHOMPS_CONTAINERS_PRIORITY_QUEUE_H */ diff --git a/src/include/queue.h b/src/include/queue.h index a333c8a..43a8d58 100644 --- a/src/include/queue.h +++ b/src/include/queue.h @@ -23,7 +23,7 @@ #ifndef BKTHOMPS_CONTAINERS_QUEUE_H #define BKTHOMPS_CONTAINERS_QUEUE_H -#include +#include "all.h" /** * The queue data structure, which adapts a container to provide a queue @@ -36,22 +36,22 @@ queue queue_init(size_t data_size); /* Utility */ size_t queue_size(queue me); -int queue_is_empty(queue me); -int queue_trim(queue me); +bk_bool queue_is_empty(queue me); +bk_err queue_trim(queue me); void queue_copy_to_array(void *arr, queue me); /* Adding */ -int queue_push(queue me, void *data); +bk_err queue_push(queue me, void *data); /* Removing */ -int queue_pop(void *data, queue me); +bk_bool queue_pop(void *data, queue me); /* Getting */ -int queue_front(void *data, queue me); -int queue_back(void *data, queue me); +bk_bool queue_front(void *data, queue me); +bk_bool queue_back(void *data, queue me); /* Ending */ -int queue_clear(queue me); +bk_err queue_clear(queue me); queue queue_destroy(queue me); #endif /* BKTHOMPS_CONTAINERS_QUEUE_H */ diff --git a/src/include/set.h b/src/include/set.h index 9e46de8..73758df 100644 --- a/src/include/set.h +++ b/src/include/set.h @@ -23,7 +23,7 @@ #ifndef BKTHOMPS_CONTAINERS_SET_H #define BKTHOMPS_CONTAINERS_SET_H -#include +#include "all.h" /** * The set data structure, which is a collection of unique keys, sorted by keys. @@ -36,12 +36,12 @@ set set_init(size_t key_size, /* Capacity */ size_t set_size(set me); -int set_is_empty(set me); +bk_bool set_is_empty(set me); /* Accessing */ -int set_put(set me, void *key); -int set_contains(set me, void *key); -int set_remove(set me, void *key); +bk_err set_put(set me, void *key); +bk_bool set_contains(set me, void *key); +bk_bool set_remove(set me, void *key); /* Ending */ void set_clear(set me); diff --git a/src/include/stack.h b/src/include/stack.h index fed592d..74bd2da 100644 --- a/src/include/stack.h +++ b/src/include/stack.h @@ -23,7 +23,7 @@ #ifndef BKTHOMPS_CONTAINERS_STACK_H #define BKTHOMPS_CONTAINERS_STACK_H -#include +#include "all.h" /** * The stack data structure, which adapts a container to provide a stack @@ -36,21 +36,21 @@ stack stack_init(size_t data_size); /* Utility */ size_t stack_size(stack me); -int stack_is_empty(stack me); -int stack_trim(stack me); +bk_bool stack_is_empty(stack me); +bk_err stack_trim(stack me); void stack_copy_to_array(void *arr, stack me); /* Adding */ -int stack_push(stack me, void *data); +bk_err stack_push(stack me, void *data); /* Removing */ -int stack_pop(void *data, stack me); +bk_bool stack_pop(void *data, stack me); /* Getting */ -int stack_top(void *data, stack me); +bk_bool stack_top(void *data, stack me); /* Ending */ -int stack_clear(stack me); +bk_err stack_clear(stack me); stack stack_destroy(stack me); #endif /* BKTHOMPS_CONTAINERS_STACK_H */ diff --git a/src/include/unordered_map.h b/src/include/unordered_map.h index a7f0c10..69a8703 100644 --- a/src/include/unordered_map.h +++ b/src/include/unordered_map.h @@ -23,7 +23,7 @@ #ifndef BKTHOMPS_CONTAINERS_UNORDERED_MAP_H #define BKTHOMPS_CONTAINERS_UNORDERED_MAP_H -#include +#include "all.h" /** * The unordered_map data structure, which is a collection of key-value pairs, @@ -39,18 +39,18 @@ unordered_map unordered_map_init(size_t key_size, const void *const two)); /* Utility */ -int unordered_map_rehash(unordered_map me); +bk_err unordered_map_rehash(unordered_map me); size_t unordered_map_size(unordered_map me); -int unordered_map_is_empty(unordered_map me); +bk_bool unordered_map_is_empty(unordered_map me); /* Accessing */ -int unordered_map_put(unordered_map me, void *key, void *value); -int unordered_map_get(void *value, unordered_map me, void *key); -int unordered_map_contains(unordered_map me, void *key); -int unordered_map_remove(unordered_map me, void *key); +bk_err unordered_map_put(unordered_map me, void *key, void *value); +bk_bool unordered_map_get(void *value, unordered_map me, void *key); +bk_bool unordered_map_contains(unordered_map me, void *key); +bk_bool unordered_map_remove(unordered_map me, void *key); /* Ending */ -int unordered_map_clear(unordered_map me); +bk_err unordered_map_clear(unordered_map me); unordered_map unordered_map_destroy(unordered_map me); #endif /* BKTHOMPS_CONTAINERS_UNORDERED_MAP_H */ diff --git a/src/include/unordered_multimap.h b/src/include/unordered_multimap.h index cd022b1..8ea4d83 100644 --- a/src/include/unordered_multimap.h +++ b/src/include/unordered_multimap.h @@ -23,7 +23,7 @@ #ifndef BKTHOMPS_CONTAINERS_UNORDERED_MULTIMAP_H #define BKTHOMPS_CONTAINERS_UNORDERED_MULTIMAP_H -#include +#include "all.h" /** * The unordered_multimap data structure, which is a collection of key-value @@ -42,21 +42,22 @@ unordered_multimap_init(size_t key_size, const void *const two)); /* Utility */ -int unordered_multimap_rehash(unordered_multimap me); +bk_err unordered_multimap_rehash(unordered_multimap me); size_t unordered_multimap_size(unordered_multimap me); -int unordered_multimap_is_empty(unordered_multimap me); +bk_bool unordered_multimap_is_empty(unordered_multimap me); /* Accessing */ -int unordered_multimap_put(unordered_multimap me, void *key, void *value); +bk_err unordered_multimap_put(unordered_multimap me, void *key, void *value); void unordered_multimap_get_start(unordered_multimap me, void *key); -int unordered_multimap_get_next(void *value, unordered_multimap me); -int unordered_multimap_count(unordered_multimap me, void *key); -int unordered_multimap_contains(unordered_multimap me, void *key); -int unordered_multimap_remove(unordered_multimap me, void *key, void *value); -int unordered_multimap_remove_all(unordered_multimap me, void *key); +bk_bool unordered_multimap_get_next(void *value, unordered_multimap me); +size_t unordered_multimap_count(unordered_multimap me, void *key); +bk_bool unordered_multimap_contains(unordered_multimap me, void *key); +bk_bool unordered_multimap_remove(unordered_multimap me, + void *key, void *value); +bk_bool unordered_multimap_remove_all(unordered_multimap me, void *key); /* Ending */ -int unordered_multimap_clear(unordered_multimap me); +bk_err unordered_multimap_clear(unordered_multimap me); unordered_multimap unordered_multimap_destroy(unordered_multimap me); #endif /* BKTHOMPS_CONTAINERS_UNORDERED_MULTIMAP_H */ diff --git a/src/include/unordered_multiset.h b/src/include/unordered_multiset.h index 357e92b..56f4001 100644 --- a/src/include/unordered_multiset.h +++ b/src/include/unordered_multiset.h @@ -23,7 +23,7 @@ #ifndef BKTHOMPS_CONTAINERS_UNORDERED_MULTISET_H #define BKTHOMPS_CONTAINERS_UNORDERED_MULTISET_H -#include +#include "all.h" /** * The unordered_multiset data structure, which is a collection of keys, hashed @@ -39,19 +39,19 @@ unordered_multiset_init(size_t key_size, const void *const two)); /* Utility */ -int unordered_multiset_rehash(unordered_multiset me); +bk_err unordered_multiset_rehash(unordered_multiset me); size_t unordered_multiset_size(unordered_multiset me); -int unordered_multiset_is_empty(unordered_multiset me); +bk_bool unordered_multiset_is_empty(unordered_multiset me); /* Accessing */ -int unordered_multiset_put(unordered_multiset me, void *key); +bk_err unordered_multiset_put(unordered_multiset me, void *key); size_t unordered_multiset_count(unordered_multiset me, void *key); -int unordered_multiset_contains(unordered_multiset me, void *key); -int unordered_multiset_remove(unordered_multiset me, void *key); -int unordered_multiset_remove_all(unordered_multiset me, void *key); +bk_bool unordered_multiset_contains(unordered_multiset me, void *key); +bk_bool unordered_multiset_remove(unordered_multiset me, void *key); +bk_bool unordered_multiset_remove_all(unordered_multiset me, void *key); /* Ending */ -int unordered_multiset_clear(unordered_multiset me); +bk_err unordered_multiset_clear(unordered_multiset me); unordered_multiset unordered_multiset_destroy(unordered_multiset me); #endif /* BKTHOMPS_CONTAINERS_UNORDERED_MULTISET_H */ diff --git a/src/include/unordered_set.h b/src/include/unordered_set.h index f59c48f..69625a7 100644 --- a/src/include/unordered_set.h +++ b/src/include/unordered_set.h @@ -23,7 +23,7 @@ #ifndef BKTHOMPS_CONTAINERS_UNORDERED_SET_H #define BKTHOMPS_CONTAINERS_UNORDERED_SET_H -#include +#include "all.h" /** * The unordered_set data structure, which is a collection of unique keys, @@ -38,17 +38,17 @@ unordered_set unordered_set_init(size_t key_size, const void *const two)); /* Utility */ -int unordered_set_rehash(unordered_set me); +bk_err unordered_set_rehash(unordered_set me); size_t unordered_set_size(unordered_set me); -int unordered_set_is_empty(unordered_set me); +bk_bool unordered_set_is_empty(unordered_set me); /* Accessing */ -int unordered_set_put(unordered_set me, void *key); -int unordered_set_contains(unordered_set me, void *key); -int unordered_set_remove(unordered_set me, void *key); +bk_err unordered_set_put(unordered_set me, void *key); +bk_bool unordered_set_contains(unordered_set me, void *key); +bk_bool unordered_set_remove(unordered_set me, void *key); /* Ending */ -int unordered_set_clear(unordered_set me); +bk_err unordered_set_clear(unordered_set me); unordered_set unordered_set_destroy(unordered_set me); #endif /* BKTHOMPS_CONTAINERS_UNORDERED_SET_H */ diff --git a/src/include/vector.h b/src/include/vector.h index 376d3ce..0624932 100644 --- a/src/include/vector.h +++ b/src/include/vector.h @@ -23,7 +23,7 @@ #ifndef BKTHOMPS_CONTAINERS_VECTOR_H #define BKTHOMPS_CONTAINERS_VECTOR_H -#include +#include "all.h" /** * The vector data structure, which is a dynamic contiguous array. @@ -36,34 +36,34 @@ vector vector_init(size_t data_size); /* Utility */ size_t vector_size(vector me); size_t vector_capacity(vector me); -int vector_is_empty(vector me); -int vector_reserve(vector me, size_t size); -int vector_trim(vector me); +bk_bool vector_is_empty(vector me); +bk_err vector_reserve(vector me, size_t size); +bk_err vector_trim(vector me); void vector_copy_to_array(void *arr, vector me); void *vector_get_data(vector me); /* Adding */ -int vector_add_first(vector me, void *data); -int vector_add_at(vector me, size_t index, void *data); -int vector_add_last(vector me, void *data); +bk_err vector_add_first(vector me, void *data); +bk_err vector_add_at(vector me, size_t index, void *data); +bk_err vector_add_last(vector me, void *data); /* Removing */ -int vector_remove_first(vector me); -int vector_remove_at(vector me, size_t index); -int vector_remove_last(vector me); +bk_err vector_remove_first(vector me); +bk_err vector_remove_at(vector me, size_t index); +bk_err vector_remove_last(vector me); /* Setting */ -int vector_set_first(vector me, void *data); -int vector_set_at(vector me, size_t index, void *data); -int vector_set_last(vector me, void *data); +bk_err vector_set_first(vector me, void *data); +bk_err vector_set_at(vector me, size_t index, void *data); +bk_err vector_set_last(vector me, void *data); /* Getting */ -int vector_get_first(void *data, vector me); -int vector_get_at(void *data, vector me, size_t index); -int vector_get_last(void *data, vector me); +bk_err vector_get_first(void *data, vector me); +bk_err vector_get_at(void *data, vector me, size_t index); +bk_err vector_get_last(void *data, vector me); /* Ending */ -int vector_clear(vector me); +bk_err vector_clear(vector me); vector vector_destroy(vector me); #endif /* BKTHOMPS_CONTAINERS_VECTOR_H */ diff --git a/src/list.c b/src/list.c index eeb535a..ab2b687 100644 --- a/src/list.c +++ b/src/list.c @@ -21,7 +21,6 @@ */ #include -#include #include "include/list.h" struct internal_list { @@ -79,9 +78,9 @@ size_t list_size(list me) * * @param me the doubly-linked list to check * - * @return 1 if the list is empty, otherwise 0 + * @return BK_TRUE if the list is empty, otherwise BK_FALSE */ -int list_is_empty(list me) +bk_bool list_is_empty(list me) { return list_size(me) == 0; } @@ -156,10 +155,10 @@ static char *list_get_node_at(list me, const size_t index) * @param me the doubly-linked list to add data to * @param data the data to add to the doubly-linked list * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int list_add_first(list me, void *const data) +bk_err list_add_first(list me, void *const data) { return list_add_at(me, 0, data); } @@ -175,19 +174,19 @@ int list_add_first(list me, void *const data) * @param index the index to add the data at * @param data the data to add to the doubly-linked list * - * @return 0 if no error - * @return -ENOMEM if out of memory - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory + * @return -BK_EINVAL if invalid argument */ -int list_add_at(list me, const size_t index, void *const data) +bk_err list_add_at(list me, const size_t index, void *const data) { char *node; if (index > me->item_count) { - return -EINVAL; + return -BK_EINVAL; } node = malloc(2 * ptr_size + me->bytes_per_item); if (!node) { - return -ENOMEM; + return -BK_ENOMEM; } memcpy(node + node_data_ptr_offset, data, me->bytes_per_item); if (!me->head) { @@ -217,7 +216,7 @@ int list_add_at(list me, const size_t index, void *const data) memcpy(traverse + node_prev_ptr_offset, &node, ptr_size); } me->item_count++; - return 0; + return BK_OK; } /** @@ -230,10 +229,10 @@ int list_add_at(list me, const size_t index, void *const data) * @param me the doubly-linked list to add data to * @param data the data to add to the doubly-linked list * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int list_add_last(list me, void *const data) +bk_err list_add_last(list me, void *const data) { return list_add_at(me, me->item_count, data); } @@ -243,10 +242,10 @@ int list_add_last(list me, void *const data) * * @param me the doubly-linked list to remove data from * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int list_remove_first(list me) +bk_err list_remove_first(list me) { return list_remove_at(me, 0); } @@ -257,14 +256,14 @@ int list_remove_first(list me) * @param me the doubly-linked list to remove data from * @param index the index to remove from * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int list_remove_at(list me, const size_t index) +bk_err list_remove_at(list me, const size_t index) { char *traverse; if (index >= me->item_count) { - return -EINVAL; + return -BK_EINVAL; } traverse = list_get_node_at(me, index); if (me->item_count == 1) { @@ -290,7 +289,7 @@ int list_remove_at(list me, const size_t index) } free(traverse); me->item_count--; - return 0; + return BK_OK; } /** @@ -298,10 +297,10 @@ int list_remove_at(list me, const size_t index) * * @param me the doubly-linked list to remove data from * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int list_remove_last(list me) +bk_err list_remove_last(list me) { return list_remove_at(me, me->item_count - 1); } @@ -316,10 +315,10 @@ int list_remove_last(list me) * @param me the doubly-linked list to set data for * @param data the data to set in the doubly-linked list * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int list_set_first(list me, void *const data) +bk_err list_set_first(list me, void *const data) { return list_set_at(me, 0, data); } @@ -335,18 +334,18 @@ int list_set_first(list me, void *const data) * @param index the index to set data in the doubly-linked list * @param data the data to set in the doubly-linked list * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int list_set_at(list me, const size_t index, void *const data) +bk_err list_set_at(list me, const size_t index, void *const data) { char *traverse; if (index >= me->item_count) { - return -EINVAL; + return -BK_EINVAL; } traverse = list_get_node_at(me, index); memcpy(traverse + node_data_ptr_offset, data, me->bytes_per_item); - return 0; + return BK_OK; } /** @@ -359,10 +358,10 @@ int list_set_at(list me, const size_t index, void *const data) * @param me the doubly-linked list to set data for * @param data the data to set in the doubly-linked list * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int list_set_last(list me, void *const data) +bk_err list_set_last(list me, void *const data) { return list_set_at(me, me->item_count - 1, data); } @@ -378,10 +377,10 @@ int list_set_last(list me, void *const data) * @param data the data to get * @param me the doubly-linked list to get data from * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int list_get_first(void *const data, list me) +bk_err list_get_first(void *const data, list me) { return list_get_at(data, me, 0); } @@ -398,18 +397,18 @@ int list_get_first(void *const data, list me) * @param me the doubly-linked list to get data from * @param index the index to get data from * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int list_get_at(void *const data, list me, const size_t index) +bk_err list_get_at(void *const data, list me, const size_t index) { char *traverse; if (index >= me->item_count) { - return -EINVAL; + return -BK_EINVAL; } traverse = list_get_node_at(me, index); memcpy(data, traverse + node_data_ptr_offset, me->bytes_per_item); - return 0; + return BK_OK; } /** @@ -423,10 +422,10 @@ int list_get_at(void *const data, list me, const size_t index) * @param data the data to get * @param me the doubly-linked list to get data from * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int list_get_last(void *const data, list me) +bk_err list_get_last(void *const data, list me) { return list_get_at(data, me, me->item_count - 1); } diff --git a/src/map.c b/src/map.c index 450d547..fbee0fc 100644 --- a/src/map.c +++ b/src/map.c @@ -21,7 +21,6 @@ */ #include -#include #include "include/map.h" struct internal_map { @@ -88,9 +87,9 @@ size_t map_size(map me) * * @param me the map to check * - * @return 1 if the map is empty, otherwise 0 + * @return BK_TRUE if the map is empty, otherwise BK_FALSE */ -int map_is_empty(map me) +bk_bool map_is_empty(map me) { return map_size(me) == 0; } @@ -309,19 +308,19 @@ static char *map_create_node(map me, const void *const key, * @param key the key to add * @param value the value to add * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int map_put(map me, void *const key, void *const value) +bk_err map_put(map me, void *const key, void *const value) { char *traverse; if (!me->root) { char *insert = map_create_node(me, key, value, NULL); if (!insert) { - return -ENOMEM; + return -BK_ENOMEM; } me->root = insert; - return 0; + return BK_OK; } traverse = me->root; for (;;) { @@ -334,11 +333,11 @@ int map_put(map me, void *const key, void *const value) } else { char *insert = map_create_node(me, key, value, traverse); if (!insert) { - return -ENOMEM; + return -BK_ENOMEM; } memcpy(traverse + node_left_child_offset, &insert, ptr_size); map_insert_balance(me, insert); - return 0; + return BK_OK; } } else if (compare > 0) { char *traverse_right; @@ -349,16 +348,16 @@ int map_put(map me, void *const key, void *const value) } else { char *insert = map_create_node(me, key, value, traverse); if (!insert) { - return -ENOMEM; + return -BK_ENOMEM; } memcpy(traverse + node_right_child_offset, &insert, ptr_size); map_insert_balance(me, insert); - return 0; + return BK_OK; } } else { memcpy(traverse + node_key_offset + me->key_size, value, me->value_size); - return 0; + return BK_OK; } } } @@ -409,16 +408,16 @@ static char *map_equal_match(map me, const void *const key) * @param me the map to get from * @param key the key to search for * - * @return 1 if the map contained the key-value pair, otherwise 0 + * @return BK_TRUE if the map contained the key-value pair, otherwise BK_FALSE */ -int map_get(void *const value, map me, void *const key) +bk_bool map_get(void *const value, map me, void *const key) { char *const traverse = map_equal_match(me, key); if (!traverse) { - return 0; + return BK_FALSE; } memcpy(value, traverse + node_key_offset + me->key_size, me->value_size); - return 1; + return BK_TRUE; } /** @@ -431,9 +430,9 @@ int map_get(void *const value, map me, void *const key) * @param me the map to check for the element * @param key the key to check * - * @return 1 if the map contained the element, otherwise 0 + * @return BK_TRUE if the map contained the element, otherwise BK_FALSE */ -int map_contains(map me, void *const key) +bk_bool map_contains(map me, void *const key) { return map_equal_match(me, key) != NULL; } @@ -704,16 +703,16 @@ static void map_remove_element(map me, char *const traverse) * @param me the map to remove an element from * @param key the key to remove * - * @return 1 if the map contained the key-value pair, otherwise 0 + * @return BK_TRUE if the map contained the key-value pair, otherwise BK_FALSE */ -int map_remove(map me, void *const key) +bk_bool map_remove(map me, void *const key) { char *const traverse = map_equal_match(me, key); if (!traverse) { - return 0; + return BK_FALSE; } map_remove_element(me, traverse); - return 1; + return BK_TRUE; } /** diff --git a/src/multimap.c b/src/multimap.c index 0334a95..ce41fdf 100644 --- a/src/multimap.c +++ b/src/multimap.c @@ -21,7 +21,6 @@ */ #include -#include #include "include/multimap.h" struct internal_multimap { @@ -105,9 +104,9 @@ size_t multimap_size(multimap me) * * @param me the multi-map to check * - * @return 1 if the multi-map is empty, otherwise 0 + * @return BK_TRUE if the multi-map is empty, otherwise BK_FALSE */ -int multimap_is_empty(multimap me) +bk_bool multimap_is_empty(multimap me) { return multimap_size(me) == 0; } @@ -356,19 +355,19 @@ static char *multimap_create_node(multimap me, const void *const key, * @param key the key to add * @param value the value to add * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int multimap_put(multimap me, void *const key, void *const value) +bk_err multimap_put(multimap me, void *const key, void *const value) { char *traverse; if (!me->root) { char *insert = multimap_create_node(me, key, value, NULL); if (!insert) { - return -ENOMEM; + return -BK_ENOMEM; } me->root = insert; - return 0; + return BK_OK; } traverse = me->root; for (;;) { @@ -381,11 +380,11 @@ int multimap_put(multimap me, void *const key, void *const value) } else { char *insert = multimap_create_node(me, key, value, traverse); if (!insert) { - return -ENOMEM; + return -BK_ENOMEM; } memcpy(traverse + node_left_child_offset, &insert, ptr_size); multimap_insert_balance(me, insert); - return 0; + return BK_OK; } } else if (compare > 0) { char *traverse_right; @@ -396,11 +395,11 @@ int multimap_put(multimap me, void *const key, void *const value) } else { char *insert = multimap_create_node(me, key, value, traverse); if (!insert) { - return -ENOMEM; + return -BK_ENOMEM; } memcpy(traverse + node_right_child_offset, &insert, ptr_size); multimap_insert_balance(me, insert); - return 0; + return BK_OK; } } else { char *value_traverse; @@ -423,7 +422,7 @@ int multimap_put(multimap me, void *const key, void *const value) count++; memcpy(traverse + node_value_count_offset, &count, count_size); me->size++; - return 0; + return BK_OK; } } } @@ -494,21 +493,21 @@ void multimap_get_start(multimap me, void *const key) * @param value the value to be copied to from iteration * @param me the multi-map to iterate over * - * @return 1 if there exist more values for the key which is being iterated - * over, otherwise 0 + * @return BK_TRUE if there exist more values for the key which is being + * iterated over, otherwise BK_FALSE */ -int multimap_get_next(void *const value, multimap me) +bk_bool multimap_get_next(void *const value, multimap me) { char *item; char *next; if (!me->iterate_get) { - return 0; + return BK_FALSE; } item = me->iterate_get; memcpy(value, item + value_node_value_offset, me->value_size); memcpy(&next, item + value_node_next_offset, ptr_size); me->iterate_get = next; - return 1; + return BK_TRUE; } /** @@ -544,9 +543,9 @@ size_t multimap_count(multimap me, void *const key) * @param me the multi-map to check for the key * @param key the key to check * - * @return 1 if the multi-map contained the key, otherwise 0 + * @return BK_TRUE if the multi-map contained the key, otherwise BK_FALSE */ -int multimap_contains(multimap me, void *const key) +bk_bool multimap_contains(multimap me, void *const key) { return multimap_equal_match(me, key) != NULL; } @@ -821,15 +820,15 @@ static void multimap_remove_element(multimap me, char *const traverse) * @param key the key to remove * @param value the value to remove * - * @return 1 if the multi-map contained the key, otherwise 0 + * @return BK_TRUE if the multi-map contained the key, otherwise BK_FALSE */ -int multimap_remove(multimap me, void *const key, void *const value) +bk_bool multimap_remove(multimap me, void *const key, void *const value) { char *current_value_node; char *const traverse = multimap_equal_match(me, key); size_t count; if (!traverse) { - return 0; + return BK_FALSE; } memcpy(¤t_value_node, traverse + node_value_head_offset, ptr_size); if (me->value_comparator(current_value_node + value_node_value_offset, @@ -847,7 +846,7 @@ int multimap_remove(multimap me, void *const key, void *const value) current_value_node + value_node_next_offset, ptr_size); } if (!current_value_node) { - return 0; + return BK_FALSE; } memcpy(previous_value_node + value_node_next_offset, current_value_node + value_node_next_offset, ptr_size); @@ -861,7 +860,7 @@ int multimap_remove(multimap me, void *const key, void *const value) memcpy(traverse + node_value_count_offset, &count, count_size); } me->size--; - return 1; + return BK_TRUE; } /* @@ -893,16 +892,16 @@ static void multimap_remove_all_elements(multimap me, char *const traverse) * @param me the multi-map to remove a key-value pair from * @param key the key to remove * - * @return 1 if the multi-map contained the key, otherwise 0 + * @return BK_TRUE if the multi-map contained the key, otherwise BK_FALSE */ -int multimap_remove_all(multimap me, void *const key) +bk_bool multimap_remove_all(multimap me, void *const key) { char *const traverse = multimap_equal_match(me, key); if (!traverse) { - return 0; + return BK_FALSE; } multimap_remove_all_elements(me, traverse); - return 1; + return BK_TRUE; } /** diff --git a/src/multiset.c b/src/multiset.c index c1d0d53..0244ba2 100644 --- a/src/multiset.c +++ b/src/multiset.c @@ -21,7 +21,6 @@ */ #include -#include #include "include/multiset.h" struct internal_multiset { @@ -90,9 +89,9 @@ size_t multiset_size(multiset me) * * @param me the multi-set to check * - * @return 1 if the multi-set is empty, otherwise 0 + * @return BK_TRUE if the multi-set is empty, otherwise BK_FALSE */ -int multiset_is_empty(multiset me) +bk_bool multiset_is_empty(multiset me) { return multiset_size(me) == 0; } @@ -317,19 +316,19 @@ static char *multiset_create_node(multiset me, const void *const data, * @param me the multi-set to add to * @param key the key to add * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int multiset_put(multiset me, void *const key) +bk_bool multiset_put(multiset me, void *const key) { char *traverse; if (!me->root) { char *insert = multiset_create_node(me, key, NULL); if (!insert) { - return -ENOMEM; + return -BK_ENOMEM; } me->root = insert; - return 0; + return BK_OK; } traverse = me->root; for (;;) { @@ -342,11 +341,11 @@ int multiset_put(multiset me, void *const key) } else { char *insert = multiset_create_node(me, key, traverse); if (!insert) { - return -ENOMEM; + return -BK_ENOMEM; } memcpy(traverse + node_left_child_offset, &insert, ptr_size); multiset_insert_balance(me, insert); - return 0; + return BK_OK; } } else if (compare > 0) { char *traverse_right; @@ -357,11 +356,11 @@ int multiset_put(multiset me, void *const key) } else { char *insert = multiset_create_node(me, key, traverse); if (!insert) { - return -ENOMEM; + return -BK_ENOMEM; } memcpy(traverse + node_right_child_offset, &insert, ptr_size); multiset_insert_balance(me, insert); - return 0; + return BK_OK; } } else { size_t count; @@ -369,7 +368,7 @@ int multiset_put(multiset me, void *const key) count++; memcpy(traverse + node_count_offset, &count, count_size); me->size++; - return 0; + return BK_OK; } } } @@ -441,9 +440,9 @@ size_t multiset_count(multiset me, void *const key) * @param me the multi-set to check for the key * @param key the key to check * - * @return 1 if the multiset contained the key, otherwise 0 + * @return BK_TRUE if the multiset contained the key, otherwise BK_FALSE */ -int multiset_contains(multiset me, void *const key) +bk_bool multiset_contains(multiset me, void *const key) { return multiset_equal_match(me, key) != NULL; } @@ -716,14 +715,14 @@ static void multiset_remove_element(multiset me, char *const traverse) * @param me the multi-set to remove a key from * @param key the key to remove * - * @return 1 if the multi-set contained the key, otherwise 0 + * @return BK_TRUE if the multi-set contained the key, otherwise BK_FALSE */ -int multiset_remove(multiset me, void *const key) +bk_bool multiset_remove(multiset me, void *const key) { char *const traverse = multiset_equal_match(me, key); size_t traverse_count; if (!traverse) { - return 0; + return BK_FALSE; } memcpy(&traverse_count, traverse + node_count_offset, count_size); if (traverse_count == 1) { @@ -733,7 +732,7 @@ int multiset_remove(multiset me, void *const key) memcpy(traverse + node_count_offset, &traverse_count, count_size); } me->size--; - return 1; + return BK_TRUE; } /** @@ -746,19 +745,19 @@ int multiset_remove(multiset me, void *const key) * @param me the multi-set to remove a key from * @param key the key to remove * - * @return 1 if the multi-set contained the key, otherwise 0 + * @return BK_TRUE if the multi-set contained the key, otherwise BK_FALSE */ -int multiset_remove_all(multiset me, void *const key) +bk_bool multiset_remove_all(multiset me, void *const key) { char *const traverse = multiset_equal_match(me, key); size_t traverse_count; if (!traverse) { - return 0; + return BK_FALSE; } memcpy(&traverse_count, traverse + node_count_offset, count_size); me->size -= traverse_count; multiset_remove_element(me, traverse); - return 1; + return BK_TRUE; } /** diff --git a/src/priority_queue.c b/src/priority_queue.c index fc5a219..0626e21 100644 --- a/src/priority_queue.c +++ b/src/priority_queue.c @@ -21,7 +21,6 @@ */ #include -#include #include "include/vector.h" #include "include/priority_queue.h" @@ -81,9 +80,9 @@ size_t priority_queue_size(priority_queue me) * * @param me the priority queue to check * - * @return 1 if the priority queue is empty, otherwise 0 + * @return BK_TRUE if the priority queue is empty, otherwise BK_FALSE */ -int priority_queue_is_empty(priority_queue me) +bk_bool priority_queue_is_empty(priority_queue me) { return vector_is_empty(me->data); } @@ -98,12 +97,12 @@ int priority_queue_is_empty(priority_queue me) * @param me the priority queue to add an element to * @param data the data to add to the queue * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int priority_queue_push(priority_queue me, void *const data) +bk_err priority_queue_push(priority_queue me, void *const data) { - int rc; + bk_err rc; char *vector_storage; size_t index; size_t parent_index; @@ -111,10 +110,10 @@ int priority_queue_push(priority_queue me, void *const data) char *data_parent_index; char *const temp = malloc(me->data_size); if (!temp) { - return -ENOMEM; + return -BK_ENOMEM; } rc = vector_add_last(me->data, data); - if (rc != 0) { + if (rc != BK_OK) { free(temp); return rc; } @@ -133,7 +132,7 @@ int priority_queue_push(priority_queue me, void *const data) data_parent_index = vector_storage + parent_index * me->data_size; } free(temp); - return 0; + return BK_OK; } /** @@ -147,9 +146,9 @@ int priority_queue_push(priority_queue me, void *const data) * @param data the data to have copied from the priority queue * @param me the priority queue to pop the next element from * - * @return 1 if the priority queue contained elements, otherwise 0 + * @return BK_TRUE if the priority queue contained elements, otherwise BK_FALSE */ -int priority_queue_pop(void *const data, priority_queue me) +bk_bool priority_queue_pop(void *const data, priority_queue me) { char *vector_storage; size_t size; @@ -160,9 +159,9 @@ int priority_queue_pop(void *const data, priority_queue me) char *data_index; char *data_left_index; char *data_right_index; - const int rc = vector_get_first(data, me->data); - if (rc != 0) { - return 0; + const bk_err rc = vector_get_first(data, me->data); + if (rc != BK_OK) { + return BK_FALSE; } vector_storage = vector_get_data(me->data); size = vector_size(me->data) - 1; @@ -199,7 +198,7 @@ int priority_queue_pop(void *const data, priority_queue me) data_right_index = vector_storage + right_index * me->data_size; } vector_remove_last(me->data); - return 1; + return BK_TRUE; } /** @@ -214,9 +213,9 @@ int priority_queue_pop(void *const data, priority_queue me) * queue * @param me the priority queue to copy from * - * @return 1 if the priority queue contained elements, otherwise 0 + * @return BK_TRUE if the priority queue contained elements, otherwise BK_FALSE */ -int priority_queue_front(void *const data, priority_queue me) +bk_bool priority_queue_front(void *const data, priority_queue me) { return vector_get_first(data, me->data) == 0; } @@ -226,10 +225,10 @@ int priority_queue_front(void *const data, priority_queue me) * * @param me the priority queue to clear * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int priority_queue_clear(priority_queue me) +bk_err priority_queue_clear(priority_queue me) { return vector_clear(me->data); } diff --git a/src/queue.c b/src/queue.c index c8c0da8..aab38cd 100644 --- a/src/queue.c +++ b/src/queue.c @@ -55,9 +55,9 @@ size_t queue_size(queue me) * * @param me the queue to check if empty * - * @return 1 if the queue is empty, otherwise 0 + * @return BK_TRUE if the queue is empty, otherwise BK_FALSE */ -int queue_is_empty(queue me) +bk_bool queue_is_empty(queue me) { return deque_is_empty(me); } @@ -67,10 +67,10 @@ int queue_is_empty(queue me) * * @param me the queue to trim * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int queue_trim(queue me) +bk_err queue_trim(queue me) { return deque_trim(me); } @@ -99,10 +99,10 @@ void queue_copy_to_array(void *const arr, queue me) * @param me the queue to add an element to * @param data the data to add to the queue * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int queue_push(queue me, void *const data) +bk_err queue_push(queue me, void *const data) { return deque_push_back(me, data); } @@ -117,9 +117,9 @@ int queue_push(queue me, void *const data) * @param data the data to have copied from the queue * @param me the queue to pop the next element from * - * @return 1 if the queue contained elements, otherwise 0 + * @return BK_TRUE if the queue contained elements, otherwise BK_FALSE */ -int queue_pop(void *const data, queue me) +bk_bool queue_pop(void *const data, queue me) { return deque_pop_front(data, me) == 0; } @@ -134,9 +134,9 @@ int queue_pop(void *const data, queue me) * @param data the copy of the front element of the queue * @param me the queue to copy from * - * @return 1 if the queue contained elements, otherwise 0 + * @return BK_TRUE if the queue contained elements, otherwise BK_FALSE */ -int queue_front(void *const data, queue me) +bk_bool queue_front(void *const data, queue me) { return deque_get_first(data, me) == 0; } @@ -151,9 +151,9 @@ int queue_front(void *const data, queue me) * @param data the copy of the back element of the queue * @param me the queue to copy from * - * @return 1 if the queue contained elements, otherwise 0 + * @return BK_TRUE if the queue contained elements, otherwise BK_FALSE */ -int queue_back(void *const data, queue me) +bk_bool queue_back(void *const data, queue me) { return deque_get_last(data, me) == 0; } @@ -163,10 +163,10 @@ int queue_back(void *const data, queue me) * * @param me the queue to clear * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int queue_clear(queue me) +bk_err queue_clear(queue me) { return deque_clear(me); } diff --git a/src/set.c b/src/set.c index 72044aa..b704c83 100644 --- a/src/set.c +++ b/src/set.c @@ -21,7 +21,6 @@ */ #include -#include #include "include/set.h" struct internal_set { @@ -84,9 +83,9 @@ size_t set_size(set me) * * @param me the set to check * - * @return 1 if the set is empty, otherwise 0 + * @return BK_TRUE if the set is empty, otherwise BK_FALSE */ -int set_is_empty(set me) +bk_bool set_is_empty(set me) { return set_size(me) == 0; } @@ -301,19 +300,19 @@ static char *set_create_node(set me, const void *const data, char *const parent) * @param me the set to add to * @param key the key to add * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int set_put(set me, void *const key) +bk_err set_put(set me, void *const key) { char *traverse; if (!me->root) { char *insert = set_create_node(me, key, NULL); if (!insert) { - return -ENOMEM; + return -BK_ENOMEM; } me->root = insert; - return 0; + return BK_OK; } traverse = me->root; for (;;) { @@ -326,11 +325,11 @@ int set_put(set me, void *const key) } else { char *insert = set_create_node(me, key, traverse); if (!insert) { - return -ENOMEM; + return -BK_ENOMEM; } memcpy(traverse + node_left_child_offset, &insert, ptr_size); set_insert_balance(me, insert); - return 0; + return BK_OK; } } else if (compare > 0) { char *traverse_right; @@ -341,14 +340,14 @@ int set_put(set me, void *const key) } else { char *insert = set_create_node(me, key, traverse); if (!insert) { - return -ENOMEM; + return -BK_ENOMEM; } memcpy(traverse + node_right_child_offset, &insert, ptr_size); set_insert_balance(me, insert); - return 0; + return BK_OK; } } else { - return 0; + return BK_OK; } } } @@ -397,9 +396,9 @@ static char *set_equal_match(set me, const void *const key) * @param me the set to check for the key * @param key the key to check * - * @return 1 if the set contained the key, otherwise 0 + * @return BK_TRUE if the set contained the key, otherwise BK_FALSE */ -int set_contains(set me, void *const key) +bk_bool set_contains(set me, void *const key) { return set_equal_match(me, key) != NULL; } @@ -670,16 +669,16 @@ static void set_remove_element(set me, char *const traverse) * @param me the set to remove an key from * @param key the key to remove * - * @return 1 if the set contained the key, otherwise 0 + * @return BK_TRUE if the set contained the key, otherwise BK_FALSE */ -int set_remove(set me, void *const key) +bk_err set_remove(set me, void *const key) { char *const traverse = set_equal_match(me, key); if (!traverse) { - return 0; + return BK_FALSE; } set_remove_element(me, traverse); - return 1; + return BK_TRUE; } /** diff --git a/src/stack.c b/src/stack.c index b37608e..5548887 100644 --- a/src/stack.c +++ b/src/stack.c @@ -55,9 +55,9 @@ size_t stack_size(stack me) * * @param me the stack to check if empty * - * @return 1 if the stack is empty, otherwise 0 + * @return BK_TRUE if the stack is empty, otherwise BK_FALSE */ -int stack_is_empty(stack me) +bk_bool stack_is_empty(stack me) { return deque_is_empty(me); } @@ -67,10 +67,10 @@ int stack_is_empty(stack me) * * @param me the stack to trim * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int stack_trim(stack me) +bk_err stack_trim(stack me) { return deque_trim(me); } @@ -99,10 +99,10 @@ void stack_copy_to_array(void *const arr, stack me) * @param me the stack to add an element to * @param data the data to add to the stack * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int stack_push(stack me, void *const data) +bk_err stack_push(stack me, void *const data) { return deque_push_back(me, data); } @@ -118,9 +118,9 @@ int stack_push(stack me, void *const data) * @param data the copy of the element being removed * @param me the stack to remove the top element from * - * @return 1 if the stack contained elements, otherwise 0 + * @return BK_TRUE if the stack contained elements, otherwise BK_FALSE */ -int stack_pop(void *const data, stack me) +bk_bool stack_pop(void *const data, stack me) { return deque_pop_back(data, me) == 0; } @@ -135,9 +135,9 @@ int stack_pop(void *const data, stack me) * @param data the copy of the top element of the stack * @param me the stack to copy from * - * @return 1 if the stack contained elements, otherwise 0 + * @return BK_TRUE if the stack contained elements, otherwise BK_FALSE */ -int stack_top(void *const data, stack me) +bk_bool stack_top(void *const data, stack me) { return deque_get_last(data, me) == 0; } @@ -147,10 +147,10 @@ int stack_top(void *const data, stack me) * * @param me the stack to clear * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int stack_clear(stack me) +bk_err stack_clear(stack me) { return deque_clear(me); } diff --git a/src/unordered_map.c b/src/unordered_map.c index 9b9f9c1..5a09a80 100644 --- a/src/unordered_map.c +++ b/src/unordered_map.c @@ -21,7 +21,6 @@ */ #include -#include #include "include/unordered_map.h" #define BKTHOMPS_U_MAP_STARTING_BUCKETS 16 @@ -133,17 +132,17 @@ static void unordered_map_add_item(unordered_map me, char *const add) * * @param me the unordered map to rehash * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int unordered_map_rehash(unordered_map me) +bk_err unordered_map_rehash(unordered_map me) { size_t i; char **old_buckets = me->buckets; me->buckets = calloc(me->capacity, ptr_size); if (!me->buckets) { me->buckets = old_buckets; - return -ENOMEM; + return -BK_ENOMEM; } for (i = 0; i < me->capacity; i++) { char *traverse = old_buckets[i]; @@ -158,7 +157,7 @@ int unordered_map_rehash(unordered_map me) } } free(old_buckets); - return 0; + return BK_OK; } /** @@ -178,9 +177,9 @@ size_t unordered_map_size(unordered_map me) * * @param me the unordered map to check * - * @return 1 if the unordered map is empty, otherwise 0 + * @return BK_TRUE if the unordered map is empty, otherwise BK_FALSE */ -int unordered_map_is_empty(unordered_map me) +bk_bool unordered_map_is_empty(unordered_map me) { return unordered_map_size(me) == 0; } @@ -188,7 +187,7 @@ int unordered_map_is_empty(unordered_map me) /* * Increases the size of the map and redistributes the nodes. */ -static int unordered_map_resize(unordered_map me) +static bk_err unordered_map_resize(unordered_map me) { size_t i; const size_t old_capacity = me->capacity; @@ -197,7 +196,7 @@ static int unordered_map_resize(unordered_map me) me->buckets = calloc(new_capacity, ptr_size); if (!me->buckets) { me->buckets = old_buckets; - return -ENOMEM; + return -BK_ENOMEM; } me->capacity = new_capacity; for (i = 0; i < old_capacity; i++) { @@ -210,15 +209,15 @@ static int unordered_map_resize(unordered_map me) } } free(old_buckets); - return 0; + return BK_OK; } /* * Determines if an element is equal to the key. */ -static int unordered_map_is_equal(unordered_map me, char *const item, - const unsigned long hash, - const void *const key) +static bk_bool unordered_map_is_equal(unordered_map me, char *const item, + const unsigned long hash, + const void *const key) { unsigned long item_hash; memcpy(&item_hash, item + node_hash_offset, hash_size); @@ -258,24 +257,24 @@ static char *unordered_map_create_element(unordered_map me, * @param key the key to add * @param value the value to add * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int unordered_map_put(unordered_map me, void *const key, void *const value) +bk_err unordered_map_put(unordered_map me, void *const key, void *const value) { const unsigned long hash = unordered_map_hash(me, key); - int index; + size_t index; if (me->size + 1 >= (size_t) (BKTHOMPS_U_MAP_RESIZE_AT * me->capacity)) { - const int rc = unordered_map_resize(me); - if (rc != 0) { + const bk_err rc = unordered_map_resize(me); + if (rc != BK_OK) { return rc; } } - index = (size_t) (hash % me->capacity); + index = hash % me->capacity; if (!me->buckets[index]) { me->buckets[index] = unordered_map_create_element(me, hash, key, value); if (!me->buckets[index]) { - return -ENOMEM; + return -BK_ENOMEM; } } else { char *traverse = me->buckets[index]; @@ -283,7 +282,7 @@ int unordered_map_put(unordered_map me, void *const key, void *const value) if (unordered_map_is_equal(me, traverse, hash, key)) { memcpy(traverse + node_key_offset + me->key_size, value, me->value_size); - return 0; + return BK_OK; } memcpy(&traverse_next, traverse + node_next_offset, ptr_size); while (traverse_next) { @@ -292,17 +291,17 @@ int unordered_map_put(unordered_map me, void *const key, void *const value) if (unordered_map_is_equal(me, traverse, hash, key)) { memcpy(traverse + node_key_offset + me->key_size, value, me->value_size); - return 0; + return BK_OK; } } traverse_next = unordered_map_create_element(me, hash, key, value); if (!traverse_next) { - return -ENOMEM; + return -BK_ENOMEM; } memcpy(traverse + node_next_offset, &traverse_next, ptr_size); } me->size++; - return 0; + return BK_OK; } /** @@ -317,9 +316,10 @@ int unordered_map_put(unordered_map me, void *const key, void *const value) * @param me the unordered map to get from * @param key the key to search for * - * @return 1 if the unordered map contained the key-value pair, otherwise 0 + * @return BK_TRUE if the unordered map contained the key-value pair, + * otherwise BK_FALSE */ -int unordered_map_get(void *const value, unordered_map me, void *const key) +bk_bool unordered_map_get(void *const value, unordered_map me, void *const key) { const unsigned long hash = unordered_map_hash(me, key); char *traverse = me->buckets[hash % me->capacity]; @@ -327,11 +327,11 @@ int unordered_map_get(void *const value, unordered_map me, void *const key) if (unordered_map_is_equal(me, traverse, hash, key)) { memcpy(value, traverse + node_key_offset + me->key_size, me->value_size); - return 1; + return BK_TRUE; } memcpy(&traverse, traverse + node_next_offset, ptr_size); } - return 0; + return BK_FALSE; } /** @@ -344,19 +344,19 @@ int unordered_map_get(void *const value, unordered_map me, void *const key) * @param me the unordered map to check for the key * @param key the key to check * - * @return 1 if the unordered map contained the key, otherwise 0 + * @return BK_TRUE if the unordered map contained the key, otherwise BK_FALSE */ -int unordered_map_contains(unordered_map me, void *const key) +bk_bool unordered_map_contains(unordered_map me, void *const key) { const unsigned long hash = unordered_map_hash(me, key); char *traverse = me->buckets[hash % me->capacity]; while (traverse) { if (unordered_map_is_equal(me, traverse, hash, key)) { - return 1; + return BK_TRUE; } memcpy(&traverse, traverse + node_next_offset, ptr_size); } - return 0; + return BK_FALSE; } /** @@ -369,23 +369,23 @@ int unordered_map_contains(unordered_map me, void *const key) * @param me the unordered map to remove a key from * @param key the key to remove * - * @return 1 if the unordered map contained the key, otherwise 0 + * @return BK_TRUE if the unordered map contained the key, otherwise BK_FALSE */ -int unordered_map_remove(unordered_map me, void *const key) +bk_bool unordered_map_remove(unordered_map me, void *const key) { char *traverse; char *traverse_next; const unsigned long hash = unordered_map_hash(me, key); const size_t index = hash % me->capacity; if (!me->buckets[index]) { - return 0; + return BK_FALSE; } traverse = me->buckets[index]; if (unordered_map_is_equal(me, traverse, hash, key)) { memcpy(me->buckets + index, traverse + node_next_offset, ptr_size); free(traverse); me->size--; - return 1; + return BK_TRUE; } memcpy(&traverse_next, traverse + node_next_offset, ptr_size); while (traverse_next) { @@ -394,12 +394,12 @@ int unordered_map_remove(unordered_map me, void *const key) traverse_next + node_next_offset, ptr_size); free(traverse_next); me->size--; - return 1; + return BK_TRUE; } traverse = traverse_next; memcpy(&traverse_next, traverse + node_next_offset, ptr_size); } - return 0; + return BK_FALSE; } /** @@ -407,15 +407,15 @@ int unordered_map_remove(unordered_map me, void *const key) * * @param me the unordered map to clear * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ int unordered_map_clear(unordered_map me) { size_t i; char **updated_buckets = calloc(BKTHOMPS_U_MAP_STARTING_BUCKETS, ptr_size); if (!updated_buckets) { - return -ENOMEM; + return -BK_ENOMEM; } for (i = 0; i < me->capacity; i++) { char *traverse = me->buckets[i]; @@ -429,7 +429,7 @@ int unordered_map_clear(unordered_map me) me->size = 0; me->capacity = BKTHOMPS_U_MAP_STARTING_BUCKETS; me->buckets = updated_buckets; - return 0; + return BK_OK; } /** diff --git a/src/unordered_multimap.c b/src/unordered_multimap.c index 9e08086..54c5c1b 100644 --- a/src/unordered_multimap.c +++ b/src/unordered_multimap.c @@ -21,7 +21,6 @@ */ #include -#include #include "include/unordered_multimap.h" #define BKTHOMPS_U_MULTIMAP_STARTING_BUCKETS 16 @@ -152,17 +151,17 @@ static void unordered_multimap_add_item(unordered_multimap me, char *const add) * * @param me the unordered multi-map to rehash * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int unordered_multimap_rehash(unordered_multimap me) +bk_err unordered_multimap_rehash(unordered_multimap me) { size_t i; char **old_buckets = me->buckets; me->buckets = calloc(me->capacity, ptr_size); if (!me->buckets) { me->buckets = old_buckets; - return -ENOMEM; + return -BK_ENOMEM; } for (i = 0; i < me->capacity; i++) { char *traverse = old_buckets[i]; @@ -177,7 +176,7 @@ int unordered_multimap_rehash(unordered_multimap me) } } free(old_buckets); - return 0; + return BK_OK; } /** @@ -197,9 +196,9 @@ size_t unordered_multimap_size(unordered_multimap me) * * @param me the unordered multi-map to check * - * @return 1 if the unordered multi-map is empty, otherwise 0 + * @return BK_TRUE if the unordered multi-map is empty, otherwise BK_FALSE */ -int unordered_multimap_is_empty(unordered_multimap me) +bk_bool unordered_multimap_is_empty(unordered_multimap me) { return unordered_multimap_size(me) == 0; } @@ -207,7 +206,7 @@ int unordered_multimap_is_empty(unordered_multimap me) /* * Increases the size of the multi-map and redistributes the nodes. */ -static int unordered_multimap_resize(unordered_multimap me) +static bk_err unordered_multimap_resize(unordered_multimap me) { size_t i; const size_t old_capacity = me->capacity; @@ -216,7 +215,7 @@ static int unordered_multimap_resize(unordered_multimap me) me->buckets = calloc(new_capacity, ptr_size); if (!me->buckets) { me->buckets = old_buckets; - return -ENOMEM; + return -BK_ENOMEM; } me->capacity = new_capacity; for (i = 0; i < old_capacity; i++) { @@ -229,15 +228,16 @@ static int unordered_multimap_resize(unordered_multimap me) } } free(old_buckets); - return 0; + return BK_OK; } /* * Determines if an element is equal to the key. */ -static int unordered_multimap_is_equal(unordered_multimap me, char *const item, - const unsigned long hash, - const void *const key) +static bk_bool unordered_multimap_is_equal(unordered_multimap me, + char *const item, + const unsigned long hash, + const void *const key) { unsigned long item_hash; memcpy(&item_hash, item + node_hash_offset, hash_size); @@ -276,28 +276,27 @@ static char *unordered_multimap_create_element(unordered_multimap me, * @param key the key to add * @param value the value to add * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int unordered_multimap_put(unordered_multimap me, - void *const key, - void *const value) +bk_err unordered_multimap_put(unordered_multimap me, void *const key, + void *const value) { const unsigned long hash = unordered_multimap_hash(me, key); - int index; + size_t index; if (me->size + 1 >= (size_t) (BKTHOMPS_U_MULTIMAP_RESIZE_AT * me->capacity)) { - const int rc = unordered_multimap_resize(me); - if (rc != 0) { + const bk_err rc = unordered_multimap_resize(me); + if (rc != BK_OK) { return rc; } } - index = (size_t) (hash % me->capacity); + index = hash % me->capacity; if (!me->buckets[index]) { me->buckets[index] = unordered_multimap_create_element(me, hash, key, value); if (!me->buckets[index]) { - return -ENOMEM; + return -BK_ENOMEM; } } else { char *traverse = me->buckets[index]; @@ -309,12 +308,12 @@ int unordered_multimap_put(unordered_multimap me, } traverse_next = unordered_multimap_create_element(me, hash, key, value); if (!traverse_next) { - return -ENOMEM; + return -BK_ENOMEM; } memcpy(traverse + node_next_offset, &traverse_next, ptr_size); } me->size++; - return 0; + return BK_OK; } /** @@ -357,15 +356,15 @@ void unordered_multimap_get_start(unordered_multimap me, void *const key) * @param value the value to be copied to from iteration * @param me the unordered multi-map to iterate over * - * @return 1 if there exist more values for the key which is being iterated - * over, otherwise 0 + * @return BK_TRUE if there exist more values for the key which is being + * iterated over, otherwise BK_FALSE */ -int unordered_multimap_get_next(void *const value, unordered_multimap me) +bk_bool unordered_multimap_get_next(void *const value, unordered_multimap me) { char *item; char *traverse; if (!me->iterate_element) { - return 0; + return BK_FALSE; } item = me->iterate_element; memcpy(&traverse, item + node_next_offset, ptr_size); @@ -375,13 +374,13 @@ int unordered_multimap_get_next(void *const value, unordered_multimap me) me->iterate_element = traverse; memcpy(value, item + node_key_offset + me->key_size, me->value_size); - return 1; + return BK_TRUE; } memcpy(&traverse, traverse + node_next_offset, ptr_size); } me->iterate_element = NULL; memcpy(value, item + node_key_offset + me->key_size, me->value_size); - return 1; + return BK_TRUE; } /** @@ -397,9 +396,9 @@ int unordered_multimap_get_next(void *const value, unordered_multimap me) * * @return the number of times the key appears in the unordered multi-map */ -int unordered_multimap_count(unordered_multimap me, void *const key) +size_t unordered_multimap_count(unordered_multimap me, void *const key) { - int count = 0; + size_t count = 0; const unsigned long hash = unordered_multimap_hash(me, key); char *traverse = me->buckets[hash % me->capacity]; while (traverse) { @@ -421,19 +420,20 @@ int unordered_multimap_count(unordered_multimap me, void *const key) * @param me the unordered multi-map to check for the key * @param key the key to check * - * @return 1 if the unordered multi-map contained the key, otherwise 0 + * @return BK_TRUE if the unordered multi-map contained the key, + * otherwise BK_FALSE */ -int unordered_multimap_contains(unordered_multimap me, void *const key) +bk_bool unordered_multimap_contains(unordered_multimap me, void *const key) { const unsigned long hash = unordered_multimap_hash(me, key); char *traverse = me->buckets[hash % me->capacity]; while (traverse) { if (unordered_multimap_is_equal(me, traverse, hash, key)) { - return 1; + return BK_TRUE; } memcpy(&traverse, traverse + node_next_offset, ptr_size); } - return 0; + return BK_FALSE; } /** @@ -448,18 +448,18 @@ int unordered_multimap_contains(unordered_multimap me, void *const key) * @param key the key to remove * @param value the value to remove * - * @return 1 if the unordered multi-map contained the key, otherwise 0 + * @return BK_TRUE if the unordered multi-map contained the key, + * otherwise BK_FALSE */ -int unordered_multimap_remove(unordered_multimap me, - void *const key, - void *const value) +bk_bool unordered_multimap_remove(unordered_multimap me, void *const key, + void *const value) { char *traverse; char *traverse_next; const unsigned long hash = unordered_multimap_hash(me, key); const size_t index = hash % me->capacity; if (!me->buckets[index]) { - return 0; + return BK_FALSE; } traverse = me->buckets[index]; if (unordered_multimap_is_equal(me, traverse, hash, key) @@ -468,7 +468,7 @@ int unordered_multimap_remove(unordered_multimap me, memcpy(me->buckets + index, traverse + node_next_offset, ptr_size); free(traverse); me->size--; - return 1; + return BK_TRUE; } memcpy(&traverse_next, traverse + node_next_offset, ptr_size); while (traverse_next) { @@ -479,12 +479,12 @@ int unordered_multimap_remove(unordered_multimap me, traverse_next + node_next_offset, ptr_size); free(traverse_next); me->size--; - return 1; + return BK_TRUE; } traverse = traverse_next; memcpy(&traverse_next, traverse + node_next_offset, ptr_size); } - return 0; + return BK_FALSE; } /** @@ -498,13 +498,14 @@ int unordered_multimap_remove(unordered_multimap me, * @param me the unordered multi-map to remove a key-value pair from * @param key the key to remove * - * @return 1 if the unordered multi-map contained the key, otherwise 0 + * @return BK_TRUE if the unordered multi-map contained the key, + * otherwise BK_FALSE */ -int unordered_multimap_remove_all(unordered_multimap me, void *const key) +bk_bool unordered_multimap_remove_all(unordered_multimap me, void *const key) { const unsigned long hash = unordered_multimap_hash(me, key); - const int index = (int) (hash % me->capacity); - int was_modified = 0; + const size_t index = hash % me->capacity; + bk_bool was_modified = BK_FALSE; for (;;) { char *traverse = me->buckets[index]; char *traverse_next; @@ -516,7 +517,7 @@ int unordered_multimap_remove_all(unordered_multimap me, void *const key) me->buckets[index] = traverse_next; free(traverse); me->size--; - was_modified = 1; + was_modified = BK_TRUE; continue; } while (traverse_next) { @@ -525,7 +526,7 @@ int unordered_multimap_remove_all(unordered_multimap me, void *const key) traverse_next + node_next_offset, ptr_size); free(traverse_next); me->size--; - was_modified = 1; + was_modified = BK_TRUE; memcpy(&traverse_next, traverse + node_next_offset, ptr_size); continue; } @@ -542,16 +543,16 @@ int unordered_multimap_remove_all(unordered_multimap me, void *const key) * * @param me the unordered multi-map to clear * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int unordered_multimap_clear(unordered_multimap me) +bk_err unordered_multimap_clear(unordered_multimap me) { size_t i; char **updated_buckets = calloc(BKTHOMPS_U_MULTIMAP_STARTING_BUCKETS, ptr_size); if (!updated_buckets) { - return -ENOMEM; + return -BK_ENOMEM; } for (i = 0; i < me->capacity; i++) { char *traverse = me->buckets[i]; @@ -565,7 +566,7 @@ int unordered_multimap_clear(unordered_multimap me) me->size = 0; me->capacity = BKTHOMPS_U_MULTIMAP_STARTING_BUCKETS; me->buckets = updated_buckets; - return 0; + return BK_OK; } /** diff --git a/src/unordered_multiset.c b/src/unordered_multiset.c index 5115fc6..b4866d1 100644 --- a/src/unordered_multiset.c +++ b/src/unordered_multiset.c @@ -21,7 +21,6 @@ */ #include -#include #include "include/unordered_multiset.h" #define BKTHOMPS_U_MULTISET_STARTING_BUCKETS 16 @@ -132,17 +131,17 @@ static void unordered_multiset_add_item(unordered_multiset me, char *const add) * * @param me the unordered multi-set to rehash * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int unordered_multiset_rehash(unordered_multiset me) +bk_err unordered_multiset_rehash(unordered_multiset me) { size_t i; char **old_buckets = me->buckets; me->buckets = calloc(me->capacity, ptr_size); if (!me->buckets) { me->buckets = old_buckets; - return -ENOMEM; + return -BK_ENOMEM; } for (i = 0; i < me->capacity; i++) { char *traverse = old_buckets[i]; @@ -157,7 +156,7 @@ int unordered_multiset_rehash(unordered_multiset me) } } free(old_buckets); - return 0; + return BK_OK; } /** @@ -177,9 +176,9 @@ size_t unordered_multiset_size(unordered_multiset me) * * @param me the unordered multi-set to check * - * @return 1 if the unordered multi-set is empty, otherwise 0 + * @return BK_TRUE if the unordered multi-set is empty, otherwise BK_FALSE */ -int unordered_multiset_is_empty(unordered_multiset me) +bk_bool unordered_multiset_is_empty(unordered_multiset me) { return unordered_multiset_size(me) == 0; } @@ -187,7 +186,7 @@ int unordered_multiset_is_empty(unordered_multiset me) /* * Increases the size of the multi-set and redistributes the nodes. */ -static int unordered_multiset_resize(unordered_multiset me) +static bk_err unordered_multiset_resize(unordered_multiset me) { size_t i; const size_t old_capacity = me->capacity; @@ -196,7 +195,7 @@ static int unordered_multiset_resize(unordered_multiset me) me->buckets = calloc(new_capacity, ptr_size); if (!me->buckets) { me->buckets = old_buckets; - return -ENOMEM; + return -BK_ENOMEM; } me->capacity = new_capacity; for (i = 0; i < old_capacity; i++) { @@ -209,15 +208,16 @@ static int unordered_multiset_resize(unordered_multiset me) } } free(old_buckets); - return 0; + return BK_OK; } /* * Determines if an element is equal to the key. */ -static int unordered_multiset_is_equal(unordered_multiset me, char *const item, - const unsigned long hash, - const void *const key) +static bk_bool unordered_multiset_is_equal(unordered_multiset me, + char *const item, + const unsigned long hash, + const void *const key) { unsigned long item_hash; memcpy(&item_hash, item + node_hash_offset, hash_size); @@ -254,25 +254,25 @@ static char *unordered_multiset_create_element(unordered_multiset me, * @param me the unordered multi-set to add to * @param key the element to add * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int unordered_multiset_put(unordered_multiset me, void *const key) +bk_err unordered_multiset_put(unordered_multiset me, void *const key) { const unsigned long hash = unordered_multiset_hash(me, key); - int index; + size_t index; if (me->used + 1 >= (size_t) (BKTHOMPS_U_MULTISET_RESIZE_AT * me->capacity)) { - const int rc = unordered_multiset_resize(me); - if (rc != 0) { + const bk_err rc = unordered_multiset_resize(me); + if (rc != BK_OK) { return rc; } } - index = (size_t) (hash % me->capacity); + index = hash % me->capacity; if (!me->buckets[index]) { me->buckets[index] = unordered_multiset_create_element(me, hash, key); if (!me->buckets[index]) { - return -ENOMEM; + return -BK_ENOMEM; } } else { char *traverse = me->buckets[index]; @@ -283,7 +283,7 @@ int unordered_multiset_put(unordered_multiset me, void *const key) count++; memcpy(traverse + node_count_offset, &count, count_size); me->size++; - return 0; + return BK_OK; } memcpy(&traverse_next, traverse + node_next_offset, ptr_size); while (traverse_next) { @@ -295,18 +295,18 @@ int unordered_multiset_put(unordered_multiset me, void *const key) count++; memcpy(traverse + node_count_offset, &count, count_size); me->size++; - return 0; + return BK_OK; } } traverse_next = unordered_multiset_create_element(me, hash, key); if (!traverse_next) { - return -ENOMEM; + return -BK_ENOMEM; } memcpy(traverse + node_next_offset, &traverse_next, ptr_size); } me->size++; me->used++; - return 0; + return BK_OK; } /** @@ -346,9 +346,10 @@ size_t unordered_multiset_count(unordered_multiset me, void *const key) * @param me the unordered multi-set to check for the key * @param key the key to check * - * @return 1 if the unordered multi-set contained the key, otherwise 0 + * @return BK_TRUE if the unordered multi-set contained the key, + * otherwise BK_FALSE */ -int unordered_multiset_contains(unordered_multiset me, void *const key) +bk_bool unordered_multiset_contains(unordered_multiset me, void *const key) { return unordered_multiset_count(me, key) != 0; } @@ -363,16 +364,17 @@ int unordered_multiset_contains(unordered_multiset me, void *const key) * @param me the unordered multi-set to remove a key from * @param key the key to remove * - * @return 1 if the unordered multi-set contained the key, otherwise 0 + * @return BK_TRUE if the unordered multi-set contained the key, + * otherwise BK_FALSE */ -int unordered_multiset_remove(unordered_multiset me, void *const key) +bk_bool unordered_multiset_remove(unordered_multiset me, void *const key) { char *traverse; char *traverse_next; const unsigned long hash = unordered_multiset_hash(me, key); const size_t index = hash % me->capacity; if (!me->buckets[index]) { - return 0; + return BK_FALSE; } traverse = me->buckets[index]; if (unordered_multiset_is_equal(me, traverse, hash, key)) { @@ -387,7 +389,7 @@ int unordered_multiset_remove(unordered_multiset me, void *const key) memcpy(traverse + node_count_offset, &count, count_size); } me->size--; - return 1; + return BK_TRUE; } memcpy(&traverse_next, traverse + node_next_offset, ptr_size); while (traverse_next) { @@ -404,12 +406,12 @@ int unordered_multiset_remove(unordered_multiset me, void *const key) memcpy(traverse_next + node_count_offset, &count, count_size); } me->size--; - return 1; + return BK_TRUE; } traverse = traverse_next; memcpy(&traverse_next, traverse + node_next_offset, ptr_size); } - return 0; + return BK_FALSE; } /** @@ -422,16 +424,17 @@ int unordered_multiset_remove(unordered_multiset me, void *const key) * @param me the unordered multi-set to remove a key from * @param key the key to remove * - * @return 1 if the unordered multi-set contained the key, otherwise 0 + * @return BK_TRUE if the unordered multi-set contained the key, + * otherwise BK_FALSE */ -int unordered_multiset_remove_all(unordered_multiset me, void *const key) +bk_bool unordered_multiset_remove_all(unordered_multiset me, void *const key) { char *traverse; char *traverse_next; const unsigned long hash = unordered_multiset_hash(me, key); const size_t index = hash % me->capacity; if (!me->buckets[index]) { - return 0; + return BK_FALSE; } traverse = me->buckets[index]; if (unordered_multiset_is_equal(me, traverse, hash, key)) { @@ -441,7 +444,7 @@ int unordered_multiset_remove_all(unordered_multiset me, void *const key) free(traverse); me->used--; me->size -= count; - return 1; + return BK_TRUE; } memcpy(&traverse_next, traverse + node_next_offset, ptr_size); while (traverse_next) { @@ -453,12 +456,12 @@ int unordered_multiset_remove_all(unordered_multiset me, void *const key) free(traverse_next); me->used--; me->size -= count; - return 1; + return BK_TRUE; } traverse = traverse_next; memcpy(&traverse_next, traverse + node_next_offset, ptr_size); } - return 0; + return BK_FALSE; } /** @@ -466,16 +469,16 @@ int unordered_multiset_remove_all(unordered_multiset me, void *const key) * * @param me the unordered multi-set to clear * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int unordered_multiset_clear(unordered_multiset me) +bk_err unordered_multiset_clear(unordered_multiset me) { size_t i; char **updated_buckets = calloc(BKTHOMPS_U_MULTISET_STARTING_BUCKETS, ptr_size); if (!updated_buckets) { - return -ENOMEM; + return -BK_ENOMEM; } for (i = 0; i < me->capacity; i++) { char *traverse = me->buckets[i]; @@ -490,7 +493,7 @@ int unordered_multiset_clear(unordered_multiset me) me->capacity = BKTHOMPS_U_MULTISET_STARTING_BUCKETS; me->used = 0; me->buckets = updated_buckets; - return 0; + return BK_OK; } /** diff --git a/src/unordered_set.c b/src/unordered_set.c index 978c73a..fadda4f 100644 --- a/src/unordered_set.c +++ b/src/unordered_set.c @@ -21,7 +21,6 @@ */ #include -#include #include "include/unordered_set.h" #define BKTHOMPS_U_SET_STARTING_BUCKETS 16 @@ -126,17 +125,17 @@ static void unordered_set_add_item(unordered_set me, char *const add) * * @param me the unordered set to rehash * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int unordered_set_rehash(unordered_set me) +bk_err unordered_set_rehash(unordered_set me) { size_t i; char **old_buckets = me->buckets; me->buckets = calloc(me->capacity, ptr_size); if (!me->buckets) { me->buckets = old_buckets; - return -ENOMEM; + return -BK_ENOMEM; } for (i = 0; i < me->capacity; i++) { char *traverse = old_buckets[i]; @@ -151,7 +150,7 @@ int unordered_set_rehash(unordered_set me) } } free(old_buckets); - return 0; + return BK_OK; } /** @@ -171,9 +170,9 @@ size_t unordered_set_size(unordered_set me) * * @param me the unordered set to check * - * @return 1 if the unordered set is empty, otherwise 0 + * @return BK_TRUE if the unordered set is empty, otherwise BK_FALSE */ -int unordered_set_is_empty(unordered_set me) +bk_bool unordered_set_is_empty(unordered_set me) { return unordered_set_size(me) == 0; } @@ -181,7 +180,7 @@ int unordered_set_is_empty(unordered_set me) /* * Increases the size of the set and redistributes the nodes. */ -static int unordered_set_resize(unordered_set me) +static bk_err unordered_set_resize(unordered_set me) { size_t i; const size_t old_capacity = me->capacity; @@ -190,7 +189,7 @@ static int unordered_set_resize(unordered_set me) me->buckets = calloc(new_capacity, ptr_size); if (!me->buckets) { me->buckets = old_buckets; - return -ENOMEM; + return -BK_ENOMEM; } me->capacity = new_capacity; for (i = 0; i < old_capacity; i++) { @@ -203,15 +202,15 @@ static int unordered_set_resize(unordered_set me) } } free(old_buckets); - return 0; + return BK_OK; } /* * Determines if an element is equal to the key. */ -static int unordered_set_is_equal(unordered_set me, char *const item, - const unsigned long hash, - const void *const key) +static bk_bool unordered_set_is_equal(unordered_set me, char *const item, + const unsigned long hash, + const void *const key) { unsigned long item_hash; memcpy(&item_hash, item + node_hash_offset, hash_size); @@ -247,47 +246,47 @@ static char *unordered_set_create_element(unordered_set me, * @param me the unordered set to add to * @param key the element to add * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ int unordered_set_put(unordered_set me, void *const key) { const unsigned long hash = unordered_set_hash(me, key); - int index; + size_t index; if (me->size + 1 >= (size_t) (BKTHOMPS_U_SET_RESIZE_AT * me->capacity)) { - const int rc = unordered_set_resize(me); - if (rc != 0) { + const bk_err rc = unordered_set_resize(me); + if (rc != BK_OK) { return rc; } } - index = (size_t) (hash % me->capacity); + index = hash % me->capacity; if (!me->buckets[index]) { me->buckets[index] = unordered_set_create_element(me, hash, key); if (!me->buckets[index]) { - return -ENOMEM; + return -BK_ENOMEM; } } else { char *traverse = me->buckets[index]; char *traverse_next; if (unordered_set_is_equal(me, traverse, hash, key)) { - return 0; + return BK_OK; } memcpy(&traverse_next, traverse + node_next_offset, ptr_size); while (traverse_next) { traverse = traverse_next; memcpy(&traverse_next, traverse + node_next_offset, ptr_size); if (unordered_set_is_equal(me, traverse, hash, key)) { - return 0; + return BK_OK; } } traverse_next = unordered_set_create_element(me, hash, key); if (!traverse_next) { - return -ENOMEM; + return -BK_ENOMEM; } memcpy(traverse + node_next_offset, &traverse_next, ptr_size); } me->size++; - return 0; + return BK_OK; } /** @@ -300,7 +299,8 @@ int unordered_set_put(unordered_set me, void *const key) * @param me the unordered set to check for the element * @param key the element to check * - * @return 1 if the unordered set contained the element, otherwise 0 + * @return BK_TRUE if the unordered set contained the element, + * otherwise BK_FALSE */ int unordered_set_contains(unordered_set me, void *const key) { @@ -308,11 +308,11 @@ int unordered_set_contains(unordered_set me, void *const key) char *traverse = me->buckets[hash % me->capacity]; while (traverse) { if (unordered_set_is_equal(me, traverse, hash, key)) { - return 1; + return BK_TRUE; } memcpy(&traverse, traverse + node_next_offset, ptr_size); } - return 0; + return BK_FALSE; } /** @@ -325,7 +325,7 @@ int unordered_set_contains(unordered_set me, void *const key) * @param me the unordered set to remove a key from * @param key the key to remove * - * @return 1 if the unordered set contained the key, otherwise 0 + * @return BK_TRUE if the unordered set contained the key, otherwise BK_FALSE */ int unordered_set_remove(unordered_set me, void *const key) { @@ -334,14 +334,14 @@ int unordered_set_remove(unordered_set me, void *const key) const unsigned long hash = unordered_set_hash(me, key); const size_t index = hash % me->capacity; if (!me->buckets[index]) { - return 0; + return BK_FALSE; } traverse = me->buckets[index]; if (unordered_set_is_equal(me, traverse, hash, key)) { memcpy(me->buckets + index, traverse + node_next_offset, ptr_size); free(traverse); me->size--; - return 1; + return BK_TRUE; } memcpy(&traverse_next, traverse + node_next_offset, ptr_size); while (traverse_next) { @@ -350,12 +350,12 @@ int unordered_set_remove(unordered_set me, void *const key) traverse_next + node_next_offset, ptr_size); free(traverse_next); me->size--; - return 1; + return BK_TRUE; } traverse = traverse_next; memcpy(&traverse_next, traverse + node_next_offset, ptr_size); } - return 0; + return BK_FALSE; } /** @@ -363,15 +363,15 @@ int unordered_set_remove(unordered_set me, void *const key) * * @param me the unordered set to clear * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ int unordered_set_clear(unordered_set me) { size_t i; char **updated_buckets = calloc(BKTHOMPS_U_SET_STARTING_BUCKETS, ptr_size); if (!updated_buckets) { - return -ENOMEM; + return -BK_ENOMEM; } for (i = 0; i < me->capacity; i++) { char *traverse = me->buckets[i]; @@ -385,7 +385,7 @@ int unordered_set_clear(unordered_set me) me->size = 0; me->capacity = BKTHOMPS_U_SET_STARTING_BUCKETS; me->buckets = updated_buckets; - return 0; + return BK_OK; } /** diff --git a/src/vector.c b/src/vector.c index c0732fe..27ddf31 100644 --- a/src/vector.c +++ b/src/vector.c @@ -21,7 +21,6 @@ */ #include -#include #include "include/vector.h" #define BKTHOMPS_VECTOR_START_SPACE 8 @@ -93,9 +92,9 @@ size_t vector_capacity(vector me) * * @param me the vector to check * - * @return 1 if the vector is empty, otherwise 0 + * @return BK_TRUE if the vector is empty, otherwise BK_FALSE */ -int vector_is_empty(vector me) +bk_bool vector_is_empty(vector me) { return vector_size(me) == 0; } @@ -104,15 +103,15 @@ int vector_is_empty(vector me) * Sets the space of the buffer. Assumes that size is at least the same as the * number of items currently in the vector. */ -static int vector_set_space(vector me, const int size) +static bk_err vector_set_space(vector me, const int size) { char *const temp = realloc(me->data, size * me->bytes_per_item); if (!temp) { - return -ENOMEM; + return -BK_ENOMEM; } me->item_capacity = size; me->data = temp; - return 0; + return BK_OK; } /** @@ -122,13 +121,13 @@ static int vector_set_space(vector me, const int size) * @param me the vector to reserve space for * @param size the space to reserve * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int vector_reserve(vector me, size_t size) +bk_err vector_reserve(vector me, size_t size) { if (me->item_capacity >= size) { - return 0; + return BK_OK; } return vector_set_space(me, size); } @@ -138,10 +137,10 @@ int vector_reserve(vector me, size_t size) * * @param me the vector to trim * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int vector_trim(vector me) +bk_err vector_trim(vector me) { return vector_set_space(me, me->item_count); } @@ -171,7 +170,8 @@ void vector_copy_to_array(void *const arr, vector me) * the queried array. This pointer is not a copy, thus any modification to the * data will cause the vector structure data to be modified. Operations using * the vector functions may invalidate this pointer. The vector owns this - * memory, thus it should not be freed. + * memory, thus it should not be freed. This should not be used if the vector + * is empty. * * @param me the vector to get the storage element from * @@ -192,10 +192,10 @@ void *vector_get_data(vector me) * @param me the vector to add to * @param data the data to add to the vector * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int vector_add_first(vector me, void *const data) +bk_err vector_add_first(vector me, void *const data) { return vector_add_at(me, 0, data); } @@ -211,21 +211,21 @@ int vector_add_first(vector me, void *const data) * @param index the location in the vector to add the data to * @param data the data to add to the vector * - * @return 0 if no error - * @return -ENOMEM if out of memory - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory + * @return -BK_EINVAL if invalid argument */ -int vector_add_at(vector me, const size_t index, void *const data) +bk_err vector_add_at(vector me, const size_t index, void *const data) { if (index > me->item_count) { - return -EINVAL; + return -BK_EINVAL; } if (me->item_count + 1 >= me->item_capacity) { const size_t new_space = (size_t) (me->item_capacity * BKTHOMPS_VECTOR_RESIZE_RATIO); char *const temp = realloc(me->data, new_space * me->bytes_per_item); if (!temp) { - return -ENOMEM; + return -BK_ENOMEM; } me->data = temp; me->item_capacity = new_space; @@ -237,7 +237,7 @@ int vector_add_at(vector me, const size_t index, void *const data) } memcpy(me->data + index * me->bytes_per_item, data, me->bytes_per_item); me->item_count++; - return 0; + return BK_OK; } /** @@ -246,10 +246,10 @@ int vector_add_at(vector me, const size_t index, void *const data) * @param me the vector to add to * @param data the data to add to the vector * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int vector_add_last(vector me, void *const data) +bk_err vector_add_last(vector me, void *const data) { return vector_add_at(me, me->item_count, data); } @@ -259,10 +259,10 @@ int vector_add_last(vector me, void *const data) * * @param me the vector to remove from * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int vector_remove_first(vector me) +bk_err vector_remove_first(vector me) { return vector_remove_at(me, 0); } @@ -273,19 +273,19 @@ int vector_remove_first(vector me) * @param me the vector to remove from * @param index the location in the vector to remove the data from * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int vector_remove_at(vector me, const size_t index) +bk_err vector_remove_at(vector me, const size_t index) { if (index >= me->item_count) { - return -EINVAL; + return -BK_EINVAL; } me->item_count--; memmove(me->data + index * me->bytes_per_item, me->data + (index + 1) * me->bytes_per_item, (me->item_count - index) * me->bytes_per_item); - return 0; + return BK_OK; } /** @@ -293,16 +293,16 @@ int vector_remove_at(vector me, const size_t index) * * @param me the vector to remove from * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int vector_remove_last(vector me) +bk_err vector_remove_last(vector me) { if (me->item_count == 0) { - return -EINVAL; + return -BK_EINVAL; } me->item_count--; - return 0; + return BK_OK; } /** @@ -315,10 +315,10 @@ int vector_remove_last(vector me) * @param me the vector to set data for * @param data the data to set at the start of the vector * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int vector_set_first(vector me, void *const data) +bk_err vector_set_first(vector me, void *const data) { return vector_set_at(me, 0, data); } @@ -334,16 +334,16 @@ int vector_set_first(vector me, void *const data) * @param index the location to set data at in the vector * @param data the data to set at the location in the vector * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int vector_set_at(vector me, const size_t index, void *const data) +bk_err vector_set_at(vector me, const size_t index, void *const data) { if (index >= me->item_count) { - return -EINVAL; + return -BK_EINVAL; } memcpy(me->data + index * me->bytes_per_item, data, me->bytes_per_item); - return 0; + return BK_OK; } /** @@ -356,10 +356,10 @@ int vector_set_at(vector me, const size_t index, void *const data) * @param me the vector to set data for * @param data the data to set at the end of the vector * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int vector_set_last(vector me, void *const data) +bk_err vector_set_last(vector me, void *const data) { return vector_set_at(me, me->item_count - 1, data); } @@ -374,10 +374,10 @@ int vector_set_last(vector me, void *const data) * @param data the data to copy to * @param me the vector to copy from * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int vector_get_first(void *const data, vector me) +bk_err vector_get_first(void *const data, vector me) { return vector_get_at(data, me, 0); } @@ -393,16 +393,16 @@ int vector_get_first(void *const data, vector me) * @param me the vector to copy from * @param index the index to copy from in the vector * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int vector_get_at(void *const data, vector me, const size_t index) +bk_err vector_get_at(void *const data, vector me, const size_t index) { if (index >= me->item_count) { - return -EINVAL; + return -BK_EINVAL; } memcpy(data, me->data + index * me->bytes_per_item, me->bytes_per_item); - return 0; + return BK_OK; } /** @@ -415,10 +415,10 @@ int vector_get_at(void *const data, vector me, const size_t index) * @param data the data to copy to * @param me the vector to copy from * - * @return 0 if no error - * @return -EINVAL if invalid argument + * @return BK_OK if no error + * @return -BK_EINVAL if invalid argument */ -int vector_get_last(void *const data, vector me) +bk_err vector_get_last(void *const data, vector me) { return vector_get_at(data, me, me->item_count - 1); } @@ -428,10 +428,10 @@ int vector_get_last(void *const data, vector me) * * @param me the vector to clear * - * @return 0 if no error - * @return -ENOMEM if out of memory + * @return BK_OK if no error + * @return -BK_ENOMEM if out of memory */ -int vector_clear(vector me) +bk_err vector_clear(vector me) { me->item_count = 0; return vector_set_space(me, BKTHOMPS_VECTOR_START_SPACE); diff --git a/tst/test.h b/tst/test.h index 5c0a088..d2380a3 100644 --- a/tst/test.h +++ b/tst/test.h @@ -4,6 +4,8 @@ #include #include #include +#include +#include #define STUB_MALLOC 1 diff --git a/tst/test_array.c b/tst/test_array.c index 0eaacd4..0b4ca4b 100644 --- a/tst/test_array.c +++ b/tst/test_array.c @@ -1,4 +1,3 @@ -#include #include "test.h" #include "../src/include/array.h" diff --git a/tst/test_deque.c b/tst/test_deque.c index 8f1dc0c..2540b51 100644 --- a/tst/test_deque.c +++ b/tst/test_deque.c @@ -1,4 +1,3 @@ -#include #include "test.h" #include "../src/include/deque.h" diff --git a/tst/test_forward_list.c b/tst/test_forward_list.c index e572c71..166be38 100644 --- a/tst/test_forward_list.c +++ b/tst/test_forward_list.c @@ -1,4 +1,3 @@ -#include #include "test.h" #include "../src/include/forward_list.h" diff --git a/tst/test_list.c b/tst/test_list.c index a2867c1..fc5ea89 100644 --- a/tst/test_list.c +++ b/tst/test_list.c @@ -1,4 +1,3 @@ -#include #include "test.h" #include "../src/include/list.h" diff --git a/tst/test_map.c b/tst/test_map.c index 3a9b424..d4dfa27 100644 --- a/tst/test_map.c +++ b/tst/test_map.c @@ -1,5 +1,3 @@ -#include -#include #include "test.h" #include "../src/include/map.h" diff --git a/tst/test_multimap.c b/tst/test_multimap.c index 85b0503..dfd1142 100644 --- a/tst/test_multimap.c +++ b/tst/test_multimap.c @@ -1,5 +1,3 @@ -#include -#include #include "test.h" #include "../src/include/multimap.h" diff --git a/tst/test_multiset.c b/tst/test_multiset.c index 7993c78..6e1a09b 100644 --- a/tst/test_multiset.c +++ b/tst/test_multiset.c @@ -1,5 +1,3 @@ -#include -#include #include "test.h" #include "../src/include/multiset.h" diff --git a/tst/test_priority_queue.c b/tst/test_priority_queue.c index 3a8e117..9d6120f 100644 --- a/tst/test_priority_queue.c +++ b/tst/test_priority_queue.c @@ -1,4 +1,3 @@ -#include #include "test.h" #include "../src/include/vector.h" #include "../src/include/priority_queue.h" diff --git a/tst/test_queue.c b/tst/test_queue.c index df196c7..2a2d356 100644 --- a/tst/test_queue.c +++ b/tst/test_queue.c @@ -1,4 +1,3 @@ -#include #include "test.h" #include "../src/include/queue.h" diff --git a/tst/test_set.c b/tst/test_set.c index 87df060..914c7de 100644 --- a/tst/test_set.c +++ b/tst/test_set.c @@ -1,5 +1,3 @@ -#include -#include #include "test.h" #include "../src/include/set.h" diff --git a/tst/test_stack.c b/tst/test_stack.c index 804058e..515e6fa 100644 --- a/tst/test_stack.c +++ b/tst/test_stack.c @@ -1,4 +1,3 @@ -#include #include "test.h" #include "../src/include/stack.h" diff --git a/tst/test_unordered_map.c b/tst/test_unordered_map.c index 7b1ab24..d63be5a 100644 --- a/tst/test_unordered_map.c +++ b/tst/test_unordered_map.c @@ -1,4 +1,3 @@ -#include #include "test.h" #include "../src/include/unordered_map.h" diff --git a/tst/test_unordered_multimap.c b/tst/test_unordered_multimap.c index 483233f..c8581e0 100644 --- a/tst/test_unordered_multimap.c +++ b/tst/test_unordered_multimap.c @@ -1,4 +1,3 @@ -#include #include "test.h" #include "../src/include/unordered_multimap.h" diff --git a/tst/test_unordered_multiset.c b/tst/test_unordered_multiset.c index 3016d0b..c6b08f5 100644 --- a/tst/test_unordered_multiset.c +++ b/tst/test_unordered_multiset.c @@ -1,4 +1,3 @@ -#include #include "test.h" #include "../src/include/unordered_multiset.h" diff --git a/tst/test_unordered_set.c b/tst/test_unordered_set.c index 1049ff1..ee0de6d 100644 --- a/tst/test_unordered_set.c +++ b/tst/test_unordered_set.c @@ -1,4 +1,3 @@ -#include #include "test.h" #include "../src/include/unordered_set.h" diff --git a/tst/test_vector.c b/tst/test_vector.c index 309babd..ab25e73 100644 --- a/tst/test_vector.c +++ b/tst/test_vector.c @@ -1,5 +1,3 @@ -#include -#include #include "test.h" #include "../src/include/vector.h"