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

Simplify return values (#114)

Browse Source 
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.
This commit is contained in:
Bailey Thompson
2020-08-17 16:55:29 -04:00
committed by GitHub
parent 724c0e51c9
commit e3bc87298f
53 changed files with 904 additions and 884 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
compile_headers.py
View File

@@ -50,7 +50,11 @@ folder_path = 'src/include'
for filename in sorted(glob.glob(os.path.join(folder_path, '*.h'))): for filename in sorted(glob.glob(os.path.join(folder_path, '*.h'))):
with open(filename, 'r') as file: with open(filename, 'r') as file:
text = file.read() 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 = open("containers.h", "w+")
containers_header_file.write(header) containers_header_file.write(header)

304
containers.h
View File

@@ -27,11 +27,32 @@
*/ */
#ifndef BKTHOMPS_CONTAINERS_ARRAY_H #ifndef BKTHOMPS_CONTAINERS_ALL_H
#define BKTHOMPS_CONTAINERS_ARRAY_H #define BKTHOMPS_CONTAINERS_ALL_H
#include <stdlib.h> #include <stdlib.h>
/*
* Cannot use <errno.h> 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 <stdbool.h> 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. * 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); void *array_get_data(array me);
/* Accessing */ /* Accessing */
int array_set(array me, size_t index, void *data); bk_err array_set(array me, size_t index, void *data);
int array_get(void *data, array me, size_t index); bk_err array_get(void *data, array me, size_t index);
/* Ending */ /* Ending */
array array_destroy(array me); array array_destroy(array me);
@@ -58,8 +79,6 @@ array array_destroy(array me);
#ifndef BKTHOMPS_CONTAINERS_DEQUE_H #ifndef BKTHOMPS_CONTAINERS_DEQUE_H
#define BKTHOMPS_CONTAINERS_DEQUE_H #define BKTHOMPS_CONTAINERS_DEQUE_H
#include <stdlib.h>
/** /**
* The deque data structure, which is a doubly-ended queue. * The deque data structure, which is a doubly-ended queue.
*/ */
@@ -70,30 +89,30 @@ deque deque_init(size_t data_size);
/* Utility */ /* Utility */
size_t deque_size(deque me); size_t deque_size(deque me);
int deque_is_empty(deque me); bk_bool deque_is_empty(deque me);
int deque_trim(deque me); bk_err deque_trim(deque me);
void deque_copy_to_array(void *arr, deque me); void deque_copy_to_array(void *arr, deque me);
/* Adding */ /* Adding */
int deque_push_front(deque me, void *data); bk_err deque_push_front(deque me, void *data);
int deque_push_back(deque me, void *data); bk_err deque_push_back(deque me, void *data);
/* Removing */ /* Removing */
int deque_pop_front(void *data, deque me); bk_err deque_pop_front(void *data, deque me);
int deque_pop_back(void *data, deque me); bk_err deque_pop_back(void *data, deque me);
/* Setting */ /* Setting */
int deque_set_first(deque me, void *data); bk_err deque_set_first(deque me, void *data);
int deque_set_at(deque me, size_t index, void *data); bk_err deque_set_at(deque me, size_t index, void *data);
int deque_set_last(deque me, void *data); bk_err deque_set_last(deque me, void *data);
/* Getting */ /* Getting */
int deque_get_first(void *data, deque me); bk_err deque_get_first(void *data, deque me);
int deque_get_at(void *data, deque me, size_t index); bk_err deque_get_at(void *data, deque me, size_t index);
int deque_get_last(void *data, deque me); bk_err deque_get_last(void *data, deque me);
/* Ending */ /* Ending */
int deque_clear(deque me); bk_err deque_clear(deque me);
deque deque_destroy(deque me); deque deque_destroy(deque me);
#endif /* BKTHOMPS_CONTAINERS_DEQUE_H */ #endif /* BKTHOMPS_CONTAINERS_DEQUE_H */
@@ -102,8 +121,6 @@ deque deque_destroy(deque me);
#ifndef BKTHOMPS_CONTAINERS_FORWARD_LIST_H #ifndef BKTHOMPS_CONTAINERS_FORWARD_LIST_H
#define BKTHOMPS_CONTAINERS_FORWARD_LIST_H #define BKTHOMPS_CONTAINERS_FORWARD_LIST_H
#include <stdlib.h>
/** /**
* The forward_list data structure, which is a singly-linked list. * 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 */ /* Utility */
size_t forward_list_size(forward_list me); 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); void forward_list_copy_to_array(void *arr, forward_list me);
/* Adding */ /* Adding */
int forward_list_add_first(forward_list me, void *data); bk_err forward_list_add_first(forward_list me, void *data);
int forward_list_add_at(forward_list me, size_t index, void *data); bk_err 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_last(forward_list me, void *data);
/* Removing */ /* Removing */
int forward_list_remove_first(forward_list me); bk_err forward_list_remove_first(forward_list me);
int forward_list_remove_at(forward_list me, size_t index); bk_err forward_list_remove_at(forward_list me, size_t index);
int forward_list_remove_last(forward_list me); bk_err forward_list_remove_last(forward_list me);
/* Setting */ /* Setting */
int forward_list_set_first(forward_list me, void *data); bk_err forward_list_set_first(forward_list me, void *data);
int forward_list_set_at(forward_list me, size_t index, void *data); bk_err 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_last(forward_list me, void *data);
/* Getting */ /* Getting */
int forward_list_get_first(void *data, forward_list me); bk_err forward_list_get_first(void *data, forward_list me);
int forward_list_get_at(void *data, forward_list me, size_t index); bk_err 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_last(void *data, forward_list me);
/* Ending */ /* Ending */
void forward_list_clear(forward_list me); void forward_list_clear(forward_list me);
@@ -147,8 +164,6 @@ forward_list forward_list_destroy(forward_list me);
#ifndef BKTHOMPS_CONTAINERS_LIST_H #ifndef BKTHOMPS_CONTAINERS_LIST_H
#define BKTHOMPS_CONTAINERS_LIST_H #define BKTHOMPS_CONTAINERS_LIST_H
#include <stdlib.h>
/** /**
* The list data structure, which is a doubly-linked list. * The list data structure, which is a doubly-linked list.
*/ */
@@ -159,28 +174,28 @@ list list_init(size_t data_size);
/* Utility */ /* Utility */
size_t list_size(list me); 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); void list_copy_to_array(void *arr, list me);
/* Adding */ /* Adding */
int list_add_first(list me, void *data); bk_err list_add_first(list me, void *data);
int list_add_at(list me, size_t index, void *data); bk_err list_add_at(list me, size_t index, void *data);
int list_add_last(list me, void *data); bk_err list_add_last(list me, void *data);
/* Removing */ /* Removing */
int list_remove_first(list me); bk_err list_remove_first(list me);
int list_remove_at(list me, size_t index); bk_err list_remove_at(list me, size_t index);
int list_remove_last(list me); bk_err list_remove_last(list me);
/* Setting */ /* Setting */
int list_set_first(list me, void *data); bk_err list_set_first(list me, void *data);
int list_set_at(list me, size_t index, void *data); bk_err list_set_at(list me, size_t index, void *data);
int list_set_last(list me, void *data); bk_err list_set_last(list me, void *data);
/* Getting */ /* Getting */
int list_get_first(void *data, list me); bk_err list_get_first(void *data, list me);
int list_get_at(void *data, list me, size_t index); bk_err list_get_at(void *data, list me, size_t index);
int list_get_last(void *data, list me); bk_err list_get_last(void *data, list me);
/* Ending */ /* Ending */
void list_clear(list me); void list_clear(list me);
@@ -192,8 +207,6 @@ list list_destroy(list me);
#ifndef BKTHOMPS_CONTAINERS_MAP_H #ifndef BKTHOMPS_CONTAINERS_MAP_H
#define BKTHOMPS_CONTAINERS_MAP_H #define BKTHOMPS_CONTAINERS_MAP_H
#include <stdlib.h>
/** /**
* The map data structure, which is a collection of key-value pairs, sorted by * The map data structure, which is a collection of key-value pairs, sorted by
* keys, keys are unique. * keys, keys are unique.
@@ -206,13 +219,13 @@ map map_init(size_t key_size, size_t value_size,
/* Capacity */ /* Capacity */
size_t map_size(map me); size_t map_size(map me);
int map_is_empty(map me); bk_bool map_is_empty(map me);
/* Accessing */ /* Accessing */
int map_put(map me, void *key, void *value); bk_err map_put(map me, void *key, void *value);
int map_get(void *value, map me, void *key); bk_bool map_get(void *value, map me, void *key);
int map_contains(map me, void *key); bk_bool map_contains(map me, void *key);
int map_remove(map me, void *key); bk_bool map_remove(map me, void *key);
/* Ending */ /* Ending */
void map_clear(map me); void map_clear(map me);
@@ -224,8 +237,6 @@ map map_destroy(map me);
#ifndef BKTHOMPS_CONTAINERS_MULTIMAP_H #ifndef BKTHOMPS_CONTAINERS_MULTIMAP_H
#define BKTHOMPS_CONTAINERS_MULTIMAP_H #define BKTHOMPS_CONTAINERS_MULTIMAP_H
#include <stdlib.h>
/** /**
* The multimap data structure, which is a collection of key-value pairs, sorted * The multimap data structure, which is a collection of key-value pairs, sorted
* by keys. * by keys.
@@ -241,16 +252,16 @@ multimap multimap_init(size_t key_size, size_t value_size,
/* Capacity */ /* Capacity */
size_t multimap_size(multimap me); size_t multimap_size(multimap me);
int multimap_is_empty(multimap me); bk_bool multimap_is_empty(multimap me);
/* Accessing */ /* 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); 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); size_t multimap_count(multimap me, void *key);
int multimap_contains(multimap me, void *key); bk_bool multimap_contains(multimap me, void *key);
int multimap_remove(multimap me, void *key, void *value); bk_bool multimap_remove(multimap me, void *key, void *value);
int multimap_remove_all(multimap me, void *key); bk_bool multimap_remove_all(multimap me, void *key);
/* Ending */ /* Ending */
void multimap_clear(multimap me); void multimap_clear(multimap me);
@@ -262,8 +273,6 @@ multimap multimap_destroy(multimap me);
#ifndef BKTHOMPS_CONTAINERS_MULTISET_H #ifndef BKTHOMPS_CONTAINERS_MULTISET_H
#define BKTHOMPS_CONTAINERS_MULTISET_H #define BKTHOMPS_CONTAINERS_MULTISET_H
#include <stdlib.h>
/** /**
* The multiset data structure, which is a collection of key-value pairs, sorted * The multiset data structure, which is a collection of key-value pairs, sorted
* by keys, keys are unique * by keys, keys are unique
@@ -277,14 +286,14 @@ multiset multiset_init(size_t key_size,
/* Capacity */ /* Capacity */
size_t multiset_size(multiset me); size_t multiset_size(multiset me);
int multiset_is_empty(multiset me); bk_bool multiset_is_empty(multiset me);
/* Accessing */ /* Accessing */
int multiset_put(multiset me, void *key); bk_err multiset_put(multiset me, void *key);
size_t multiset_count(multiset me, void *key); size_t multiset_count(multiset me, void *key);
int multiset_contains(multiset me, void *key); bk_bool multiset_contains(multiset me, void *key);
int multiset_remove(multiset me, void *key); bk_bool multiset_remove(multiset me, void *key);
int multiset_remove_all(multiset me, void *key); bk_bool multiset_remove_all(multiset me, void *key);
/* Ending */ /* Ending */
void multiset_clear(multiset me); void multiset_clear(multiset me);
@@ -296,8 +305,6 @@ multiset multiset_destroy(multiset me);
#ifndef BKTHOMPS_CONTAINERS_PRIORITY_QUEUE_H #ifndef BKTHOMPS_CONTAINERS_PRIORITY_QUEUE_H
#define BKTHOMPS_CONTAINERS_PRIORITY_QUEUE_H #define BKTHOMPS_CONTAINERS_PRIORITY_QUEUE_H
#include <stdlib.h>
/** /**
* The priority_queue data structure, which adapts a container to provide a * The priority_queue data structure, which adapts a container to provide a
* priority queue. Adapts the vector container. * priority queue. Adapts the vector container.
@@ -311,19 +318,19 @@ priority_queue priority_queue_init(size_t data_size,
/* Utility */ /* Utility */
size_t priority_queue_size(priority_queue me); 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 */ /* Adding */
int priority_queue_push(priority_queue me, void *data); bk_err priority_queue_push(priority_queue me, void *data);
/* Removing */ /* Removing */
int priority_queue_pop(void *data, priority_queue me); bk_bool priority_queue_pop(void *data, priority_queue me);
/* Getting */ /* Getting */
int priority_queue_front(void *data, priority_queue me); bk_bool priority_queue_front(void *data, priority_queue me);
/* Ending */ /* Ending */
int priority_queue_clear(priority_queue me); bk_err priority_queue_clear(priority_queue me);
priority_queue priority_queue_destroy(priority_queue me); priority_queue priority_queue_destroy(priority_queue me);
#endif /* BKTHOMPS_CONTAINERS_PRIORITY_QUEUE_H */ #endif /* BKTHOMPS_CONTAINERS_PRIORITY_QUEUE_H */
@@ -332,8 +339,6 @@ priority_queue priority_queue_destroy(priority_queue me);
#ifndef BKTHOMPS_CONTAINERS_QUEUE_H #ifndef BKTHOMPS_CONTAINERS_QUEUE_H
#define BKTHOMPS_CONTAINERS_QUEUE_H #define BKTHOMPS_CONTAINERS_QUEUE_H
#include <stdlib.h>
/** /**
* The queue data structure, which adapts a container to provide a queue * The queue data structure, which adapts a container to provide a queue
* (first-in first-out). Adapts the deque container. * (first-in first-out). Adapts the deque container.
@@ -345,22 +350,22 @@ queue queue_init(size_t data_size);
/* Utility */ /* Utility */
size_t queue_size(queue me); size_t queue_size(queue me);
int queue_is_empty(queue me); bk_bool queue_is_empty(queue me);
int queue_trim(queue me); bk_err queue_trim(queue me);
void queue_copy_to_array(void *arr, queue me); void queue_copy_to_array(void *arr, queue me);
/* Adding */ /* Adding */
int queue_push(queue me, void *data); bk_err queue_push(queue me, void *data);
/* Removing */ /* Removing */
int queue_pop(void *data, queue me); bk_bool queue_pop(void *data, queue me);
/* Getting */ /* Getting */
int queue_front(void *data, queue me); bk_bool queue_front(void *data, queue me);
int queue_back(void *data, queue me); bk_bool queue_back(void *data, queue me);
/* Ending */ /* Ending */
int queue_clear(queue me); bk_err queue_clear(queue me);
queue queue_destroy(queue me); queue queue_destroy(queue me);
#endif /* BKTHOMPS_CONTAINERS_QUEUE_H */ #endif /* BKTHOMPS_CONTAINERS_QUEUE_H */
@@ -369,8 +374,6 @@ queue queue_destroy(queue me);
#ifndef BKTHOMPS_CONTAINERS_SET_H #ifndef BKTHOMPS_CONTAINERS_SET_H
#define BKTHOMPS_CONTAINERS_SET_H #define BKTHOMPS_CONTAINERS_SET_H
#include <stdlib.h>
/** /**
* The set data structure, which is a collection of unique keys, sorted by keys. * 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 */ /* Capacity */
size_t set_size(set me); size_t set_size(set me);
int set_is_empty(set me); bk_bool set_is_empty(set me);
/* Accessing */ /* Accessing */
int set_put(set me, void *key); bk_err set_put(set me, void *key);
int set_contains(set me, void *key); bk_bool set_contains(set me, void *key);
int set_remove(set me, void *key); bk_bool set_remove(set me, void *key);
/* Ending */ /* Ending */
void set_clear(set me); void set_clear(set me);
@@ -399,8 +402,6 @@ set set_destroy(set me);
#ifndef BKTHOMPS_CONTAINERS_STACK_H #ifndef BKTHOMPS_CONTAINERS_STACK_H
#define BKTHOMPS_CONTAINERS_STACK_H #define BKTHOMPS_CONTAINERS_STACK_H
#include <stdlib.h>
/** /**
* The stack data structure, which adapts a container to provide a stack * The stack data structure, which adapts a container to provide a stack
* (last-in first-out). Adapts the deque container. * (last-in first-out). Adapts the deque container.
@@ -412,21 +413,21 @@ stack stack_init(size_t data_size);
/* Utility */ /* Utility */
size_t stack_size(stack me); size_t stack_size(stack me);
int stack_is_empty(stack me); bk_bool stack_is_empty(stack me);
int stack_trim(stack me); bk_err stack_trim(stack me);
void stack_copy_to_array(void *arr, stack me); void stack_copy_to_array(void *arr, stack me);
/* Adding */ /* Adding */
int stack_push(stack me, void *data); bk_err stack_push(stack me, void *data);
/* Removing */ /* Removing */
int stack_pop(void *data, stack me); bk_bool stack_pop(void *data, stack me);
/* Getting */ /* Getting */
int stack_top(void *data, stack me); bk_bool stack_top(void *data, stack me);
/* Ending */ /* Ending */
int stack_clear(stack me); bk_err stack_clear(stack me);
stack stack_destroy(stack me); stack stack_destroy(stack me);
#endif /* BKTHOMPS_CONTAINERS_STACK_H */ #endif /* BKTHOMPS_CONTAINERS_STACK_H */
@@ -435,8 +436,6 @@ stack stack_destroy(stack me);
#ifndef BKTHOMPS_CONTAINERS_UNORDERED_MAP_H #ifndef BKTHOMPS_CONTAINERS_UNORDERED_MAP_H
#define BKTHOMPS_CONTAINERS_UNORDERED_MAP_H #define BKTHOMPS_CONTAINERS_UNORDERED_MAP_H
#include <stdlib.h>
/** /**
* The unordered_map data structure, which is a collection of key-value pairs, * The unordered_map data structure, which is a collection of key-value pairs,
* hashed by keys, keys are unique * hashed by keys, keys are unique
@@ -451,18 +450,18 @@ unordered_map unordered_map_init(size_t key_size,
const void *const two)); const void *const two));
/* Utility */ /* Utility */
int unordered_map_rehash(unordered_map me); bk_err unordered_map_rehash(unordered_map me);
size_t unordered_map_size(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 */ /* Accessing */
int unordered_map_put(unordered_map me, void *key, void *value); bk_err unordered_map_put(unordered_map me, void *key, void *value);
int unordered_map_get(void *value, unordered_map me, void *key); bk_bool unordered_map_get(void *value, unordered_map me, void *key);
int unordered_map_contains(unordered_map me, void *key); bk_bool unordered_map_contains(unordered_map me, void *key);
int unordered_map_remove(unordered_map me, void *key); bk_bool unordered_map_remove(unordered_map me, void *key);
/* Ending */ /* Ending */
int unordered_map_clear(unordered_map me); bk_err unordered_map_clear(unordered_map me);
unordered_map unordered_map_destroy(unordered_map me); unordered_map unordered_map_destroy(unordered_map me);
#endif /* BKTHOMPS_CONTAINERS_UNORDERED_MAP_H */ #endif /* BKTHOMPS_CONTAINERS_UNORDERED_MAP_H */
@@ -471,8 +470,6 @@ unordered_map unordered_map_destroy(unordered_map me);
#ifndef BKTHOMPS_CONTAINERS_UNORDERED_MULTIMAP_H #ifndef BKTHOMPS_CONTAINERS_UNORDERED_MULTIMAP_H
#define BKTHOMPS_CONTAINERS_UNORDERED_MULTIMAP_H #define BKTHOMPS_CONTAINERS_UNORDERED_MULTIMAP_H
#include <stdlib.h>
/** /**
* The unordered_multimap data structure, which is a collection of key-value * The unordered_multimap data structure, which is a collection of key-value
* pairs, hashed by keys. * pairs, hashed by keys.
@@ -490,21 +487,22 @@ unordered_multimap_init(size_t key_size,
const void *const two)); const void *const two));
/* Utility */ /* Utility */
int unordered_multimap_rehash(unordered_multimap me); bk_err unordered_multimap_rehash(unordered_multimap me);
size_t unordered_multimap_size(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 */ /* 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); void unordered_multimap_get_start(unordered_multimap me, void *key);
int unordered_multimap_get_next(void *value, unordered_multimap me); bk_bool unordered_multimap_get_next(void *value, unordered_multimap me);
int unordered_multimap_count(unordered_multimap me, void *key); size_t unordered_multimap_count(unordered_multimap me, void *key);
int unordered_multimap_contains(unordered_multimap me, void *key); bk_bool unordered_multimap_contains(unordered_multimap me, void *key);
int unordered_multimap_remove(unordered_multimap me, void *key, void *value); bk_bool unordered_multimap_remove(unordered_multimap me,
int unordered_multimap_remove_all(unordered_multimap me, void *key); void *key, void *value);
bk_bool unordered_multimap_remove_all(unordered_multimap me, void *key);
/* Ending */ /* Ending */
int unordered_multimap_clear(unordered_multimap me); bk_err unordered_multimap_clear(unordered_multimap me);
unordered_multimap unordered_multimap_destroy(unordered_multimap me); unordered_multimap unordered_multimap_destroy(unordered_multimap me);
#endif /* BKTHOMPS_CONTAINERS_UNORDERED_MULTIMAP_H */ #endif /* BKTHOMPS_CONTAINERS_UNORDERED_MULTIMAP_H */
@@ -513,8 +511,6 @@ unordered_multimap unordered_multimap_destroy(unordered_multimap me);
#ifndef BKTHOMPS_CONTAINERS_UNORDERED_MULTISET_H #ifndef BKTHOMPS_CONTAINERS_UNORDERED_MULTISET_H
#define BKTHOMPS_CONTAINERS_UNORDERED_MULTISET_H #define BKTHOMPS_CONTAINERS_UNORDERED_MULTISET_H
#include <stdlib.h>
/** /**
* The unordered_multiset data structure, which is a collection of keys, hashed * The unordered_multiset data structure, which is a collection of keys, hashed
* by keys. * by keys.
@@ -529,19 +525,19 @@ unordered_multiset_init(size_t key_size,
const void *const two)); const void *const two));
/* Utility */ /* Utility */
int unordered_multiset_rehash(unordered_multiset me); bk_err unordered_multiset_rehash(unordered_multiset me);
size_t unordered_multiset_size(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 */ /* 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); size_t unordered_multiset_count(unordered_multiset me, void *key);
int unordered_multiset_contains(unordered_multiset me, void *key); bk_bool unordered_multiset_contains(unordered_multiset me, void *key);
int unordered_multiset_remove(unordered_multiset me, void *key); bk_bool unordered_multiset_remove(unordered_multiset me, void *key);
int unordered_multiset_remove_all(unordered_multiset me, void *key); bk_bool unordered_multiset_remove_all(unordered_multiset me, void *key);
/* Ending */ /* Ending */
int unordered_multiset_clear(unordered_multiset me); bk_err unordered_multiset_clear(unordered_multiset me);
unordered_multiset unordered_multiset_destroy(unordered_multiset me); unordered_multiset unordered_multiset_destroy(unordered_multiset me);
#endif /* BKTHOMPS_CONTAINERS_UNORDERED_MULTISET_H */ #endif /* BKTHOMPS_CONTAINERS_UNORDERED_MULTISET_H */
@@ -550,8 +546,6 @@ unordered_multiset unordered_multiset_destroy(unordered_multiset me);
#ifndef BKTHOMPS_CONTAINERS_UNORDERED_SET_H #ifndef BKTHOMPS_CONTAINERS_UNORDERED_SET_H
#define BKTHOMPS_CONTAINERS_UNORDERED_SET_H #define BKTHOMPS_CONTAINERS_UNORDERED_SET_H
#include <stdlib.h>
/** /**
* The unordered_set data structure, which is a collection of unique keys, * The unordered_set data structure, which is a collection of unique keys,
* hashed by keys. * hashed by keys.
@@ -565,17 +559,17 @@ unordered_set unordered_set_init(size_t key_size,
const void *const two)); const void *const two));
/* Utility */ /* Utility */
int unordered_set_rehash(unordered_set me); bk_err unordered_set_rehash(unordered_set me);
size_t unordered_set_size(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 */ /* Accessing */
int unordered_set_put(unordered_set me, void *key); bk_err unordered_set_put(unordered_set me, void *key);
int unordered_set_contains(unordered_set me, void *key); bk_bool unordered_set_contains(unordered_set me, void *key);
int unordered_set_remove(unordered_set me, void *key); bk_bool unordered_set_remove(unordered_set me, void *key);
/* Ending */ /* Ending */
int unordered_set_clear(unordered_set me); bk_err unordered_set_clear(unordered_set me);
unordered_set unordered_set_destroy(unordered_set me); unordered_set unordered_set_destroy(unordered_set me);
#endif /* BKTHOMPS_CONTAINERS_UNORDERED_SET_H */ #endif /* BKTHOMPS_CONTAINERS_UNORDERED_SET_H */
@@ -584,8 +578,6 @@ unordered_set unordered_set_destroy(unordered_set me);
#ifndef BKTHOMPS_CONTAINERS_VECTOR_H #ifndef BKTHOMPS_CONTAINERS_VECTOR_H
#define BKTHOMPS_CONTAINERS_VECTOR_H #define BKTHOMPS_CONTAINERS_VECTOR_H
#include <stdlib.h>
/** /**
* The vector data structure, which is a dynamic contiguous array. * The vector data structure, which is a dynamic contiguous array.
*/ */
@@ -597,34 +589,34 @@ vector vector_init(size_t data_size);
/* Utility */ /* Utility */
size_t vector_size(vector me); size_t vector_size(vector me);
size_t vector_capacity(vector me); size_t vector_capacity(vector me);
int vector_is_empty(vector me); bk_bool vector_is_empty(vector me);
int vector_reserve(vector me, size_t size); bk_err vector_reserve(vector me, size_t size);
int vector_trim(vector me); bk_err vector_trim(vector me);
void vector_copy_to_array(void *arr, vector me); void vector_copy_to_array(void *arr, vector me);
void *vector_get_data(vector me); void *vector_get_data(vector me);
/* Adding */ /* Adding */
int vector_add_first(vector me, void *data); bk_err vector_add_first(vector me, void *data);
int vector_add_at(vector me, size_t index, void *data); bk_err vector_add_at(vector me, size_t index, void *data);
int vector_add_last(vector me, void *data); bk_err vector_add_last(vector me, void *data);
/* Removing */ /* Removing */
int vector_remove_first(vector me); bk_err vector_remove_first(vector me);
int vector_remove_at(vector me, size_t index); bk_err vector_remove_at(vector me, size_t index);
int vector_remove_last(vector me); bk_err vector_remove_last(vector me);
/* Setting */ /* Setting */
int vector_set_first(vector me, void *data); bk_err vector_set_first(vector me, void *data);
int vector_set_at(vector me, size_t index, void *data); bk_err vector_set_at(vector me, size_t index, void *data);
int vector_set_last(vector me, void *data); bk_err vector_set_last(vector me, void *data);
/* Getting */ /* Getting */
int vector_get_first(void *data, vector me); bk_err vector_get_first(void *data, vector me);
int vector_get_at(void *data, vector me, size_t index); bk_err vector_get_at(void *data, vector me, size_t index);
int vector_get_last(void *data, vector me); bk_err vector_get_last(void *data, vector me);
/* Ending */ /* Ending */
int vector_clear(vector me); bk_err vector_clear(vector me);
vector vector_destroy(vector me); vector vector_destroy(vector me);
#endif /* BKTHOMPS_CONTAINERS_VECTOR_H */ #endif /* BKTHOMPS_CONTAINERS_VECTOR_H */

7
documentation.md
View File

@@ -61,10 +61,10 @@ int):
deque d = deque_init(sizeof(int)); deque d = deque_init(sizeof(int));
... ...
int add = 5; 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 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 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 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 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 # Comparators and Hash Functions
The associative containers and the priority queue require the user to initialize The associative containers and the priority queue require the user to initialize

23
src/array.c
View File

@@ -21,7 +21,6 @@
*/ */
#include <string.h> #include <string.h>
#include <errno.h>
#include "include/array.h" #include "include/array.h"
static const size_t book_keeping_size = sizeof(size_t); 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 * 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 * cause the array structure data to be modified. Operations using the array
* functions may invalidate this pointer. The array owns this memory, thus it * 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 * @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 index the location to set data at in the array
* @param data the data to set at the location in the array * @param data the data to set at the location in the array
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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 element_count;
size_t data_size; size_t data_size;
memcpy(&element_count, me + arr_size_offset, book_keeping_size); memcpy(&element_count, me + arr_size_offset, book_keeping_size);
if (index >= element_count) { if (index >= element_count) {
return -EINVAL; return -BK_EINVAL;
} }
memcpy(&data_size, me + data_size_offset, book_keeping_size); memcpy(&data_size, me + data_size_offset, book_keeping_size);
memcpy(me + data_ptr_offset + index * data_size, data, data_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 me the array to copy from
* @param index the index to copy from in the array * @param index the index to copy from in the array
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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 element_count;
size_t data_size; size_t data_size;
memcpy(&element_count, me + arr_size_offset, book_keeping_size); memcpy(&element_count, me + arr_size_offset, book_keeping_size);
if (index >= element_count) { if (index >= element_count) {
return -EINVAL; return -BK_EINVAL;
} }
memcpy(&data_size, me + data_size_offset, book_keeping_size); memcpy(&data_size, me + data_size_offset, book_keeping_size);
memcpy(data, me + data_ptr_offset + index * data_size, data_size); memcpy(data, me + data_ptr_offset + index * data_size, data_size);
return 0; return BK_OK;
} }
/** /**

115
src/deque.c
View File

@@ -21,7 +21,6 @@
*/ */
#include <string.h> #include <string.h>
#include <errno.h>
#include "include/deque.h" #include "include/deque.h"
#define BKTHOMPS_DEQUE_MAX_BLOCK_BYTE_SIZE 4096 #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 * @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; return deque_size(me) == 0;
} }
@@ -115,10 +114,10 @@ int deque_is_empty(deque me)
* *
* @param me the deque to trim * @param me the deque to trim
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @return -BK_ENOMEM if out of memory
*/ */
int deque_trim(deque me) bk_err deque_trim(deque me)
{ {
size_t i; size_t i;
const size_t start_block_index = me->start_index / me->block_size; 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; const size_t updated_block_count = end_block_index - start_block_index + 1;
char **updated_data = malloc(updated_block_count * sizeof(char *)); char **updated_data = malloc(updated_block_count * sizeof(char *));
if (!updated_data) { if (!updated_data) {
return -ENOMEM; return -BK_ENOMEM;
} }
memcpy(updated_data, me->data + start_block_index, memcpy(updated_data, me->data + start_block_index,
updated_block_count * sizeof(char *)); updated_block_count * sizeof(char *));
@@ -146,7 +145,7 @@ int deque_trim(deque me)
me->end_index -= start_block_index * me->block_size; me->end_index -= start_block_index * me->block_size;
me->block_count = updated_block_count; me->block_count = updated_block_count;
me->data = updated_data; 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 me the deque to add an element to
* @param data the element to add * @param data the element to add
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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) { if (me->start_index == 0) {
const size_t updated_block_count = 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; const size_t added_blocks = updated_block_count - me->block_count;
char **temp = realloc(me->data, updated_block_count * sizeof(char *)); char **temp = realloc(me->data, updated_block_count * sizeof(char *));
if (!temp) { if (!temp) {
return -ENOMEM; return -BK_ENOMEM;
} }
memmove(temp + added_blocks, temp, me->block_count * sizeof(char *)); memmove(temp + added_blocks, temp, me->block_count * sizeof(char *));
memset(temp, 0, added_blocks * sizeof(char *)); memset(temp, 0, added_blocks * sizeof(char *));
@@ -229,7 +228,7 @@ int deque_push_front(deque me, void *const data)
if (!block) { if (!block) {
block = malloc(me->block_size * me->data_size); block = malloc(me->block_size * me->data_size);
if (!block) { if (!block) {
return -ENOMEM; return -BK_ENOMEM;
} }
memcpy(me->data + previous_block_index, &block, sizeof(char *)); 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, me->data + block_index, sizeof(char *));
memcpy(block + inner_index * me->data_size, data, me->data_size); 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 me the deque to add an element to
* @param data the element to add * @param data the element to add
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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) { if (me->end_index == me->block_count * me->block_size) {
const size_t updated_block_count = 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; const size_t added_blocks = updated_block_count - me->block_count;
char **temp = realloc(me->data, updated_block_count * sizeof(char *)); char **temp = realloc(me->data, updated_block_count * sizeof(char *));
if (!temp) { if (!temp) {
return -ENOMEM; return -BK_ENOMEM;
} }
memset(temp + me->block_count, 0, added_blocks * sizeof(char *)); memset(temp + me->block_count, 0, added_blocks * sizeof(char *));
me->data = temp; me->data = temp;
@@ -279,7 +278,7 @@ int deque_push_back(deque me, void *const data)
if (!block) { if (!block) {
block = malloc(me->block_size * me->data_size); block = malloc(me->block_size * me->data_size);
if (!block) { if (!block) {
return -ENOMEM; return -BK_ENOMEM;
} }
memcpy(me->data + tentative_block_index, &block, sizeof(char *)); 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); memcpy(block + inner_index * me->data_size, data, me->data_size);
} }
me->end_index++; 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 data the value to copy to
* @param me the deque to remove from * @param me the deque to remove from
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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; char *block;
const size_t block_index = me->start_index / me->block_size; const size_t block_index = me->start_index / me->block_size;
const size_t inner_index = me->start_index % me->block_size; const size_t inner_index = me->start_index % me->block_size;
if (deque_is_empty(me)) { if (deque_is_empty(me)) {
return -EINVAL; return -BK_EINVAL;
} }
memcpy(&block, me->data + block_index, sizeof(char *)); memcpy(&block, me->data + block_index, sizeof(char *));
memcpy(data, block + inner_index * me->data_size, me->data_size); memcpy(data, block + inner_index * me->data_size, me->data_size);
me->start_index++; 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 data the value to copy to
* @param me the deque to remove from * @param me the deque to remove from
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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; char *block;
const size_t block_index = (me->end_index - 1) / me->block_size; const size_t block_index = (me->end_index - 1) / me->block_size;
const size_t inner_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)) { if (deque_is_empty(me)) {
return -EINVAL; return -BK_EINVAL;
} }
memcpy(&block, me->data + block_index, sizeof(char *)); memcpy(&block, me->data + block_index, sizeof(char *));
memcpy(data, block + inner_index * me->data_size, me->data_size); memcpy(data, block + inner_index * me->data_size, me->data_size);
me->end_index--; 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 me the deque to set the value of
* @param data the data to set * @param data the data to set
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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); 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 index the index to set at
* @param data the data to set * @param data the data to set
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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; char *block;
const size_t block_index = (index + me->start_index) / me->block_size; const size_t block_index = (index + me->start_index) / me->block_size;
const size_t inner_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)) { if (index >= deque_size(me)) {
return -EINVAL; return -BK_EINVAL;
} }
memcpy(&block, me->data + block_index, sizeof(char *)); memcpy(&block, me->data + block_index, sizeof(char *));
memcpy(block + inner_index * me->data_size, data, me->data_size); 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 me the deque to set the value of
* @param data the data to set * @param data the data to set
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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); 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 data the data to set
* @param me the deque to set the value of * @param me the deque to set the value of
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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); 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 me the deque to set the value of
* @param index the index to set at * @param index the index to set at
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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; char *block;
const size_t block_index = (index + me->start_index) / me->block_size; const size_t block_index = (index + me->start_index) / me->block_size;
const size_t inner_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)) { if (index >= deque_size(me)) {
return -EINVAL; return -BK_EINVAL;
} }
memcpy(&block, me->data + block_index, sizeof(char *)); memcpy(&block, me->data + block_index, sizeof(char *));
memcpy(data, block + inner_index * me->data_size, me->data_size); 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 data the data to set
* @param me the deque to set the value of * @param me the deque to set the value of
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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); 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 * @param me the deque to clear
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @return -BK_ENOMEM if out of memory
*/ */
int deque_clear(deque me) bk_err deque_clear(deque me)
{ {
size_t i; size_t i;
char *updated_block; char *updated_block;
char **updated_data = calloc(BKTHOMPS_DEQUE_INITIAL_BLOCK_COUNT, char **updated_data = calloc(BKTHOMPS_DEQUE_INITIAL_BLOCK_COUNT,
sizeof(char *)); sizeof(char *));
if (!updated_data) { if (!updated_data) {
return -ENOMEM; return -BK_ENOMEM;
} }
updated_block = malloc(me->block_size * me->data_size); updated_block = malloc(me->block_size * me->data_size);
if (!updated_block) { if (!updated_block) {
free(updated_data); free(updated_data);
return -ENOMEM; return -BK_ENOMEM;
} }
for (i = 0; i < me->block_count; i++) { for (i = 0; i < me->block_count; i++) {
char *block; char *block;
@@ -511,7 +510,7 @@ int deque_clear(deque me)
me->data = updated_data; me->data = updated_data;
memcpy(me->data + me->start_index / me->block_size, &updated_block, memcpy(me->data + me->start_index / me->block_size, &updated_block,
sizeof(char *)); sizeof(char *));
return 0; return BK_OK;
} }
/** /**

100
src/forward_list.c
View File

@@ -21,7 +21,6 @@
*/ */
#include <string.h> #include <string.h>
#include <errno.h>
#include "include/forward_list.h" #include "include/forward_list.h"
struct internal_forward_list { struct internal_forward_list {
@@ -78,9 +77,9 @@ size_t forward_list_size(forward_list me)
* *
* @param me the singly-linked list to check * @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; 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 me the singly-linked list to add data to
* @param data the data to add to the singly-linked list * @param data the data to add to the singly-linked list
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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); 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 index the index to add the data at
* @param data the data to add to the singly-linked list * @param data the data to add to the singly-linked list
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @return -BK_ENOMEM if out of memory
* @return -EINVAL if invalid argument * @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; char *node;
if (index > me->item_count) { if (index > me->item_count) {
return -EINVAL; return -BK_EINVAL;
} }
node = malloc(ptr_size + me->bytes_per_item); node = malloc(ptr_size + me->bytes_per_item);
if (!node) { if (!node) {
return -ENOMEM; return -BK_ENOMEM;
} }
memcpy(node + node_data_ptr_offset, data, me->bytes_per_item); memcpy(node + node_data_ptr_offset, data, me->bytes_per_item);
if (index == 0) { 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++; 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 me the singly-linked list to add data to
* @param data the data to add to the singly-linked list * @param data the data to add to the singly-linked list
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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); 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 * @param me the singly-linked list to remove data from
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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); 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 me the singly-linked list to remove data from
* @param index the index to remove from * @param index the index to remove from
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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) { if (index >= me->item_count) {
return -EINVAL; return -BK_EINVAL;
} }
if (index == 0) { if (index == 0) {
char *temp = me->head; char *temp = me->head;
@@ -257,7 +257,7 @@ int forward_list_remove_at(forward_list me, const size_t index)
free(backup); free(backup);
} }
me->item_count--; 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 * @param me the singly-linked list to remove data from
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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); 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 me the singly-linked list to set data for
* @param data the data to set in the singly-linked list * @param data the data to set in the singly-linked list
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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); 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 index the index to set data in the singly-linked list
* @param data the data to set in the singly-linked list * @param data the data to set in the singly-linked list
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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; char *traverse;
if (index >= me->item_count) { if (index >= me->item_count) {
return -EINVAL; return -BK_EINVAL;
} }
traverse = forward_list_get_node_at(me, index); traverse = forward_list_get_node_at(me, index);
memcpy(traverse + node_data_ptr_offset, data, me->bytes_per_item); 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 me the singly-linked list to set data for
* @param data the data to set in the singly-linked list * @param data the data to set in the singly-linked list
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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); 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 data the data to get
* @param me the singly-linked list to get data from * @param me the singly-linked list to get data from
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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); 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 me the singly-linked list to get data from
* @param index the index to get data from * @param index the index to get data from
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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; char *traverse;
if (index >= me->item_count) { if (index >= me->item_count) {
return -EINVAL; return -BK_EINVAL;
} }
traverse = forward_list_get_node_at(me, index); traverse = forward_list_get_node_at(me, index);
memcpy(data, traverse + node_data_ptr_offset, me->bytes_per_item); 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 data the data to get
* @param me the singly-linked list to get data from * @param me the singly-linked list to get data from
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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); return forward_list_get_at(data, me, me->item_count - 1);
} }

