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;
PtrArray postorder = wm_postorder_traversal(node1);
TreeNode **postorder_nodes = (TreeNode**)postorder.ptrs;
NodeArray *postorder = wm_postorder_traversal(node1);
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[1]->id, 5);
assert_int_equal(postorder_nodes[2]->id, 6);
assert_int_equal(postorder_nodes[3]->id, 2);
assert_int_equal(postorder_nodes[4]->id, 7);
assert_int_equal(postorder_nodes[5]->id, 8);
assert_int_equal(postorder_nodes[6]->id, 3);
assert_int_equal(postorder_nodes[7]->id, 1);
assert_int_equal(postorder->nodes[0]->id, 4);
assert_int_equal(postorder->nodes[1]->id, 5);
assert_int_equal(postorder->nodes[2]->id, 6);
assert_int_equal(postorder->nodes[3]->id, 2);
assert_int_equal(postorder->nodes[4]->id, 7);
assert_int_equal(postorder->nodes[5]->id, 8);
assert_int_equal(postorder->nodes[6]->id, 3);
assert_int_equal(postorder->nodes[7]->id, 1);
wm_ptrarray_free(&postorder);
wm_nodearray_free(postorder);
}
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;
PtrArray postorder = wm_postorder_traversal(node1);
TreeNode **postorder_nodes = (TreeNode**)postorder.ptrs;
NodeArray *postorder = wm_postorder_traversal(node1);
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[1]), 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[4]), false);
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[7]), true);
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[2]), true);
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[5]), true);
assert_int_equal(wm_is_treenode_keyroot(postorder->nodes[6]), 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)
{
TreeNode *node1 = (TreeNode*)*state;
PtrArray ret = wm_treenode_all_lmds(node1);
TreeNode **lmds = (TreeNode**)ret.ptrs;
NodeArray *lmds = wm_treenode_all_lmds(node1);
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[1]->id, 5);
assert_int_equal(lmds[2]->id, 6);
assert_int_equal(lmds[3]->id, 4);
assert_int_equal(lmds[4]->id, 7);
assert_int_equal(lmds[5]->id, 8);
assert_int_equal(lmds[6]->id, 7);
assert_int_equal(lmds[7]->id, 4);
assert_int_equal(lmds->nodes[0]->id, 4);
assert_int_equal(lmds->nodes[1]->id, 5);
assert_int_equal(lmds->nodes[2]->id, 6);
assert_int_equal(lmds->nodes[3]->id, 4);
assert_int_equal(lmds->nodes[4]->id, 7);
assert_int_equal(lmds->nodes[5]->id, 8);
assert_int_equal(lmds->nodes[6]->id, 7);
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)
{
TreeNode *node1 = (TreeNode*)*state;
PtrArray keyroots = wm_treenode_all_keyroots(node1);
TreeNode **keyroot_nodes = (TreeNode**)keyroots.ptrs;
NodeArray *keyroots = wm_treenode_all_keyroots(node1);
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(keyroot_nodes[1]->id, 6);
assert_int_equal(keyroot_nodes[2]->id, 8);
assert_int_equal(keyroot_nodes[3]->id, 3);
assert_int_equal(keyroot_nodes[4]->id, 1);
assert_int_equal(keyroots->nodes[0]->id, 5);
assert_int_equal(keyroots->nodes[1]->id, 6);
assert_int_equal(keyroots->nodes[2]->id, 8);
assert_int_equal(keyroots->nodes[3]->id, 3);
assert_int_equal(keyroots->nodes[4]->id, 1);
wm_ptrarray_free(&keyroots);
wm_nodearray_free(keyroots);
}
static int test2_setup(void **state)
@ -438,10 +438,12 @@ static int test2_setup(void **state)
*state = node1;
NodeArray *nodes = wm_all_nodes_to_array((TreeNode*)*state);
assert_non_null(nodes);
test_group2_nodes_copy = wm_nodearray_new();
for (size_t i = 0; i < nodes->size; i++) {
TreeNode *node_copy = malloc(sizeof(TreeNode));
assert_non_null(node_copy);
*node_copy = *(nodes->nodes)[i];
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]);
}
PtrArray wm_treenode_all_lmds(TreeNode *node)
NodeArray* wm_treenode_all_lmds(TreeNode *node)
{
assert(node);
PtrArray postorder = wm_postorder_traversal(node);
PtrArray ret = wm_ptrarray_new();
NodeArray *postorder = wm_postorder_traversal(node);
NodeArray *ret = wm_nodearray_new();
for (size_t i = 0; i < postorder.size; i++) {
TreeNode *lmd = wm_treenode_lmd(postorder.ptrs[i]);
for (size_t i = 0; i < postorder->size; 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;
}
PtrArray wm_postorder_traversal(TreeNode *tree)
NodeArray* wm_postorder_traversal(TreeNode *tree)
{
assert(tree);
@ -260,15 +260,15 @@ PtrArray wm_postorder_traversal(TreeNode *tree)
int root_index = 0;
PtrArray stack = wm_ptrarray_new();
PtrArray ret = wm_ptrarray_new();
NodeArray* stack = wm_nodearray_new();
NodeArray* ret = wm_nodearray_new();
while (root != NULL || stack.size > 0) {
while (root != NULL || stack->size > 0) {
if (root != NULL) {
NodeWithIndex *n = malloc(sizeof(NodeWithIndex));
n->node = root;
n->index = root_index;
wm_ptrarray_push(&stack, n);
wm_nodearray_push(stack, (void*)n);
root_index = 0;
if (root->children->size >= 1)
@ -279,28 +279,28 @@ PtrArray wm_postorder_traversal(TreeNode *tree)
}
NodeWithIndex *nptr;
wm_ptrarray_pop(&stack, (void**)&nptr);
wm_nodearray_pop(stack, (TreeNode**)(void**)&nptr);
NodeWithIndex n = *nptr;
free(nptr);
wm_ptrarray_push(&ret, n.node);
wm_nodearray_push(ret, n.node);
while (stack.size > 0 && n.index == ((NodeWithIndex**)stack.ptrs)
[stack.size-1]->node->children->size - 1) {
wm_ptrarray_pop(&stack, (void**)&nptr);
while (stack->size > 0 && n.index == ((NodeWithIndex**)stack->nodes)
[stack->size-1]->node->children->size - 1) {
wm_nodearray_pop(stack, (TreeNode**)(void**)&nptr);
n = *nptr;
free(nptr);
wm_ptrarray_push(&ret, n.node);
wm_nodearray_push(ret, n.node);
}
if (stack.size > 0) {
root = ((NodeWithIndex**)stack.ptrs)[stack.size-1]->node
if (stack->size > 0) {
root = ((NodeWithIndex**)stack->nodes)[stack->size-1]->node
->children->nodes[n.index + 1];
root_index = n.index + 1;
}
}
wm_ptrarray_free(&stack);
wm_nodearray_free(stack);
return ret;
}
@ -313,20 +313,20 @@ bool wm_is_treenode_keyroot(TreeNode *node)
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);
PtrArray ret = wm_ptrarray_new();
PtrArray postorder = wm_postorder_traversal(node);
NodeArray* ret = wm_nodearray_new();
NodeArray* postorder = wm_postorder_traversal(node);
for (size_t i = 0; i < postorder.size; i++) {
TreeNode *node = ((TreeNode**)postorder.ptrs)[i];
for (size_t i = 0; i < postorder->size; i++) {
TreeNode *node = postorder->nodes[i];
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;
}

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);
TreeNode* wm_treenode_lmd(TreeNode *node);
PtrArray wm_treenode_all_lmds(TreeNode *node);
PtrArray wm_postorder_traversal(TreeNode *tree);
NodeArray* wm_treenode_all_lmds(TreeNode *node);
NodeArray* wm_postorder_traversal(TreeNode *tree);
bool wm_is_treenode_keyroot(TreeNode *node);
PtrArray wm_treenode_all_keyroots(TreeNode *node);
NodeArray* wm_treenode_all_keyroots(TreeNode *node);
#endif