Renamed database_t to database_st and task_t to task_st.

1 files changed, 43 insertions, 43 deletions

diff --git a/main.c b/main.c
index 30178c6..ee4323c 100644
--- a/main.c
+++ b/main.c
@@ -24,34 +24,34 @@
 #define DB_BIN_PATH_NAME	"./database.bin"
 #define AR_CSV_PATH_NAME	"./archive.csv"
 
-typedef struct /*__attribute__((__packed__))*/ {
+typedef struct {
 	int64_t		times[WEEK_DAYS];
 	char		name[MAX_TASK_NAME];
-} task_t;	// TODO Rename to task_st
+} task_st;
 
-typedef struct /*__attribute__((__packed__))*/ {
-	task_t		*tasks;
+typedef struct {
+	task_st		*tasks;
 	size_t		count;
 	size_t		capacity;
 	ptrdiff_t	active_task;
 	ptrdiff_t	selected_task;
 	int64_t		modified_on;
 	int64_t		total_times[WEEK_DAYS];
-} database_t; // TODO Rename to database_st
+} database_st;
 
 #define DB_FILE_SIGN_STR			"TTT:B:01"
 const char DB_FILE_SIGN[]			= DB_FILE_SIGN_STR;
 const size_t DB_FILE_SIGN_LENGTH	= sizeof(DB_FILE_SIGN_STR)-1;
-const size_t SIZEOF_TASK_T			= sizeof(task_t);
-const size_t SIZEOF_DATABASE_T		= sizeof(database_t);
+const size_t SIZEOF_TASK_T			= sizeof(task_st);
+const size_t SIZEOF_DATABASE_T		= sizeof(database_st);
 const int64_t SECONDS_IN_MINUTE		= (int64_t)60;
 const int64_t SECONDS_IN_HOUR		= (int64_t)60*SECONDS_IN_MINUTE;
 const int64_t SECONDS_IN_DAY		= (int64_t)24*SECONDS_IN_HOUR;
 const int64_t SECONDS_IN_YEAR		= (int64_t)365*SECONDS_IN_DAY;
 
-database_t database		= { .tasks = NULL };
-database_t archive		= { .tasks = NULL };
-database_t *db			= NULL;
+database_st database		= { .tasks = NULL };
+database_st archive		= { .tasks = NULL };
+database_st *db			= NULL;
 char *string_buffer 	= NULL;
 int size_x, size_y, pos_x, pos_y;
 
@@ -191,10 +191,10 @@ int64_t sub_time(int64_t x, int64_t y) {
 }
 
 // Returns active task or NULL if none applies.