43
src/include/all.h Normal file
View File

@@ -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 <stdlib.h>
/*
* Cannot use <errno.h> 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 <stdbool.h> 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 */

6
src/include/array.h
View File

@@ -23,7 +23,7 @@
#ifndef BKTHOMPS_CONTAINERS_ARRAY_H #ifndef BKTHOMPS_CONTAINERS_ARRAY_H
#define BKTHOMPS_CONTAINERS_ARRAY_H #define BKTHOMPS_CONTAINERS_ARRAY_H
#include <stdlib.h> #include "all.h"
/** /**
* The array data structure, which is a static contiguous array. * 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); void *array_get_data(array me);
/* Accessing */ /* Accessing */
int array_set(array me, size_t index, void *data); bk_err array_set(array me, size_t index, void *data);
int array_get(void *data, array me, size_t index); bk_err array_get(void *data, array me, size_t index);
/* Ending */ /* Ending */
array array_destroy(array me); array array_destroy(array me);

28
src/include/deque.h
View File

@@ -23,7 +23,7 @@
#ifndef BKTHOMPS_CONTAINERS_DEQUE_H #ifndef BKTHOMPS_CONTAINERS_DEQUE_H
#define BKTHOMPS_CONTAINERS_DEQUE_H #define BKTHOMPS_CONTAINERS_DEQUE_H
#include <stdlib.h> #include "all.h"
/** /**
* The deque data structure, which is a doubly-ended queue. * The deque data structure, which is a doubly-ended queue.
@@ -35,30 +35,30 @@ deque deque_init(size_t data_size);
/* Utility */ /* Utility */
size_t deque_size(deque me); size_t deque_size(deque me);
int deque_is_empty(deque me); bk_bool deque_is_empty(deque me);
int deque_trim(deque me); bk_err deque_trim(deque me);
void deque_copy_to_array(void *arr, deque me); void deque_copy_to_array(void *arr, deque me);
/* Adding */ /* Adding */
int deque_push_front(deque me, void *data); bk_err deque_push_front(deque me, void *data);
int deque_push_back(deque me, void *data); bk_err deque_push_back(deque me, void *data);
/* Removing */ /* Removing */
int deque_pop_front(void *data, deque me); bk_err deque_pop_front(void *data, deque me);
int deque_pop_back(void *data, deque me); bk_err deque_pop_back(void *data, deque me);
/* Setting */ /* Setting */
int deque_set_first(deque me, void *data); bk_err deque_set_first(deque me, void *data);
int deque_set_at(deque me, size_t index, void *data); bk_err deque_set_at(deque me, size_t index, void *data);
int deque_set_last(deque me, void *data); bk_err deque_set_last(deque me, void *data);
/* Getting */ /* Getting */
int deque_get_first(void *data, deque me); bk_err deque_get_first(void *data, deque me);
int deque_get_at(void *data, deque me, size_t index); bk_err deque_get_at(void *data, deque me, size_t index);
int deque_get_last(void *data, deque me); bk_err deque_get_last(void *data, deque me);
/* Ending */ /* Ending */
int deque_clear(deque me); bk_err deque_clear(deque me);
deque deque_destroy(deque me); deque deque_destroy(deque me);
#endif /* BKTHOMPS_CONTAINERS_DEQUE_H */ #endif /* BKTHOMPS_CONTAINERS_DEQUE_H */

