From a7dda0e0060d868c8a797b5a05b64d1aa09548d7 Mon Sep 17 00:00:00 2001
From: Tucker Evans <tucker@tuckerevans.com>
Date: Mon, 6 Jul 2020 11:06:44 -0400
Subject: Fix organize functions order in double ended queue src files

---
 .../double_ended_queue/double_ended_queue.c        | 269 ++++++++++-----------
 .../double_ended_queue/double_ended_queue.h        |  34 +--
 2 files changed, 150 insertions(+), 153 deletions(-)

diff --git a/collections/double_ended_queue/double_ended_queue.c b/collections/double_ended_queue/double_ended_queue.c
index f5e9880..4872150 100644
--- a/collections/double_ended_queue/double_ended_queue.c
+++ b/collections/double_ended_queue/double_ended_queue.c
@@ -28,6 +28,19 @@ struct double_ended_queue {
 	int beg, end, limit;
 };
 
+void deq_debug_print(root)
+deq *root;
+{
+	void **tmp;
+
+	fprintf(stderr, "DEQ[base: %p, beg: %d, end:%d]:\n\t ",
+			root->base, root->beg, root->end);
+	for (tmp = root->base; tmp < root->base + root->limit; tmp++){
+		fprintf(stderr, "[%p]", *tmp);
+	}
+	fprintf(stderr, "\n");
+}
+
 deq* deq_new()
 {
 	deq *root;
@@ -111,16 +124,37 @@ deq *root;
 	root->base = tmp;
 }
 
-void* deq_index(root, index)
+deq* deq_cp(root)
 deq *root;
-int index;
 {
-	void **tmp;
+	deq *copy;
 
-	if (!root || !DEQ_IN_BOUNDS(root,index))
-		return NULL;
+	copy = deq_with_capacity(root->limit);
+	assert(copy->base);
 
-	return root->base[(root->beg + index) % root->limit];
+	copy->base = memcpy(copy->base, root->base,
+			root->limit * sizeof(void*));
+	assert(copy->base);
+
+	copy->beg = root->beg;
+	copy->end = root->end;
+
+	return copy;
+}
+
+void deq_print(root, to_string)
+deq *root;
+char* to_string(void*);
+{
+	int i, size;;
+
+	size = deq_size(root);
+
+	printf("[");
+	for (i = 0; i < size; i++) {
+		printf("%s,", to_string(deq_index(root, i)));
+	}
+	printf("\b]\n");
 }
 
 void deq_push_front(root, item)
@@ -163,54 +197,23 @@ void *item;
 		root->end = root->limit;
 }
 
-void deq_set(root, index, item)
+void* deq_front(root)
 deq *root;
-int index;
-void *item;
 {
-	if (!root || !DEQ_IN_BOUNDS(root, index))
-		return;
-	root->base[(root->beg + index) % root->limit] = item;
+	if (!root)
+		return NULL;
+
+	return root->base[root->beg];
 }
 
-void deq_insert(root, index, item)
+void* deq_back(root)
 deq *root;
-int index;
-void *item;
 {
 	if (!root)
-		return;
-
-	if (index > deq_size(root))
-		return;
-
-	if (root->end >= root->limit)
-		deq_resize(root);
-
-	index = (root->beg + index) % root->limit;
-
-	if (root->beg < root->end) {
-		memmove(root->base + index + 1, root->base + index,
-				(root->end - index) * sizeof(void*));
-		++root->end;
-		root->end = root->end % root->limit;
-	} else if (index < root->end) {
-		memmove(root->base + index + 1,
-				root->base + index,
-				(root->end - index) * sizeof(void*));
-		++root->end;
-	} else {
-		memmove(root->base + root->beg - 1, root->base + root->beg,
-				(index - root->beg) * sizeof(void*));
-		--root->beg;
-	}
-
-	if (root->end == root->beg)
-		root->end = root->limit;
+		return NULL;
 
-	root->base[index] = item;
+	return root->base[(root->end - 1) % root->limit];
 }