-task_t *get_active_task(database_t *db) {
+task_st *get_active_task(database_st *db) {
 	assert(db != NULL);
 	
-	task_t *task = NULL;
+	task_st *task = NULL;
 	if (db->active_task >= 0) {
 		task = db->tasks + db->active_task;
 	}
@@ -203,10 +203,10 @@ task_t *get_active_task(database_t *db) {
 }
 
 // Returns selected task or NULL if none applies.
-task_t *get_selected_task(database_t *db) {
+task_st *get_selected_task(database_st *db) {
 	assert(db != NULL);
 	
-	task_t *task = NULL;
+	task_st *task = NULL;
 	if (db->selected_task >= 0) {
 		task = db->tasks + db->selected_task;
 	}
@@ -216,7 +216,7 @@ task_t *get_selected_task(database_t *db) {
 
 // Creates new task returned in the pointer. If necessary, expands database capacity.
 // Returns success.
-bool create_task(database_t *db, task_t **task) {
+bool create_task(database_st *db, task_st **task) {
 	assert(db != NULL);
 	
 	if (db->count == PTRDIFF_MAX) {
@@ -231,7 +231,7 @@ bool create_task(database_t *db, task_t **task) {
 			current_capacity > PTRDIFF_MAX >> 1 ? PTRDIFF_MAX :
 			current_capacity << 1;
 		
-		task_t *new_tasks = realloc(db->tasks, new_capacity * SIZEOF_TASK_T);
+		task_st *new_tasks = realloc(db->tasks, new_capacity * SIZEOF_TASK_T);
 		if (new_tasks == NULL) {
 			fprintf(stderr, "Failed to expand database.\n");
 			return false;
@@ -257,11 +257,11 @@ bool create_task(database_t *db, task_t **task) {
 
 // Adds the given task to the database using (using create_task and memcpy).
 // Returns success.
-bool add_task(database_t *db, task_t *task) {
+bool add_task(database_st *db, task_st *task) {
 	assert(db != NULL);
 	assert(task != NULL);
 	
-	task_t *new_task;
+	task_st *new_task;
 	if (create_task(db, &new_task) == false) {
 		return false;
 	}
@@ -279,7 +279,7 @@ bool add_task(database_t *db, task_t *task) {
 
 // Deletes the task provided in the pointer. If possible, shrinks the database capacity.
 // Returns success.
-bool delete_task(database_t *db, task_t *task) {
+bool delete_task(database_st *db, task_st *task) {
 	assert(db != NULL);
 	assert(task != NULL);
 	assert(task >= db->tasks && task < &db->tasks[db->count]);
@@ -312,7 +312,7 @@ bool delete_task(database_t *db, task_t *task) {
 	size_t current_capacity = db->capacity;
 	if (db->count <= (current_capacity >> 2)) {
 		size_t new_capacity = current_capacity >> 1;
-		task_t *new_tasks = realloc(db->tasks, new_capacity * SIZEOF_TASK_T);
+		task_st *new_tasks = realloc(db->tasks, new_capacity * SIZEOF_TASK_T);
 		if (new_tasks == NULL && new_capacity > 0) {
 			fprintf(stderr, "Failed to shrink database.\n");
 			return false;
@@ -325,7 +325,7 @@ bool delete_task(database_t *db, task_t *task) {
 }
 
 // Resets database to the initial state and deallocates all memory taken by tasks.
-void reset_database(database_t *db) {
+void reset_database(database_st *db) {
 	free(db->tasks);
 	memset(db, 0, SIZEOF_DATABASE_T);
 	db->active_task = -1;
@@ -334,7 +334,7 @@ void reset_database(database_t *db) {
 
 // Stores data from database into binary file.
 // Returns success.
-bool store_database(const database_t *db, const char *path_name) {
+bool store_database(const database_st *db, const char *path_name) {
 	
 	assert(db != NULL);
 	assert(path_name != NULL);
@@ -356,7 +356,7 @@ bool store_database(const database_t *db, const char *path_name) {
 
 // Loads data from binary file into database.
 // Returns success.
-bool load_database(database_t *db, const char *path_name) {
+bool load_database(database_st *db, const char *path_name) {
 	
 	assert(db != NULL);
 	assert(path_name != NULL);
@@ -394,7 +394,7 @@ bool load_database(database_t *db, const char *path_name) {
 
 // Exports data into CSV file.
 // Returns success.
-bool export_to_csv(const database_t *db, const char *path_name) {
+bool export_to_csv(const database_st *db, const char *path_name) {
 	
 	assert(db != NULL);
 	assert(path_name != NULL);
@@ -417,8 +417,8 @@ bool export_to_csv(const database_t *db, const char *path_name) {
 	);
 	
 	char name[MAX_TASK_NAME];
-	task_t *limit = db->tasks + db->count;
-	for (task_t *task = db->tasks; task < limit; task++) {
+	task_st *limit = db->tasks + db->count;
+	for (task_st *task = db->tasks; task < limit; task++) {
 		memcpy(name, task->name, MAX_TASK_NAME);
 		replace_char(name, ',', ' ');
 		fprintf(file, "%s,%" PRId64 ",%" PRId64 ",%" PRId64 ",%" PRId64 ",%" PRId64 ",%" PRId64 ",%" PRId64 "\n",
@@ -439,7 +439,7 @@ bool export_to_csv(const database_t *db, const char *path_name) {
 
 // Imports CSV file into database.
 // Returns success.
-bool import_from_csv(database_t *db, const char *path_name) {
+bool import_from_csv(database_st *db, const char *path_name) {
 	assert(db != NULL);
 	assert(path_name != NULL);
 	
@@ -468,7 +468,7 @@ bool import_from_csv(database_t *db, const char *path_name) {
 		}
 		
 		// Prepare new task.
-		task_t *task;
+		task_st *task;
 		create_task(db, &task);
 		
 		// Import task name.
@@ -505,7 +505,7 @@ bool import_from_csv(database_t *db, const char *path_name) {
 	return true;
 }
 
-bool append_to_csv(task_t *task, const char *path_name) {
+bool append_to_csv(task_st *task, const char *path_name) {
 	assert(task != NULL);
 	assert(path_name != NULL);
 	
@@ -540,7 +540,7 @@ bool append_to_csv(task_t *task, const char *path_name) {
 	return true;
 }
 
-void update_timers(database_t *db) {
+void update_timers(database_st *db) {
 	
 	// Get current UTC time.
 	time_t stop_time = time(NULL);
@@ -552,7 +552,7 @@ void update_timers(database_t *db) {
 		return;
 	}
 	
-	task_t *active_task = db->tasks + db->active_task;
+	task_st *active_task = db->tasks + db->active_task;
 	uint8_t start_week_day;
 	while (start_time < stop_time) {
 		
@@ -576,7 +576,7 @@ void update_timers(database_t *db) {
 	db->modified_on = stop_time;
 }
 
-void update_total_timers(database_t *db) {
+void update_total_timers(database_st *db) {
 	
 	int64_t *d0 = &db->total_times[0];
 	int64_t *d1 = &db->total_times[1];
@@ -702,7 +702,7 @@ void initialize_tui() {
 	init_pair(THEME_E, COLOR_BLUE, COLOR_BLACK);
 }
 
-void draw_tui(database_t *db, layout_st *layout) {
+void draw_tui(database_st *db, layout_st *layout) {
 	
 	const static int adjust_first_day_of_week[] = {
 		(0 + FIRST_DAY_OF_WEEK) % WEEK_DAYS,
@@ -718,8 +718,8 @@ void draw_tui(database_t *db, layout_st *layout) {
 	column_st *col;
 	
 	// Get context information.
-	task_t *active_task = get_active_task(db);
-	task_t *selected_task = get_selected_task(db);
+	task_st *active_task = get_active_task(db);
+	task_st *selected_task = get_selected_task(db);
 	time_t now_utc = time(NULL);
 	int now_week_day = localtime(&now_utc)->tm_wday;
 	
@@ -800,7 +800,7 @@ void draw_tui(database_t *db, layout_st *layout) {
 	size_t idx_start = (db->selected_task / available_rows) * available_rows;
 	size_t idx_stop = idx_start + (available_rows > db->count - idx_start ? db->count - idx_start : available_rows);
 	for (size_t idx = idx_start; idx < idx_stop; idx++) {
-		task_t *task = &db->tasks[idx];
+		task_st *task = &db->tasks[idx];
 		y++;
 		x = 0;
 		
@@ -832,9 +832,9 @@ void draw_tui(database_t *db, layout_st *layout) {
 			int day_idx = (idx + FIRST_DAY_OF_WEEK) % WEEK_DAYS;
 			
 			column_width = layout->columns[L_DAYS_IDX + day_idx].width;
-			int64_t task_time = task->times[day_idx];
-			total_time = add_time(total_time, task_time);
-			format_time(string_buffer, task_time, column_width);
+			int64_t task_stime = task->times[day_idx];
+			total_time = add_time(total_time, task_stime);
+			format_time(string_buffer, task_stime, column_width);
 			mvaddstr(y, x, string_buffer);
 			x += column_width;
 		}
@@ -975,8 +975,8 @@ int main(int argc, char *argv[]) {
 	for (int key; (key = getch()) != 'q'; ) {
 	
 		timeout(INPUT_AWAIT_INF);
-		task_t *active_task = get_active_task(db);
-		task_t *selected_task = get_selected_task(db);
+		task_st *active_task = get_active_task(db);
+		task_st *selected_task = get_selected_task(db);
 		update_timers(&database);
 		
 		switch(key) {
@@ -995,7 +995,7 @@ int main(int argc, char *argv[]) {
 			case KEY_F(1):
 			{
 				// Create new task.
-				task_t *new_task;
+				task_st *new_task;
 				if (create_task(db, &new_task) == false) {
 					// TODO ERROR
 					break;
@@ -1061,7 +1061,7 @@ int main(int argc, char *argv[]) {
 				if (db != &database) {
 					break;
 				}
-				task_t *next_task = selected_task;
+				task_st *next_task = selected_task;
 				if (active_task != NULL) {
 					update_timers(db); // TODO Should I keep this even though it always does?
 					db->active_task = -1;