28
src/include/forward_list.h
View File

@@ -23,7 +23,7 @@
#ifndef BKTHOMPS_CONTAINERS_FORWARD_LIST_H #ifndef BKTHOMPS_CONTAINERS_FORWARD_LIST_H
#define BKTHOMPS_CONTAINERS_FORWARD_LIST_H #define BKTHOMPS_CONTAINERS_FORWARD_LIST_H
#include <stdlib.h> #include "all.h"
/** /**
* The forward_list data structure, which is a singly-linked list. * 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 */ /* Utility */
size_t forward_list_size(forward_list me); 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); void forward_list_copy_to_array(void *arr, forward_list me);
/* Adding */ /* Adding */
int forward_list_add_first(forward_list me, void *data); bk_err forward_list_add_first(forward_list me, void *data);
int forward_list_add_at(forward_list me, size_t index, void *data); bk_err 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_last(forward_list me, void *data);
/* Removing */ /* Removing */
int forward_list_remove_first(forward_list me); bk_err forward_list_remove_first(forward_list me);
int forward_list_remove_at(forward_list me, size_t index); bk_err forward_list_remove_at(forward_list me, size_t index);
int forward_list_remove_last(forward_list me); bk_err forward_list_remove_last(forward_list me);
/* Setting */ /* Setting */
int forward_list_set_first(forward_list me, void *data); bk_err forward_list_set_first(forward_list me, void *data);
int forward_list_set_at(forward_list me, size_t index, void *data); bk_err 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_last(forward_list me, void *data);
/* Getting */ /* Getting */
int forward_list_get_first(void *data, forward_list me); bk_err forward_list_get_first(void *data, forward_list me);
int forward_list_get_at(void *data, forward_list me, size_t index); bk_err 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_last(void *data, forward_list me);
/* Ending */ /* Ending */
void forward_list_clear(forward_list me); void forward_list_clear(forward_list me);

28
src/include/list.h
View File

@@ -23,7 +23,7 @@
#ifndef BKTHOMPS_CONTAINERS_LIST_H #ifndef BKTHOMPS_CONTAINERS_LIST_H
#define BKTHOMPS_CONTAINERS_LIST_H #define BKTHOMPS_CONTAINERS_LIST_H
#include <stdlib.h> #include "all.h"
/** /**
* The list data structure, which is a doubly-linked list. * The list data structure, which is a doubly-linked list.
@@ -35,28 +35,28 @@ list list_init(size_t data_size);
/* Utility */ /* Utility */
size_t list_size(list me); 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); void list_copy_to_array(void *arr, list me);
/* Adding */ /* Adding */
int list_add_first(list me, void *data); bk_err list_add_first(list me, void *data);
int list_add_at(list me, size_t index, void *data); bk_err list_add_at(list me, size_t index, void *data);
int list_add_last(list me, void *data); bk_err list_add_last(list me, void *data);
/* Removing */ /* Removing */
int list_remove_first(list me); bk_err list_remove_first(list me);
int list_remove_at(list me, size_t index); bk_err list_remove_at(list me, size_t index);
int list_remove_last(list me); bk_err list_remove_last(list me);
/* Setting */ /* Setting */
int list_set_first(list me, void *data); bk_err list_set_first(list me, void *data);
int list_set_at(list me, size_t index, void *data); bk_err list_set_at(list me, size_t index, void *data);
int list_set_last(list me, void *data); bk_err list_set_last(list me, void *data);
/* Getting */ /* Getting */
int list_get_first(void *data, list me); bk_err list_get_first(void *data, list me);
int list_get_at(void *data, list me, size_t index); bk_err list_get_at(void *data, list me, size_t index);
int list_get_last(void *data, list me); bk_err list_get_last(void *data, list me);
/* Ending */ /* Ending */
void list_clear(list me); void list_clear(list me);

