Experiments/libds
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Format code.

Browse Source
This commit is contained in:
Danila Fedorin 2016-12-21 14:50:32 -08:00
parent d41a085bcd
commit 52640ed8f9
7 changed files with 305 additions and 337 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.clang-format Normal file
View File

@ -0,0 +1,3 @@
DerivePointerAlignment: false
PointerAlignment: Left
BasedOnStyle: google

5
include/libds.h
View File

@ -3,10 +3,7 @@
#include <stdarg.h>
enum libds_result_e {
SUCCESS,
MALLOC
};
enum libds_result_e { SUCCESS, MALLOC };
typedef enum libds_result_e libds_result;
typedef int (*compare_func)(void*, void*);

54
src/ht.c
View File

@ -1,8 +1,8 @@
#include "ht.h"
#include <string.h>
#include <stdlib.h>
#include <string.h>
unsigned int ht_default_hash_func(void* data){
unsigned int ht_default_hash_func(void* data) {
const unsigned int fnv_prime = 16777619;
const unsigned int fnv_offset_basis = 2166136261;
unsigned int hash;
@ -15,32 +15,28 @@ unsigned int ht_default_hash_func(void* data){
}
return hash;
}
int ht_default_cmp_func(void* a, void* b){
return strcmp(a, b) == 0;
}
int ht_default_cmp_func(void* a, void* b) { return strcmp(a, b) == 0; }
void* ht_default_copy_func(void* from) {
void* copy = malloc(sizeof(char) * (strlen(from) + 1));
if(copy) {
if (copy) {
strcpy(copy, from);
}
return copy;
}
void ht_default_free_func(void* data){
free(data);
}
void ht_default_free_func(void* data) { free(data); }
void ht_init(ht* ht){
void ht_init(ht* ht) {
ht->cmp_func = ht_default_cmp_func;
ht->copy_func = ht_default_copy_func;
ht->free_func = ht_default_free_func;
ht->hash_func = ht_default_hash_func;
memset(ht->data, 0, sizeof(ht->data));
}
void ht_free(ht* ht){
void ht_free(ht* ht) {
int index = 0;
for(; index < LIBDS_HT_SIZE; index++){
for (; index < LIBDS_HT_SIZE; index++) {
ht_node* head = ht->data[index];
while(head){
while (head) {
ht_node* to_delete = head;
head = head->next;
ht->free_func(to_delete->key);
@ -49,25 +45,24 @@ void ht_free(ht* ht){
}
}
libds_result ht_put(ht* ht, void* key, void* data){
libds_result ht_put(ht* ht, void* key, void* data) {
libds_result result = SUCCESS;
ht_node* new_node = NULL;
unsigned int key_int = ht->hash_func(key) % LIBDS_HT_SIZE;
new_node = malloc(sizeof(*new_node));
if(new_node) {
if (new_node) {
new_node->data = data;
new_node->key = ht->copy_func(key);
if(new_node->key == NULL){
if (new_node->key == NULL) {
result = MALLOC;
}
} else {
result = MALLOC;
}
if(result != SUCCESS) {
if(new_node) {
if (result != SUCCESS) {
if (new_node) {
free(new_node);
new_node = NULL;
}
@ -84,8 +79,8 @@ void* ht_get(ht* ht, void* key) {
unsigned int key_int = ht->hash_func(key) % LIBDS_HT_SIZE;
search_node = ht->data[key_int];
while(search_node && data == NULL){
if(ht->cmp_func(search_node->key, key)) {
while (search_node && data == NULL) {
if (ht->cmp_func(search_node->key, key)) {
data = search_node->data;
}
search_node = search_node->next;
@ -93,13 +88,13 @@ void* ht_get(ht* ht, void* key) {
return data;
}
void ht_remove(ht* ht, void* key){
void ht_remove(ht* ht, void* key) {
ht_node** search_ptr;
unsigned int key_int = ht->hash_func(key) % LIBDS_HT_SIZE;
search_ptr = &ht->data[key_int];
while(*search_ptr){
if(ht->cmp_func((*search_ptr)->key, key)){
while (*search_ptr) {
if (ht->cmp_func((*search_ptr)->key, key)) {
ht_node* to_delete = *search_ptr;
*search_ptr = (*search_ptr)->next;
ht->free_func(to_delete->key);
@ -110,16 +105,17 @@ void ht_remove(ht* ht, void* key){
}
}
int ht_foreach(ht* ht, void* data, compare_func compare, foreach_func foreach, ...){
int ht_foreach(ht* ht, void* data, compare_func compare, foreach_func foreach,
...) {
int index = 0;
int return_code = 0;
va_list args;
for(; index < LIBDS_HT_SIZE && return_code == 0; index++){
for (; index < LIBDS_HT_SIZE && return_code == 0; index++) {
ht_node* search_node = ht->data[index];
while(search_node && return_code == 0){
if(compare(data, search_node->data)) {
while (search_node && return_code == 0) {
if (compare(data, search_node->data)) {
va_start(args, foreach);
return_code = foreach(search_node->data, args);
return_code = foreach (search_node->data, args);
va_end(args);
}
search_node = search_node->next;

4
src/libds.c
View File

@ -1,5 +1,3 @@
#include "libds.h"
int compare_always(void* a, void* b){
return 1;
}
int compare_always(void* a, void* b) { return 1; }

89
src/main.c
View File

@ -1,41 +1,39 @@
#include <stdlib.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "vec.h"
#include "ht.h"
#include "vec.h"
int _test_vec_foreach_func(void* data, va_list args){
int _test_vec_foreach_func(void* data, va_list args) {
char* real_data = data;
int* sum = va_arg(args, int*);
*sum += *real_data;
return 0;
}
int _test_vec_find_string(void* a, void* b){
return strcmp(a, b) == 0;
}
int _test_vec_find_string(void* a, void* b) { return strcmp(a, b) == 0; }
int test_vec_basic(){
int test_vec_basic() {
vec test_vec;
libds_result result = vec_init(&test_vec);
vec_free(&test_vec);
return result == SUCCESS;
}
int test_vec_add(){
int test_vec_add() {
vec test_vec;
char* test_string = "test";
int return_code;
vec_init(&test_vec);
return_code = vec_add(&test_vec, test_string) == SUCCESS;
if(return_code) return_code = *((void**) test_vec.data) == test_string;
if (return_code) return_code = *((void**)test_vec.data) == test_string;
vec_free(&test_vec);
return return_code;
}
int test_vec_remove(){
int test_vec_remove() {
vec test_vec;
char* test_string = "test";
int return_code;
@ -43,49 +41,43 @@ int test_vec_remove(){
vec_init(&test_vec);
vec_add(&test_vec, test_string);
vec_remove(&test_vec, test_string);
return_code = *((void**) test_vec.data) == NULL;
return_code = *((void**)test_vec.data) == NULL;
vec_free(&test_vec);
return return_code;
}
int test_vec_find(){
int test_vec_find() {
vec test_vec;
char* test_string = "test";
int return_code;
vec_init(&test_vec);
vec_add(&test_vec, test_string);
return_code = vec_find(&test_vec, test_string, _test_vec_find_string) == test_string;
return_code =
vec_find(&test_vec, test_string, _test_vec_find_string) == test_string;
vec_free(&test_vec);
return return_code;
}
int test_vec_foreach(){
int test_vec_foreach() {
vec test_vec;
int return_code;
int sum = 0;
char* test_strings[3] = {
"1",
"2",
"3"
};
char* test_strings[3] = {"1", "2", "3"};
vec_init(&test_vec);
vec_add(&test_vec, test_strings[0]);
vec_add(&test_vec, test_strings[1]);
vec_add(&test_vec, test_strings[2]);
vec_foreach(&test_vec, NULL, compare_always, _test_vec_foreach_func, &sum);
return_code = test_strings[0][0] + test_strings[1][0] + test_strings[2][0] == sum;
return_code =
test_strings[0][0] + test_strings[1][0] + test_strings[2][0] == sum;
vec_free(&test_vec);
return return_code;
}
int test_vec_index(){
int test_vec_index() {
vec test_vec;
int return_code;
char* test_strings[3] = {
"1",
"2",
"3"
};
char* test_strings[3] = {"1", "2", "3"};
vec_init(&test_vec);
vec_add(&test_vec, test_strings[0]);
@ -96,7 +88,7 @@ int test_vec_index(){
return return_code;
}
int _test_ht_foreach_func(void* data, va_list args){
int _test_ht_foreach_func(void* data, va_list args) {
char* real_data = data;
int* sum = va_arg(args, int*);
@ -130,11 +122,12 @@ int test_ht_get() {
ht_init(&test_ht);
ht_put(&test_ht, test_one, test_two);
ht_put(&test_ht, test_two, test_one);
return_code = ht_get(&test_ht, test_one) == test_two && ht_get(&test_ht, test_two) == test_one;
return_code = ht_get(&test_ht, test_one) == test_two &&
ht_get(&test_ht, test_two) == test_one;
ht_free(&test_ht);
return return_code;
}
int test_ht_remove(){
int test_ht_remove() {
int return_code;
ht test_ht;
char* test_one = "creamwove";
@ -148,7 +141,7 @@ int test_ht_remove(){
ht_free(&test_ht);
return return_code;
}
int test_ht_foreach(){
int test_ht_foreach() {
int return_code;
int sum = 0;
ht test_ht;
@ -170,39 +163,19 @@ int run_test(char* test_name, int (*test_func)()) {
return success;
}
int main(int argc, char** argv){
char* test_names[11] = {
"vec_basic",
"vec_add",
"vec_remove",
"vec_find",
"vec_foreach",
"vec_index",
"ht_basic",
"ht_put",
"ht_get",
"ht_remove",
"ht_foreach"
};
int main(int argc, char** argv) {
char* test_names[11] = {"vec_basic", "vec_add", "vec_remove", "vec_find",
"vec_foreach", "vec_index", "ht_basic", "ht_put",
"ht_get", "ht_remove", "ht_foreach"};
int (*test_functions[11])() = {
test_vec_basic,
test_vec_add,
test_vec_remove,
test_vec_find,
test_vec_foreach,
test_vec_index,
test_ht_basic,
test_ht_put,
test_ht_get,
test_ht_remove,
test_ht_foreach
};
test_vec_basic, test_vec_add, test_vec_remove, test_vec_find,
test_vec_foreach, test_vec_index, test_ht_basic, test_ht_put,
test_ht_get, test_ht_remove, test_ht_foreach};
int test_index = 0;
int result = 1;
for(; test_index < 11 && result; test_index++){
for (; test_index < 11 && result; test_index++) {
result = run_test(test_names[test_index], test_functions[test_index]);
}
return result ? EXIT_SUCCESS : EXIT_FAILURE;

53
src/vec.c
View File

@ -1,34 +1,34 @@
#include "vec.h"
#include <stdlib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
libds_result vec_init(vec* v){
libds_result vec_init(vec* v) {
libds_result result = SUCCESS;
v->size = 0;
v->capacity = LIBDS_VEC_CAPACITY;
v->data = calloc(LIBDS_VEC_CAPACITY, sizeof(void*));
if(v->data == NULL){
if (v->data == NULL) {
result = MALLOC;
}
return result;
}
void vec_free(vec* v){
void vec_free(vec* v) {
v->size = 0;
v->capacity = 0;
if(v->data) {
if (v->data) {
free(v->data);
}
v->data = NULL;
}
libds_result vec_add(vec* v, void* data){
libds_result vec_add(vec* v, void* data) {
libds_result result = SUCCESS;
if(v->size >= v->capacity) {
if (v->size >= v->capacity) {
void* new_mem = calloc(v->capacity *= 2, sizeof(void*));
if(new_mem) {
if (new_mem) {
memcpy(new_mem, v->data, sizeof(void*) * v->capacity / 2);
free(v->data);
v->data = new_mem;
@ -37,11 +37,11 @@ libds_result vec_add(vec* v, void* data){
}
}
if(result == SUCCESS) {
if (result == SUCCESS) {
int index = 0;
while(index < v->capacity) {
while (index < v->capacity) {
void** data_array = v->data;
if(data_array[index] == NULL) {
if (data_array[index] == NULL) {
data_array[index] = data;
v->size++;
break;
@ -52,14 +52,14 @@ libds_result vec_add(vec* v, void* data){
return result;
}
void vec_remove(vec* v, void* data){
void vec_remove(vec* v, void* data) {
int elements = v->size;
int index = 0;
void** data_array = v->data;
while(elements > 0) {
if(data_array[index]) {
while (elements > 0) {
if (data_array[index]) {
elements--;
if(data_array[index] == data) {
if (data_array[index] == data) {
data_array[index] = NULL;
v->size--;
}
@ -68,14 +68,14 @@ void vec_remove(vec* v, void* data){
}
}
void* vec_find(vec* v, void* data, compare_func compare){
void* vec_find(vec* v, void* data, compare_func compare) {
int elements = v->size;
int index = 0;
void* found = NULL;
void** data_array = v->data;
while(elements > 0 && found == NULL){
if(data_array[index]){
if(compare(data, data_array[index])){
while (elements > 0 && found == NULL) {
if (data_array[index]) {
if (compare(data, data_array[index])) {
found = data_array[index];
}
elements--;
@ -84,17 +84,18 @@ void* vec_find(vec* v, void* data, compare_func compare){
}
return found;
}
int vec_foreach(vec* v, void* data, compare_func compare, foreach_func foreach, ...){
int vec_foreach(vec* v, void* data, compare_func compare, foreach_func foreach,
...) {
int elements = v->size;
int index = 0;
int return_code = 0;
void** data_array = v->data;
va_list args;
while(elements > 0 && return_code == 0) {
if(data_array[index]){
if(compare(data, data_array[index])){
while (elements > 0 && return_code == 0) {
if (data_array[index]) {
if (compare(data, data_array[index])) {
va_start(args, foreach);
return_code = foreach(data_array[index], args);
return_code = foreach (data_array[index], args);
va_end(args);
}
elements--;
@ -104,9 +105,9 @@ int vec_foreach(vec* v, void* data, compare_func compare, foreach_func foreach,
return return_code;
}
void* vec_index(vec* v, int index){
void* vec_index(vec* v, int index) {
void* to_return = NULL;
if(index < v->capacity && index >= 0) {
if (index < v->capacity && index >= 0) {
void** data_array = v->data;
to_return = data_array[index];
}