Imagelibrary/Containers
1
0
Fork 0
mirror of https://github.com/bkthomps/Containers.git synced 2025-11-16 12:34:47 +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'))):
with open(filename, 'r') as file:
text = file.read()
header += text.split("*/", 1)[1]
entire_file = text.split("*/", 1)[1]
split_around_include = entire_file.split('#include "all.h"\n\n', 1)
header += split_around_include[0]
if len(split_around_include) == 2:
header += split_around_include[1]
containers_header_file = open("containers.h", "w+")
containers_header_file.write(header)

304
containers.h
View File

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

7
documentation.md
View File

@@ -61,10 +61,10 @@ int):
deque d = deque_init(sizeof(int));
...
int add = 5;
int rc = deque_push_back(d, &add); /* 5 has been added to the back of the deque */
bk_err rc = deque_push_back(d, &add); /* 5 has been added to the back of the deque */
...
int retrieve;
int rc = deque_pop_back(&retrieve, d); /* retrieve now is equal to 5 */
bk_err rc = deque_pop_back(&retrieve, d); /* retrieve now is equal to 5 */
...
```
@@ -72,7 +72,8 @@ Functions can fail for various reasons, such as the provided index argument
being out of bounds, or the system running out of memory. The in-depth
documentation linked above provides the exhaustive list of return codes for each
function, which are present in the `errno.h` header file. For example, an
invalid argument would return `-EINVAL`, and on success 0 would be returned.
invalid argument would return `-BK_EINVAL`, and on success `BK_OK` would be
returned.
# Comparators and Hash Functions
The associative containers and the priority queue require the user to initialize

23
src/array.c
View File

@@ -21,7 +21,6 @@
*/
#include <string.h>
#include <errno.h>
#include "include/array.h"
static const size_t book_keeping_size = sizeof(size_t);
@@ -105,7 +104,7 @@ void array_copy_to_array(void *const arr, array me)
* raw array. This pointer is not a copy, thus any modification to the data will
* cause the array structure data to be modified. Operations using the array
* functions may invalidate this pointer. The array owns this memory, thus it
* should not be freed.
* should not be freed. If the array size if 0, this should not be used.
*
* @param me the array to get the storage element from
*
@@ -132,20 +131,20 @@ void *array_get_data(array me)
* @param index the location to set data at in the array
* @param data the data to set at the location in the array
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int array_set(array me, const size_t index, void *const data)
bk_err array_set(array me, const size_t index, void *const data)
{
size_t element_count;
size_t data_size;
memcpy(&element_count, me + arr_size_offset, book_keeping_size);
if (index >= element_count) {
return -EINVAL;
return -BK_EINVAL;
}
memcpy(&data_size, me + data_size_offset, book_keeping_size);
memcpy(me + data_ptr_offset + index * data_size, data, data_size);
return 0;
return BK_OK;
}
/**
@@ -160,20 +159,20 @@ int array_set(array me, const size_t index, void *const data)
* @param me the array to copy from
* @param index the index to copy from in the array
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int array_get(void *const data, array me, const size_t index)
bk_err array_get(void *const data, array me, const size_t index)
{
size_t element_count;
size_t data_size;
memcpy(&element_count, me + arr_size_offset, book_keeping_size);
if (index >= element_count) {
return -EINVAL;
return -BK_EINVAL;
}
memcpy(&data_size, me + data_size_offset, book_keeping_size);
memcpy(data, me + data_ptr_offset + index * data_size, data_size);
return 0;
return BK_OK;
}
/**

115
src/deque.c
View File

@@ -21,7 +21,6 @@
*/
#include <string.h>
#include <errno.h>
#include "include/deque.h"
#define BKTHOMPS_DEQUE_MAX_BLOCK_BYTE_SIZE 4096
@@ -102,9 +101,9 @@ size_t deque_size(deque me)
*
* @param me the deque to check if empty
*
* @return 1 if the deque is empty, otherwise 0
* @return BK_TRUE if the deque is empty, otherwise BK_FALSE
*/
int deque_is_empty(deque me)
bk_bool deque_is_empty(deque me)
{
return deque_size(me) == 0;
}
@@ -115,10 +114,10 @@ int deque_is_empty(deque me)
*
* @param me the deque to trim
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int deque_trim(deque me)
bk_err deque_trim(deque me)
{
size_t i;
const size_t start_block_index = me->start_index / me->block_size;
@@ -127,7 +126,7 @@ int deque_trim(deque me)
const size_t updated_block_count = end_block_index - start_block_index + 1;
char **updated_data = malloc(updated_block_count * sizeof(char *));
if (!updated_data) {
return -ENOMEM;
return -BK_ENOMEM;
}
memcpy(updated_data, me->data + start_block_index,
updated_block_count * sizeof(char *));
@@ -146,7 +145,7 @@ int deque_trim(deque me)
me->end_index -= start_block_index * me->block_size;
me->block_count = updated_block_count;
me->data = updated_data;
return 0;
return BK_OK;
}
/**
@@ -201,10 +200,10 @@ void deque_copy_to_array(void *const arr, deque me)
* @param me the deque to add an element to
* @param data the element to add
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int deque_push_front(deque me, void *const data)
bk_err deque_push_front(deque me, void *const data)
{
if (me->start_index == 0) {
const size_t updated_block_count =
@@ -212,7 +211,7 @@ int deque_push_front(deque me, void *const data)
const size_t added_blocks = updated_block_count - me->block_count;
char **temp = realloc(me->data, updated_block_count * sizeof(char *));
if (!temp) {
return -ENOMEM;
return -BK_ENOMEM;
}
memmove(temp + added_blocks, temp, me->block_count * sizeof(char *));
memset(temp, 0, added_blocks * sizeof(char *));
@@ -229,7 +228,7 @@ int deque_push_front(deque me, void *const data)
if (!block) {
block = malloc(me->block_size * me->data_size);
if (!block) {
return -ENOMEM;
return -BK_ENOMEM;
}
memcpy(me->data + previous_block_index, &block, sizeof(char *));
}
@@ -242,7 +241,7 @@ int deque_push_front(deque me, void *const data)
memcpy(&block, me->data + block_index, sizeof(char *));
memcpy(block + inner_index * me->data_size, data, me->data_size);
}
return 0;
return BK_OK;
}
/**
@@ -255,10 +254,10 @@ int deque_push_front(deque me, void *const data)
* @param me the deque to add an element to
* @param data the element to add
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int deque_push_back(deque me, void *const data)
bk_err deque_push_back(deque me, void *const data)
{
if (me->end_index == me->block_count * me->block_size) {
const size_t updated_block_count =
@@ -266,7 +265,7 @@ int deque_push_back(deque me, void *const data)
const size_t added_blocks = updated_block_count - me->block_count;
char **temp = realloc(me->data, updated_block_count * sizeof(char *));
if (!temp) {
return -ENOMEM;
return -BK_ENOMEM;
}
memset(temp + me->block_count, 0, added_blocks * sizeof(char *));
me->data = temp;
@@ -279,7 +278,7 @@ int deque_push_back(deque me, void *const data)
if (!block) {
block = malloc(me->block_size * me->data_size);
if (!block) {
return -ENOMEM;
return -BK_ENOMEM;
}
memcpy(me->data + tentative_block_index, &block, sizeof(char *));
}
@@ -292,7 +291,7 @@ int deque_push_back(deque me, void *const data)
memcpy(block + inner_index * me->data_size, data, me->data_size);
}
me->end_index++;
return 0;
return BK_OK;
}
/**
@@ -306,21 +305,21 @@ int deque_push_back(deque me, void *const data)
* @param data the value to copy to
* @param me the deque to remove from
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int deque_pop_front(void *const data, deque me)
bk_err deque_pop_front(void *const data, deque me)
{
char *block;
const size_t block_index = me->start_index / me->block_size;
const size_t inner_index = me->start_index % me->block_size;
if (deque_is_empty(me)) {
return -EINVAL;
return -BK_EINVAL;
}
memcpy(&block, me->data + block_index, sizeof(char *));
memcpy(data, block + inner_index * me->data_size, me->data_size);
me->start_index++;
return 0;
return BK_OK;
}
/**
@@ -334,21 +333,21 @@ int deque_pop_front(void *const data, deque me)
* @param data the value to copy to
* @param me the deque to remove from
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int deque_pop_back(void *const data, deque me)
bk_err deque_pop_back(void *const data, deque me)
{
char *block;
const size_t block_index = (me->end_index - 1) / me->block_size;
const size_t inner_index = (me->end_index - 1) % me->block_size;
if (deque_is_empty(me)) {
return -EINVAL;
return -BK_EINVAL;
}
memcpy(&block, me->data + block_index, sizeof(char *));
memcpy(data, block + inner_index * me->data_size, me->data_size);
me->end_index--;
return 0;
return BK_OK;
}
/**
@@ -361,10 +360,10 @@ int deque_pop_back(void *const data, deque me)
* @param me the deque to set the value of
* @param data the data to set
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int deque_set_first(deque me, void *const data)
bk_err deque_set_first(deque me, void *const data)
{
return deque_set_at(me, 0, data);
}
@@ -380,20 +379,20 @@ int deque_set_first(deque me, void *const data)
* @param index the index to set at
* @param data the data to set
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int deque_set_at(deque me, size_t index, void *const data)
bk_err deque_set_at(deque me, size_t index, void *const data)
{
char *block;
const size_t block_index = (index + me->start_index) / me->block_size;
const size_t inner_index = (index + me->start_index) % me->block_size;
if (index >= deque_size(me)) {
return -EINVAL;
return -BK_EINVAL;
}
memcpy(&block, me->data + block_index, sizeof(char *));
memcpy(block + inner_index * me->data_size, data, me->data_size);
return 0;
return BK_OK;
}
/**
@@ -406,10 +405,10 @@ int deque_set_at(deque me, size_t index, void *const data)
* @param me the deque to set the value of
* @param data the data to set
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int deque_set_last(deque me, void *const data)
bk_err deque_set_last(deque me, void *const data)
{
return deque_set_at(me, deque_size(me) - 1, data);
}
@@ -424,10 +423,10 @@ int deque_set_last(deque me, void *const data)
* @param data the data to set
* @param me the deque to set the value of
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int deque_get_first(void *const data, deque me)
bk_err deque_get_first(void *const data, deque me)
{
return deque_get_at(data, me, 0);
}
@@ -443,20 +442,20 @@ int deque_get_first(void *const data, deque me)
* @param me the deque to set the value of
* @param index the index to set at
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int deque_get_at(void *const data, deque me, size_t index)
bk_err deque_get_at(void *const data, deque me, size_t index)
{
char *block;
const size_t block_index = (index + me->start_index) / me->block_size;
const size_t inner_index = (index + me->start_index) % me->block_size;
if (index >= deque_size(me)) {
return -EINVAL;
return -BK_EINVAL;
}
memcpy(&block, me->data + block_index, sizeof(char *));
memcpy(data, block + inner_index * me->data_size, me->data_size);
return 0;
return BK_OK;
}
/**
@@ -469,10 +468,10 @@ int deque_get_at(void *const data, deque me, size_t index)
* @param data the data to set
* @param me the deque to set the value of
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int deque_get_last(void *const data, deque me)
bk_err deque_get_last(void *const data, deque me)
{
return deque_get_at(data, me, deque_size(me) - 1);
}
@@ -482,22 +481,22 @@ int deque_get_last(void *const data, deque me)
*
* @param me the deque to clear
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int deque_clear(deque me)
bk_err deque_clear(deque me)
{
size_t i;
char *updated_block;
char **updated_data = calloc(BKTHOMPS_DEQUE_INITIAL_BLOCK_COUNT,
sizeof(char *));
if (!updated_data) {
return -ENOMEM;
return -BK_ENOMEM;
}
updated_block = malloc(me->block_size * me->data_size);
if (!updated_block) {
free(updated_data);
return -ENOMEM;
return -BK_ENOMEM;
}
for (i = 0; i < me->block_count; i++) {
char *block;
@@ -511,7 +510,7 @@ int deque_clear(deque me)
me->data = updated_data;
memcpy(me->data + me->start_index / me->block_size, &updated_block,
sizeof(char *));
return 0;
return BK_OK;
}
/**

100
src/forward_list.c
View File

@@ -21,7 +21,6 @@
*/
#include <string.h>
#include <errno.h>
#include "include/forward_list.h"
struct internal_forward_list {
@@ -78,9 +77,9 @@ size_t forward_list_size(forward_list me)
*
* @param me the singly-linked list to check
*
* @return 1 if the singly-linked list is empty, otherwise 0
* @return BK_TRUE if the singly-linked list is empty, otherwise BK_FALSE
*/
int forward_list_is_empty(forward_list me)
bk_bool forward_list_is_empty(forward_list me)
{
return forward_list_size(me) == 0;
}
@@ -139,10 +138,10 @@ static char *forward_list_get_node_at(forward_list me, const size_t index)
* @param me the singly-linked list to add data to
* @param data the data to add to the singly-linked list
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int forward_list_add_first(forward_list me, void *const data)
bk_err forward_list_add_first(forward_list me, void *const data)
{
return forward_list_add_at(me, 0, data);
}
@@ -158,19 +157,20 @@ int forward_list_add_first(forward_list me, void *const data)
* @param index the index to add the data at
* @param data the data to add to the singly-linked list
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
* @return -BK_EINVAL if invalid argument
*/
int forward_list_add_at(forward_list me, const size_t index, void *const data)
bk_err forward_list_add_at(forward_list me, const size_t index,
void *const data)
{
char *node;
if (index > me->item_count) {
return -EINVAL;
return -BK_EINVAL;
}
node = malloc(ptr_size + me->bytes_per_item);
if (!node) {
return -ENOMEM;
return -BK_ENOMEM;
}
memcpy(node + node_data_ptr_offset, data, me->bytes_per_item);
if (index == 0) {
@@ -188,7 +188,7 @@ int forward_list_add_at(forward_list me, const size_t index, void *const data)
}
}
me->item_count++;
return 0;
return BK_OK;
}
/**
@@ -201,10 +201,10 @@ int forward_list_add_at(forward_list me, const size_t index, void *const data)
* @param me the singly-linked list to add data to
* @param data the data to add to the singly-linked list
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int forward_list_add_last(forward_list me, void *const data)
bk_err forward_list_add_last(forward_list me, void *const data)
{
return forward_list_add_at(me, me->item_count, data);
}
@@ -214,10 +214,10 @@ int forward_list_add_last(forward_list me, void *const data)
*
* @param me the singly-linked list to remove data from
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int forward_list_remove_first(forward_list me)
bk_err forward_list_remove_first(forward_list me)
{
return forward_list_remove_at(me, 0);
}
@@ -228,13 +228,13 @@ int forward_list_remove_first(forward_list me)
* @param me the singly-linked list to remove data from
* @param index the index to remove from
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int forward_list_remove_at(forward_list me, const size_t index)
bk_err forward_list_remove_at(forward_list me, const size_t index)
{
if (index >= me->item_count) {
return -EINVAL;
return -BK_EINVAL;
}
if (index == 0) {
char *temp = me->head;
@@ -257,7 +257,7 @@ int forward_list_remove_at(forward_list me, const size_t index)
free(backup);
}
me->item_count--;
return 0;
return BK_OK;
}
/**
@@ -265,10 +265,10 @@ int forward_list_remove_at(forward_list me, const size_t index)
*
* @param me the singly-linked list to remove data from
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int forward_list_remove_last(forward_list me)
bk_err forward_list_remove_last(forward_list me)
{
return forward_list_remove_at(me, me->item_count - 1);
}
@@ -283,10 +283,10 @@ int forward_list_remove_last(forward_list me)
* @param me the singly-linked list to set data for
* @param data the data to set in the singly-linked list
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int forward_list_set_first(forward_list me, void *const data)
bk_err forward_list_set_first(forward_list me, void *const data)
{
return forward_list_set_at(me, 0, data);
}
@@ -302,18 +302,19 @@ int forward_list_set_first(forward_list me, void *const data)
* @param index the index to set data in the singly-linked list
* @param data the data to set in the singly-linked list
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int forward_list_set_at(forward_list me, const size_t index, void *const data)
bk_err forward_list_set_at(forward_list me, const size_t index,
void *const data)
{
char *traverse;
if (index >= me->item_count) {
return -EINVAL;
return -BK_EINVAL;
}
traverse = forward_list_get_node_at(me, index);
memcpy(traverse + node_data_ptr_offset, data, me->bytes_per_item);
return 0;
return BK_OK;
}
/**
@@ -326,10 +327,10 @@ int forward_list_set_at(forward_list me, const size_t index, void *const data)
* @param me the singly-linked list to set data for
* @param data the data to set in the singly-linked list
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int forward_list_set_last(forward_list me, void *const data)
bk_err forward_list_set_last(forward_list me, void *const data)
{
return forward_list_set_at(me, me->item_count - 1, data);
}
@@ -345,10 +346,10 @@ int forward_list_set_last(forward_list me, void *const data)
* @param data the data to get
* @param me the singly-linked list to get data from
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int forward_list_get_first(void *const data, forward_list me)
bk_err forward_list_get_first(void *const data, forward_list me)
{
return forward_list_get_at(data, me, 0);
}
@@ -365,18 +366,19 @@ int forward_list_get_first(void *const data, forward_list me)
* @param me the singly-linked list to get data from
* @param index the index to get data from
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int forward_list_get_at(void *const data, forward_list me, const size_t index)
bk_err forward_list_get_at(void *const data, forward_list me,
const size_t index)
{
char *traverse;
if (index >= me->item_count) {
return -EINVAL;
return -BK_EINVAL;
}
traverse = forward_list_get_node_at(me, index);
memcpy(data, traverse + node_data_ptr_offset, me->bytes_per_item);
return 0;
return BK_OK;
}
/**
@@ -390,10 +392,10 @@ int forward_list_get_at(void *const data, forward_list me, const size_t index)
* @param data the data to get
* @param me the singly-linked list to get data from
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int forward_list_get_last(void *const data, forward_list me)
bk_err forward_list_get_last(void *const data, forward_list me)
{
return forward_list_get_at(data, me, me->item_count - 1);
}

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

28
src/include/deque.h
View File

@@ -23,7 +23,7 @@
#ifndef 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.
@@ -35,30 +35,30 @@ deque deque_init(size_t data_size);
/* Utility */
size_t deque_size(deque me);
int deque_is_empty(deque me);
int deque_trim(deque me);
bk_bool deque_is_empty(deque me);
bk_err deque_trim(deque me);
void deque_copy_to_array(void *arr, deque me);
/* Adding */
int deque_push_front(deque me, void *data);
int deque_push_back(deque me, void *data);
bk_err deque_push_front(deque me, void *data);
bk_err deque_push_back(deque me, void *data);
/* Removing */
int deque_pop_front(void *data, deque me);
int deque_pop_back(void *data, deque me);
bk_err deque_pop_front(void *data, deque me);
bk_err deque_pop_back(void *data, deque me);
/* Setting */
int deque_set_first(deque me, void *data);
int deque_set_at(deque me, size_t index, void *data);
int deque_set_last(deque me, void *data);
bk_err deque_set_first(deque me, void *data);
bk_err deque_set_at(deque me, size_t index, void *data);
bk_err deque_set_last(deque me, void *data);
/* Getting */
int deque_get_first(void *data, deque me);
int deque_get_at(void *data, deque me, size_t index);
int deque_get_last(void *data, deque me);
bk_err deque_get_first(void *data, deque me);
bk_err deque_get_at(void *data, deque me, size_t index);
bk_err deque_get_last(void *data, deque me);
/* Ending */
int deque_clear(deque me);
bk_err deque_clear(deque me);
deque deque_destroy(deque me);
#endif /* BKTHOMPS_CONTAINERS_DEQUE_H */

28
src/include/forward_list.h
View File

@@ -23,7 +23,7 @@
#ifndef 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.
@@ -35,28 +35,28 @@ forward_list forward_list_init(size_t data_size);
/* Utility */
size_t forward_list_size(forward_list me);
int forward_list_is_empty(forward_list me);
bk_bool forward_list_is_empty(forward_list me);
void forward_list_copy_to_array(void *arr, forward_list me);
/* Adding */
int forward_list_add_first(forward_list me, void *data);
int forward_list_add_at(forward_list me, size_t index, void *data);
int forward_list_add_last(forward_list me, void *data);
bk_err forward_list_add_first(forward_list me, void *data);
bk_err forward_list_add_at(forward_list me, size_t index, void *data);
bk_err forward_list_add_last(forward_list me, void *data);
/* Removing */
int forward_list_remove_first(forward_list me);
int forward_list_remove_at(forward_list me, size_t index);
int forward_list_remove_last(forward_list me);
bk_err forward_list_remove_first(forward_list me);
bk_err forward_list_remove_at(forward_list me, size_t index);
bk_err forward_list_remove_last(forward_list me);
/* Setting */
int forward_list_set_first(forward_list me, void *data);
int forward_list_set_at(forward_list me, size_t index, void *data);
int forward_list_set_last(forward_list me, void *data);
bk_err forward_list_set_first(forward_list me, void *data);
bk_err forward_list_set_at(forward_list me, size_t index, void *data);
bk_err forward_list_set_last(forward_list me, void *data);
/* Getting */
int forward_list_get_first(void *data, forward_list me);
int forward_list_get_at(void *data, forward_list me, size_t index);
int forward_list_get_last(void *data, forward_list me);
bk_err forward_list_get_first(void *data, forward_list me);
bk_err forward_list_get_at(void *data, forward_list me, size_t index);
bk_err forward_list_get_last(void *data, forward_list me);
/* Ending */
void forward_list_clear(forward_list me);

28
src/include/list.h
View File

@@ -23,7 +23,7 @@
#ifndef 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.
@@ -35,28 +35,28 @@ list list_init(size_t data_size);
/* Utility */
size_t list_size(list me);
int list_is_empty(list me);
bk_bool list_is_empty(list me);
void list_copy_to_array(void *arr, list me);
/* Adding */
int list_add_first(list me, void *data);
int list_add_at(list me, size_t index, void *data);
int list_add_last(list me, void *data);
bk_err list_add_first(list me, void *data);
bk_err list_add_at(list me, size_t index, void *data);
bk_err list_add_last(list me, void *data);
/* Removing */
int list_remove_first(list me);
int list_remove_at(list me, size_t index);
int list_remove_last(list me);
bk_err list_remove_first(list me);
bk_err list_remove_at(list me, size_t index);
bk_err list_remove_last(list me);
/* Setting */
int list_set_first(list me, void *data);
int list_set_at(list me, size_t index, void *data);
int list_set_last(list me, void *data);
bk_err list_set_first(list me, void *data);
bk_err list_set_at(list me, size_t index, void *data);
bk_err list_set_last(list me, void *data);
/* Getting */
int list_get_first(void *data, list me);
int list_get_at(void *data, list me, size_t index);
int list_get_last(void *data, list me);
bk_err list_get_first(void *data, list me);
bk_err list_get_at(void *data, list me, size_t index);
bk_err list_get_last(void *data, list me);
/* Ending */
void list_clear(list me);

12
src/include/map.h
View File

@@ -23,7 +23,7 @@
#ifndef 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
@@ -37,13 +37,13 @@ map map_init(size_t key_size, size_t value_size,
/* Capacity */
size_t map_size(map me);
int map_is_empty(map me);
bk_bool map_is_empty(map me);
/* Accessing */
int map_put(map me, void *key, void *value);
int map_get(void *value, map me, void *key);
int map_contains(map me, void *key);
int map_remove(map me, void *key);
bk_err map_put(map me, void *key, void *value);
bk_bool map_get(void *value, map me, void *key);
bk_bool map_contains(map me, void *key);
bk_bool map_remove(map me, void *key);
/* Ending */
void map_clear(map me);

14
src/include/multimap.h
View File

@@ -23,7 +23,7 @@
#ifndef 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
@@ -40,16 +40,16 @@ multimap multimap_init(size_t key_size, size_t value_size,
/* Capacity */
size_t multimap_size(multimap me);
int multimap_is_empty(multimap me);
bk_bool multimap_is_empty(multimap me);
/* Accessing */
int multimap_put(multimap me, void *key, void *value);
bk_err multimap_put(multimap me, void *key, void *value);
void multimap_get_start(multimap me, void *key);
int multimap_get_next(void *value, multimap me);
bk_bool multimap_get_next(void *value, multimap me);
size_t multimap_count(multimap me, void *key);
int multimap_contains(multimap me, void *key);
int multimap_remove(multimap me, void *key, void *value);
int multimap_remove_all(multimap me, void *key);
bk_bool multimap_contains(multimap me, void *key);
bk_bool multimap_remove(multimap me, void *key, void *value);
bk_bool multimap_remove_all(multimap me, void *key);
/* Ending */
void multimap_clear(multimap me);

12
src/include/multiset.h
View File

@@ -23,7 +23,7 @@
#ifndef 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
@@ -38,14 +38,14 @@ multiset multiset_init(size_t key_size,
/* Capacity */
size_t multiset_size(multiset me);
int multiset_is_empty(multiset me);
bk_bool multiset_is_empty(multiset me);
/* Accessing */
int multiset_put(multiset me, void *key);
bk_err multiset_put(multiset me, void *key);
size_t multiset_count(multiset me, void *key);
int multiset_contains(multiset me, void *key);
int multiset_remove(multiset me, void *key);
int multiset_remove_all(multiset me, void *key);
bk_bool multiset_contains(multiset me, void *key);
bk_bool multiset_remove(multiset me, void *key);
bk_bool multiset_remove_all(multiset me, void *key);
/* Ending */
void multiset_clear(multiset me);

12
src/include/priority_queue.h
View File

@@ -23,7 +23,7 @@
#ifndef 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
@@ -38,19 +38,19 @@ priority_queue priority_queue_init(size_t data_size,
/* Utility */
size_t priority_queue_size(priority_queue me);
int priority_queue_is_empty(priority_queue me);
bk_bool priority_queue_is_empty(priority_queue me);
/* Adding */
int priority_queue_push(priority_queue me, void *data);
bk_err priority_queue_push(priority_queue me, void *data);
/* Removing */
int priority_queue_pop(void *data, priority_queue me);
bk_bool priority_queue_pop(void *data, priority_queue me);
/* Getting */
int priority_queue_front(void *data, priority_queue me);
bk_bool priority_queue_front(void *data, priority_queue me);
/* Ending */
int priority_queue_clear(priority_queue me);
bk_err priority_queue_clear(priority_queue me);
priority_queue priority_queue_destroy(priority_queue me);
#endif /* BKTHOMPS_CONTAINERS_PRIORITY_QUEUE_H */

16
src/include/queue.h
View File

@@ -23,7 +23,7 @@
#ifndef 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
@@ -36,22 +36,22 @@ queue queue_init(size_t data_size);
/* Utility */
size_t queue_size(queue me);
int queue_is_empty(queue me);
int queue_trim(queue me);
bk_bool queue_is_empty(queue me);
bk_err queue_trim(queue me);
void queue_copy_to_array(void *arr, queue me);
/* Adding */
int queue_push(queue me, void *data);
bk_err queue_push(queue me, void *data);
/* Removing */
int queue_pop(void *data, queue me);
bk_bool queue_pop(void *data, queue me);
/* Getting */
int queue_front(void *data, queue me);
int queue_back(void *data, queue me);
bk_bool queue_front(void *data, queue me);
bk_bool queue_back(void *data, queue me);
/* Ending */
int queue_clear(queue me);
bk_err queue_clear(queue me);
queue queue_destroy(queue me);
#endif /* BKTHOMPS_CONTAINERS_QUEUE_H */

10
src/include/set.h
View File

@@ -23,7 +23,7 @@
#ifndef 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.
@@ -36,12 +36,12 @@ set set_init(size_t key_size,
/* Capacity */
size_t set_size(set me);
int set_is_empty(set me);
bk_bool set_is_empty(set me);
/* Accessing */
int set_put(set me, void *key);
int set_contains(set me, void *key);
int set_remove(set me, void *key);
bk_err set_put(set me, void *key);
bk_bool set_contains(set me, void *key);
bk_bool set_remove(set me, void *key);
/* Ending */
void set_clear(set me);

14
src/include/stack.h
View File

@@ -23,7 +23,7 @@
#ifndef 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
@@ -36,21 +36,21 @@ stack stack_init(size_t data_size);
/* Utility */
size_t stack_size(stack me);
int stack_is_empty(stack me);
int stack_trim(stack me);
bk_bool stack_is_empty(stack me);
bk_err stack_trim(stack me);
void stack_copy_to_array(void *arr, stack me);
/* Adding */
int stack_push(stack me, void *data);
bk_err stack_push(stack me, void *data);
/* Removing */
int stack_pop(void *data, stack me);
bk_bool stack_pop(void *data, stack me);
/* Getting */
int stack_top(void *data, stack me);
bk_bool stack_top(void *data, stack me);
/* Ending */
int stack_clear(stack me);
bk_err stack_clear(stack me);
stack stack_destroy(stack me);
#endif /* BKTHOMPS_CONTAINERS_STACK_H */

16
src/include/unordered_map.h
View File

@@ -23,7 +23,7 @@
#ifndef 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,
@@ -39,18 +39,18 @@ unordered_map unordered_map_init(size_t key_size,
const void *const two));
/* Utility */
int unordered_map_rehash(unordered_map me);
bk_err unordered_map_rehash(unordered_map me);
size_t unordered_map_size(unordered_map me);
int unordered_map_is_empty(unordered_map me);
bk_bool unordered_map_is_empty(unordered_map me);
/* Accessing */
int unordered_map_put(unordered_map me, void *key, void *value);
int unordered_map_get(void *value, unordered_map me, void *key);
int unordered_map_contains(unordered_map me, void *key);
int unordered_map_remove(unordered_map me, void *key);
bk_err unordered_map_put(unordered_map me, void *key, void *value);
bk_bool unordered_map_get(void *value, unordered_map me, void *key);
bk_bool unordered_map_contains(unordered_map me, void *key);
bk_bool unordered_map_remove(unordered_map me, void *key);
/* Ending */
int unordered_map_clear(unordered_map me);
bk_err unordered_map_clear(unordered_map me);
unordered_map unordered_map_destroy(unordered_map me);
#endif /* BKTHOMPS_CONTAINERS_UNORDERED_MAP_H */

21
src/include/unordered_multimap.h
View File

@@ -23,7 +23,7 @@
#ifndef 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
@@ -42,21 +42,22 @@ unordered_multimap_init(size_t key_size,
const void *const two));
/* Utility */
int unordered_multimap_rehash(unordered_multimap me);
bk_err unordered_multimap_rehash(unordered_multimap me);
size_t unordered_multimap_size(unordered_multimap me);
int unordered_multimap_is_empty(unordered_multimap me);
bk_bool unordered_multimap_is_empty(unordered_multimap me);
/* Accessing */
int unordered_multimap_put(unordered_multimap me, void *key, void *value);
bk_err unordered_multimap_put(unordered_multimap me, void *key, void *value);
void unordered_multimap_get_start(unordered_multimap me, void *key);
int unordered_multimap_get_next(void *value, unordered_multimap me);
int unordered_multimap_count(unordered_multimap me, void *key);
int unordered_multimap_contains(unordered_multimap me, void *key);
int unordered_multimap_remove(unordered_multimap me, void *key, void *value);
int unordered_multimap_remove_all(unordered_multimap me, void *key);
bk_bool unordered_multimap_get_next(void *value, unordered_multimap me);
size_t unordered_multimap_count(unordered_multimap me, void *key);
bk_bool unordered_multimap_contains(unordered_multimap me, void *key);
bk_bool unordered_multimap_remove(unordered_multimap me,
void *key, void *value);
bk_bool unordered_multimap_remove_all(unordered_multimap me, void *key);
/* Ending */
int unordered_multimap_clear(unordered_multimap me);
bk_err unordered_multimap_clear(unordered_multimap me);
unordered_multimap unordered_multimap_destroy(unordered_multimap me);
#endif /* BKTHOMPS_CONTAINERS_UNORDERED_MULTIMAP_H */

16
src/include/unordered_multiset.h
View File

@@ -23,7 +23,7 @@
#ifndef 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
@@ -39,19 +39,19 @@ unordered_multiset_init(size_t key_size,
const void *const two));
/* Utility */
int unordered_multiset_rehash(unordered_multiset me);
bk_err unordered_multiset_rehash(unordered_multiset me);
size_t unordered_multiset_size(unordered_multiset me);
int unordered_multiset_is_empty(unordered_multiset me);
bk_bool unordered_multiset_is_empty(unordered_multiset me);
/* Accessing */
int unordered_multiset_put(unordered_multiset me, void *key);
bk_err unordered_multiset_put(unordered_multiset me, void *key);
size_t unordered_multiset_count(unordered_multiset me, void *key);
int unordered_multiset_contains(unordered_multiset me, void *key);
int unordered_multiset_remove(unordered_multiset me, void *key);
int unordered_multiset_remove_all(unordered_multiset me, void *key);
bk_bool unordered_multiset_contains(unordered_multiset me, void *key);
bk_bool unordered_multiset_remove(unordered_multiset me, void *key);
bk_bool unordered_multiset_remove_all(unordered_multiset me, void *key);
/* Ending */
int unordered_multiset_clear(unordered_multiset me);
bk_err unordered_multiset_clear(unordered_multiset me);
unordered_multiset unordered_multiset_destroy(unordered_multiset me);
#endif /* BKTHOMPS_CONTAINERS_UNORDERED_MULTISET_H */

14
src/include/unordered_set.h
View File

@@ -23,7 +23,7 @@
#ifndef 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,
@@ -38,17 +38,17 @@ unordered_set unordered_set_init(size_t key_size,
const void *const two));
/* Utility */
int unordered_set_rehash(unordered_set me);
bk_err unordered_set_rehash(unordered_set me);
size_t unordered_set_size(unordered_set me);
int unordered_set_is_empty(unordered_set me);
bk_bool unordered_set_is_empty(unordered_set me);
/* Accessing */
int unordered_set_put(unordered_set me, void *key);
int unordered_set_contains(unordered_set me, void *key);
int unordered_set_remove(unordered_set me, void *key);
bk_err unordered_set_put(unordered_set me, void *key);
bk_bool unordered_set_contains(unordered_set me, void *key);
bk_bool unordered_set_remove(unordered_set me, void *key);
/* Ending */
int unordered_set_clear(unordered_set me);
bk_err unordered_set_clear(unordered_set me);
unordered_set unordered_set_destroy(unordered_set me);
#endif /* BKTHOMPS_CONTAINERS_UNORDERED_SET_H */

34
src/include/vector.h
View File

@@ -23,7 +23,7 @@
#ifndef 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.
@@ -36,34 +36,34 @@ vector vector_init(size_t data_size);
/* Utility */
size_t vector_size(vector me);
size_t vector_capacity(vector me);
int vector_is_empty(vector me);
int vector_reserve(vector me, size_t size);
int vector_trim(vector me);
bk_bool vector_is_empty(vector me);
bk_err vector_reserve(vector me, size_t size);
bk_err vector_trim(vector me);
void vector_copy_to_array(void *arr, vector me);
void *vector_get_data(vector me);
/* Adding */
int vector_add_first(vector me, void *data);
int vector_add_at(vector me, size_t index, void *data);
int vector_add_last(vector me, void *data);
bk_err vector_add_first(vector me, void *data);
bk_err vector_add_at(vector me, size_t index, void *data);
bk_err vector_add_last(vector me, void *data);
/* Removing */
int vector_remove_first(vector me);
int vector_remove_at(vector me, size_t index);
int vector_remove_last(vector me);
bk_err vector_remove_first(vector me);
bk_err vector_remove_at(vector me, size_t index);
bk_err vector_remove_last(vector me);
/* Setting */
int vector_set_first(vector me, void *data);
int vector_set_at(vector me, size_t index, void *data);
int vector_set_last(vector me, void *data);
bk_err vector_set_first(vector me, void *data);
bk_err vector_set_at(vector me, size_t index, void *data);
bk_err vector_set_last(vector me, void *data);
/* Getting */
int vector_get_first(void *data, vector me);
int vector_get_at(void *data, vector me, size_t index);
int vector_get_last(void *data, vector me);
bk_err vector_get_first(void *data, vector me);
bk_err vector_get_at(void *data, vector me, size_t index);
bk_err vector_get_last(void *data, vector me);
/* Ending */
int vector_clear(vector me);
bk_err vector_clear(vector me);
vector vector_destroy(vector me);
#endif /* BKTHOMPS_CONTAINERS_VECTOR_H */

97
src/list.c
View File

@@ -21,7 +21,6 @@
*/
#include <string.h>
#include <errno.h>
#include "include/list.h"
struct internal_list {
@@ -79,9 +78,9 @@ size_t list_size(list me)
*
* @param me the doubly-linked list to check
*
* @return 1 if the list is empty, otherwise 0
* @return BK_TRUE if the list is empty, otherwise BK_FALSE
*/
int list_is_empty(list me)
bk_bool list_is_empty(list me)
{
return list_size(me) == 0;
}
@@ -156,10 +155,10 @@ static char *list_get_node_at(list me, const size_t index)
* @param me the doubly-linked list to add data to
* @param data the data to add to the doubly-linked list
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int list_add_first(list me, void *const data)
bk_err list_add_first(list me, void *const data)
{
return list_add_at(me, 0, data);
}
@@ -175,19 +174,19 @@ int list_add_first(list me, void *const data)
* @param index the index to add the data at
* @param data the data to add to the doubly-linked list
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
* @return -BK_EINVAL if invalid argument
*/
int list_add_at(list me, const size_t index, void *const data)
bk_err list_add_at(list me, const size_t index, void *const data)
{
char *node;
if (index > me->item_count) {
return -EINVAL;
return -BK_EINVAL;
}
node = malloc(2 * ptr_size + me->bytes_per_item);
if (!node) {
return -ENOMEM;
return -BK_ENOMEM;
}
memcpy(node + node_data_ptr_offset, data, me->bytes_per_item);
if (!me->head) {
@@ -217,7 +216,7 @@ int list_add_at(list me, const size_t index, void *const data)
memcpy(traverse + node_prev_ptr_offset, &node, ptr_size);
}
me->item_count++;
return 0;
return BK_OK;
}
/**
@@ -230,10 +229,10 @@ int list_add_at(list me, const size_t index, void *const data)
* @param me the doubly-linked list to add data to
* @param data the data to add to the doubly-linked list
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int list_add_last(list me, void *const data)
bk_err list_add_last(list me, void *const data)
{
return list_add_at(me, me->item_count, data);
}
@@ -243,10 +242,10 @@ int list_add_last(list me, void *const data)
*
* @param me the doubly-linked list to remove data from
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int list_remove_first(list me)
bk_err list_remove_first(list me)
{
return list_remove_at(me, 0);
}
@@ -257,14 +256,14 @@ int list_remove_first(list me)
* @param me the doubly-linked list to remove data from
* @param index the index to remove from
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int list_remove_at(list me, const size_t index)
bk_err list_remove_at(list me, const size_t index)
{
char *traverse;
if (index >= me->item_count) {
return -EINVAL;
return -BK_EINVAL;
}
traverse = list_get_node_at(me, index);
if (me->item_count == 1) {
@@ -290,7 +289,7 @@ int list_remove_at(list me, const size_t index)
}
free(traverse);
me->item_count--;
return 0;
return BK_OK;
}
/**
@@ -298,10 +297,10 @@ int list_remove_at(list me, const size_t index)
*
* @param me the doubly-linked list to remove data from
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int list_remove_last(list me)
bk_err list_remove_last(list me)
{
return list_remove_at(me, me->item_count - 1);
}
@@ -316,10 +315,10 @@ int list_remove_last(list me)
* @param me the doubly-linked list to set data for
* @param data the data to set in the doubly-linked list
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int list_set_first(list me, void *const data)
bk_err list_set_first(list me, void *const data)
{
return list_set_at(me, 0, data);
}
@@ -335,18 +334,18 @@ int list_set_first(list me, void *const data)
* @param index the index to set data in the doubly-linked list
* @param data the data to set in the doubly-linked list
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int list_set_at(list me, const size_t index, void *const data)
bk_err list_set_at(list me, const size_t index, void *const data)
{
char *traverse;
if (index >= me->item_count) {
return -EINVAL;
return -BK_EINVAL;
}
traverse = list_get_node_at(me, index);
memcpy(traverse + node_data_ptr_offset, data, me->bytes_per_item);
return 0;
return BK_OK;
}
/**
@@ -359,10 +358,10 @@ int list_set_at(list me, const size_t index, void *const data)
* @param me the doubly-linked list to set data for
* @param data the data to set in the doubly-linked list
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int list_set_last(list me, void *const data)
bk_err list_set_last(list me, void *const data)
{
return list_set_at(me, me->item_count - 1, data);
}
@@ -378,10 +377,10 @@ int list_set_last(list me, void *const data)
* @param data the data to get
* @param me the doubly-linked list to get data from
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int list_get_first(void *const data, list me)
bk_err list_get_first(void *const data, list me)
{
return list_get_at(data, me, 0);
}
@@ -398,18 +397,18 @@ int list_get_first(void *const data, list me)
* @param me the doubly-linked list to get data from
* @param index the index to get data from
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int list_get_at(void *const data, list me, const size_t index)
bk_err list_get_at(void *const data, list me, const size_t index)
{
char *traverse;
if (index >= me->item_count) {
return -EINVAL;
return -BK_EINVAL;
}
traverse = list_get_node_at(me, index);
memcpy(data, traverse + node_data_ptr_offset, me->bytes_per_item);
return 0;
return BK_OK;
}
/**
@@ -423,10 +422,10 @@ int list_get_at(void *const data, list me, const size_t index)
* @param data the data to get
* @param me the doubly-linked list to get data from
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int list_get_last(void *const data, list me)
bk_err list_get_last(void *const data, list me)
{
return list_get_at(data, me, me->item_count - 1);
}

45
src/map.c
View File

@@ -21,7 +21,6 @@
*/
#include <string.h>
#include <errno.h>
#include "include/map.h"
struct internal_map {
@@ -88,9 +87,9 @@ size_t map_size(map me)
*
* @param me the map to check
*
* @return 1 if the map is empty, otherwise 0
* @return BK_TRUE if the map is empty, otherwise BK_FALSE
*/
int map_is_empty(map me)
bk_bool map_is_empty(map me)
{
return map_size(me) == 0;
}
@@ -309,19 +308,19 @@ static char *map_create_node(map me, const void *const key,
* @param key the key to add
* @param value the value to add
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int map_put(map me, void *const key, void *const value)
bk_err map_put(map me, void *const key, void *const value)
{
char *traverse;
if (!me->root) {
char *insert = map_create_node(me, key, value, NULL);
if (!insert) {
return -ENOMEM;
return -BK_ENOMEM;
}
me->root = insert;
return 0;
return BK_OK;
}
traverse = me->root;
for (;;) {
@@ -334,11 +333,11 @@ int map_put(map me, void *const key, void *const value)
} else {
char *insert = map_create_node(me, key, value, traverse);
if (!insert) {
return -ENOMEM;
return -BK_ENOMEM;
}
memcpy(traverse + node_left_child_offset, &insert, ptr_size);
map_insert_balance(me, insert);
return 0;
return BK_OK;
}
} else if (compare > 0) {
char *traverse_right;
@@ -349,16 +348,16 @@ int map_put(map me, void *const key, void *const value)
} else {
char *insert = map_create_node(me, key, value, traverse);
if (!insert) {
return -ENOMEM;
return -BK_ENOMEM;
}
memcpy(traverse + node_right_child_offset, &insert, ptr_size);
map_insert_balance(me, insert);
return 0;
return BK_OK;
}
} else {
memcpy(traverse + node_key_offset + me->key_size, value,
me->value_size);
return 0;
return BK_OK;
}
}
}
@@ -409,16 +408,16 @@ static char *map_equal_match(map me, const void *const key)
* @param me the map to get from
* @param key the key to search for
*
* @return 1 if the map contained the key-value pair, otherwise 0
* @return BK_TRUE if the map contained the key-value pair, otherwise BK_FALSE
*/
int map_get(void *const value, map me, void *const key)
bk_bool map_get(void *const value, map me, void *const key)
{
char *const traverse = map_equal_match(me, key);
if (!traverse) {
return 0;
return BK_FALSE;
}
memcpy(value, traverse + node_key_offset + me->key_size, me->value_size);
return 1;
return BK_TRUE;
}
/**
@@ -431,9 +430,9 @@ int map_get(void *const value, map me, void *const key)
* @param me the map to check for the element
* @param key the key to check
*
* @return 1 if the map contained the element, otherwise 0
* @return BK_TRUE if the map contained the element, otherwise BK_FALSE
*/
int map_contains(map me, void *const key)
bk_bool map_contains(map me, void *const key)
{
return map_equal_match(me, key) != NULL;
}
@@ -704,16 +703,16 @@ static void map_remove_element(map me, char *const traverse)
* @param me the map to remove an element from
* @param key the key to remove
*
* @return 1 if the map contained the key-value pair, otherwise 0
* @return BK_TRUE if the map contained the key-value pair, otherwise BK_FALSE
*/
int map_remove(map me, void *const key)
bk_bool map_remove(map me, void *const key)
{
char *const traverse = map_equal_match(me, key);
if (!traverse) {
return 0;
return BK_FALSE;
}
map_remove_element(me, traverse);
return 1;
return BK_TRUE;
}
/**

57
src/multimap.c
View File

@@ -21,7 +21,6 @@
*/
#include <string.h>
#include <errno.h>
#include "include/multimap.h"
struct internal_multimap {
@@ -105,9 +104,9 @@ size_t multimap_size(multimap me)
*
* @param me the multi-map to check
*
* @return 1 if the multi-map is empty, otherwise 0
* @return BK_TRUE if the multi-map is empty, otherwise BK_FALSE
*/
int multimap_is_empty(multimap me)
bk_bool multimap_is_empty(multimap me)
{
return multimap_size(me) == 0;
}
@@ -356,19 +355,19 @@ static char *multimap_create_node(multimap me, const void *const key,
* @param key the key to add
* @param value the value to add
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int multimap_put(multimap me, void *const key, void *const value)
bk_err multimap_put(multimap me, void *const key, void *const value)
{
char *traverse;
if (!me->root) {
char *insert = multimap_create_node(me, key, value, NULL);
if (!insert) {
return -ENOMEM;
return -BK_ENOMEM;
}
me->root = insert;
return 0;
return BK_OK;
}
traverse = me->root;
for (;;) {
@@ -381,11 +380,11 @@ int multimap_put(multimap me, void *const key, void *const value)
} else {
char *insert = multimap_create_node(me, key, value, traverse);
if (!insert) {
return -ENOMEM;
return -BK_ENOMEM;
}
memcpy(traverse + node_left_child_offset, &insert, ptr_size);
multimap_insert_balance(me, insert);
return 0;
return BK_OK;
}
} else if (compare > 0) {
char *traverse_right;
@@ -396,11 +395,11 @@ int multimap_put(multimap me, void *const key, void *const value)
} else {
char *insert = multimap_create_node(me, key, value, traverse);
if (!insert) {
return -ENOMEM;
return -BK_ENOMEM;
}
memcpy(traverse + node_right_child_offset, &insert, ptr_size);
multimap_insert_balance(me, insert);
return 0;
return BK_OK;
}
} else {
char *value_traverse;
@@ -423,7 +422,7 @@ int multimap_put(multimap me, void *const key, void *const value)
count++;
memcpy(traverse + node_value_count_offset, &count, count_size);
me->size++;
return 0;
return BK_OK;
}
}
}
@@ -494,21 +493,21 @@ void multimap_get_start(multimap me, void *const key)
* @param value the value to be copied to from iteration
* @param me the multi-map to iterate over
*
* @return 1 if there exist more values for the key which is being iterated
* over, otherwise 0
* @return BK_TRUE if there exist more values for the key which is being
* iterated over, otherwise BK_FALSE
*/
int multimap_get_next(void *const value, multimap me)
bk_bool multimap_get_next(void *const value, multimap me)
{
char *item;
char *next;
if (!me->iterate_get) {
return 0;
return BK_FALSE;
}
item = me->iterate_get;
memcpy(value, item + value_node_value_offset, me->value_size);
memcpy(&next, item + value_node_next_offset, ptr_size);
me->iterate_get = next;
return 1;
return BK_TRUE;
}
/**
@@ -544,9 +543,9 @@ size_t multimap_count(multimap me, void *const key)
* @param me the multi-map to check for the key
* @param key the key to check
*
* @return 1 if the multi-map contained the key, otherwise 0
* @return BK_TRUE if the multi-map contained the key, otherwise BK_FALSE
*/
int multimap_contains(multimap me, void *const key)
bk_bool multimap_contains(multimap me, void *const key)
{
return multimap_equal_match(me, key) != NULL;
}
@@ -821,15 +820,15 @@ static void multimap_remove_element(multimap me, char *const traverse)
* @param key the key to remove
* @param value the value to remove
*
* @return 1 if the multi-map contained the key, otherwise 0
* @return BK_TRUE if the multi-map contained the key, otherwise BK_FALSE
*/
int multimap_remove(multimap me, void *const key, void *const value)
bk_bool multimap_remove(multimap me, void *const key, void *const value)
{
char *current_value_node;
char *const traverse = multimap_equal_match(me, key);
size_t count;
if (!traverse) {
return 0;
return BK_FALSE;
}
memcpy(&current_value_node, traverse + node_value_head_offset, ptr_size);
if (me->value_comparator(current_value_node + value_node_value_offset,
@@ -847,7 +846,7 @@ int multimap_remove(multimap me, void *const key, void *const value)
current_value_node + value_node_next_offset, ptr_size);
}
if (!current_value_node) {
return 0;
return BK_FALSE;
}
memcpy(previous_value_node + value_node_next_offset,
current_value_node + value_node_next_offset, ptr_size);
@@ -861,7 +860,7 @@ int multimap_remove(multimap me, void *const key, void *const value)
memcpy(traverse + node_value_count_offset, &count, count_size);
}
me->size--;
return 1;
return BK_TRUE;
}
/*
@@ -893,16 +892,16 @@ static void multimap_remove_all_elements(multimap me, char *const traverse)
* @param me the multi-map to remove a key-value pair from
* @param key the key to remove
*
* @return 1 if the multi-map contained the key, otherwise 0
* @return BK_TRUE if the multi-map contained the key, otherwise BK_FALSE
*/
int multimap_remove_all(multimap me, void *const key)
bk_bool multimap_remove_all(multimap me, void *const key)
{
char *const traverse = multimap_equal_match(me, key);
if (!traverse) {
return 0;
return BK_FALSE;
}
multimap_remove_all_elements(me, traverse);
return 1;
return BK_TRUE;
}
/**

45
src/multiset.c
View File

@@ -21,7 +21,6 @@
*/
#include <string.h>
#include <errno.h>
#include "include/multiset.h"
struct internal_multiset {
@@ -90,9 +89,9 @@ size_t multiset_size(multiset me)
*
* @param me the multi-set to check
*
* @return 1 if the multi-set is empty, otherwise 0
* @return BK_TRUE if the multi-set is empty, otherwise BK_FALSE
*/
int multiset_is_empty(multiset me)
bk_bool multiset_is_empty(multiset me)
{
return multiset_size(me) == 0;
}
@@ -317,19 +316,19 @@ static char *multiset_create_node(multiset me, const void *const data,
* @param me the multi-set to add to
* @param key the key to add
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int multiset_put(multiset me, void *const key)
bk_bool multiset_put(multiset me, void *const key)
{
char *traverse;
if (!me->root) {
char *insert = multiset_create_node(me, key, NULL);
if (!insert) {
return -ENOMEM;
return -BK_ENOMEM;
}
me->root = insert;
return 0;
return BK_OK;
}
traverse = me->root;
for (;;) {
@@ -342,11 +341,11 @@ int multiset_put(multiset me, void *const key)
} else {
char *insert = multiset_create_node(me, key, traverse);
if (!insert) {
return -ENOMEM;
return -BK_ENOMEM;
}
memcpy(traverse + node_left_child_offset, &insert, ptr_size);
multiset_insert_balance(me, insert);
return 0;
return BK_OK;
}
} else if (compare > 0) {
char *traverse_right;
@@ -357,11 +356,11 @@ int multiset_put(multiset me, void *const key)
} else {
char *insert = multiset_create_node(me, key, traverse);
if (!insert) {
return -ENOMEM;
return -BK_ENOMEM;
}
memcpy(traverse + node_right_child_offset, &insert, ptr_size);
multiset_insert_balance(me, insert);
return 0;
return BK_OK;
}
} else {
size_t count;
@@ -369,7 +368,7 @@ int multiset_put(multiset me, void *const key)
count++;
memcpy(traverse + node_count_offset, &count, count_size);
me->size++;
return 0;
return BK_OK;
}
}
}
@@ -441,9 +440,9 @@ size_t multiset_count(multiset me, void *const key)
* @param me the multi-set to check for the key
* @param key the key to check
*
* @return 1 if the multiset contained the key, otherwise 0
* @return BK_TRUE if the multiset contained the key, otherwise BK_FALSE
*/
int multiset_contains(multiset me, void *const key)
bk_bool multiset_contains(multiset me, void *const key)
{
return multiset_equal_match(me, key) != NULL;
}
@@ -716,14 +715,14 @@ static void multiset_remove_element(multiset me, char *const traverse)
* @param me the multi-set to remove a key from
* @param key the key to remove
*
* @return 1 if the multi-set contained the key, otherwise 0
* @return BK_TRUE if the multi-set contained the key, otherwise BK_FALSE
*/
int multiset_remove(multiset me, void *const key)
bk_bool multiset_remove(multiset me, void *const key)
{
char *const traverse = multiset_equal_match(me, key);
size_t traverse_count;
if (!traverse) {
return 0;
return BK_FALSE;
}
memcpy(&traverse_count, traverse + node_count_offset, count_size);
if (traverse_count == 1) {
@@ -733,7 +732,7 @@ int multiset_remove(multiset me, void *const key)
memcpy(traverse + node_count_offset, &traverse_count, count_size);
}
me->size--;
return 1;
return BK_TRUE;
}
/**
@@ -746,19 +745,19 @@ int multiset_remove(multiset me, void *const key)
* @param me the multi-set to remove a key from
* @param key the key to remove
*
* @return 1 if the multi-set contained the key, otherwise 0
* @return BK_TRUE if the multi-set contained the key, otherwise BK_FALSE
*/
int multiset_remove_all(multiset me, void *const key)
bk_bool multiset_remove_all(multiset me, void *const key)
{
char *const traverse = multiset_equal_match(me, key);
size_t traverse_count;
if (!traverse) {
return 0;
return BK_FALSE;
}
memcpy(&traverse_count, traverse + node_count_offset, count_size);
me->size -= traverse_count;
multiset_remove_element(me, traverse);
return 1;
return BK_TRUE;
}
/**

41
src/priority_queue.c
View File

@@ -21,7 +21,6 @@
*/
#include <string.h>
#include <errno.h>
#include "include/vector.h"
#include "include/priority_queue.h"
@@ -81,9 +80,9 @@ size_t priority_queue_size(priority_queue me)
*
* @param me the priority queue to check
*
* @return 1 if the priority queue is empty, otherwise 0
* @return BK_TRUE if the priority queue is empty, otherwise BK_FALSE
*/
int priority_queue_is_empty(priority_queue me)
bk_bool priority_queue_is_empty(priority_queue me)
{
return vector_is_empty(me->data);
}
@@ -98,12 +97,12 @@ int priority_queue_is_empty(priority_queue me)
* @param me the priority queue to add an element to
* @param data the data to add to the queue
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int priority_queue_push(priority_queue me, void *const data)
bk_err priority_queue_push(priority_queue me, void *const data)
{
int rc;
bk_err rc;
char *vector_storage;
size_t index;
size_t parent_index;
@@ -111,10 +110,10 @@ int priority_queue_push(priority_queue me, void *const data)
char *data_parent_index;
char *const temp = malloc(me->data_size);
if (!temp) {
return -ENOMEM;
return -BK_ENOMEM;
}
rc = vector_add_last(me->data, data);
if (rc != 0) {
if (rc != BK_OK) {
free(temp);
return rc;
}
@@ -133,7 +132,7 @@ int priority_queue_push(priority_queue me, void *const data)
data_parent_index = vector_storage + parent_index * me->data_size;
}
free(temp);
return 0;
return BK_OK;
}
/**
@@ -147,9 +146,9 @@ int priority_queue_push(priority_queue me, void *const data)
* @param data the data to have copied from the priority queue
* @param me the priority queue to pop the next element from
*
* @return 1 if the priority queue contained elements, otherwise 0
* @return BK_TRUE if the priority queue contained elements, otherwise BK_FALSE
*/
int priority_queue_pop(void *const data, priority_queue me)
bk_bool priority_queue_pop(void *const data, priority_queue me)
{
char *vector_storage;
size_t size;
@@ -160,9 +159,9 @@ int priority_queue_pop(void *const data, priority_queue me)
char *data_index;
char *data_left_index;
char *data_right_index;
const int rc = vector_get_first(data, me->data);
if (rc != 0) {
return 0;
const bk_err rc = vector_get_first(data, me->data);
if (rc != BK_OK) {
return BK_FALSE;
}
vector_storage = vector_get_data(me->data);
size = vector_size(me->data) - 1;
@@ -199,7 +198,7 @@ int priority_queue_pop(void *const data, priority_queue me)
data_right_index = vector_storage + right_index * me->data_size;
}
vector_remove_last(me->data);
return 1;
return BK_TRUE;
}
/**
@@ -214,9 +213,9 @@ int priority_queue_pop(void *const data, priority_queue me)
* queue
* @param me the priority queue to copy from
*
* @return 1 if the priority queue contained elements, otherwise 0
* @return BK_TRUE if the priority queue contained elements, otherwise BK_FALSE
*/
int priority_queue_front(void *const data, priority_queue me)
bk_bool priority_queue_front(void *const data, priority_queue me)
{
return vector_get_first(data, me->data) == 0;
}
@@ -226,10 +225,10 @@ int priority_queue_front(void *const data, priority_queue me)
*
* @param me the priority queue to clear
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int priority_queue_clear(priority_queue me)
bk_err priority_queue_clear(priority_queue me)
{
return vector_clear(me->data);
}

34
src/queue.c
View File

@@ -55,9 +55,9 @@ size_t queue_size(queue me)
*
* @param me the queue to check if empty
*
* @return 1 if the queue is empty, otherwise 0
* @return BK_TRUE if the queue is empty, otherwise BK_FALSE
*/
int queue_is_empty(queue me)
bk_bool queue_is_empty(queue me)
{
return deque_is_empty(me);
}
@@ -67,10 +67,10 @@ int queue_is_empty(queue me)
*
* @param me the queue to trim
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int queue_trim(queue me)
bk_err queue_trim(queue me)
{
return deque_trim(me);
}
@@ -99,10 +99,10 @@ void queue_copy_to_array(void *const arr, queue me)
* @param me the queue to add an element to
* @param data the data to add to the queue
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int queue_push(queue me, void *const data)
bk_err queue_push(queue me, void *const data)
{
return deque_push_back(me, data);
}
@@ -117,9 +117,9 @@ int queue_push(queue me, void *const data)
* @param data the data to have copied from the queue
* @param me the queue to pop the next element from
*
* @return 1 if the queue contained elements, otherwise 0
* @return BK_TRUE if the queue contained elements, otherwise BK_FALSE
*/
int queue_pop(void *const data, queue me)
bk_bool queue_pop(void *const data, queue me)
{
return deque_pop_front(data, me) == 0;
}
@@ -134,9 +134,9 @@ int queue_pop(void *const data, queue me)
* @param data the copy of the front element of the queue
* @param me the queue to copy from
*
* @return 1 if the queue contained elements, otherwise 0
* @return BK_TRUE if the queue contained elements, otherwise BK_FALSE
*/
int queue_front(void *const data, queue me)
bk_bool queue_front(void *const data, queue me)
{
return deque_get_first(data, me) == 0;
}
@@ -151,9 +151,9 @@ int queue_front(void *const data, queue me)
* @param data the copy of the back element of the queue
* @param me the queue to copy from
*
* @return 1 if the queue contained elements, otherwise 0
* @return BK_TRUE if the queue contained elements, otherwise BK_FALSE
*/
int queue_back(void *const data, queue me)
bk_bool queue_back(void *const data, queue me)
{
return deque_get_last(data, me) == 0;
}
@@ -163,10 +163,10 @@ int queue_back(void *const data, queue me)
*
* @param me the queue to clear
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int queue_clear(queue me)
bk_err queue_clear(queue me)
{
return deque_clear(me);
}

37
src/set.c
View File

@@ -21,7 +21,6 @@
*/
#include <string.h>
#include <errno.h>
#include "include/set.h"
struct internal_set {
@@ -84,9 +83,9 @@ size_t set_size(set me)
*
* @param me the set to check
*
* @return 1 if the set is empty, otherwise 0
* @return BK_TRUE if the set is empty, otherwise BK_FALSE
*/
int set_is_empty(set me)
bk_bool set_is_empty(set me)
{
return set_size(me) == 0;
}
@@ -301,19 +300,19 @@ static char *set_create_node(set me, const void *const data, char *const parent)
* @param me the set to add to
* @param key the key to add
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int set_put(set me, void *const key)
bk_err set_put(set me, void *const key)
{
char *traverse;
if (!me->root) {
char *insert = set_create_node(me, key, NULL);
if (!insert) {
return -ENOMEM;
return -BK_ENOMEM;
}
me->root = insert;
return 0;
return BK_OK;
}
traverse = me->root;
for (;;) {
@@ -326,11 +325,11 @@ int set_put(set me, void *const key)
} else {
char *insert = set_create_node(me, key, traverse);
if (!insert) {
return -ENOMEM;
return -BK_ENOMEM;
}
memcpy(traverse + node_left_child_offset, &insert, ptr_size);
set_insert_balance(me, insert);
return 0;
return BK_OK;
}
} else if (compare > 0) {
char *traverse_right;
@@ -341,14 +340,14 @@ int set_put(set me, void *const key)
} else {
char *insert = set_create_node(me, key, traverse);
if (!insert) {
return -ENOMEM;
return -BK_ENOMEM;
}
memcpy(traverse + node_right_child_offset, &insert, ptr_size);
set_insert_balance(me, insert);
return 0;
return BK_OK;
}
} else {
return 0;
return BK_OK;
}
}
}
@@ -397,9 +396,9 @@ static char *set_equal_match(set me, const void *const key)
* @param me the set to check for the key
* @param key the key to check
*
* @return 1 if the set contained the key, otherwise 0
* @return BK_TRUE if the set contained the key, otherwise BK_FALSE
*/
int set_contains(set me, void *const key)
bk_bool set_contains(set me, void *const key)
{
return set_equal_match(me, key) != NULL;
}
@@ -670,16 +669,16 @@ static void set_remove_element(set me, char *const traverse)
* @param me the set to remove an key from
* @param key the key to remove
*
* @return 1 if the set contained the key, otherwise 0
* @return BK_TRUE if the set contained the key, otherwise BK_FALSE
*/
int set_remove(set me, void *const key)
bk_err set_remove(set me, void *const key)
{
char *const traverse = set_equal_match(me, key);
if (!traverse) {
return 0;
return BK_FALSE;
}
set_remove_element(me, traverse);
return 1;
return BK_TRUE;
}
/**

30
src/stack.c
View File

@@ -55,9 +55,9 @@ size_t stack_size(stack me)
*
* @param me the stack to check if empty
*
* @return 1 if the stack is empty, otherwise 0
* @return BK_TRUE if the stack is empty, otherwise BK_FALSE
*/
int stack_is_empty(stack me)
bk_bool stack_is_empty(stack me)
{
return deque_is_empty(me);
}
@@ -67,10 +67,10 @@ int stack_is_empty(stack me)
*
* @param me the stack to trim
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int stack_trim(stack me)
bk_err stack_trim(stack me)
{
return deque_trim(me);
}
@@ -99,10 +99,10 @@ void stack_copy_to_array(void *const arr, stack me)
* @param me the stack to add an element to
* @param data the data to add to the stack
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int stack_push(stack me, void *const data)
bk_err stack_push(stack me, void *const data)
{
return deque_push_back(me, data);
}
@@ -118,9 +118,9 @@ int stack_push(stack me, void *const data)
* @param data the copy of the element being removed
* @param me the stack to remove the top element from
*
* @return 1 if the stack contained elements, otherwise 0
* @return BK_TRUE if the stack contained elements, otherwise BK_FALSE
*/
int stack_pop(void *const data, stack me)
bk_bool stack_pop(void *const data, stack me)
{
return deque_pop_back(data, me) == 0;
}
@@ -135,9 +135,9 @@ int stack_pop(void *const data, stack me)
* @param data the copy of the top element of the stack
* @param me the stack to copy from
*
* @return 1 if the stack contained elements, otherwise 0
* @return BK_TRUE if the stack contained elements, otherwise BK_FALSE
*/
int stack_top(void *const data, stack me)
bk_bool stack_top(void *const data, stack me)
{
return deque_get_last(data, me) == 0;
}
@@ -147,10 +147,10 @@ int stack_top(void *const data, stack me)
*
* @param me the stack to clear
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int stack_clear(stack me)
bk_err stack_clear(stack me)
{
return deque_clear(me);
}

84
src/unordered_map.c
View File

@@ -21,7 +21,6 @@
*/
#include <string.h>
#include <errno.h>
#include "include/unordered_map.h"
#define BKTHOMPS_U_MAP_STARTING_BUCKETS 16
@@ -133,17 +132,17 @@ static void unordered_map_add_item(unordered_map me, char *const add)
*
* @param me the unordered map to rehash
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int unordered_map_rehash(unordered_map me)
bk_err unordered_map_rehash(unordered_map me)
{
size_t i;
char **old_buckets = me->buckets;
me->buckets = calloc(me->capacity, ptr_size);
if (!me->buckets) {
me->buckets = old_buckets;
return -ENOMEM;
return -BK_ENOMEM;
}
for (i = 0; i < me->capacity; i++) {
char *traverse = old_buckets[i];
@@ -158,7 +157,7 @@ int unordered_map_rehash(unordered_map me)
}
}
free(old_buckets);
return 0;
return BK_OK;
}
/**
@@ -178,9 +177,9 @@ size_t unordered_map_size(unordered_map me)
*
* @param me the unordered map to check
*
* @return 1 if the unordered map is empty, otherwise 0
* @return BK_TRUE if the unordered map is empty, otherwise BK_FALSE
*/
int unordered_map_is_empty(unordered_map me)
bk_bool unordered_map_is_empty(unordered_map me)
{
return unordered_map_size(me) == 0;
}
@@ -188,7 +187,7 @@ int unordered_map_is_empty(unordered_map me)
/*
* Increases the size of the map and redistributes the nodes.
*/
static int unordered_map_resize(unordered_map me)
static bk_err unordered_map_resize(unordered_map me)
{
size_t i;
const size_t old_capacity = me->capacity;
@@ -197,7 +196,7 @@ static int unordered_map_resize(unordered_map me)
me->buckets = calloc(new_capacity, ptr_size);
if (!me->buckets) {
me->buckets = old_buckets;
return -ENOMEM;
return -BK_ENOMEM;
}
me->capacity = new_capacity;
for (i = 0; i < old_capacity; i++) {
@@ -210,13 +209,13 @@ static int unordered_map_resize(unordered_map me)
}
}
free(old_buckets);
return 0;
return BK_OK;
}
/*
* Determines if an element is equal to the key.
*/
static int unordered_map_is_equal(unordered_map me, char *const item,
static bk_bool unordered_map_is_equal(unordered_map me, char *const item,
const unsigned long hash,
const void *const key)
{
@@ -258,24 +257,24 @@ static char *unordered_map_create_element(unordered_map me,
* @param key the key to add
* @param value the value to add
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int unordered_map_put(unordered_map me, void *const key, void *const value)
bk_err unordered_map_put(unordered_map me, void *const key, void *const value)
{
const unsigned long hash = unordered_map_hash(me, key);
int index;
size_t index;
if (me->size + 1 >= (size_t) (BKTHOMPS_U_MAP_RESIZE_AT * me->capacity)) {
const int rc = unordered_map_resize(me);
if (rc != 0) {
const bk_err rc = unordered_map_resize(me);
if (rc != BK_OK) {
return rc;
}
}
index = (size_t) (hash % me->capacity);
index = hash % me->capacity;
if (!me->buckets[index]) {
me->buckets[index] = unordered_map_create_element(me, hash, key, value);
if (!me->buckets[index]) {
return -ENOMEM;
return -BK_ENOMEM;
}
} else {
char *traverse = me->buckets[index];
@@ -283,7 +282,7 @@ int unordered_map_put(unordered_map me, void *const key, void *const value)
if (unordered_map_is_equal(me, traverse, hash, key)) {
memcpy(traverse + node_key_offset + me->key_size, value,
me->value_size);
return 0;
return BK_OK;
}
memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
while (traverse_next) {
@@ -292,17 +291,17 @@ int unordered_map_put(unordered_map me, void *const key, void *const value)
if (unordered_map_is_equal(me, traverse, hash, key)) {
memcpy(traverse + node_key_offset + me->key_size, value,
me->value_size);
return 0;
return BK_OK;
}
}
traverse_next = unordered_map_create_element(me, hash, key, value);
if (!traverse_next) {
return -ENOMEM;
return -BK_ENOMEM;
}
memcpy(traverse + node_next_offset, &traverse_next, ptr_size);
}
me->size++;
return 0;
return BK_OK;
}
/**
@@ -317,9 +316,10 @@ int unordered_map_put(unordered_map me, void *const key, void *const value)
* @param me the unordered map to get from
* @param key the key to search for
*
* @return 1 if the unordered map contained the key-value pair, otherwise 0
* @return BK_TRUE if the unordered map contained the key-value pair,
* otherwise BK_FALSE
*/
int unordered_map_get(void *const value, unordered_map me, void *const key)
bk_bool unordered_map_get(void *const value, unordered_map me, void *const key)
{
const unsigned long hash = unordered_map_hash(me, key);
char *traverse = me->buckets[hash % me->capacity];
@@ -327,11 +327,11 @@ int unordered_map_get(void *const value, unordered_map me, void *const key)
if (unordered_map_is_equal(me, traverse, hash, key)) {
memcpy(value, traverse + node_key_offset + me->key_size,
me->value_size);
return 1;
return BK_TRUE;
}
memcpy(&traverse, traverse + node_next_offset, ptr_size);
}
return 0;
return BK_FALSE;
}
/**
@@ -344,19 +344,19 @@ int unordered_map_get(void *const value, unordered_map me, void *const key)
* @param me the unordered map to check for the key
* @param key the key to check
*
* @return 1 if the unordered map contained the key, otherwise 0
* @return BK_TRUE if the unordered map contained the key, otherwise BK_FALSE
*/
int unordered_map_contains(unordered_map me, void *const key)
bk_bool unordered_map_contains(unordered_map me, void *const key)
{
const unsigned long hash = unordered_map_hash(me, key);
char *traverse = me->buckets[hash % me->capacity];
while (traverse) {
if (unordered_map_is_equal(me, traverse, hash, key)) {
return 1;
return BK_TRUE;
}
memcpy(&traverse, traverse + node_next_offset, ptr_size);
}
return 0;
return BK_FALSE;
}
/**
@@ -369,23 +369,23 @@ int unordered_map_contains(unordered_map me, void *const key)
* @param me the unordered map to remove a key from
* @param key the key to remove
*
* @return 1 if the unordered map contained the key, otherwise 0
* @return BK_TRUE if the unordered map contained the key, otherwise BK_FALSE
*/
int unordered_map_remove(unordered_map me, void *const key)
bk_bool unordered_map_remove(unordered_map me, void *const key)
{
char *traverse;
char *traverse_next;
const unsigned long hash = unordered_map_hash(me, key);
const size_t index = hash % me->capacity;
if (!me->buckets[index]) {
return 0;
return BK_FALSE;
}
traverse = me->buckets[index];
if (unordered_map_is_equal(me, traverse, hash, key)) {
memcpy(me->buckets + index, traverse + node_next_offset, ptr_size);
free(traverse);
me->size--;
return 1;
return BK_TRUE;
}
memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
while (traverse_next) {
@@ -394,12 +394,12 @@ int unordered_map_remove(unordered_map me, void *const key)
traverse_next + node_next_offset, ptr_size);
free(traverse_next);
me->size--;
return 1;
return BK_TRUE;
}
traverse = traverse_next;
memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
}
return 0;
return BK_FALSE;
}
/**
@@ -407,15 +407,15 @@ int unordered_map_remove(unordered_map me, void *const key)
*
* @param me the unordered map to clear
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int unordered_map_clear(unordered_map me)
{
size_t i;
char **updated_buckets = calloc(BKTHOMPS_U_MAP_STARTING_BUCKETS, ptr_size);
if (!updated_buckets) {
return -ENOMEM;
return -BK_ENOMEM;
}
for (i = 0; i < me->capacity; i++) {
char *traverse = me->buckets[i];
@@ -429,7 +429,7 @@ int unordered_map_clear(unordered_map me)
me->size = 0;
me->capacity = BKTHOMPS_U_MAP_STARTING_BUCKETS;
me->buckets = updated_buckets;
return 0;
return BK_OK;
}
/**

107
src/unordered_multimap.c
View File

@@ -21,7 +21,6 @@
*/
#include <string.h>
#include <errno.h>
#include "include/unordered_multimap.h"
#define BKTHOMPS_U_MULTIMAP_STARTING_BUCKETS 16
@@ -152,17 +151,17 @@ static void unordered_multimap_add_item(unordered_multimap me, char *const add)
*
* @param me the unordered multi-map to rehash
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int unordered_multimap_rehash(unordered_multimap me)
bk_err unordered_multimap_rehash(unordered_multimap me)
{
size_t i;
char **old_buckets = me->buckets;
me->buckets = calloc(me->capacity, ptr_size);
if (!me->buckets) {
me->buckets = old_buckets;
return -ENOMEM;
return -BK_ENOMEM;
}
for (i = 0; i < me->capacity; i++) {
char *traverse = old_buckets[i];
@@ -177,7 +176,7 @@ int unordered_multimap_rehash(unordered_multimap me)
}
}
free(old_buckets);
return 0;
return BK_OK;
}
/**
@@ -197,9 +196,9 @@ size_t unordered_multimap_size(unordered_multimap me)
*
* @param me the unordered multi-map to check
*
* @return 1 if the unordered multi-map is empty, otherwise 0
* @return BK_TRUE if the unordered multi-map is empty, otherwise BK_FALSE
*/
int unordered_multimap_is_empty(unordered_multimap me)
bk_bool unordered_multimap_is_empty(unordered_multimap me)
{
return unordered_multimap_size(me) == 0;
}
@@ -207,7 +206,7 @@ int unordered_multimap_is_empty(unordered_multimap me)
/*
* Increases the size of the multi-map and redistributes the nodes.
*/
static int unordered_multimap_resize(unordered_multimap me)
static bk_err unordered_multimap_resize(unordered_multimap me)
{
size_t i;
const size_t old_capacity = me->capacity;
@@ -216,7 +215,7 @@ static int unordered_multimap_resize(unordered_multimap me)
me->buckets = calloc(new_capacity, ptr_size);
if (!me->buckets) {
me->buckets = old_buckets;
return -ENOMEM;
return -BK_ENOMEM;
}
me->capacity = new_capacity;
for (i = 0; i < old_capacity; i++) {
@@ -229,13 +228,14 @@ static int unordered_multimap_resize(unordered_multimap me)
}
}
free(old_buckets);
return 0;
return BK_OK;
}
/*
* Determines if an element is equal to the key.
*/
static int unordered_multimap_is_equal(unordered_multimap me, char *const item,
static bk_bool unordered_multimap_is_equal(unordered_multimap me,
char *const item,
const unsigned long hash,
const void *const key)
{
@@ -276,28 +276,27 @@ static char *unordered_multimap_create_element(unordered_multimap me,
* @param key the key to add
* @param value the value to add
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int unordered_multimap_put(unordered_multimap me,
void *const key,
bk_err unordered_multimap_put(unordered_multimap me, void *const key,
void *const value)
{
const unsigned long hash = unordered_multimap_hash(me, key);
int index;
size_t index;
if (me->size + 1 >=
(size_t) (BKTHOMPS_U_MULTIMAP_RESIZE_AT * me->capacity)) {
const int rc = unordered_multimap_resize(me);
if (rc != 0) {
const bk_err rc = unordered_multimap_resize(me);
if (rc != BK_OK) {
return rc;
}
}
index = (size_t) (hash % me->capacity);
index = hash % me->capacity;
if (!me->buckets[index]) {
me->buckets[index] = unordered_multimap_create_element(me, hash, key,
value);
if (!me->buckets[index]) {
return -ENOMEM;
return -BK_ENOMEM;
}
} else {
char *traverse = me->buckets[index];
@@ -309,12 +308,12 @@ int unordered_multimap_put(unordered_multimap me,
}
traverse_next = unordered_multimap_create_element(me, hash, key, value);
if (!traverse_next) {
return -ENOMEM;
return -BK_ENOMEM;
}
memcpy(traverse + node_next_offset, &traverse_next, ptr_size);
}
me->size++;
return 0;
return BK_OK;
}
/**
@@ -357,15 +356,15 @@ void unordered_multimap_get_start(unordered_multimap me, void *const key)
* @param value the value to be copied to from iteration
* @param me the unordered multi-map to iterate over
*
* @return 1 if there exist more values for the key which is being iterated
* over, otherwise 0
* @return BK_TRUE if there exist more values for the key which is being
* iterated over, otherwise BK_FALSE
*/
int unordered_multimap_get_next(void *const value, unordered_multimap me)
bk_bool unordered_multimap_get_next(void *const value, unordered_multimap me)
{
char *item;
char *traverse;
if (!me->iterate_element) {
return 0;
return BK_FALSE;
}
item = me->iterate_element;
memcpy(&traverse, item + node_next_offset, ptr_size);
@@ -375,13 +374,13 @@ int unordered_multimap_get_next(void *const value, unordered_multimap me)
me->iterate_element = traverse;
memcpy(value, item + node_key_offset + me->key_size,
me->value_size);
return 1;
return BK_TRUE;
}
memcpy(&traverse, traverse + node_next_offset, ptr_size);
}
me->iterate_element = NULL;
memcpy(value, item + node_key_offset + me->key_size, me->value_size);
return 1;
return BK_TRUE;
}
/**
@@ -397,9 +396,9 @@ int unordered_multimap_get_next(void *const value, unordered_multimap me)
*
* @return the number of times the key appears in the unordered multi-map
*/
int unordered_multimap_count(unordered_multimap me, void *const key)
size_t unordered_multimap_count(unordered_multimap me, void *const key)
{
int count = 0;
size_t count = 0;
const unsigned long hash = unordered_multimap_hash(me, key);
char *traverse = me->buckets[hash % me->capacity];
while (traverse) {
@@ -421,19 +420,20 @@ int unordered_multimap_count(unordered_multimap me, void *const key)
* @param me the unordered multi-map to check for the key
* @param key the key to check
*
* @return 1 if the unordered multi-map contained the key, otherwise 0
* @return BK_TRUE if the unordered multi-map contained the key,
* otherwise BK_FALSE
*/
int unordered_multimap_contains(unordered_multimap me, void *const key)
bk_bool unordered_multimap_contains(unordered_multimap me, void *const key)
{
const unsigned long hash = unordered_multimap_hash(me, key);
char *traverse = me->buckets[hash % me->capacity];
while (traverse) {
if (unordered_multimap_is_equal(me, traverse, hash, key)) {
return 1;
return BK_TRUE;
}
memcpy(&traverse, traverse + node_next_offset, ptr_size);
}
return 0;
return BK_FALSE;
}
/**
@@ -448,10 +448,10 @@ int unordered_multimap_contains(unordered_multimap me, void *const key)
* @param key the key to remove
* @param value the value to remove
*
* @return 1 if the unordered multi-map contained the key, otherwise 0
* @return BK_TRUE if the unordered multi-map contained the key,
* otherwise BK_FALSE
*/
int unordered_multimap_remove(unordered_multimap me,
void *const key,
bk_bool unordered_multimap_remove(unordered_multimap me, void *const key,
void *const value)
{
char *traverse;
@@ -459,7 +459,7 @@ int unordered_multimap_remove(unordered_multimap me,
const unsigned long hash = unordered_multimap_hash(me, key);
const size_t index = hash % me->capacity;
if (!me->buckets[index]) {
return 0;
return BK_FALSE;
}
traverse = me->buckets[index];
if (unordered_multimap_is_equal(me, traverse, hash, key)
@@ -468,7 +468,7 @@ int unordered_multimap_remove(unordered_multimap me,
memcpy(me->buckets + index, traverse + node_next_offset, ptr_size);
free(traverse);
me->size--;
return 1;
return BK_TRUE;
}
memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
while (traverse_next) {
@@ -479,12 +479,12 @@ int unordered_multimap_remove(unordered_multimap me,
traverse_next + node_next_offset, ptr_size);
free(traverse_next);
me->size--;
return 1;
return BK_TRUE;
}
traverse = traverse_next;
memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
}
return 0;
return BK_FALSE;
}
/**
@@ -498,13 +498,14 @@ int unordered_multimap_remove(unordered_multimap me,
* @param me the unordered multi-map to remove a key-value pair from
* @param key the key to remove
*
* @return 1 if the unordered multi-map contained the key, otherwise 0
* @return BK_TRUE if the unordered multi-map contained the key,
* otherwise BK_FALSE
*/
int unordered_multimap_remove_all(unordered_multimap me, void *const key)
bk_bool unordered_multimap_remove_all(unordered_multimap me, void *const key)
{
const unsigned long hash = unordered_multimap_hash(me, key);
const int index = (int) (hash % me->capacity);
int was_modified = 0;
const size_t index = hash % me->capacity;
bk_bool was_modified = BK_FALSE;
for (;;) {
char *traverse = me->buckets[index];
char *traverse_next;
@@ -516,7 +517,7 @@ int unordered_multimap_remove_all(unordered_multimap me, void *const key)
me->buckets[index] = traverse_next;
free(traverse);
me->size--;
was_modified = 1;
was_modified = BK_TRUE;
continue;
}
while (traverse_next) {
@@ -525,7 +526,7 @@ int unordered_multimap_remove_all(unordered_multimap me, void *const key)
traverse_next + node_next_offset, ptr_size);
free(traverse_next);
me->size--;
was_modified = 1;
was_modified = BK_TRUE;
memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
continue;
}
@@ -542,16 +543,16 @@ int unordered_multimap_remove_all(unordered_multimap me, void *const key)
*
* @param me the unordered multi-map to clear
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int unordered_multimap_clear(unordered_multimap me)
bk_err unordered_multimap_clear(unordered_multimap me)
{
size_t i;
char **updated_buckets = calloc(BKTHOMPS_U_MULTIMAP_STARTING_BUCKETS,
ptr_size);
if (!updated_buckets) {
return -ENOMEM;
return -BK_ENOMEM;
}
for (i = 0; i < me->capacity; i++) {
char *traverse = me->buckets[i];
@@ -565,7 +566,7 @@ int unordered_multimap_clear(unordered_multimap me)
me->size = 0;
me->capacity = BKTHOMPS_U_MULTIMAP_STARTING_BUCKETS;
me->buckets = updated_buckets;
return 0;
return BK_OK;
}
/**

89
src/unordered_multiset.c
View File

@@ -21,7 +21,6 @@
*/
#include <string.h>
#include <errno.h>
#include "include/unordered_multiset.h"
#define BKTHOMPS_U_MULTISET_STARTING_BUCKETS 16
@@ -132,17 +131,17 @@ static void unordered_multiset_add_item(unordered_multiset me, char *const add)
*
* @param me the unordered multi-set to rehash
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int unordered_multiset_rehash(unordered_multiset me)
bk_err unordered_multiset_rehash(unordered_multiset me)
{
size_t i;
char **old_buckets = me->buckets;
me->buckets = calloc(me->capacity, ptr_size);
if (!me->buckets) {
me->buckets = old_buckets;
return -ENOMEM;
return -BK_ENOMEM;
}
for (i = 0; i < me->capacity; i++) {
char *traverse = old_buckets[i];
@@ -157,7 +156,7 @@ int unordered_multiset_rehash(unordered_multiset me)
}
}
free(old_buckets);
return 0;
return BK_OK;
}
/**
@@ -177,9 +176,9 @@ size_t unordered_multiset_size(unordered_multiset me)
*
* @param me the unordered multi-set to check
*
* @return 1 if the unordered multi-set is empty, otherwise 0
* @return BK_TRUE if the unordered multi-set is empty, otherwise BK_FALSE
*/
int unordered_multiset_is_empty(unordered_multiset me)
bk_bool unordered_multiset_is_empty(unordered_multiset me)
{
return unordered_multiset_size(me) == 0;
}
@@ -187,7 +186,7 @@ int unordered_multiset_is_empty(unordered_multiset me)
/*
* Increases the size of the multi-set and redistributes the nodes.
*/
static int unordered_multiset_resize(unordered_multiset me)
static bk_err unordered_multiset_resize(unordered_multiset me)
{
size_t i;
const size_t old_capacity = me->capacity;
@@ -196,7 +195,7 @@ static int unordered_multiset_resize(unordered_multiset me)
me->buckets = calloc(new_capacity, ptr_size);
if (!me->buckets) {
me->buckets = old_buckets;
return -ENOMEM;
return -BK_ENOMEM;
}
me->capacity = new_capacity;
for (i = 0; i < old_capacity; i++) {
@@ -209,13 +208,14 @@ static int unordered_multiset_resize(unordered_multiset me)
}
}
free(old_buckets);
return 0;
return BK_OK;
}
/*
* Determines if an element is equal to the key.
*/
static int unordered_multiset_is_equal(unordered_multiset me, char *const item,
static bk_bool unordered_multiset_is_equal(unordered_multiset me,
char *const item,
const unsigned long hash,
const void *const key)
{
@@ -254,25 +254,25 @@ static char *unordered_multiset_create_element(unordered_multiset me,
* @param me the unordered multi-set to add to
* @param key the element to add
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int unordered_multiset_put(unordered_multiset me, void *const key)
bk_err unordered_multiset_put(unordered_multiset me, void *const key)
{
const unsigned long hash = unordered_multiset_hash(me, key);
int index;
size_t index;
if (me->used + 1 >=
(size_t) (BKTHOMPS_U_MULTISET_RESIZE_AT * me->capacity)) {
const int rc = unordered_multiset_resize(me);
if (rc != 0) {
const bk_err rc = unordered_multiset_resize(me);
if (rc != BK_OK) {
return rc;
}
}
index = (size_t) (hash % me->capacity);
index = hash % me->capacity;
if (!me->buckets[index]) {
me->buckets[index] = unordered_multiset_create_element(me, hash, key);
if (!me->buckets[index]) {
return -ENOMEM;
return -BK_ENOMEM;
}
} else {
char *traverse = me->buckets[index];
@@ -283,7 +283,7 @@ int unordered_multiset_put(unordered_multiset me, void *const key)
count++;
memcpy(traverse + node_count_offset, &count, count_size);
me->size++;
return 0;
return BK_OK;
}
memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
while (traverse_next) {
@@ -295,18 +295,18 @@ int unordered_multiset_put(unordered_multiset me, void *const key)
count++;
memcpy(traverse + node_count_offset, &count, count_size);
me->size++;
return 0;
return BK_OK;
}
}
traverse_next = unordered_multiset_create_element(me, hash, key);
if (!traverse_next) {
return -ENOMEM;
return -BK_ENOMEM;
}
memcpy(traverse + node_next_offset, &traverse_next, ptr_size);
}
me->size++;
me->used++;
return 0;
return BK_OK;
}
/**
@@ -346,9 +346,10 @@ size_t unordered_multiset_count(unordered_multiset me, void *const key)
* @param me the unordered multi-set to check for the key
* @param key the key to check
*
* @return 1 if the unordered multi-set contained the key, otherwise 0
* @return BK_TRUE if the unordered multi-set contained the key,
* otherwise BK_FALSE
*/
int unordered_multiset_contains(unordered_multiset me, void *const key)
bk_bool unordered_multiset_contains(unordered_multiset me, void *const key)
{
return unordered_multiset_count(me, key) != 0;
}
@@ -363,16 +364,17 @@ int unordered_multiset_contains(unordered_multiset me, void *const key)
* @param me the unordered multi-set to remove a key from
* @param key the key to remove
*
* @return 1 if the unordered multi-set contained the key, otherwise 0
* @return BK_TRUE if the unordered multi-set contained the key,
* otherwise BK_FALSE
*/
int unordered_multiset_remove(unordered_multiset me, void *const key)
bk_bool unordered_multiset_remove(unordered_multiset me, void *const key)
{
char *traverse;
char *traverse_next;
const unsigned long hash = unordered_multiset_hash(me, key);
const size_t index = hash % me->capacity;
if (!me->buckets[index]) {
return 0;
return BK_FALSE;
}
traverse = me->buckets[index];
if (unordered_multiset_is_equal(me, traverse, hash, key)) {
@@ -387,7 +389,7 @@ int unordered_multiset_remove(unordered_multiset me, void *const key)
memcpy(traverse + node_count_offset, &count, count_size);
}
me->size--;
return 1;
return BK_TRUE;
}
memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
while (traverse_next) {
@@ -404,12 +406,12 @@ int unordered_multiset_remove(unordered_multiset me, void *const key)
memcpy(traverse_next + node_count_offset, &count, count_size);
}
me->size--;
return 1;
return BK_TRUE;
}
traverse = traverse_next;
memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
}
return 0;
return BK_FALSE;
}
/**
@@ -422,16 +424,17 @@ int unordered_multiset_remove(unordered_multiset me, void *const key)
* @param me the unordered multi-set to remove a key from
* @param key the key to remove
*
* @return 1 if the unordered multi-set contained the key, otherwise 0
* @return BK_TRUE if the unordered multi-set contained the key,
* otherwise BK_FALSE
*/
int unordered_multiset_remove_all(unordered_multiset me, void *const key)
bk_bool unordered_multiset_remove_all(unordered_multiset me, void *const key)
{
char *traverse;
char *traverse_next;
const unsigned long hash = unordered_multiset_hash(me, key);
const size_t index = hash % me->capacity;
if (!me->buckets[index]) {
return 0;
return BK_FALSE;
}
traverse = me->buckets[index];
if (unordered_multiset_is_equal(me, traverse, hash, key)) {
@@ -441,7 +444,7 @@ int unordered_multiset_remove_all(unordered_multiset me, void *const key)
free(traverse);
me->used--;
me->size -= count;
return 1;
return BK_TRUE;
}
memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
while (traverse_next) {
@@ -453,12 +456,12 @@ int unordered_multiset_remove_all(unordered_multiset me, void *const key)
free(traverse_next);
me->used--;
me->size -= count;
return 1;
return BK_TRUE;
}
traverse = traverse_next;
memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
}
return 0;
return BK_FALSE;
}
/**
@@ -466,16 +469,16 @@ int unordered_multiset_remove_all(unordered_multiset me, void *const key)
*
* @param me the unordered multi-set to clear
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int unordered_multiset_clear(unordered_multiset me)
bk_err unordered_multiset_clear(unordered_multiset me)
{
size_t i;
char **updated_buckets = calloc(BKTHOMPS_U_MULTISET_STARTING_BUCKETS,
ptr_size);
if (!updated_buckets) {
return -ENOMEM;
return -BK_ENOMEM;
}
for (i = 0; i < me->capacity; i++) {
char *traverse = me->buckets[i];
@@ -490,7 +493,7 @@ int unordered_multiset_clear(unordered_multiset me)
me->capacity = BKTHOMPS_U_MULTISET_STARTING_BUCKETS;
me->used = 0;
me->buckets = updated_buckets;
return 0;
return BK_OK;
}
/**

70
src/unordered_set.c
View File

@@ -21,7 +21,6 @@
*/
#include <string.h>
#include <errno.h>
#include "include/unordered_set.h"
#define BKTHOMPS_U_SET_STARTING_BUCKETS 16
@@ -126,17 +125,17 @@ static void unordered_set_add_item(unordered_set me, char *const add)
*
* @param me the unordered set to rehash
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int unordered_set_rehash(unordered_set me)
bk_err unordered_set_rehash(unordered_set me)
{
size_t i;
char **old_buckets = me->buckets;
me->buckets = calloc(me->capacity, ptr_size);
if (!me->buckets) {
me->buckets = old_buckets;
return -ENOMEM;
return -BK_ENOMEM;
}
for (i = 0; i < me->capacity; i++) {
char *traverse = old_buckets[i];
@@ -151,7 +150,7 @@ int unordered_set_rehash(unordered_set me)
}
}
free(old_buckets);
return 0;
return BK_OK;
}
/**
@@ -171,9 +170,9 @@ size_t unordered_set_size(unordered_set me)
*
* @param me the unordered set to check
*
* @return 1 if the unordered set is empty, otherwise 0
* @return BK_TRUE if the unordered set is empty, otherwise BK_FALSE
*/
int unordered_set_is_empty(unordered_set me)
bk_bool unordered_set_is_empty(unordered_set me)
{
return unordered_set_size(me) == 0;
}
@@ -181,7 +180,7 @@ int unordered_set_is_empty(unordered_set me)
/*
* Increases the size of the set and redistributes the nodes.
*/
static int unordered_set_resize(unordered_set me)
static bk_err unordered_set_resize(unordered_set me)
{
size_t i;
const size_t old_capacity = me->capacity;
@@ -190,7 +189,7 @@ static int unordered_set_resize(unordered_set me)
me->buckets = calloc(new_capacity, ptr_size);
if (!me->buckets) {
me->buckets = old_buckets;
return -ENOMEM;
return -BK_ENOMEM;
}
me->capacity = new_capacity;
for (i = 0; i < old_capacity; i++) {
@@ -203,13 +202,13 @@ static int unordered_set_resize(unordered_set me)
}
}
free(old_buckets);
return 0;
return BK_OK;
}
/*
* Determines if an element is equal to the key.
*/
static int unordered_set_is_equal(unordered_set me, char *const item,
static bk_bool unordered_set_is_equal(unordered_set me, char *const item,
const unsigned long hash,
const void *const key)
{
@@ -247,47 +246,47 @@ static char *unordered_set_create_element(unordered_set me,
* @param me the unordered set to add to
* @param key the element to add
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int unordered_set_put(unordered_set me, void *const key)
{
const unsigned long hash = unordered_set_hash(me, key);
int index;
size_t index;
if (me->size + 1 >= (size_t) (BKTHOMPS_U_SET_RESIZE_AT * me->capacity)) {
const int rc = unordered_set_resize(me);
if (rc != 0) {
const bk_err rc = unordered_set_resize(me);
if (rc != BK_OK) {
return rc;
}
}
index = (size_t) (hash % me->capacity);
index = hash % me->capacity;
if (!me->buckets[index]) {
me->buckets[index] = unordered_set_create_element(me, hash, key);
if (!me->buckets[index]) {
return -ENOMEM;
return -BK_ENOMEM;
}
} else {
char *traverse = me->buckets[index];
char *traverse_next;
if (unordered_set_is_equal(me, traverse, hash, key)) {
return 0;
return BK_OK;
}
memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
while (traverse_next) {
traverse = traverse_next;
memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
if (unordered_set_is_equal(me, traverse, hash, key)) {
return 0;
return BK_OK;
}
}
traverse_next = unordered_set_create_element(me, hash, key);
if (!traverse_next) {
return -ENOMEM;
return -BK_ENOMEM;
}
memcpy(traverse + node_next_offset, &traverse_next, ptr_size);
}
me->size++;
return 0;
return BK_OK;
}
/**
@@ -300,7 +299,8 @@ int unordered_set_put(unordered_set me, void *const key)
* @param me the unordered set to check for the element
* @param key the element to check
*
* @return 1 if the unordered set contained the element, otherwise 0
* @return BK_TRUE if the unordered set contained the element,
* otherwise BK_FALSE
*/
int unordered_set_contains(unordered_set me, void *const key)
{
@@ -308,11 +308,11 @@ int unordered_set_contains(unordered_set me, void *const key)
char *traverse = me->buckets[hash % me->capacity];
while (traverse) {
if (unordered_set_is_equal(me, traverse, hash, key)) {
return 1;
return BK_TRUE;
}
memcpy(&traverse, traverse + node_next_offset, ptr_size);
}
return 0;
return BK_FALSE;
}
/**
@@ -325,7 +325,7 @@ int unordered_set_contains(unordered_set me, void *const key)
* @param me the unordered set to remove a key from
* @param key the key to remove
*
* @return 1 if the unordered set contained the key, otherwise 0
* @return BK_TRUE if the unordered set contained the key, otherwise BK_FALSE
*/
int unordered_set_remove(unordered_set me, void *const key)
{
@@ -334,14 +334,14 @@ int unordered_set_remove(unordered_set me, void *const key)
const unsigned long hash = unordered_set_hash(me, key);
const size_t index = hash % me->capacity;
if (!me->buckets[index]) {
return 0;
return BK_FALSE;
}
traverse = me->buckets[index];
if (unordered_set_is_equal(me, traverse, hash, key)) {
memcpy(me->buckets + index, traverse + node_next_offset, ptr_size);
free(traverse);
me->size--;
return 1;
return BK_TRUE;
}
memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
while (traverse_next) {
@@ -350,12 +350,12 @@ int unordered_set_remove(unordered_set me, void *const key)
traverse_next + node_next_offset, ptr_size);
free(traverse_next);
me->size--;
return 1;
return BK_TRUE;
}
traverse = traverse_next;
memcpy(&traverse_next, traverse + node_next_offset, ptr_size);
}
return 0;
return BK_FALSE;
}
/**
@@ -363,15 +363,15 @@ int unordered_set_remove(unordered_set me, void *const key)
*
* @param me the unordered set to clear
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int unordered_set_clear(unordered_set me)
{
size_t i;
char **updated_buckets = calloc(BKTHOMPS_U_SET_STARTING_BUCKETS, ptr_size);
if (!updated_buckets) {
return -ENOMEM;
return -BK_ENOMEM;
}
for (i = 0; i < me->capacity; i++) {
char *traverse = me->buckets[i];
@@ -385,7 +385,7 @@ int unordered_set_clear(unordered_set me)
me->size = 0;
me->capacity = BKTHOMPS_U_SET_STARTING_BUCKETS;
me->buckets = updated_buckets;
return 0;
return BK_OK;
}
/**

130
src/vector.c
View File

@@ -21,7 +21,6 @@
*/
#include <string.h>
#include <errno.h>
#include "include/vector.h"
#define BKTHOMPS_VECTOR_START_SPACE 8
@@ -93,9 +92,9 @@ size_t vector_capacity(vector me)
*
* @param me the vector to check
*
* @return 1 if the vector is empty, otherwise 0
* @return BK_TRUE if the vector is empty, otherwise BK_FALSE
*/
int vector_is_empty(vector me)
bk_bool vector_is_empty(vector me)
{
return vector_size(me) == 0;
}
@@ -104,15 +103,15 @@ int vector_is_empty(vector me)
* Sets the space of the buffer. Assumes that size is at least the same as the
* number of items currently in the vector.
*/
static int vector_set_space(vector me, const int size)
static bk_err vector_set_space(vector me, const int size)
{
char *const temp = realloc(me->data, size * me->bytes_per_item);
if (!temp) {
return -ENOMEM;
return -BK_ENOMEM;
}
me->item_capacity = size;
me->data = temp;
return 0;
return BK_OK;
}
/**
@@ -122,13 +121,13 @@ static int vector_set_space(vector me, const int size)
* @param me the vector to reserve space for
* @param size the space to reserve
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int vector_reserve(vector me, size_t size)
bk_err vector_reserve(vector me, size_t size)
{
if (me->item_capacity >= size) {
return 0;
return BK_OK;
}
return vector_set_space(me, size);
}
@@ -138,10 +137,10 @@ int vector_reserve(vector me, size_t size)
*
* @param me the vector to trim
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int vector_trim(vector me)
bk_err vector_trim(vector me)
{
return vector_set_space(me, me->item_count);
}
@@ -171,7 +170,8 @@ void vector_copy_to_array(void *const arr, vector me)
* the queried array. This pointer is not a copy, thus any modification to the
* data will cause the vector structure data to be modified. Operations using
* the vector functions may invalidate this pointer. The vector owns this
* memory, thus it should not be freed.
* memory, thus it should not be freed. This should not be used if the vector
* is empty.
*
* @param me the vector to get the storage element from
*
@@ -192,10 +192,10 @@ void *vector_get_data(vector me)
* @param me the vector to add to
* @param data the data to add to the vector
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int vector_add_first(vector me, void *const data)
bk_err vector_add_first(vector me, void *const data)
{
return vector_add_at(me, 0, data);
}
@@ -211,21 +211,21 @@ int vector_add_first(vector me, void *const data)
* @param index the location in the vector to add the data to
* @param data the data to add to the vector
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
* @return -BK_EINVAL if invalid argument
*/
int vector_add_at(vector me, const size_t index, void *const data)
bk_err vector_add_at(vector me, const size_t index, void *const data)
{
if (index > me->item_count) {
return -EINVAL;
return -BK_EINVAL;
}
if (me->item_count + 1 >= me->item_capacity) {
const size_t new_space =
(size_t) (me->item_capacity * BKTHOMPS_VECTOR_RESIZE_RATIO);
char *const temp = realloc(me->data, new_space * me->bytes_per_item);
if (!temp) {
return -ENOMEM;
return -BK_ENOMEM;
}
me->data = temp;
me->item_capacity = new_space;
@@ -237,7 +237,7 @@ int vector_add_at(vector me, const size_t index, void *const data)
}
memcpy(me->data + index * me->bytes_per_item, data, me->bytes_per_item);
me->item_count++;
return 0;
return BK_OK;
}
/**
@@ -246,10 +246,10 @@ int vector_add_at(vector me, const size_t index, void *const data)
* @param me the vector to add to
* @param data the data to add to the vector
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int vector_add_last(vector me, void *const data)
bk_err vector_add_last(vector me, void *const data)
{
return vector_add_at(me, me->item_count, data);
}
@@ -259,10 +259,10 @@ int vector_add_last(vector me, void *const data)
*
* @param me the vector to remove from
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int vector_remove_first(vector me)
bk_err vector_remove_first(vector me)
{
return vector_remove_at(me, 0);
}
@@ -273,19 +273,19 @@ int vector_remove_first(vector me)
* @param me the vector to remove from
* @param index the location in the vector to remove the data from
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int vector_remove_at(vector me, const size_t index)
bk_err vector_remove_at(vector me, const size_t index)
{
if (index >= me->item_count) {
return -EINVAL;
return -BK_EINVAL;
}
me->item_count--;
memmove(me->data + index * me->bytes_per_item,
me->data + (index + 1) * me->bytes_per_item,
(me->item_count - index) * me->bytes_per_item);
return 0;
return BK_OK;
}
/**
@@ -293,16 +293,16 @@ int vector_remove_at(vector me, const size_t index)
*
* @param me the vector to remove from
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int vector_remove_last(vector me)
bk_err vector_remove_last(vector me)
{
if (me->item_count == 0) {
return -EINVAL;
return -BK_EINVAL;
}
me->item_count--;
return 0;
return BK_OK;
}
/**
@@ -315,10 +315,10 @@ int vector_remove_last(vector me)
* @param me the vector to set data for
* @param data the data to set at the start of the vector
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int vector_set_first(vector me, void *const data)
bk_err vector_set_first(vector me, void *const data)
{
return vector_set_at(me, 0, data);
}
@@ -334,16 +334,16 @@ int vector_set_first(vector me, void *const data)
* @param index the location to set data at in the vector
* @param data the data to set at the location in the vector
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int vector_set_at(vector me, const size_t index, void *const data)
bk_err vector_set_at(vector me, const size_t index, void *const data)
{
if (index >= me->item_count) {
return -EINVAL;
return -BK_EINVAL;
}
memcpy(me->data + index * me->bytes_per_item, data, me->bytes_per_item);
return 0;
return BK_OK;
}
/**
@@ -356,10 +356,10 @@ int vector_set_at(vector me, const size_t index, void *const data)
* @param me the vector to set data for
* @param data the data to set at the end of the vector
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int vector_set_last(vector me, void *const data)
bk_err vector_set_last(vector me, void *const data)
{
return vector_set_at(me, me->item_count - 1, data);
}
@@ -374,10 +374,10 @@ int vector_set_last(vector me, void *const data)
* @param data the data to copy to
* @param me the vector to copy from
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int vector_get_first(void *const data, vector me)
bk_err vector_get_first(void *const data, vector me)
{
return vector_get_at(data, me, 0);
}
@@ -393,16 +393,16 @@ int vector_get_first(void *const data, vector me)
* @param me the vector to copy from
* @param index the index to copy from in the vector
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int vector_get_at(void *const data, vector me, const size_t index)
bk_err vector_get_at(void *const data, vector me, const size_t index)
{
if (index >= me->item_count) {
return -EINVAL;
return -BK_EINVAL;
}
memcpy(data, me->data + index * me->bytes_per_item, me->bytes_per_item);
return 0;
return BK_OK;
}
/**
@@ -415,10 +415,10 @@ int vector_get_at(void *const data, vector me, const size_t index)
* @param data the data to copy to
* @param me the vector to copy from
*
* @return 0 if no error
* @return -EINVAL if invalid argument
* @return BK_OK if no error
* @return -BK_EINVAL if invalid argument
*/
int vector_get_last(void *const data, vector me)
bk_err vector_get_last(void *const data, vector me)
{
return vector_get_at(data, me, me->item_count - 1);
}
@@ -428,10 +428,10 @@ int vector_get_last(void *const data, vector me)
*
* @param me the vector to clear
*
* @return 0 if no error
* @return -ENOMEM if out of memory
* @return BK_OK if no error
* @return -BK_ENOMEM if out of memory
*/
int vector_clear(vector me)
bk_err vector_clear(vector me)
{
me->item_count = 0;
return vector_set_space(me, BKTHOMPS_VECTOR_START_SPACE);

2
tst/test.h
View File

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

1
tst/test_array.c
View File

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

1
tst/test_deque.c
View File

@@ -1,4 +1,3 @@
#include <limits.h>
#include "test.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 "../src/include/forward_list.h"

1
tst/test_list.c
View File

@@ -1,4 +1,3 @@
#include <limits.h>
#include "test.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 "../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 "../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 "../src/include/multiset.h"

1
tst/test_priority_queue.c
View File

@@ -1,4 +1,3 @@
#include <limits.h>
#include "test.h"
#include "../src/include/vector.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 "../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 "../src/include/set.h"

1
tst/test_stack.c
View File

@@ -1,4 +1,3 @@
#include <limits.h>
#include "test.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 "../src/include/unordered_map.h"

1
tst/test_unordered_multimap.c
View File

@@ -1,4 +1,3 @@
#include <limits.h>
#include "test.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 "../src/include/unordered_multiset.h"

1
tst/test_unordered_set.c
View File

@@ -1,4 +1,3 @@
#include <limits.h>
#include "test.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 "../src/include/vector.h"