12
src/include/map.h
View File

@@ -23,7 +23,7 @@
#ifndef BKTHOMPS_CONTAINERS_MAP_H #ifndef BKTHOMPS_CONTAINERS_MAP_H
#define BKTHOMPS_CONTAINERS_MAP_H #define BKTHOMPS_CONTAINERS_MAP_H
#include <stdlib.h> #include "all.h"
/** /**
* The map data structure, which is a collection of key-value pairs, sorted by * 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 */ /* Capacity */
size_t map_size(map me); size_t map_size(map me);
int map_is_empty(map me); bk_bool map_is_empty(map me);
/* Accessing */ /* Accessing */
int map_put(map me, void *key, void *value); bk_err map_put(map me, void *key, void *value);
int map_get(void *value, map me, void *key); bk_bool map_get(void *value, map me, void *key);
int map_contains(map me, void *key); bk_bool map_contains(map me, void *key);
int map_remove(map me, void *key); bk_bool map_remove(map me, void *key);
/* Ending */ /* Ending */
void map_clear(map me); void map_clear(map me);

14
src/include/multimap.h
View File

@@ -23,7 +23,7 @@
#ifndef BKTHOMPS_CONTAINERS_MULTIMAP_H #ifndef BKTHOMPS_CONTAINERS_MULTIMAP_H
#define BKTHOMPS_CONTAINERS_MULTIMAP_H #define BKTHOMPS_CONTAINERS_MULTIMAP_H
#include <stdlib.h> #include "all.h"
/** /**
* The multimap data structure, which is a collection of key-value pairs, sorted * 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 */ /* Capacity */
size_t multimap_size(multimap me); size_t multimap_size(multimap me);
int multimap_is_empty(multimap me); bk_bool multimap_is_empty(multimap me);
/* Accessing */ /* 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); 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); size_t multimap_count(multimap me, void *key);
int multimap_contains(multimap me, void *key); bk_bool multimap_contains(multimap me, void *key);
int multimap_remove(multimap me, void *key, void *value); bk_bool multimap_remove(multimap me, void *key, void *value);
int multimap_remove_all(multimap me, void *key); bk_bool multimap_remove_all(multimap me, void *key);
/* Ending */ /* Ending */
void multimap_clear(multimap me); void multimap_clear(multimap me);

12
src/include/multiset.h
View File

@@ -23,7 +23,7 @@
#ifndef BKTHOMPS_CONTAINERS_MULTISET_H #ifndef BKTHOMPS_CONTAINERS_MULTISET_H
#define BKTHOMPS_CONTAINERS_MULTISET_H #define BKTHOMPS_CONTAINERS_MULTISET_H
#include <stdlib.h> #include "all.h"
/** /**
* The multiset data structure, which is a collection of key-value pairs, sorted * 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 */ /* Capacity */
size_t multiset_size(multiset me); size_t multiset_size(multiset me);
int multiset_is_empty(multiset me); bk_bool multiset_is_empty(multiset me);
/* Accessing */ /* Accessing */
int multiset_put(multiset me, void *key); bk_err multiset_put(multiset me, void *key);
size_t multiset_count(multiset me, void *key); size_t multiset_count(multiset me, void *key);
int multiset_contains(multiset me, void *key); bk_bool multiset_contains(multiset me, void *key);
int multiset_remove(multiset me, void *key); bk_bool multiset_remove(multiset me, void *key);
int multiset_remove_all(multiset me, void *key); bk_bool multiset_remove_all(multiset me, void *key);
/* Ending */ /* Ending */
void multiset_clear(multiset me); void multiset_clear(multiset me);

12
src/include/priority_queue.h
View File

@@ -23,7 +23,7 @@
#ifndef BKTHOMPS_CONTAINERS_PRIORITY_QUEUE_H #ifndef BKTHOMPS_CONTAINERS_PRIORITY_QUEUE_H
#define BKTHOMPS_CONTAINERS_PRIORITY_QUEUE_H #define BKTHOMPS_CONTAINERS_PRIORITY_QUEUE_H
#include <stdlib.h> #include "all.h"
/** /**
* The priority_queue data structure, which adapts a container to provide a * 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 */ /* Utility */
size_t priority_queue_size(priority_queue me); 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 */ /* Adding */
int priority_queue_push(priority_queue me, void *data); bk_err priority_queue_push(priority_queue me, void *data);
/* Removing */ /* Removing */
int priority_queue_pop(void *data, priority_queue me); bk_bool priority_queue_pop(void *data, priority_queue me);
/* Getting */ /* Getting */
int priority_queue_front(void *data, priority_queue me); bk_bool priority_queue_front(void *data, priority_queue me);
/* Ending */ /* Ending */
int priority_queue_clear(priority_queue me); bk_err priority_queue_clear(priority_queue me);
priority_queue priority_queue_destroy(priority_queue me); priority_queue priority_queue_destroy(priority_queue me);
#endif /* BKTHOMPS_CONTAINERS_PRIORITY_QUEUE_H */ #endif /* BKTHOMPS_CONTAINERS_PRIORITY_QUEUE_H */

16
src/include/queue.h
View File

@@ -23,7 +23,7 @@
#ifndef BKTHOMPS_CONTAINERS_QUEUE_H #ifndef BKTHOMPS_CONTAINERS_QUEUE_H
#define BKTHOMPS_CONTAINERS_QUEUE_H #define BKTHOMPS_CONTAINERS_QUEUE_H
#include <stdlib.h> #include "all.h"
/** /**
* The queue data structure, which adapts a container to provide a queue * The queue data structure, which adapts a container to provide a queue
@@ -36,22 +36,22 @@ queue queue_init(size_t data_size);
/* Utility */ /* Utility */
size_t queue_size(queue me); size_t queue_size(queue me);
int queue_is_empty(queue me); bk_bool queue_is_empty(queue me);
int queue_trim(queue me); bk_err queue_trim(queue me);
void queue_copy_to_array(void *arr, queue me); void queue_copy_to_array(void *arr, queue me);
/* Adding */ /* Adding */
int queue_push(queue me, void *data); bk_err queue_push(queue me, void *data);
/* Removing */ /* Removing */
int queue_pop(void *data, queue me); bk_bool queue_pop(void *data, queue me);
/* Getting */ /* Getting */
int queue_front(void *data, queue me); bk_bool queue_front(void *data, queue me);
int queue_back(void *data, queue me); bk_bool queue_back(void *data, queue me);
/* Ending */ /* Ending */
int queue_clear(queue me); bk_err queue_clear(queue me);
queue queue_destroy(queue me); queue queue_destroy(queue me);
#endif /* BKTHOMPS_CONTAINERS_QUEUE_H */ #endif /* BKTHOMPS_CONTAINERS_QUEUE_H */

10
src/include/set.h
View File

@@ -23,7 +23,7 @@
#ifndef BKTHOMPS_CONTAINERS_SET_H #ifndef BKTHOMPS_CONTAINERS_SET_H
#define BKTHOMPS_CONTAINERS_SET_H #define BKTHOMPS_CONTAINERS_SET_H
#include <stdlib.h> #include "all.h"
/** /**
* The set data structure, which is a collection of unique keys, sorted by keys. * 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 */ /* Capacity */
size_t set_size(set me); size_t set_size(set me);
int set_is_empty(set me); bk_bool set_is_empty(set me);
/* Accessing */ /* Accessing */
int set_put(set me, void *key); bk_err set_put(set me, void *key);
int set_contains(set me, void *key); bk_bool set_contains(set me, void *key);
int set_remove(set me, void *key); bk_bool set_remove(set me, void *key);
/* Ending */ /* Ending */
void set_clear(set me); void set_clear(set me);

14
src/include/stack.h
View File

@@ -23,7 +23,7 @@
#ifndef BKTHOMPS_CONTAINERS_STACK_H #ifndef BKTHOMPS_CONTAINERS_STACK_H
#define BKTHOMPS_CONTAINERS_STACK_H #define BKTHOMPS_CONTAINERS_STACK_H
#include <stdlib.h> #include "all.h"
/** /**
* The stack data structure, which adapts a container to provide a stack * The stack data structure, which adapts a container to provide a stack
@@ -36,21 +36,21 @@ stack stack_init(size_t data_size);
/* Utility */ /* Utility */
size_t stack_size(stack me); size_t stack_size(stack me);
int stack_is_empty(stack me); bk_bool stack_is_empty(stack me);
int stack_trim(stack me); bk_err stack_trim(stack me);
void stack_copy_to_array(void *arr, stack me); void stack_copy_to_array(void *arr, stack me);
/* Adding */ /* Adding */
int stack_push(stack me, void *data); bk_err stack_push(stack me, void *data);
/* Removing */ /* Removing */
int stack_pop(void *data, stack me); bk_bool stack_pop(void *data, stack me);
/* Getting */ /* Getting */
int stack_top(void *data, stack me); bk_bool stack_top(void *data, stack me);
/* Ending */ /* Ending */
int stack_clear(stack me); bk_err stack_clear(stack me);
stack stack_destroy(stack me); stack stack_destroy(stack me);
#endif /* BKTHOMPS_CONTAINERS_STACK_H */ #endif /* BKTHOMPS_CONTAINERS_STACK_H */

16
src/include/unordered_map.h
View File

@@ -23,7 +23,7 @@
#ifndef BKTHOMPS_CONTAINERS_UNORDERED_MAP_H #ifndef BKTHOMPS_CONTAINERS_UNORDERED_MAP_H
#define BKTHOMPS_CONTAINERS_UNORDERED_MAP_H #define BKTHOMPS_CONTAINERS_UNORDERED_MAP_H
#include <stdlib.h> #include "all.h"
/** /**
* The unordered_map data structure, which is a collection of key-value pairs, * 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)); const void *const two));
/* Utility */ /* Utility */
int unordered_map_rehash(unordered_map me); bk_err unordered_map_rehash(unordered_map me);
size_t unordered_map_size(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 */ /* Accessing */
int unordered_map_put(unordered_map me, void *key, void *value); bk_err unordered_map_put(unordered_map me, void *key, void *value);
int unordered_map_get(void *value, unordered_map me, void *key); bk_bool unordered_map_get(void *value, unordered_map me, void *key);
int unordered_map_contains(unordered_map me, void *key); bk_bool unordered_map_contains(unordered_map me, void *key);
int unordered_map_remove(unordered_map me, void *key); bk_bool unordered_map_remove(unordered_map me, void *key);
/* Ending */ /* Ending */
int unordered_map_clear(unordered_map me); bk_err unordered_map_clear(unordered_map me);
unordered_map unordered_map_destroy(unordered_map me); unordered_map unordered_map_destroy(unordered_map me);
#endif /* BKTHOMPS_CONTAINERS_UNORDERED_MAP_H */ #endif /* BKTHOMPS_CONTAINERS_UNORDERED_MAP_H */

21
src/include/unordered_multimap.h
View File

@@ -23,7 +23,7 @@
#ifndef BKTHOMPS_CONTAINERS_UNORDERED_MULTIMAP_H #ifndef BKTHOMPS_CONTAINERS_UNORDERED_MULTIMAP_H
#define BKTHOMPS_CONTAINERS_UNORDERED_MULTIMAP_H #define BKTHOMPS_CONTAINERS_UNORDERED_MULTIMAP_H
#include <stdlib.h> #include "all.h"
/** /**
* The unordered_multimap data structure, which is a collection of key-value * 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)); const void *const two));
/* Utility */ /* Utility */
int unordered_multimap_rehash(unordered_multimap me); bk_err unordered_multimap_rehash(unordered_multimap me);
size_t unordered_multimap_size(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 */ /* 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); void unordered_multimap_get_start(unordered_multimap me, void *key);
int unordered_multimap_get_next(void *value, unordered_multimap me); bk_bool unordered_multimap_get_next(void *value, unordered_multimap me);
int unordered_multimap_count(unordered_multimap me, void *key); size_t unordered_multimap_count(unordered_multimap me, void *key);
int unordered_multimap_contains(unordered_multimap me, void *key); bk_bool unordered_multimap_contains(unordered_multimap me, void *key);
int unordered_multimap_remove(unordered_multimap me, void *key, void *value); bk_bool unordered_multimap_remove(unordered_multimap me,
int unordered_multimap_remove_all(unordered_multimap me, void *key); void *key, void *value);
bk_bool unordered_multimap_remove_all(unordered_multimap me, void *key);
/* Ending */ /* Ending */
int unordered_multimap_clear(unordered_multimap me); bk_err unordered_multimap_clear(unordered_multimap me);
unordered_multimap unordered_multimap_destroy(unordered_multimap me); unordered_multimap unordered_multimap_destroy(unordered_multimap me);
#endif /* BKTHOMPS_CONTAINERS_UNORDERED_MULTIMAP_H */ #endif /* BKTHOMPS_CONTAINERS_UNORDERED_MULTIMAP_H */

16
src/include/unordered_multiset.h
View File

@@ -23,7 +23,7 @@
#ifndef BKTHOMPS_CONTAINERS_UNORDERED_MULTISET_H #ifndef BKTHOMPS_CONTAINERS_UNORDERED_MULTISET_H
#define BKTHOMPS_CONTAINERS_UNORDERED_MULTISET_H #define BKTHOMPS_CONTAINERS_UNORDERED_MULTISET_H
#include <stdlib.h> #include "all.h"
/** /**
* The unordered_multiset data structure, which is a collection of keys, hashed * 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)); const void *const two));
/* Utility */ /* Utility */
int unordered_multiset_rehash(unordered_multiset me); bk_err unordered_multiset_rehash(unordered_multiset me);
size_t unordered_multiset_size(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 */ /* 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); size_t unordered_multiset_count(unordered_multiset me, void *key);
int unordered_multiset_contains(unordered_multiset me, void *key); bk_bool unordered_multiset_contains(unordered_multiset me, void *key);
int unordered_multiset_remove(unordered_multiset me, void *key); bk_bool unordered_multiset_remove(unordered_multiset me, void *key);
int unordered_multiset_remove_all(unordered_multiset me, void *key); bk_bool unordered_multiset_remove_all(unordered_multiset me, void *key);
/* Ending */ /* Ending */
int unordered_multiset_clear(unordered_multiset me); bk_err unordered_multiset_clear(unordered_multiset me);
unordered_multiset unordered_multiset_destroy(unordered_multiset me); unordered_multiset unordered_multiset_destroy(unordered_multiset me);
#endif /* BKTHOMPS_CONTAINERS_UNORDERED_MULTISET_H */ #endif /* BKTHOMPS_CONTAINERS_UNORDERED_MULTISET_H */

14
src/include/unordered_set.h
View File

@@ -23,7 +23,7 @@
#ifndef BKTHOMPS_CONTAINERS_UNORDERED_SET_H #ifndef BKTHOMPS_CONTAINERS_UNORDERED_SET_H
#define BKTHOMPS_CONTAINERS_UNORDERED_SET_H #define BKTHOMPS_CONTAINERS_UNORDERED_SET_H
#include <stdlib.h> #include "all.h"
/** /**
* The unordered_set data structure, which is a collection of unique keys, * 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)); const void *const two));
/* Utility */ /* Utility */
int unordered_set_rehash(unordered_set me); bk_err unordered_set_rehash(unordered_set me);
size_t unordered_set_size(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 */ /* Accessing */
int unordered_set_put(unordered_set me, void *key); bk_err unordered_set_put(unordered_set me, void *key);
int unordered_set_contains(unordered_set me, void *key); bk_bool unordered_set_contains(unordered_set me, void *key);
int unordered_set_remove(unordered_set me, void *key); bk_bool unordered_set_remove(unordered_set me, void *key);
/* Ending */ /* Ending */
int unordered_set_clear(unordered_set me); bk_err unordered_set_clear(unordered_set me);
unordered_set unordered_set_destroy(unordered_set me); unordered_set unordered_set_destroy(unordered_set me);
#endif /* BKTHOMPS_CONTAINERS_UNORDERED_SET_H */ #endif /* BKTHOMPS_CONTAINERS_UNORDERED_SET_H */

34
src/include/vector.h
View File

@@ -23,7 +23,7 @@
#ifndef BKTHOMPS_CONTAINERS_VECTOR_H #ifndef BKTHOMPS_CONTAINERS_VECTOR_H
#define BKTHOMPS_CONTAINERS_VECTOR_H #define BKTHOMPS_CONTAINERS_VECTOR_H
#include <stdlib.h> #include "all.h"
/** /**
* The vector data structure, which is a dynamic contiguous array. * The vector data structure, which is a dynamic contiguous array.
@@ -36,34 +36,34 @@ vector vector_init(size_t data_size);
/* Utility */ /* Utility */
size_t vector_size(vector me); size_t vector_size(vector me);
size_t vector_capacity(vector me); size_t vector_capacity(vector me);
int vector_is_empty(vector me); bk_bool vector_is_empty(vector me);
int vector_reserve(vector me, size_t size); bk_err vector_reserve(vector me, size_t size);
int vector_trim(vector me); bk_err vector_trim(vector me);
void vector_copy_to_array(void *arr, vector me); void vector_copy_to_array(void *arr, vector me);
void *vector_get_data(vector me); void *vector_get_data(vector me);
/* Adding */ /* Adding */
int vector_add_first(vector me, void *data); bk_err vector_add_first(vector me, void *data);
int vector_add_at(vector me, size_t index, void *data); bk_err vector_add_at(vector me, size_t index, void *data);
int vector_add_last(vector me, void *data); bk_err vector_add_last(vector me, void *data);
/* Removing */ /* Removing */
int vector_remove_first(vector me); bk_err vector_remove_first(vector me);
int vector_remove_at(vector me, size_t index); bk_err vector_remove_at(vector me, size_t index);
int vector_remove_last(vector me); bk_err vector_remove_last(vector me);
/* Setting */ /* Setting */
int vector_set_first(vector me, void *data); bk_err vector_set_first(vector me, void *data);
int vector_set_at(vector me, size_t index, void *data); bk_err vector_set_at(vector me, size_t index, void *data);
int vector_set_last(vector me, void *data); bk_err vector_set_last(vector me, void *data);
/* Getting */ /* Getting */
int vector_get_first(void *data, vector me); bk_err vector_get_first(void *data, vector me);
int vector_get_at(void *data, vector me, size_t index); bk_err vector_get_at(void *data, vector me, size_t index);
int vector_get_last(void *data, vector me); bk_err vector_get_last(void *data, vector me);
/* Ending */ /* Ending */
int vector_clear(vector me); bk_err vector_clear(vector me);
vector vector_destroy(vector me); vector vector_destroy(vector me);
#endif /* BKTHOMPS_CONTAINERS_VECTOR_H */ #endif /* BKTHOMPS_CONTAINERS_VECTOR_H */

97
src/list.c
View File

@@ -21,7 +21,6 @@
*/ */
#include <string.h> #include <string.h>
#include <errno.h>
#include "include/list.h" #include "include/list.h"
struct internal_list { struct internal_list {
@@ -79,9 +78,9 @@ size_t list_size(list me)
* *
* @param me the doubly-linked list to check * @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; 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 me the doubly-linked list to add data to
* @param data the data to add to the doubly-linked list * @param data the data to add to the doubly-linked list
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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); 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 index the index to add the data at
* @param data the data to add to the doubly-linked list * @param data the data to add to the doubly-linked list
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @return -BK_ENOMEM if out of memory
* @return -EINVAL if invalid argument * @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; char *node;
if (index > me->item_count) { if (index > me->item_count) {
return -EINVAL; return -BK_EINVAL;
} }
node = malloc(2 * ptr_size + me->bytes_per_item); node = malloc(2 * ptr_size + me->bytes_per_item);
if (!node) { if (!node) {
return -ENOMEM; return -BK_ENOMEM;
} }
memcpy(node + node_data_ptr_offset, data, me->bytes_per_item); memcpy(node + node_data_ptr_offset, data, me->bytes_per_item);
if (!me->head) { 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); memcpy(traverse + node_prev_ptr_offset, &node, ptr_size);
} }
me->item_count++; 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 me the doubly-linked list to add data to
* @param data the data to add to the doubly-linked list * @param data the data to add to the doubly-linked list
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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); 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 * @param me the doubly-linked list to remove data from
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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); 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 me the doubly-linked list to remove data from
* @param index the index to remove from * @param index the index to remove from
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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; char *traverse;
if (index >= me->item_count) { if (index >= me->item_count) {
return -EINVAL; return -BK_EINVAL;
} }
traverse = list_get_node_at(me, index); traverse = list_get_node_at(me, index);
if (me->item_count == 1) { if (me->item_count == 1) {
@@ -290,7 +289,7 @@ int list_remove_at(list me, const size_t index)
} }
free(traverse); free(traverse);
me->item_count--; 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 * @param me the doubly-linked list to remove data from
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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); 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 me the doubly-linked list to set data for
* @param data the data to set in the doubly-linked list * @param data the data to set in the doubly-linked list
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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); 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 index the index to set data in the doubly-linked list
* @param data the data to set in the doubly-linked list * @param data the data to set in the doubly-linked list
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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; char *traverse;
if (index >= me->item_count) { if (index >= me->item_count) {
return -EINVAL; return -BK_EINVAL;
} }
traverse = list_get_node_at(me, index); traverse = list_get_node_at(me, index);
memcpy(traverse + node_data_ptr_offset, data, me->bytes_per_item); 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 me the doubly-linked list to set data for
* @param data the data to set in the doubly-linked list * @param data the data to set in the doubly-linked list
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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); 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 data the data to get
* @param me the doubly-linked list to get data from * @param me the doubly-linked list to get data from
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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); 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 me the doubly-linked list to get data from
* @param index the index to get data from * @param index the index to get data from
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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; char *traverse;
if (index >= me->item_count) { if (index >= me->item_count) {
return -EINVAL; return -BK_EINVAL;
} }
traverse = list_get_node_at(me, index); traverse = list_get_node_at(me, index);
memcpy(data, traverse + node_data_ptr_offset, me->bytes_per_item); 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 data the data to get
* @param me the doubly-linked list to get data from * @param me the doubly-linked list to get data from
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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); return list_get_at(data, me, me->item_count - 1);
} }

