koma/wm
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

use NodeArray instead of PtrArray

Browse Source
This commit is contained in:
Akos Horvath 2023-12-30 13:45:23 +01:00
parent 653b5112ba
commit 38c124b772
3 changed files with 78 additions and 76 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
src/tests.c
View File

@ -287,21 +287,21 @@ static void test_wm_postorder_traversal(void **state)
{ {
TreeNode *node1 = (TreeNode*)*state; TreeNode *node1 = (TreeNode*)*state;
PtrArray postorder = wm_postorder_traversal(node1); NodeArray *postorder = wm_postorder_traversal(node1);
TreeNode **postorder_nodes = (TreeNode**)postorder.ptrs;
assert_int_equal(postorder.size, 8); assert_non_null(postorder);
assert_int_equal(postorder->size, 8);
assert_int_equal(postorder_nodes[0]->id, 4); assert_int_equal(postorder->nodes[0]->id, 4);
assert_int_equal(postorder_nodes[1]->id, 5); assert_int_equal(postorder->nodes[1]->id, 5);
assert_int_equal(postorder_nodes[2]->id, 6); assert_int_equal(postorder->nodes[2]->id, 6);
assert_int_equal(postorder_nodes[3]->id, 2); assert_int_equal(postorder->nodes[3]->id, 2);
assert_int_equal(postorder_nodes[4]->id, 7); assert_int_equal(postorder->nodes[4]->id, 7);
assert_int_equal(postorder_nodes[5]->id, 8); assert_int_equal(postorder->nodes[5]->id, 8);
assert_int_equal(postorder_nodes[6]->id, 3); assert_int_equal(postorder->nodes[6]->id, 3);
assert_int_equal(postorder_nodes[7]->id, 1); assert_int_equal(postorder->nodes[7]->id, 1);
wm_ptrarray_free(&postorder); wm_nodearray_free(postorder);
} }
static void test_wm_treenode_lmd(void **state) static void test_wm_treenode_lmd(void **state)
@ -329,60 +329,60 @@ static void test_wm_is_treenode_keyroot(void **state)
{ {
TreeNode *node1 = (TreeNode*)*state; TreeNode *node1 = (TreeNode*)*state;
PtrArray postorder = wm_postorder_traversal(node1); NodeArray *postorder = wm_postorder_traversal(node1);
TreeNode **postorder_nodes = (TreeNode**)postorder.ptrs;
assert_int_equal(postorder.size, 8); assert_non_null(postorder);
assert_int_equal(postorder->size, 8);
assert_int_equal(wm_is_treenode_keyroot(postorder_nodes[0]), false); assert_int_equal(wm_is_treenode_keyroot(postorder->nodes[0]), false);
assert_int_equal(wm_is_treenode_keyroot(postorder_nodes[1]), true); assert_int_equal(wm_is_treenode_keyroot(postorder->nodes[1]), true);
assert_int_equal(wm_is_treenode_keyroot(postorder_nodes[2]), true); assert_int_equal(wm_is_treenode_keyroot(postorder->nodes[2]), true);
assert_int_equal(wm_is_treenode_keyroot(postorder_nodes[3]), false); assert_int_equal(wm_is_treenode_keyroot(postorder->nodes[3]), false);
assert_int_equal(wm_is_treenode_keyroot(postorder_nodes[4]), false); assert_int_equal(wm_is_treenode_keyroot(postorder->nodes[4]), false);
assert_int_equal(wm_is_treenode_keyroot(postorder_nodes[5]), true); assert_int_equal(wm_is_treenode_keyroot(postorder->nodes[5]), true);
assert_int_equal(wm_is_treenode_keyroot(postorder_nodes[6]), true); assert_int_equal(wm_is_treenode_keyroot(postorder->nodes[6]), true);
assert_int_equal(wm_is_treenode_keyroot(postorder_nodes[7]), true); assert_int_equal(wm_is_treenode_keyroot(postorder->nodes[7]), true);
wm_ptrarray_free(&postorder); wm_nodearray_free(postorder);
} }
static void test_wm_treenode_all_lmds(void **state) static void test_wm_treenode_all_lmds(void **state)
{ {
TreeNode *node1 = (TreeNode*)*state; TreeNode *node1 = (TreeNode*)*state;
PtrArray ret = wm_treenode_all_lmds(node1); NodeArray *lmds = wm_treenode_all_lmds(node1);
TreeNode **lmds = (TreeNode**)ret.ptrs;
assert_int_equal(ret.size, 8); assert_non_null(lmds);
assert_int_equal(lmds->size, 8);
assert_int_equal(lmds[0]->id, 4); assert_int_equal(lmds->nodes[0]->id, 4);
assert_int_equal(lmds[1]->id, 5); assert_int_equal(lmds->nodes[1]->id, 5);
assert_int_equal(lmds[2]->id, 6); assert_int_equal(lmds->nodes[2]->id, 6);
assert_int_equal(lmds[3]->id, 4); assert_int_equal(lmds->nodes[3]->id, 4);
assert_int_equal(lmds[4]->id, 7); assert_int_equal(lmds->nodes[4]->id, 7);
assert_int_equal(lmds[5]->id, 8); assert_int_equal(lmds->nodes[5]->id, 8);
assert_int_equal(lmds[6]->id, 7); assert_int_equal(lmds->nodes[6]->id, 7);
assert_int_equal(lmds[7]->id, 4); assert_int_equal(lmds->nodes[7]->id, 4);
wm_ptrarray_free(&ret); wm_nodearray_free(lmds);
} }
static void test_wm_treenode_all_keyroots(void **state) static void test_wm_treenode_all_keyroots(void **state)
{ {
TreeNode *node1 = (TreeNode*)*state; TreeNode *node1 = (TreeNode*)*state;
PtrArray keyroots = wm_treenode_all_keyroots(node1); NodeArray *keyroots = wm_treenode_all_keyroots(node1);
TreeNode **keyroot_nodes = (TreeNode**)keyroots.ptrs;
assert_int_equal(keyroots.size, 5); assert_non_null(keyroots);
assert_int_equal(keyroots->size, 5);
assert_int_equal(keyroot_nodes[0]->id, 5); assert_int_equal(keyroots->nodes[0]->id, 5);
assert_int_equal(keyroot_nodes[1]->id, 6); assert_int_equal(keyroots->nodes[1]->id, 6);
assert_int_equal(keyroot_nodes[2]->id, 8); assert_int_equal(keyroots->nodes[2]->id, 8);
assert_int_equal(keyroot_nodes[3]->id, 3); assert_int_equal(keyroots->nodes[3]->id, 3);
assert_int_equal(keyroot_nodes[4]->id, 1); assert_int_equal(keyroots->nodes[4]->id, 1);
wm_ptrarray_free(&keyroots); wm_nodearray_free(keyroots);
} }
static int test2_setup(void **state) static int test2_setup(void **state)
@ -438,10 +438,12 @@ static int test2_setup(void **state)
*state = node1; *state = node1;
NodeArray *nodes = wm_all_nodes_to_array((TreeNode*)*state); NodeArray *nodes = wm_all_nodes_to_array((TreeNode*)*state);
assert_non_null(nodes);
test_group2_nodes_copy = wm_nodearray_new(); test_group2_nodes_copy = wm_nodearray_new();
for (size_t i = 0; i < nodes->size; i++) { for (size_t i = 0; i < nodes->size; i++) {
TreeNode *node_copy = malloc(sizeof(TreeNode)); TreeNode *node_copy = malloc(sizeof(TreeNode));
assert_non_null(node_copy);
*node_copy = *(nodes->nodes)[i]; *node_copy = *(nodes->nodes)[i];
wm_nodearray_push(test_group2_nodes_copy, node_copy); wm_nodearray_push(test_group2_nodes_copy, node_copy);
} }

