Skip to content

Commit

Permalink
Removed the error handling functions.
Browse files Browse the repository at this point in the history 
Removed insert/removal functions that use indexing when
linked lists aren't really built for that.
  • Loading branch information
@kpluas21
kpluas21 committed May 20, 2023
1 parent 6eebe04 commit 62781d2
Show file tree
Hide file tree
Showing 3 changed files with 88 additions and 188 deletions.
173 changes: 60 additions & 113 deletions Data_Structures/LinkC/src/LinkC.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -13,24 +13,23 @@
#include<stdlib.h>
#include<string.h>
#include<math.h>
#include<errno.h>

#include"LinkC.h"

static const char *status_string;

LinkC *LinkC_init(size_t data_size, void *data) {
LinkC *list = malloc(sizeof(LinkC));
LinkCNode *head = malloc(sizeof(LinkCNode));

if(list == NULL || head == NULL) {
LinkC_error_report(E_OUT_OF_MEMORY);
errno = ENOMEM;
return NULL;
}

head->data = malloc(data_size);

if(head->data == NULL) {
LinkC_error_report(E_OUT_OF_MEMORY);
errno = ENOMEM;
return NULL;
}
memcpy(head->data, data, data_size);
Expand All @@ -50,20 +49,20 @@ size_t LinkC_size(LinkC *list) {
return list->alloc_Data / list->data_size;
}

void LinkC_insert_at_end(LinkC *list, void* data) {
int LinkC_insert_at_end(LinkC *list, void* data) {
LinkCNode *current = list->tail;

LinkCNode *newNode = malloc(sizeof(LinkCNode));
if(newNode == NULL) {
LinkC_error_report(E_OUT_OF_MEMORY);
return;
errno = ENOMEM;
return -1;
}

newNode->data = malloc(list->data_size);
if(newNode->data == NULL) {
free(newNode);
LinkC_error_report(E_OUT_OF_MEMORY);
return;
errno = ENOMEM;
return -1;
}

memcpy(newNode->data, data, list->data_size);
Expand All @@ -75,6 +74,7 @@ void LinkC_insert_at_end(LinkC *list, void* data) {

list->alloc_Data += list->data_size;

return 0;
}

void *LinkC_get(LinkC *list, size_t indexOfElem) {
Expand Down Expand Up @@ -107,7 +107,7 @@ int LinkC_find(LinkC *list, void *data) {

void LinkC_delete(LinkC **list) {
if(list == NULL || (*list) == NULL) {
LinkC_error_report(E_INVALID_ARGUMENT);
errno = EINVAL;
return; //Prevents double free's
}

Expand All @@ -126,49 +126,49 @@ void LinkC_delete(LinkC **list) {

}

void LinkC_remove_at_middle(LinkC *list, size_t index) {
size_t curr_list_size = LinkC_size(list);
if(index >= curr_list_size) {
LinkC_error_report(E_OUT_OF_BOUNDS_INDEX);
return;
}

//if beginning or ending index is provided, simply use those dedicated
//functions.

//REMOVE HEAD
else if(index == 0) {
LinkC_remove_head(list);
return;
}
//REMOVE TAIL
else if(index == curr_list_size - 1) {
LinkC_remove_tail(list);
return;
}

//Now we remove a node at the middle. There should be a valid node
//on both sides of the one to be removed.
LinkCNode *traversal_ptr = list->head;

//Traverse until we reach right before the node to be removed.
for (size_t i = 0; i < index; i++) {
traversal_ptr = traversal_ptr->next;
}
//This node will be the one to be free'd
LinkCNode *temp = traversal_ptr->next;

temp->prev->next = temp->next;
temp->next->prev = temp->prev;
free(temp->data);
free(temp);

list->alloc_Data -= list->data_size;

return;
}

void LinkC_remove_head(LinkC *list) {
// void LinkC_remove_at_middle(LinkC *list, size_t index) {
// size_t curr_list_size = LinkC_size(list);
// if(index >= curr_list_size) {
// errno = EINVAL;
// return;
// }

// //if beginning or ending index is provided, simply use those dedicated
// //functions.

// //REMOVE HEAD
// else if(index == 0) {
// LinkC_remove_first(list);
// return;
// }
// //REMOVE TAIL
// else if(index == curr_list_size - 1) {
// LinkC_remove_last(list);
// return;
// }

// //Now we remove a node at the middle. There should be a valid node
// //on both sides of the one to be removed.
// LinkCNode *traversal_ptr = list->head;

// //Traverse until we reach right before the node to be removed.
// for (size_t i = 0; i < index; i++) {
// traversal_ptr = traversal_ptr->next;
// }
// //This node will be the one to be free'd
// LinkCNode *temp = traversal_ptr->next;

// temp->prev->next = temp->next;
// temp->next->prev = temp->prev;
// free(temp->data);
// free(temp);

// list->alloc_Data -= list->data_size;

// return;
// }

void LinkC_remove_first(LinkC *list) {
if(list->head == list->tail) {
//Only one element in the list
free(list->head->data);
Expand All @@ -192,7 +192,7 @@ void LinkC_remove_head(LinkC *list) {
return;
}

void LinkC_remove_tail(LinkC *list) {
void LinkC_remove_last(LinkC *list) {
if(list->head == list->tail) {
//Only one element in the list
free(list->head->data);
Expand All @@ -213,19 +213,19 @@ void LinkC_remove_tail(LinkC *list) {
return;
}

void LinkC_insert_at_start(LinkC *list, void *data)
int LinkC_insert_at_start(LinkC *list, void *data)
{
LinkCNode *newNode = malloc(sizeof(LinkCNode));
if(newNode == NULL) {
LinkC_error_report(E_OUT_OF_MEMORY);
return;
errno = ENOMEM;
return -1;
}

newNode->data = malloc(list->data_size);
if(newNode->data == NULL) {
free(newNode);
LinkC_error_report(E_OUT_OF_MEMORY);
return;
errno = ENOMEM;
return -1;
}

memcpy(newNode->data, data, list->data_size);
Expand All @@ -237,58 +237,5 @@ void LinkC_insert_at_start(LinkC *list, void *data)
list->head = newNode;

list->alloc_Data += list->data_size;
return;
}

void LinkC_insert_at_index(LinkC *list, void *data, size_t index) {
if(index == 0) {
LinkC_insert_at_start(list, data);
return;
}

if(index == LinkC_size(list)) {
LinkC_insert_at_end(list, data);
return;
}

if(index > LinkC_size(list)) {
return;
}
LinkCNode *current = list->head;

LinkCNode *newNode = malloc(sizeof(LinkCNode));
if(newNode == NULL) {
LinkC_error_report(E_OUT_OF_MEMORY);
return;
}

newNode->data = malloc(list->data_size);
if(newNode->data == NULL) {
free(newNode);
LinkC_error_report(E_OUT_OF_MEMORY);
return;
}

memcpy(newNode->data, data, list->data_size);

size_t currIndex = 0;
while(currIndex != index) {
current = current->next;
}

newNode->next = current;
current->prev->next = newNode;
current->prev = newNode;

return;
}

void LinkC_error_report(ErrorCode code) {
const char *error_string = NULL;
if(code >= E_ERROR_COUNT) {
status_string = NULL;
}

error_string = ERROR_STRINGS[code];
status_string = error_string;
return 0;
}
90 changes: 22 additions & 68 deletions Data_Structures/LinkC/src/LinkC.h
View file
Original file line number Diff line number Diff line change
Expand Up @@ -10,48 +10,11 @@
* @copyright Copyright (c) 2023
*
*
* @note The nodes are capable of storing ANY types of data, however I wanted to keep
* it simple and only allow one type for the entire list.
*/

#include<stddef.h>

/**
* @brief ErrorCodes used for debugging errors that occur while using LinkC
* @note The nodes are capable of storing ANY type of data with a defined size in bytes.
*
*/
typedef enum ErrorCode {
E_SUCCESS = 0,
E_OUT_OF_MEMORY,
E_INVALID_ARGUMENT,
E_INVALID_DATATYPE,
E_OUT_OF_BOUNDS_INDEX,
E_UNKNOWN_ERROR,
E_ERROR_COUNT, //Dummy error, used to determine how many valid codes there are

}ErrorCode;

static const char* const ERROR_STRINGS[] = {
"E_SUCCESS",
"E_OUT_OF_MEMORY",
"E_INVALID_ARGUMENT",
"E_INVALID_DATATYPE",
"E_OUT_OF_BOUNDS_INDEX",
"E_UNKNOWN_ERROR",
};

/**
* @enum DataType
* @brief Constants used to label the data type of the elements in our linked list
*/
typedef enum DataType {
INT,
CHAR,
FLOAT,
DOUBLE,
STRING,

}DataType;
#include<stddef.h>

//Forward declaration
typedef struct LinkCNode LinkCNode;
Expand Down Expand Up @@ -117,13 +80,21 @@ LinkC *LinkC_init(size_t data_size, void *data);
*/
size_t LinkC_size(LinkC *list);

/**
* @brief Inserts a single element at the end of the list.
*
* @param list LinkC pointer to our list
* @param data Void pointer to our data to be inserted
*/
int LinkC_insert_at_start(LinkC *list, void *data);

/**
* @brief Inserts a single element at the end of the list
*
* @param list LinkC pointer to our list
* @param data Void pointer to our data
*/
void LinkC_insert_at_end(LinkC *list, void *data);
int LinkC_insert_at_end(LinkC *list, void *data);

/**
* @brief Retrieves the data at the index specified
Expand All @@ -150,53 +121,36 @@ int LinkC_find(LinkC *list, void *data);
*/
void LinkC_delete(LinkC **list);


/**
* @brief Removes a single node from the middle of the list at the
* specified index
*
* @param list The linked list
* @param index The index of the element to be removed
*/
void LinkC_remove_at_middle(LinkC *list, size_t index);

/**
* @brief Removes the first node at the head of the list
*
* @param list
*/
void LinkC_remove_head(LinkC *list);
void LinkC_remove_first(LinkC *list);

/**
* @brief Removes the last node at the tail of the list
*
* @param list
*/
void LinkC_remove_tail(LinkC *list);
void LinkC_remove_last(LinkC *list);

/**
* @brief Inserts a single element at the end of the list.
* @brief Traverses through the list and calls a user provided function pointer to print the data.
*
* @param list LinkC pointer to our list
* @param data Void pointer to our data to be inserted
* @param list A pointer to a valid LinkC object
*/
void LinkC_insert_at_start(LinkC *list, void *data);
void LinkC_print(LinkC *list,
void (*LinkC_print_data) (void *data));

/**
* @brief Inserts a single element at the specified index.
* @brief Same as LinkC_print but in reverse order.
*
* @param list LinkC pointer to our list
* @param data Void pointer to our data to be inserted
* @param index The index where the data is to be inserted
* @param list
* @param LinkC_print A function pointer to a print function.
*/
void LinkC_insert_at_index(LinkC *list, void *data, size_t index);
void LinkC_print_reverse(LinkC *list,
void (*LinkC_print_data) (void *data));

/**
* @brief Displays an error message
*
* @param code The type of error encountered
* @return A string detailing the error encountered.
*/
void LinkC_error_report(ErrorCode code);

#endif //LINK_C
Loading

0 comments on commit 62781d2

Please sign in to comment.