45
src/map.c
View File

@@ -21,7 +21,6 @@
*/ */
#include <string.h> #include <string.h>
#include <errno.h>
#include "include/map.h" #include "include/map.h"
struct internal_map { struct internal_map {
@@ -88,9 +87,9 @@ size_t map_size(map me)
* *
* @param me the map to check * @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; 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 key the key to add
* @param value the value to add * @param value the value to add
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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; char *traverse;
if (!me->root) { if (!me->root) {
char *insert = map_create_node(me, key, value, NULL); char *insert = map_create_node(me, key, value, NULL);
if (!insert) { if (!insert) {
return -ENOMEM; return -BK_ENOMEM;
} }
me->root = insert; me->root = insert;
return 0; return BK_OK;
} }
traverse = me->root; traverse = me->root;
for (;;) { for (;;) {
@@ -334,11 +333,11 @@ int map_put(map me, void *const key, void *const value)
} else { } else {
char *insert = map_create_node(me, key, value, traverse); char *insert = map_create_node(me, key, value, traverse);
if (!insert) { if (!insert) {
return -ENOMEM; return -BK_ENOMEM;
} }
memcpy(traverse + node_left_child_offset, &insert, ptr_size); memcpy(traverse + node_left_child_offset, &insert, ptr_size);
map_insert_balance(me, insert); map_insert_balance(me, insert);
return 0; return BK_OK;
} }
} else if (compare > 0) { } else if (compare > 0) {
char *traverse_right; char *traverse_right;
@@ -349,16 +348,16 @@ int map_put(map me, void *const key, void *const value)
} else { } else {
char *insert = map_create_node(me, key, value, traverse); char *insert = map_create_node(me, key, value, traverse);
if (!insert) { if (!insert) {
return -ENOMEM; return -BK_ENOMEM;
} }
memcpy(traverse + node_right_child_offset, &insert, ptr_size); memcpy(traverse + node_right_child_offset, &insert, ptr_size);
map_insert_balance(me, insert); map_insert_balance(me, insert);
return 0; return BK_OK;
} }
} else { } else {
memcpy(traverse + node_key_offset + me->key_size, value, memcpy(traverse + node_key_offset + me->key_size, value,
me->value_size); 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 me the map to get from
* @param key the key to search for * @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); char *const traverse = map_equal_match(me, key);
if (!traverse) { if (!traverse) {
return 0; return BK_FALSE;
} }
memcpy(value, traverse + node_key_offset + me->key_size, me->value_size); 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 me the map to check for the element
* @param key the key to check * @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; 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 me the map to remove an element from
* @param key the key to remove * @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); char *const traverse = map_equal_match(me, key);
if (!traverse) { if (!traverse) {
return 0; return BK_FALSE;
} }
map_remove_element(me, traverse); map_remove_element(me, traverse);
return 1; return BK_TRUE;
} }
/** /**

57
src/multimap.c
View File

@@ -21,7 +21,6 @@
*/ */
#include <string.h> #include <string.h>
#include <errno.h>
#include "include/multimap.h" #include "include/multimap.h"
struct internal_multimap { struct internal_multimap {
@@ -105,9 +104,9 @@ size_t multimap_size(multimap me)
* *
* @param me the multi-map to check * @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; 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 key the key to add
* @param value the value to add * @param value the value to add
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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; char *traverse;
if (!me->root) { if (!me->root) {
char *insert = multimap_create_node(me, key, value, NULL); char *insert = multimap_create_node(me, key, value, NULL);
if (!insert) { if (!insert) {
return -ENOMEM; return -BK_ENOMEM;
} }
me->root = insert; me->root = insert;
return 0; return BK_OK;
} }
traverse = me->root; traverse = me->root;
for (;;) { for (;;) {
@@ -381,11 +380,11 @@ int multimap_put(multimap me, void *const key, void *const value)
} else { } else {
char *insert = multimap_create_node(me, key, value, traverse); char *insert = multimap_create_node(me, key, value, traverse);
if (!insert) { if (!insert) {
return -ENOMEM; return -BK_ENOMEM;
} }
memcpy(traverse + node_left_child_offset, &insert, ptr_size); memcpy(traverse + node_left_child_offset, &insert, ptr_size);
multimap_insert_balance(me, insert); multimap_insert_balance(me, insert);
return 0; return BK_OK;
} }
} else if (compare > 0) { } else if (compare > 0) {
char *traverse_right; char *traverse_right;
@@ -396,11 +395,11 @@ int multimap_put(multimap me, void *const key, void *const value)
} else { } else {
char *insert = multimap_create_node(me, key, value, traverse); char *insert = multimap_create_node(me, key, value, traverse);
if (!insert) { if (!insert) {
return -ENOMEM; return -BK_ENOMEM;
} }
memcpy(traverse + node_right_child_offset, &insert, ptr_size); memcpy(traverse + node_right_child_offset, &insert, ptr_size);
multimap_insert_balance(me, insert); multimap_insert_balance(me, insert);
return 0; return BK_OK;
} }
} else { } else {
char *value_traverse; char *value_traverse;
@@ -423,7 +422,7 @@ int multimap_put(multimap me, void *const key, void *const value)
count++; count++;
memcpy(traverse + node_value_count_offset, &count, count_size); memcpy(traverse + node_value_count_offset, &count, count_size);
me->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 value the value to be copied to from iteration
* @param me the multi-map to iterate over * @param me the multi-map to iterate over
* *
* @return 1 if there exist more values for the key which is being iterated * @return BK_TRUE if there exist more values for the key which is being
* over, otherwise 0 * 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 *item;
char *next; char *next;
if (!me->iterate_get) { if (!me->iterate_get) {
return 0; return BK_FALSE;
} }
item = me->iterate_get; item = me->iterate_get;
memcpy(value, item + value_node_value_offset, me->value_size); memcpy(value, item + value_node_value_offset, me->value_size);
memcpy(&next, item + value_node_next_offset, ptr_size); memcpy(&next, item + value_node_next_offset, ptr_size);
me->iterate_get = next; 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 me the multi-map to check for the key
* @param key the key to check * @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; 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 key the key to remove
* @param value the value 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 *current_value_node;
char *const traverse = multimap_equal_match(me, key); char *const traverse = multimap_equal_match(me, key);
size_t count; size_t count;
if (!traverse) { if (!traverse) {
return 0; return BK_FALSE;
} }
memcpy(&current_value_node, traverse + node_value_head_offset, ptr_size); memcpy(&current_value_node, traverse + node_value_head_offset, ptr_size);
if (me->value_comparator(current_value_node + value_node_value_offset, 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); current_value_node + value_node_next_offset, ptr_size);
} }
if (!current_value_node) { if (!current_value_node) {
return 0; return BK_FALSE;
} }
memcpy(previous_value_node + value_node_next_offset, memcpy(previous_value_node + value_node_next_offset,
current_value_node + value_node_next_offset, ptr_size); 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); memcpy(traverse + node_value_count_offset, &count, count_size);
} }
me->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 me the multi-map to remove a key-value pair from
* @param key the key to remove * @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); char *const traverse = multimap_equal_match(me, key);
if (!traverse) { if (!traverse) {
return 0; return BK_FALSE;
} }
multimap_remove_all_elements(me, traverse); multimap_remove_all_elements(me, traverse);
return 1; return BK_TRUE;
} }
/** /**

45
src/multiset.c
View File

@@ -21,7 +21,6 @@
*/ */
#include <string.h> #include <string.h>
#include <errno.h>
#include "include/multiset.h" #include "include/multiset.h"
struct internal_multiset { struct internal_multiset {
@@ -90,9 +89,9 @@ size_t multiset_size(multiset me)
* *
* @param me the multi-set to check * @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; 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 me the multi-set to add to
* @param key the key to add * @param key the key to add
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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; char *traverse;
if (!me->root) { if (!me->root) {
char *insert = multiset_create_node(me, key, NULL); char *insert = multiset_create_node(me, key, NULL);
if (!insert) { if (!insert) {
return -ENOMEM; return -BK_ENOMEM;
} }
me->root = insert; me->root = insert;
return 0; return BK_OK;
} }
traverse = me->root; traverse = me->root;
for (;;) { for (;;) {
@@ -342,11 +341,11 @@ int multiset_put(multiset me, void *const key)
} else { } else {
char *insert = multiset_create_node(me, key, traverse); char *insert = multiset_create_node(me, key, traverse);
if (!insert) { if (!insert) {
return -ENOMEM; return -BK_ENOMEM;
} }
memcpy(traverse + node_left_child_offset, &insert, ptr_size); memcpy(traverse + node_left_child_offset, &insert, ptr_size);
multiset_insert_balance(me, insert); multiset_insert_balance(me, insert);
return 0; return BK_OK;
} }
} else if (compare > 0) { } else if (compare > 0) {
char *traverse_right; char *traverse_right;
@@ -357,11 +356,11 @@ int multiset_put(multiset me, void *const key)
} else { } else {
char *insert = multiset_create_node(me, key, traverse); char *insert = multiset_create_node(me, key, traverse);
if (!insert) { if (!insert) {
return -ENOMEM; return -BK_ENOMEM;
} }
memcpy(traverse + node_right_child_offset, &insert, ptr_size); memcpy(traverse + node_right_child_offset, &insert, ptr_size);
multiset_insert_balance(me, insert); multiset_insert_balance(me, insert);
return 0; return BK_OK;
} }
} else { } else {
size_t count; size_t count;
@@ -369,7 +368,7 @@ int multiset_put(multiset me, void *const key)
count++; count++;
memcpy(traverse + node_count_offset, &count, count_size); memcpy(traverse + node_count_offset, &count, count_size);
me->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 me the multi-set to check for the key
* @param key the key to check * @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; 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 me the multi-set to remove a key from
* @param key the key to remove * @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); char *const traverse = multiset_equal_match(me, key);
size_t traverse_count; size_t traverse_count;
if (!traverse) { if (!traverse) {
return 0; return BK_FALSE;
} }
memcpy(&traverse_count, traverse + node_count_offset, count_size); memcpy(&traverse_count, traverse + node_count_offset, count_size);
if (traverse_count == 1) { 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); memcpy(traverse + node_count_offset, &traverse_count, count_size);
} }
me->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 me the multi-set to remove a key from
* @param key the key to remove * @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); char *const traverse = multiset_equal_match(me, key);
size_t traverse_count; size_t traverse_count;
if (!traverse) { if (!traverse) {
return 0; return BK_FALSE;
} }
memcpy(&traverse_count, traverse + node_count_offset, count_size); memcpy(&traverse_count, traverse + node_count_offset, count_size);
me->size -= traverse_count; me->size -= traverse_count;
multiset_remove_element(me, traverse); multiset_remove_element(me, traverse);
return 1; return BK_TRUE;
} }
/** /**

41
src/priority_queue.c
View File

@@ -21,7 +21,6 @@
*/ */
#include <string.h> #include <string.h>
#include <errno.h>
#include "include/vector.h" #include "include/vector.h"
#include "include/priority_queue.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 * @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); 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 me the priority queue to add an element to
* @param data the data to add to the queue * @param data the data to add to the queue
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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; char *vector_storage;
size_t index; size_t index;
size_t parent_index; size_t parent_index;
@@ -111,10 +110,10 @@ int priority_queue_push(priority_queue me, void *const data)
char *data_parent_index; char *data_parent_index;
char *const temp = malloc(me->data_size); char *const temp = malloc(me->data_size);
if (!temp) { if (!temp) {
return -ENOMEM; return -BK_ENOMEM;
} }
rc = vector_add_last(me->data, data); rc = vector_add_last(me->data, data);
if (rc != 0) { if (rc != BK_OK) {
free(temp); free(temp);
return rc; 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; data_parent_index = vector_storage + parent_index * me->data_size;
} }
free(temp); 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 data the data to have copied from the priority queue
* @param me the priority queue to pop the next element from * @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; char *vector_storage;
size_t size; size_t size;
@@ -160,9 +159,9 @@ int priority_queue_pop(void *const data, priority_queue me)
char *data_index; char *data_index;
char *data_left_index; char *data_left_index;
char *data_right_index; char *data_right_index;
const int rc = vector_get_first(data, me->data); const bk_err rc = vector_get_first(data, me->data);
if (rc != 0) { if (rc != BK_OK) {
return 0; return BK_FALSE;
} }
vector_storage = vector_get_data(me->data); vector_storage = vector_get_data(me->data);
size = vector_size(me->data) - 1; 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; data_right_index = vector_storage + right_index * me->data_size;
} }
vector_remove_last(me->data); 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 * queue
* @param me the priority queue to copy from * @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; 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 * @param me the priority queue to clear
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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); return vector_clear(me->data);
} }