-
 void* deq_pop_front(root)
 deq *root;
 {
@@ -238,52 +241,64 @@ deq *root;
 	return root->base[root->end];
 }
 
-void* deq_swap_rm_front(root, index)
+void deq_set(root, index, item)
 deq *root;
 int index;
+void *item;
 {
-	if (!root || !DEQ_IN_BOUNDS(root,index))
-		return NULL;
-
-	deq_swap(root, 0, index);
-	return deq_pop_front(root);
+	if (!root || !DEQ_IN_BOUNDS(root, index))
+		return;
+	root->base[(root->beg + index) % root->limit] = item;
 }
 
-void* deq_swap_rm_back(root, index)
+void* deq_index(root, index)
 deq *root;
 int index;
 {
+	void **tmp;
+
 	if (!root || !DEQ_IN_BOUNDS(root,index))
 		return NULL;
 
-	deq_swap(root,deq_size(root) - 1,index);
-	return deq_pop_back(root);
+	return root->base[(root->beg + index) % root->limit];
 }
 
-void deq_swap(root, i, j)
+void deq_insert(root, index, item)
 deq *root;
-int i, j;
+int index;
+void *item;
 {
-	int len;
-	void *tmp;
-
 	if (!root)
 		return;
 
-	len = deq_size(root);
-
-	if (i >= len || j >= len)
+	if (index > deq_size(root))
 		return;
 
-	i += root->beg;
-	i %= root->limit;
+	if (root->end >= root->limit)
+		deq_resize(root);
 
-	j += root->beg;
-	j %= root->limit;
+	index = (root->beg + index) % root->limit;
 
-	tmp = root->base[i];
-	root->base[i] = root->base[j];
-	root->base[j] = tmp;
+	if (root->beg < root->end) {
+		memmove(root->base + index + 1, root->base + index,
+				(root->end - index) * sizeof(void*));
+		++root->end;
+		root->end = root->end % root->limit;
+	} else if (index < root->end) {
+		memmove(root->base + index + 1,
+				root->base + index,
+				(root->end - index) * sizeof(void*));
+		++root->end;
+	} else {
+		memmove(root->base + root->beg - 1, root->base + root->beg,
+				(index - root->beg) * sizeof(void*));
+		--root->beg;
+	}
+
+	if (root->end == root->beg)
+		root->end = root->limit;
+
+	root->base[index] = item;
 }
 
 void deq_remove(root, index)
@@ -308,76 +323,54 @@ int index;
 	}
 }
 
-/* Note: Elements are not freed
- * deq_clear should be called before if they are no longer needed.
- */
-void deq_free(root)
+void deq_swap(root, i, j)
 deq *root;
+int i, j;
 {
-	free(root->base);
-	root->base = NULL;
+	int len;
+	void *tmp;
 
-	free(root);
-}
+	if (!root)
+		return;
 
-void deq_clear(root)
-deq *root;
-{
-	int i, size;
+	len = deq_size(root);
 
-	size = deq_size(root);
-	for (i = 0; i < size; i++) {
-		free(deq_index(root, i));
-	}
-}
+	if (i >= len || j >= len)
+		return;
 
-void deq_print(root, to_string)
-deq *root;
-char* to_string(void*);
-{
-	int i, size;;
+	i += root->beg;
+	i %= root->limit;
 
-	size = deq_size(root);
+	j += root->beg;
+	j %= root->limit;
 
-	printf("[");
-	for (i = 0; i < size; i++) {
-		printf("%s,", to_string(deq_index(root, i)));
-	}
-	printf("\b]\n");
+	tmp = root->base[i];
+	root->base[i] = root->base[j];
+	root->base[j] = tmp;
 }
 
-void deq_debug_print(root)
+void* deq_swap_rm_front(root, index)
 deq *root;
+int index;
 {
-	void **tmp;
+	if (!root || !DEQ_IN_BOUNDS(root,index))
+		return NULL;
 
-	fprintf(stderr, "DEQ[base: %p, beg: %d, end:%d]:\n\t ",
-			root->base, root->beg, root->end);
-	for (tmp = root->base; tmp < root->base + root->limit; tmp++){
-		fprintf(stderr, "[%p]", *tmp);
-	}
-	fprintf(stderr, "\n");
+	deq_swap(root, 0, index);
+	return deq_pop_front(root);
 }
 