56
src/util.c
View File

@ -230,24 +230,24 @@ TreeNode* wm_treenode_lmd(TreeNode *node)
return wm_treenode_lmd(node->children->nodes[0]); return wm_treenode_lmd(node->children->nodes[0]);
} }
PtrArray wm_treenode_all_lmds(TreeNode *node) NodeArray* wm_treenode_all_lmds(TreeNode *node)
{ {
assert(node); assert(node);
PtrArray postorder = wm_postorder_traversal(node); NodeArray *postorder = wm_postorder_traversal(node);
PtrArray ret = wm_ptrarray_new(); NodeArray *ret = wm_nodearray_new();
for (size_t i = 0; i < postorder.size; i++) { for (size_t i = 0; i < postorder->size; i++) {
TreeNode *lmd = wm_treenode_lmd(postorder.ptrs[i]); TreeNode *lmd = wm_treenode_lmd(postorder->nodes[i]);
wm_ptrarray_push(&ret, (void*)lmd); wm_nodearray_push(ret, lmd);
} }
wm_ptrarray_free(&postorder); wm_nodearray_free(postorder);
return ret; return ret;
} }
PtrArray wm_postorder_traversal(TreeNode *tree) NodeArray* wm_postorder_traversal(TreeNode *tree)
{ {
assert(tree); assert(tree);
@ -260,15 +260,15 @@ PtrArray wm_postorder_traversal(TreeNode *tree)
int root_index = 0; int root_index = 0;
PtrArray stack = wm_ptrarray_new(); NodeArray* stack = wm_nodearray_new();
PtrArray ret = wm_ptrarray_new(); NodeArray* ret = wm_nodearray_new();
while (root != NULL || stack.size > 0) { while (root != NULL || stack->size > 0) {
if (root != NULL) { if (root != NULL) {
NodeWithIndex *n = malloc(sizeof(NodeWithIndex)); NodeWithIndex *n = malloc(sizeof(NodeWithIndex));
n->node = root; n->node = root;
n->index = root_index; n->index = root_index;
wm_ptrarray_push(&stack, n); wm_nodearray_push(stack, (void*)n);
root_index = 0; root_index = 0;
if (root->children->size >= 1) if (root->children->size >= 1)
@ -279,28 +279,28 @@ PtrArray wm_postorder_traversal(TreeNode *tree)
} }
NodeWithIndex *nptr; NodeWithIndex *nptr;
wm_ptrarray_pop(&stack, (void**)&nptr); wm_nodearray_pop(stack, (TreeNode**)(void**)&nptr);
NodeWithIndex n = *nptr; NodeWithIndex n = *nptr;
free(nptr); free(nptr);
wm_ptrarray_push(&ret, n.node); wm_nodearray_push(ret, n.node);
while (stack.size > 0 && n.index == ((NodeWithIndex**)stack.ptrs) while (stack->size > 0 && n.index == ((NodeWithIndex**)stack->nodes)
[stack.size-1]->node->children->size - 1) { [stack->size-1]->node->children->size - 1) {
wm_ptrarray_pop(&stack, (void**)&nptr); wm_nodearray_pop(stack, (TreeNode**)(void**)&nptr);
n = *nptr; n = *nptr;
free(nptr); free(nptr);
wm_ptrarray_push(&ret, n.node); wm_nodearray_push(ret, n.node);
} }
if (stack.size > 0) { if (stack->size > 0) {
root = ((NodeWithIndex**)stack.ptrs)[stack.size-1]->node root = ((NodeWithIndex**)stack->nodes)[stack->size-1]->node
->children->nodes[n.index + 1]; ->children->nodes[n.index + 1];
root_index = n.index + 1; root_index = n.index + 1;
} }
} }
wm_ptrarray_free(&stack); wm_nodearray_free(stack);
return ret; return ret;
} }
@ -313,20 +313,20 @@ bool wm_is_treenode_keyroot(TreeNode *node)
return wm_treenode_lmd(node) != wm_treenode_lmd(node->parent); return wm_treenode_lmd(node) != wm_treenode_lmd(node->parent);
} }
PtrArray wm_treenode_all_keyroots(TreeNode *node) NodeArray* wm_treenode_all_keyroots(TreeNode *node)
{ {
assert(node); assert(node);
PtrArray ret = wm_ptrarray_new(); NodeArray* ret = wm_nodearray_new();
PtrArray postorder = wm_postorder_traversal(node); NodeArray* postorder = wm_postorder_traversal(node);
for (size_t i = 0; i < postorder.size; i++) { for (size_t i = 0; i < postorder->size; i++) {
TreeNode *node = ((TreeNode**)postorder.ptrs)[i]; TreeNode *node = postorder->nodes[i];
if (wm_is_treenode_keyroot(node)) if (wm_is_treenode_keyroot(node))
wm_ptrarray_push(&ret, node); wm_nodearray_push(ret, node);
} }
wm_ptrarray_free(&postorder); wm_nodearray_free(postorder);
return ret; return ret;
} }

6
src/util.h
View File

@ -96,9 +96,9 @@ NodeArray* wm_all_nodes_to_array(TreeNode *root);
void wm_log_state(Wm *wm, const char *prefixstr, const char* logfile); void wm_log_state(Wm *wm, const char *prefixstr, const char* logfile);
TreeNode* wm_treenode_lmd(TreeNode *node); TreeNode* wm_treenode_lmd(TreeNode *node);
PtrArray wm_treenode_all_lmds(TreeNode *node); NodeArray* wm_treenode_all_lmds(TreeNode *node);
PtrArray wm_postorder_traversal(TreeNode *tree); NodeArray* wm_postorder_traversal(TreeNode *tree);
bool wm_is_treenode_keyroot(TreeNode *node); bool wm_is_treenode_keyroot(TreeNode *node);
PtrArray wm_treenode_all_keyroots(TreeNode *node); NodeArray* wm_treenode_all_keyroots(TreeNode *node);
#endif #endif