34
src/queue.c
View File

@@ -55,9 +55,9 @@ size_t queue_size(queue me)
* *
* @param me the queue to check if empty * @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); return deque_is_empty(me);
} }
@@ -67,10 +67,10 @@ int queue_is_empty(queue me)
* *
* @param me the queue to trim * @param me the queue to trim
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @return -BK_ENOMEM if out of memory
*/ */
int queue_trim(queue me) bk_err queue_trim(queue me)
{ {
return deque_trim(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 me the queue to add an element to
* @param data the data to add to the queue * @param data the data to add to the queue
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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); 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 data the data to have copied from the queue
* @param me the queue to pop the next element from * @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; 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 data the copy of the front element of the queue
* @param me the queue to copy from * @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; 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 data the copy of the back element of the queue
* @param me the queue to copy from * @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; 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 * @param me the queue to clear
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @return -BK_ENOMEM if out of memory
*/ */
int queue_clear(queue me) bk_err queue_clear(queue me)
{ {
return deque_clear(me); return deque_clear(me);
} }

37
src/set.c
View File

@@ -21,7 +21,6 @@
*/ */
#include <string.h> #include <string.h>
#include <errno.h>
#include "include/set.h" #include "include/set.h"
struct internal_set { struct internal_set {
@@ -84,9 +83,9 @@ size_t set_size(set me)
* *
* @param me the set to check * @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; 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 me the set to add to
* @param key the key to add * @param key the key to add
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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; char *traverse;
if (!me->root) { if (!me->root) {
char *insert = set_create_node(me, key, NULL); char *insert = set_create_node(me, key, NULL);
if (!insert) { if (!insert) {
return -ENOMEM; return -BK_ENOMEM;
} }
me->root = insert; me->root = insert;
return 0; return BK_OK;
} }
traverse = me->root; traverse = me->root;
for (;;) { for (;;) {
@@ -326,11 +325,11 @@ int set_put(set me, void *const key)
} else { } else {
char *insert = set_create_node(me, key, traverse); char *insert = set_create_node(me, key, traverse);
if (!insert) { if (!insert) {
return -ENOMEM; return -BK_ENOMEM;
} }
memcpy(traverse + node_left_child_offset, &insert, ptr_size); memcpy(traverse + node_left_child_offset, &insert, ptr_size);
set_insert_balance(me, insert); set_insert_balance(me, insert);
return 0; return BK_OK;
} }
} else if (compare > 0) { } else if (compare > 0) {
char *traverse_right; char *traverse_right;
@@ -341,14 +340,14 @@ int set_put(set me, void *const key)
} else { } else {
char *insert = set_create_node(me, key, traverse); char *insert = set_create_node(me, key, traverse);
if (!insert) { if (!insert) {
return -ENOMEM; return -BK_ENOMEM;
} }
memcpy(traverse + node_right_child_offset, &insert, ptr_size); memcpy(traverse + node_right_child_offset, &insert, ptr_size);
set_insert_balance(me, insert); set_insert_balance(me, insert);
return 0; return BK_OK;
} }
} else { } 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 me the set to check for the key
* @param key the key to check * @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; 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 me the set to remove an key from
* @param key the key to remove * @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); char *const traverse = set_equal_match(me, key);
if (!traverse) { if (!traverse) {
return 0; return BK_FALSE;
} }
set_remove_element(me, traverse); set_remove_element(me, traverse);
return 1; return BK_TRUE;
} }
/** /**

30
src/stack.c
View File

@@ -55,9 +55,9 @@ size_t stack_size(stack me)
* *
* @param me the stack to check if empty * @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); return deque_is_empty(me);
} }
@@ -67,10 +67,10 @@ int stack_is_empty(stack me)
* *
* @param me the stack to trim * @param me the stack to trim
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @return -BK_ENOMEM if out of memory
*/ */
int stack_trim(stack me) bk_err stack_trim(stack me)
{ {
return deque_trim(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 me the stack to add an element to
* @param data the data to add to the stack * @param data the data to add to the stack
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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); 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 data the copy of the element being removed
* @param me the stack to remove the top element from * @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; 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 data the copy of the top element of the stack
* @param me the stack to copy from * @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; 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 * @param me the stack to clear
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @return -BK_ENOMEM if out of memory
*/ */
int stack_clear(stack me) bk_err stack_clear(stack me)
{ {
return deque_clear(me); return deque_clear(me);
} }

88
src/unordered_map.c
View File

@@ -21,7 +21,6 @@
*/ */
#include <string.h> #include <string.h>
#include <errno.h>
#include "include/unordered_map.h" #include "include/unordered_map.h"
#define BKTHOMPS_U_MAP_STARTING_BUCKETS 16 #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 * @param me the unordered map to rehash
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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; size_t i;
char **old_buckets = me->buckets; char **old_buckets = me->buckets;
me->buckets = calloc(me->capacity, ptr_size); me->buckets = calloc(me->capacity, ptr_size);
if (!me->buckets) { if (!me->buckets) {
me->buckets = old_buckets; me->buckets = old_buckets;
return -ENOMEM; return -BK_ENOMEM;
} }
for (i = 0; i < me->capacity; i++) { for (i = 0; i < me->capacity; i++) {
char *traverse = old_buckets[i]; char *traverse = old_buckets[i];
@@ -158,7 +157,7 @@ int unordered_map_rehash(unordered_map me)
} }
} }
free(old_buckets); 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 * @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; 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. * 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; size_t i;
const size_t old_capacity = me->capacity; 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); me->buckets = calloc(new_capacity, ptr_size);
if (!me->buckets) { if (!me->buckets) {
me->buckets = old_buckets; me->buckets = old_buckets;
return -ENOMEM; return -BK_ENOMEM;
} }
me->capacity = new_capacity; me->capacity = new_capacity;
for (i = 0; i < old_capacity; i++) { for (i = 0; i < old_capacity; i++) {
@@ -210,15 +209,15 @@ static int unordered_map_resize(unordered_map me)
} }
} }
free(old_buckets); free(old_buckets);
return 0; return BK_OK;
} }
/* /*
* Determines if an element is equal to the key. * Determines if an element is equal to the key.
*/ */
static int unordered_map_is_equal(unordered_map me, char *const item, static bk_bool unordered_map_is_equal(unordered_map me, char *const item,
const unsigned long hash, const unsigned long hash,
const void *const key) const void *const key)
{ {
unsigned long item_hash; unsigned long item_hash;
memcpy(&item_hash, item + node_hash_offset, hash_size); 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 key the key to add
* @param value the value to add * @param value the value to add
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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); 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)) { if (me->size + 1 >= (size_t) (BKTHOMPS_U_MAP_RESIZE_AT * me->capacity)) {
const int rc = unordered_map_resize(me); const bk_err rc = unordered_map_resize(me);
if (rc != 0) { if (rc != BK_OK) {
return rc; return rc;
} }
} }
index = (size_t) (hash % me->capacity); index = hash % me->capacity;
if (!me->buckets[index]) { if (!me->buckets[index]) {
me->buckets[index] = unordered_map_create_element(me, hash, key, value); me->buckets[index] = unordered_map_create_element(me, hash, key, value);
if (!me->buckets[index]) { if (!me->buckets[index]) {
return -ENOMEM; return -BK_ENOMEM;
} }
} else { } else {
char *traverse = me->buckets[index]; 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)) { if (unordered_map_is_equal(me, traverse, hash, key)) {
memcpy(traverse + node_key_offset + me->key_size, value, memcpy(traverse + node_key_offset + me->key_size, value,
me->value_size); me->value_size);
return 0; return BK_OK;
} }
memcpy(&traverse_next, traverse + node_next_offset, ptr_size); memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
while (traverse_next) { 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)) { if (unordered_map_is_equal(me, traverse, hash, key)) {
memcpy(traverse + node_key_offset + me->key_size, value, memcpy(traverse + node_key_offset + me->key_size, value,
me->value_size); me->value_size);
return 0; return BK_OK;
} }
} }
traverse_next = unordered_map_create_element(me, hash, key, value); traverse_next = unordered_map_create_element(me, hash, key, value);
if (!traverse_next) { if (!traverse_next) {
return -ENOMEM; return -BK_ENOMEM;
} }
memcpy(traverse + node_next_offset, &traverse_next, ptr_size); memcpy(traverse + node_next_offset, &traverse_next, ptr_size);
} }
me->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 me the unordered map to get from
* @param key the key to search for * @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); const unsigned long hash = unordered_map_hash(me, key);
char *traverse = me->buckets[hash % me->capacity]; 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)) { if (unordered_map_is_equal(me, traverse, hash, key)) {
memcpy(value, traverse + node_key_offset + me->key_size, memcpy(value, traverse + node_key_offset + me->key_size,
me->value_size); me->value_size);
return 1; return BK_TRUE;
} }
memcpy(&traverse, traverse + node_next_offset, ptr_size); 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 me the unordered map to check for the key
* @param key the key to check * @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); const unsigned long hash = unordered_map_hash(me, key);
char *traverse = me->buckets[hash % me->capacity]; char *traverse = me->buckets[hash % me->capacity];
while (traverse) { while (traverse) {
if (unordered_map_is_equal(me, traverse, hash, key)) { if (unordered_map_is_equal(me, traverse, hash, key)) {
return 1; return BK_TRUE;
} }
memcpy(&traverse, traverse + node_next_offset, ptr_size); 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 me the unordered map to remove a key from
* @param key the key to remove * @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;
char *traverse_next; char *traverse_next;
const unsigned long hash = unordered_map_hash(me, key); const unsigned long hash = unordered_map_hash(me, key);
const size_t index = hash % me->capacity; const size_t index = hash % me->capacity;
if (!me->buckets[index]) { if (!me->buckets[index]) {
return 0; return BK_FALSE;
} }
traverse = me->buckets[index]; traverse = me->buckets[index];
if (unordered_map_is_equal(me, traverse, hash, key)) { if (unordered_map_is_equal(me, traverse, hash, key)) {
memcpy(me->buckets + index, traverse + node_next_offset, ptr_size); memcpy(me->buckets + index, traverse + node_next_offset, ptr_size);
free(traverse); free(traverse);
me->size--; me->size--;
return 1; return BK_TRUE;
} }
memcpy(&traverse_next, traverse + node_next_offset, ptr_size); memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
while (traverse_next) { while (traverse_next) {
@@ -394,12 +394,12 @@ int unordered_map_remove(unordered_map me, void *const key)
traverse_next + node_next_offset, ptr_size); traverse_next + node_next_offset, ptr_size);
free(traverse_next); free(traverse_next);
me->size--; me->size--;
return 1; return BK_TRUE;
} }
traverse = traverse_next; traverse = traverse_next;
memcpy(&traverse_next, traverse + node_next_offset, ptr_size); 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 * @param me the unordered map to clear
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @return -BK_ENOMEM if out of memory
*/ */
int unordered_map_clear(unordered_map me) int unordered_map_clear(unordered_map me)
{ {
size_t i; size_t i;
char **updated_buckets = calloc(BKTHOMPS_U_MAP_STARTING_BUCKETS, ptr_size); char **updated_buckets = calloc(BKTHOMPS_U_MAP_STARTING_BUCKETS, ptr_size);
if (!updated_buckets) { if (!updated_buckets) {
return -ENOMEM; return -BK_ENOMEM;
} }
for (i = 0; i < me->capacity; i++) { for (i = 0; i < me->capacity; i++) {
char *traverse = me->buckets[i]; char *traverse = me->buckets[i];
@@ -429,7 +429,7 @@ int unordered_map_clear(unordered_map me)
me->size = 0; me->size = 0;
me->capacity = BKTHOMPS_U_MAP_STARTING_BUCKETS; me->capacity = BKTHOMPS_U_MAP_STARTING_BUCKETS;
me->buckets = updated_buckets; me->buckets = updated_buckets;
return 0; return BK_OK;
} }
/** /**

115
src/unordered_multimap.c
View File

@@ -21,7 +21,6 @@
*/ */
#include <string.h> #include <string.h>
#include <errno.h>
#include "include/unordered_multimap.h" #include "include/unordered_multimap.h"
#define BKTHOMPS_U_MULTIMAP_STARTING_BUCKETS 16 #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 * @param me the unordered multi-map to rehash
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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; size_t i;
char **old_buckets = me->buckets; char **old_buckets = me->buckets;
me->buckets = calloc(me->capacity, ptr_size); me->buckets = calloc(me->capacity, ptr_size);
if (!me->buckets) { if (!me->buckets) {
me->buckets = old_buckets; me->buckets = old_buckets;
return -ENOMEM; return -BK_ENOMEM;
} }
for (i = 0; i < me->capacity; i++) { for (i = 0; i < me->capacity; i++) {
char *traverse = old_buckets[i]; char *traverse = old_buckets[i];
@@ -177,7 +176,7 @@ int unordered_multimap_rehash(unordered_multimap me)
} }
} }
free(old_buckets); 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 * @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; 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. * 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; size_t i;
const size_t old_capacity = me->capacity; 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); me->buckets = calloc(new_capacity, ptr_size);
if (!me->buckets) { if (!me->buckets) {
me->buckets = old_buckets; me->buckets = old_buckets;
return -ENOMEM; return -BK_ENOMEM;
} }
me->capacity = new_capacity; me->capacity = new_capacity;
for (i = 0; i < old_capacity; i++) { for (i = 0; i < old_capacity; i++) {
@@ -229,15 +228,16 @@ static int unordered_multimap_resize(unordered_multimap me)
} }
} }
free(old_buckets); free(old_buckets);
return 0; return BK_OK;
} }
/* /*
* Determines if an element is equal to the key. * Determines if an element is equal to the key.
*/ */
static int unordered_multimap_is_equal(unordered_multimap me, char *const item, static bk_bool unordered_multimap_is_equal(unordered_multimap me,
const unsigned long hash, char *const item,
const void *const key) const unsigned long hash,
const void *const key)
{ {
unsigned long item_hash; unsigned long item_hash;
memcpy(&item_hash, item + node_hash_offset, hash_size); 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 key the key to add
* @param value the value to add * @param value the value to add
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @return -BK_ENOMEM if out of memory
*/ */
int unordered_multimap_put(unordered_multimap me, bk_err unordered_multimap_put(unordered_multimap me, void *const key,
void *const key, void *const value)
void *const value)
{ {
const unsigned long hash = unordered_multimap_hash(me, key); const unsigned long hash = unordered_multimap_hash(me, key);
int index; size_t index;
if (me->size + 1 >= if (me->size + 1 >=
(size_t) (BKTHOMPS_U_MULTIMAP_RESIZE_AT * me->capacity)) { (size_t) (BKTHOMPS_U_MULTIMAP_RESIZE_AT * me->capacity)) {
const int rc = unordered_multimap_resize(me); const bk_err rc = unordered_multimap_resize(me);
if (rc != 0) { if (rc != BK_OK) {
return rc; return rc;
} }
} }
index = (size_t) (hash % me->capacity); index = hash % me->capacity;
if (!me->buckets[index]) { if (!me->buckets[index]) {
me->buckets[index] = unordered_multimap_create_element(me, hash, key, me->buckets[index] = unordered_multimap_create_element(me, hash, key,
value); value);
if (!me->buckets[index]) { if (!me->buckets[index]) {
return -ENOMEM; return -BK_ENOMEM;
} }
} else { } else {
char *traverse = me->buckets[index]; 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); traverse_next = unordered_multimap_create_element(me, hash, key, value);
if (!traverse_next) { if (!traverse_next) {
return -ENOMEM; return -BK_ENOMEM;
} }
memcpy(traverse + node_next_offset, &traverse_next, ptr_size); memcpy(traverse + node_next_offset, &traverse_next, ptr_size);
} }
me->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 value the value to be copied to from iteration
* @param me the unordered multi-map to iterate over * @param me the unordered multi-map to iterate over
* *
* @return 1 if there exist more values for the key which is being iterated * @return BK_TRUE if there exist more values for the key which is being
* over, otherwise 0 * 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 *item;
char *traverse; char *traverse;
if (!me->iterate_element) { if (!me->iterate_element) {
return 0; return BK_FALSE;
} }
item = me->iterate_element; item = me->iterate_element;
memcpy(&traverse, item + node_next_offset, ptr_size); 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; me->iterate_element = traverse;
memcpy(value, item + node_key_offset + me->key_size, memcpy(value, item + node_key_offset + me->key_size,
me->value_size); me->value_size);
return 1; return BK_TRUE;
} }
memcpy(&traverse, traverse + node_next_offset, ptr_size); memcpy(&traverse, traverse + node_next_offset, ptr_size);
} }
me->iterate_element = NULL; me->iterate_element = NULL;
memcpy(value, item + node_key_offset + me->key_size, me->value_size); 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 * @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); const unsigned long hash = unordered_multimap_hash(me, key);
char *traverse = me->buckets[hash % me->capacity]; char *traverse = me->buckets[hash % me->capacity];
while (traverse) { 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 me the unordered multi-map to check for the key
* @param key the key to check * @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); const unsigned long hash = unordered_multimap_hash(me, key);
char *traverse = me->buckets[hash % me->capacity]; char *traverse = me->buckets[hash % me->capacity];
while (traverse) { while (traverse) {
if (unordered_multimap_is_equal(me, traverse, hash, key)) { if (unordered_multimap_is_equal(me, traverse, hash, key)) {
return 1; return BK_TRUE;
} }
memcpy(&traverse, traverse + node_next_offset, ptr_size); 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 key the key to remove
* @param value the value 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, bk_bool unordered_multimap_remove(unordered_multimap me, void *const key,
void *const key, void *const value)
void *const value)
{ {
char *traverse; char *traverse;
char *traverse_next; char *traverse_next;
const unsigned long hash = unordered_multimap_hash(me, key); const unsigned long hash = unordered_multimap_hash(me, key);
const size_t index = hash % me->capacity; const size_t index = hash % me->capacity;
if (!me->buckets[index]) { if (!me->buckets[index]) {
return 0; return BK_FALSE;
} }
traverse = me->buckets[index]; traverse = me->buckets[index];
if (unordered_multimap_is_equal(me, traverse, hash, key) 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); memcpy(me->buckets + index, traverse + node_next_offset, ptr_size);
free(traverse); free(traverse);
me->size--; me->size--;
return 1; return BK_TRUE;
} }
memcpy(&traverse_next, traverse + node_next_offset, ptr_size); memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
while (traverse_next) { while (traverse_next) {
@@ -479,12 +479,12 @@ int unordered_multimap_remove(unordered_multimap me,
traverse_next + node_next_offset, ptr_size); traverse_next + node_next_offset, ptr_size);
free(traverse_next); free(traverse_next);
me->size--; me->size--;
return 1; return BK_TRUE;
} }
traverse = traverse_next; traverse = traverse_next;
memcpy(&traverse_next, traverse + node_next_offset, ptr_size); 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 me the unordered multi-map to remove a key-value pair from
* @param key the key to remove * @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 unsigned long hash = unordered_multimap_hash(me, key);
const int index = (int) (hash % me->capacity); const size_t index = hash % me->capacity;
int was_modified = 0; bk_bool was_modified = BK_FALSE;
for (;;) { for (;;) {
char *traverse = me->buckets[index]; char *traverse = me->buckets[index];
char *traverse_next; char *traverse_next;
@@ -516,7 +517,7 @@ int unordered_multimap_remove_all(unordered_multimap me, void *const key)
me->buckets[index] = traverse_next; me->buckets[index] = traverse_next;
free(traverse); free(traverse);
me->size--; me->size--;
was_modified = 1; was_modified = BK_TRUE;
continue; continue;
} }
while (traverse_next) { 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); traverse_next + node_next_offset, ptr_size);
free(traverse_next); free(traverse_next);
me->size--; me->size--;
was_modified = 1; was_modified = BK_TRUE;
memcpy(&traverse_next, traverse + node_next_offset, ptr_size); memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
continue; continue;
} }
@@ -542,16 +543,16 @@ int unordered_multimap_remove_all(unordered_multimap me, void *const key)
* *
* @param me the unordered multi-map to clear * @param me the unordered multi-map to clear
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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; size_t i;
char **updated_buckets = calloc(BKTHOMPS_U_MULTIMAP_STARTING_BUCKETS, char **updated_buckets = calloc(BKTHOMPS_U_MULTIMAP_STARTING_BUCKETS,
ptr_size); ptr_size);
if (!updated_buckets) { if (!updated_buckets) {
return -ENOMEM; return -BK_ENOMEM;
} }
for (i = 0; i < me->capacity; i++) { for (i = 0; i < me->capacity; i++) {
char *traverse = me->buckets[i]; char *traverse = me->buckets[i];
@@ -565,7 +566,7 @@ int unordered_multimap_clear(unordered_multimap me)
me->size = 0; me->size = 0;
me->capacity = BKTHOMPS_U_MULTIMAP_STARTING_BUCKETS; me->capacity = BKTHOMPS_U_MULTIMAP_STARTING_BUCKETS;
me->buckets = updated_buckets; me->buckets = updated_buckets;
return 0; return BK_OK;
} }
/** /**

93
src/unordered_multiset.c
View File

@@ -21,7 +21,6 @@
*/ */
#include <string.h> #include <string.h>
#include <errno.h>
#include "include/unordered_multiset.h" #include "include/unordered_multiset.h"
#define BKTHOMPS_U_MULTISET_STARTING_BUCKETS 16 #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 * @param me the unordered multi-set to rehash
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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; size_t i;
char **old_buckets = me->buckets; char **old_buckets = me->buckets;
me->buckets = calloc(me->capacity, ptr_size); me->buckets = calloc(me->capacity, ptr_size);
if (!me->buckets) { if (!me->buckets) {
me->buckets = old_buckets; me->buckets = old_buckets;
return -ENOMEM; return -BK_ENOMEM;
} }
for (i = 0; i < me->capacity; i++) { for (i = 0; i < me->capacity; i++) {
char *traverse = old_buckets[i]; char *traverse = old_buckets[i];
@@ -157,7 +156,7 @@ int unordered_multiset_rehash(unordered_multiset me)
} }
} }
free(old_buckets); 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 * @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; 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. * 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; size_t i;
const size_t old_capacity = me->capacity; 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); me->buckets = calloc(new_capacity, ptr_size);
if (!me->buckets) { if (!me->buckets) {
me->buckets = old_buckets; me->buckets = old_buckets;
return -ENOMEM; return -BK_ENOMEM;
} }
me->capacity = new_capacity; me->capacity = new_capacity;
for (i = 0; i < old_capacity; i++) { for (i = 0; i < old_capacity; i++) {
@@ -209,15 +208,16 @@ static int unordered_multiset_resize(unordered_multiset me)
} }
} }
free(old_buckets); free(old_buckets);
return 0; return BK_OK;
} }
/* /*
* Determines if an element is equal to the key. * Determines if an element is equal to the key.
*/ */
static int unordered_multiset_is_equal(unordered_multiset me, char *const item, static bk_bool unordered_multiset_is_equal(unordered_multiset me,
const unsigned long hash, char *const item,
const void *const key) const unsigned long hash,
const void *const key)
{ {
unsigned long item_hash; unsigned long item_hash;
memcpy(&item_hash, item + node_hash_offset, hash_size); 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 me the unordered multi-set to add to
* @param key the element to add * @param key the element to add
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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); const unsigned long hash = unordered_multiset_hash(me, key);
int index; size_t index;
if (me->used + 1 >= if (me->used + 1 >=
(size_t) (BKTHOMPS_U_MULTISET_RESIZE_AT * me->capacity)) { (size_t) (BKTHOMPS_U_MULTISET_RESIZE_AT * me->capacity)) {
const int rc = unordered_multiset_resize(me); const bk_err rc = unordered_multiset_resize(me);
if (rc != 0) { if (rc != BK_OK) {
return rc; return rc;
} }
} }
index = (size_t) (hash % me->capacity); index = hash % me->capacity;
if (!me->buckets[index]) { if (!me->buckets[index]) {
me->buckets[index] = unordered_multiset_create_element(me, hash, key); me->buckets[index] = unordered_multiset_create_element(me, hash, key);
if (!me->buckets[index]) { if (!me->buckets[index]) {
return -ENOMEM; return -BK_ENOMEM;
} }
} else { } else {
char *traverse = me->buckets[index]; char *traverse = me->buckets[index];
@@ -283,7 +283,7 @@ int unordered_multiset_put(unordered_multiset me, void *const key)
count++; count++;
memcpy(traverse + node_count_offset, &count, count_size); memcpy(traverse + node_count_offset, &count, count_size);
me->size++; me->size++;
return 0; return BK_OK;
} }
memcpy(&traverse_next, traverse + node_next_offset, ptr_size); memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
while (traverse_next) { while (traverse_next) {
@@ -295,18 +295,18 @@ int unordered_multiset_put(unordered_multiset me, void *const key)
count++; count++;
memcpy(traverse + node_count_offset, &count, count_size); memcpy(traverse + node_count_offset, &count, count_size);
me->size++; me->size++;
return 0; return BK_OK;
} }
} }
traverse_next = unordered_multiset_create_element(me, hash, key); traverse_next = unordered_multiset_create_element(me, hash, key);
if (!traverse_next) { if (!traverse_next) {
return -ENOMEM; return -BK_ENOMEM;
} }
memcpy(traverse + node_next_offset, &traverse_next, ptr_size); memcpy(traverse + node_next_offset, &traverse_next, ptr_size);
} }
me->size++; me->size++;
me->used++; 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 me the unordered multi-set to check for the key
* @param key the key to check * @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; 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 me the unordered multi-set to remove a key from
* @param key the key to remove * @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;
char *traverse_next; char *traverse_next;
const unsigned long hash = unordered_multiset_hash(me, key); const unsigned long hash = unordered_multiset_hash(me, key);
const size_t index = hash % me->capacity; const size_t index = hash % me->capacity;
if (!me->buckets[index]) { if (!me->buckets[index]) {
return 0; return BK_FALSE;
} }
traverse = me->buckets[index]; traverse = me->buckets[index];
if (unordered_multiset_is_equal(me, traverse, hash, key)) { 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); memcpy(traverse + node_count_offset, &count, count_size);
} }
me->size--; me->size--;
return 1; return BK_TRUE;
} }
memcpy(&traverse_next, traverse + node_next_offset, ptr_size); memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
while (traverse_next) { 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); memcpy(traverse_next + node_count_offset, &count, count_size);
} }
me->size--; me->size--;
return 1; return BK_TRUE;
} }
traverse = traverse_next; traverse = traverse_next;
memcpy(&traverse_next, traverse + node_next_offset, ptr_size); 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 me the unordered multi-set to remove a key from
* @param key the key to remove * @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;
char *traverse_next; char *traverse_next;
const unsigned long hash = unordered_multiset_hash(me, key); const unsigned long hash = unordered_multiset_hash(me, key);
const size_t index = hash % me->capacity; const size_t index = hash % me->capacity;
if (!me->buckets[index]) { if (!me->buckets[index]) {
return 0; return BK_FALSE;
} }
traverse = me->buckets[index]; traverse = me->buckets[index];
if (unordered_multiset_is_equal(me, traverse, hash, key)) { 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); free(traverse);
me->used--; me->used--;
me->size -= count; me->size -= count;
return 1; return BK_TRUE;
} }
memcpy(&traverse_next, traverse + node_next_offset, ptr_size); memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
while (traverse_next) { while (traverse_next) {
@@ -453,12 +456,12 @@ int unordered_multiset_remove_all(unordered_multiset me, void *const key)
free(traverse_next); free(traverse_next);
me->used--; me->used--;
me->size -= count; me->size -= count;
return 1; return BK_TRUE;
} }
traverse = traverse_next; traverse = traverse_next;
memcpy(&traverse_next, traverse + node_next_offset, ptr_size); 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 * @param me the unordered multi-set to clear
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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; size_t i;
char **updated_buckets = calloc(BKTHOMPS_U_MULTISET_STARTING_BUCKETS, char **updated_buckets = calloc(BKTHOMPS_U_MULTISET_STARTING_BUCKETS,
ptr_size); ptr_size);
if (!updated_buckets) { if (!updated_buckets) {
return -ENOMEM; return -BK_ENOMEM;
} }
for (i = 0; i < me->capacity; i++) { for (i = 0; i < me->capacity; i++) {
char *traverse = me->buckets[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->capacity = BKTHOMPS_U_MULTISET_STARTING_BUCKETS;
me->used = 0; me->used = 0;
me->buckets = updated_buckets; me->buckets = updated_buckets;
return 0; return BK_OK;
} }
/** /**

74
src/unordered_set.c
View File

@@ -21,7 +21,6 @@
*/ */
#include <string.h> #include <string.h>
#include <errno.h>
#include "include/unordered_set.h" #include "include/unordered_set.h"
#define BKTHOMPS_U_SET_STARTING_BUCKETS 16 #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 * @param me the unordered set to rehash
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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; size_t i;
char **old_buckets = me->buckets; char **old_buckets = me->buckets;
me->buckets = calloc(me->capacity, ptr_size); me->buckets = calloc(me->capacity, ptr_size);
if (!me->buckets) { if (!me->buckets) {
me->buckets = old_buckets; me->buckets = old_buckets;
return -ENOMEM; return -BK_ENOMEM;
} }
for (i = 0; i < me->capacity; i++) { for (i = 0; i < me->capacity; i++) {
char *traverse = old_buckets[i]; char *traverse = old_buckets[i];
@@ -151,7 +150,7 @@ int unordered_set_rehash(unordered_set me)
} }
} }
free(old_buckets); 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 * @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; 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. * 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; size_t i;
const size_t old_capacity = me->capacity; 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); me->buckets = calloc(new_capacity, ptr_size);
if (!me->buckets) { if (!me->buckets) {
me->buckets = old_buckets; me->buckets = old_buckets;
return -ENOMEM; return -BK_ENOMEM;
} }
me->capacity = new_capacity; me->capacity = new_capacity;
for (i = 0; i < old_capacity; i++) { for (i = 0; i < old_capacity; i++) {
@@ -203,15 +202,15 @@ static int unordered_set_resize(unordered_set me)
} }
} }
free(old_buckets); free(old_buckets);
return 0; return BK_OK;
} }
/* /*
* Determines if an element is equal to the key. * Determines if an element is equal to the key.
*/ */
static int unordered_set_is_equal(unordered_set me, char *const item, static bk_bool unordered_set_is_equal(unordered_set me, char *const item,
const unsigned long hash, const unsigned long hash,
const void *const key) const void *const key)
{ {
unsigned long item_hash; unsigned long item_hash;
memcpy(&item_hash, item + node_hash_offset, hash_size); 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 me the unordered set to add to
* @param key the element to add * @param key the element to add
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @return -BK_ENOMEM if out of memory
*/ */
int unordered_set_put(unordered_set me, void *const key) int unordered_set_put(unordered_set me, void *const key)
{ {
const unsigned long hash = unordered_set_hash(me, 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)) { if (me->size + 1 >= (size_t) (BKTHOMPS_U_SET_RESIZE_AT * me->capacity)) {
const int rc = unordered_set_resize(me); const bk_err rc = unordered_set_resize(me);
if (rc != 0) { if (rc != BK_OK) {
return rc; return rc;
} }
} }
index = (size_t) (hash % me->capacity); index = hash % me->capacity;
if (!me->buckets[index]) { if (!me->buckets[index]) {
me->buckets[index] = unordered_set_create_element(me, hash, key); me->buckets[index] = unordered_set_create_element(me, hash, key);
if (!me->buckets[index]) { if (!me->buckets[index]) {
return -ENOMEM; return -BK_ENOMEM;
} }
} else { } else {
char *traverse = me->buckets[index]; char *traverse = me->buckets[index];
char *traverse_next; char *traverse_next;
if (unordered_set_is_equal(me, traverse, hash, key)) { if (unordered_set_is_equal(me, traverse, hash, key)) {
return 0; return BK_OK;
} }
memcpy(&traverse_next, traverse + node_next_offset, ptr_size); memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
while (traverse_next) { while (traverse_next) {
traverse = traverse_next; traverse = traverse_next;
memcpy(&traverse_next, traverse + node_next_offset, ptr_size); memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
if (unordered_set_is_equal(me, traverse, hash, key)) { if (unordered_set_is_equal(me, traverse, hash, key)) {
return 0; return BK_OK;
} }
} }
traverse_next = unordered_set_create_element(me, hash, key); traverse_next = unordered_set_create_element(me, hash, key);
if (!traverse_next) { if (!traverse_next) {
return -ENOMEM; return -BK_ENOMEM;
} }
memcpy(traverse + node_next_offset, &traverse_next, ptr_size); memcpy(traverse + node_next_offset, &traverse_next, ptr_size);
} }
me->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 me the unordered set to check for the element
* @param key the element to check * @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) 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]; char *traverse = me->buckets[hash % me->capacity];
while (traverse) { while (traverse) {
if (unordered_set_is_equal(me, traverse, hash, key)) { if (unordered_set_is_equal(me, traverse, hash, key)) {
return 1; return BK_TRUE;
} }
memcpy(&traverse, traverse + node_next_offset, ptr_size); 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 me the unordered set to remove a key from
* @param key the key to remove * @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) 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 unsigned long hash = unordered_set_hash(me, key);
const size_t index = hash % me->capacity; const size_t index = hash % me->capacity;
if (!me->buckets[index]) { if (!me->buckets[index]) {
return 0; return BK_FALSE;
} }
traverse = me->buckets[index]; traverse = me->buckets[index];
if (unordered_set_is_equal(me, traverse, hash, key)) { if (unordered_set_is_equal(me, traverse, hash, key)) {
memcpy(me->buckets + index, traverse + node_next_offset, ptr_size); memcpy(me->buckets + index, traverse + node_next_offset, ptr_size);
free(traverse); free(traverse);
me->size--; me->size--;
return 1; return BK_TRUE;
} }
memcpy(&traverse_next, traverse + node_next_offset, ptr_size); memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
while (traverse_next) { while (traverse_next) {
@@ -350,12 +350,12 @@ int unordered_set_remove(unordered_set me, void *const key)
traverse_next + node_next_offset, ptr_size); traverse_next + node_next_offset, ptr_size);
free(traverse_next); free(traverse_next);
me->size--; me->size--;
return 1; return BK_TRUE;
} }
traverse = traverse_next; traverse = traverse_next;
memcpy(&traverse_next, traverse + node_next_offset, ptr_size); 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 * @param me the unordered set to clear
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @return -BK_ENOMEM if out of memory
*/ */
int unordered_set_clear(unordered_set me) int unordered_set_clear(unordered_set me)
{ {
size_t i; size_t i;
char **updated_buckets = calloc(BKTHOMPS_U_SET_STARTING_BUCKETS, ptr_size); char **updated_buckets = calloc(BKTHOMPS_U_SET_STARTING_BUCKETS, ptr_size);
if (!updated_buckets) { if (!updated_buckets) {
return -ENOMEM; return -BK_ENOMEM;
} }
for (i = 0; i < me->capacity; i++) { for (i = 0; i < me->capacity; i++) {
char *traverse = me->buckets[i]; char *traverse = me->buckets[i];
@@ -385,7 +385,7 @@ int unordered_set_clear(unordered_set me)
me->size = 0; me->size = 0;
me->capacity = BKTHOMPS_U_SET_STARTING_BUCKETS; me->capacity = BKTHOMPS_U_SET_STARTING_BUCKETS;
me->buckets = updated_buckets; me->buckets = updated_buckets;
return 0; return BK_OK;
} }
/** /**

130
src/vector.c
View File

@@ -21,7 +21,6 @@
*/ */
#include <string.h> #include <string.h>
#include <errno.h>
#include "include/vector.h" #include "include/vector.h"
#define BKTHOMPS_VECTOR_START_SPACE 8 #define BKTHOMPS_VECTOR_START_SPACE 8
@@ -93,9 +92,9 @@ size_t vector_capacity(vector me)
* *
* @param me the vector to check * @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; 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 * Sets the space of the buffer. Assumes that size is at least the same as the
* number of items currently in the vector. * 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); char *const temp = realloc(me->data, size * me->bytes_per_item);
if (!temp) { if (!temp) {
return -ENOMEM; return -BK_ENOMEM;
} }
me->item_capacity = size; me->item_capacity = size;
me->data = temp; 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 me the vector to reserve space for
* @param size the space to reserve * @param size the space to reserve
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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) { if (me->item_capacity >= size) {
return 0; return BK_OK;
} }
return vector_set_space(me, size); return vector_set_space(me, size);
} }
@@ -138,10 +137,10 @@ int vector_reserve(vector me, size_t size)
* *
* @param me the vector to trim * @param me the vector to trim
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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); 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 * 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 * data will cause the vector structure data to be modified. Operations using
* the vector functions may invalidate this pointer. The vector owns this * 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 * @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 me the vector to add to
* @param data the data to add to the vector * @param data the data to add to the vector
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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); 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 index the location in the vector to add the data to
* @param data the data to add to the vector * @param data the data to add to the vector
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @return -BK_ENOMEM if out of memory
* @return -EINVAL if invalid argument * @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) { if (index > me->item_count) {
return -EINVAL; return -BK_EINVAL;
} }
if (me->item_count + 1 >= me->item_capacity) { if (me->item_count + 1 >= me->item_capacity) {
const size_t new_space = const size_t new_space =
(size_t) (me->item_capacity * BKTHOMPS_VECTOR_RESIZE_RATIO); (size_t) (me->item_capacity * BKTHOMPS_VECTOR_RESIZE_RATIO);
char *const temp = realloc(me->data, new_space * me->bytes_per_item); char *const temp = realloc(me->data, new_space * me->bytes_per_item);
if (!temp) { if (!temp) {
return -ENOMEM; return -BK_ENOMEM;
} }
me->data = temp; me->data = temp;
me->item_capacity = new_space; 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); memcpy(me->data + index * me->bytes_per_item, data, me->bytes_per_item);
me->item_count++; 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 me the vector to add to
* @param data the data to add to the vector * @param data the data to add to the vector
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @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); 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 * @param me the vector to remove from
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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); return vector_remove_at(me, 0);
} }
@@ -273,19 +273,19 @@ int vector_remove_first(vector me)
* @param me the vector to remove from * @param me the vector to remove from
* @param index the location in the vector to remove the data from * @param index the location in the vector to remove the data from
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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) { if (index >= me->item_count) {
return -EINVAL; return -BK_EINVAL;
} }
me->item_count--; me->item_count--;
memmove(me->data + index * me->bytes_per_item, memmove(me->data + index * me->bytes_per_item,
me->data + (index + 1) * me->bytes_per_item, me->data + (index + 1) * me->bytes_per_item,
(me->item_count - index) * 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 * @param me the vector to remove from
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @return -BK_EINVAL if invalid argument
*/ */
int vector_remove_last(vector me) bk_err vector_remove_last(vector me)
{ {
if (me->item_count == 0) { if (me->item_count == 0) {
return -EINVAL; return -BK_EINVAL;
} }
me->item_count--; 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 me the vector to set data for
* @param data the data to set at the start of the vector * @param data the data to set at the start of the vector
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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); 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 index the location to set data at in the vector
* @param data the data to set at the location in the vector * @param data the data to set at the location in the vector
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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) { if (index >= me->item_count) {
return -EINVAL; return -BK_EINVAL;
} }
memcpy(me->data + index * me->bytes_per_item, data, me->bytes_per_item); 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 me the vector to set data for
* @param data the data to set at the end of the vector * @param data the data to set at the end of the vector
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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); 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 data the data to copy to
* @param me the vector to copy from * @param me the vector to copy from
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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); 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 me the vector to copy from
* @param index the index to copy from in the vector * @param index the index to copy from in the vector
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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) { if (index >= me->item_count) {
return -EINVAL; return -BK_EINVAL;
} }
memcpy(data, me->data + index * me->bytes_per_item, me->bytes_per_item); 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 data the data to copy to
* @param me the vector to copy from * @param me the vector to copy from
* *
* @return 0 if no error * @return BK_OK if no error
* @return -EINVAL if invalid argument * @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); 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 * @param me the vector to clear
* *
* @return 0 if no error * @return BK_OK if no error
* @return -ENOMEM if out of memory * @return -BK_ENOMEM if out of memory
*/ */
int vector_clear(vector me) bk_err vector_clear(vector me)
{ {
me->item_count = 0; me->item_count = 0;
return vector_set_space(me, BKTHOMPS_VECTOR_START_SPACE); return vector_set_space(me, BKTHOMPS_VECTOR_START_SPACE);

2
tst/test.h
View File

@@ -4,6 +4,8 @@
#include <stdlib.h> #include <stdlib.h>
#include <errno.h> #include <errno.h>
#include <assert.h> #include <assert.h>
#include <limits.h>
#include <string.h>
#define STUB_MALLOC 1 #define STUB_MALLOC 1

1
tst/test_array.c
View File

@@ -1,4 +1,3 @@
#include <limits.h>
#include "test.h" #include "test.h"
#include "../src/include/array.h" #include "../src/include/array.h"

1
tst/test_deque.c
View File

@@ -1,4 +1,3 @@
#include <limits.h>
#include "test.h" #include "test.h"
#include "../src/include/deque.h" #include "../src/include/deque.h"

1
tst/test_forward_list.c
View File

@@ -1,4 +1,3 @@
#include <limits.h>
#include "test.h" #include "test.h"
#include "../src/include/forward_list.h" #include "../src/include/forward_list.h"

1
tst/test_list.c
View File

@@ -1,4 +1,3 @@
#include <limits.h>
#include "test.h" #include "test.h"
#include "../src/include/list.h" #include "../src/include/list.h"

2
tst/test_map.c
View File

@@ -1,5 +1,3 @@
#include <limits.h>
#include <memory.h>
#include "test.h" #include "test.h"
#include "../src/include/map.h" #include "../src/include/map.h"

2
tst/test_multimap.c
View File

@@ -1,5 +1,3 @@
#include <limits.h>
#include <memory.h>
#include "test.h" #include "test.h"
#include "../src/include/multimap.h" #include "../src/include/multimap.h"

2
tst/test_multiset.c
View File

@@ -1,5 +1,3 @@
#include <limits.h>
#include <memory.h>
#include "test.h" #include "test.h"
#include "../src/include/multiset.h" #include "../src/include/multiset.h"

1
tst/test_priority_queue.c
View File

@@ -1,4 +1,3 @@
#include <limits.h>
#include "test.h" #include "test.h"
#include "../src/include/vector.h" #include "../src/include/vector.h"
#include "../src/include/priority_queue.h" #include "../src/include/priority_queue.h"

1
tst/test_queue.c
View File

@@ -1,4 +1,3 @@
#include <limits.h>
#include "test.h" #include "test.h"
#include "../src/include/queue.h" #include "../src/include/queue.h"

2
tst/test_set.c
View File

@@ -1,5 +1,3 @@
#include <limits.h>
#include <memory.h>
#include "test.h" #include "test.h"
#include "../src/include/set.h" #include "../src/include/set.h"

1
tst/test_stack.c
View File

@@ -1,4 +1,3 @@
#include <limits.h>
#include "test.h" #include "test.h"
#include "../src/include/stack.h" #include "../src/include/stack.h"

1
tst/test_unordered_map.c
View File

@@ -1,4 +1,3 @@
#include <limits.h>
#include "test.h" #include "test.h"
#include "../src/include/unordered_map.h" #include "../src/include/unordered_map.h"

1
tst/test_unordered_multimap.c
View File

@@ -1,4 +1,3 @@
#include <limits.h>
#include "test.h" #include "test.h"
#include "../src/include/unordered_multimap.h" #include "../src/include/unordered_multimap.h"

1
tst/test_unordered_multiset.c
View File

@@ -1,4 +1,3 @@
#include <limits.h>
#include "test.h" #include "test.h"
#include "../src/include/unordered_multiset.h" #include "../src/include/unordered_multiset.h"

1
tst/test_unordered_set.c
View File

@@ -1,4 +1,3 @@
#include <limits.h>
#include "test.h" #include "test.h"
#include "../src/include/unordered_set.h" #include "../src/include/unordered_set.h"

2
tst/test_vector.c
View File

@@ -1,5 +1,3 @@
#include <limits.h>
#include <string.h>
#include "test.h" #include "test.h"
#include "../src/include/vector.h" #include "../src/include/vector.h"