-deq* deq_cp(root)
+void* deq_swap_rm_back(root, index)
 deq *root;
+int index;
 {
-	deq *copy;
-
-	copy = deq_with_capacity(root->limit);
-	assert(copy->base);
-
-	copy->base = memcpy(copy->base, root->base,
-			root->limit * sizeof(void*));
-	assert(copy->base);
-
-	copy->beg = root->beg;
-	copy->end = root->end;
+	if (!root || !DEQ_IN_BOUNDS(root,index))
+		return NULL;
 
-	return copy;
+	deq_swap(root,deq_size(root) - 1,index);
+	return deq_pop_back(root);
 }
 
-/*Note: Does not currently reduce memory footprint*/
 void deq_truncate(root, size)
 deq *root;
 int size;
@@ -388,24 +381,6 @@ int size;
 	root->end = (root->beg + size) % root->limit;
 }
 
-void* deq_front(root)
-deq *root;
-{
-	if (!root)
-		return NULL;
-
-	return root->base[root->beg];
-}
-
-void* deq_back(root)
-deq *root;
-{
-	if (!root)
-		return NULL;
-
-	return root->base[(root->end - 1) % root->limit];
-}
-
 void deq_reserve(root, size)
 deq *root;
 int size;
@@ -439,3 +414,23 @@ int size;
 	free(root->base);
 	root->base = tmp;
 }
+
+void deq_clear(root)
+deq *root;
+{
+	int i, size;
+
+	size = deq_size(root);
+	for (i = 0; i < size; i++) {
+		free(deq_index(root, i));
+	}
+}
+
+void deq_free(root)
+deq *root;
+{
+	free(root->base);
+	root->base = NULL;
+
+	free(root);
+}
diff --git a/collections/double_ended_queue/double_ended_queue.h b/collections/double_ended_queue/double_ended_queue.h
index df3b038..790015c 100644
--- a/collections/double_ended_queue/double_ended_queue.h
+++ b/collections/double_ended_queue/double_ended_queue.h
@@ -11,33 +11,35 @@ deq* deq_with_capacity(int);
 int deq_size(deq*);
 int deq_capacity(deq*);
 deq* deq_cp(deq*);
-
-/* Note: Elements are not freed
- * deq_clear should be called before if they are no longer needed.*/
-void deq_free(deq*);
-
-/*Free all elements within queue*/
-void deq_clear(deq*);
+void deq_print(deq*, char* (void*));
 
 /*data*/
 void deq_push_front(deq*, void*);
 void deq_push_back(deq*, void*);
-void deq_set(deq*, int, void*);
-void deq_insert(deq*, int, void*);
+void* deq_front(deq*);
+void* deq_back(deq*);
 void* deq_pop_front(deq*);
 void* deq_pop_back(deq*);
+
+void deq_set(deq*, int, void*);
 void* deq_index(deq*, int);
-void* deq_front(deq*);
-void* deq_back(deq*);
-void* deq_swap_rm_front(deq*, int);
-void* deq_swap_rm_back(deq*, int);
+
+void deq_insert(deq*, int, void*);
+void deq_remove(deq*, int);
 
 void deq_swap(deq*, int, int);
+void* deq_swap_rm_front(deq*, int);
+void* deq_swap_rm_back(deq*, int);
 
-/*Note: Does not currently reduce memory footprint*/
+/*memory*/
 void deq_truncate(deq*, int);
+	/*Note: Does not currently reduce memory footprint*/
 void deq_reserve(deq*, int);
 
-void deq_remove(deq*, int);
-void deq_print(deq*, char* (void*));
+void deq_clear(deq*);
+	/*Free all elements within queue*/
+void deq_free(deq*);
+	/* Note: Elements are not freed
+	 * deq_clear should be called before if they are no longer needed.*/
+
 #endif
-- 
cgit v1.1