Mercurial > hg > ucx / changeset

     1.1 --- a/src/tree.c	Mon Feb 19 22:08:09 2024 +0100
     1.2 +++ b/src/tree.c	Mon Feb 19 22:09:16 2024 +0100
     1.3 @@ -178,9 +178,50 @@
     1.4  
     1.5  static void cx_tree_iter_next(void *it) {
     1.6      struct cx_tree_iterator_s *iter = it;
     1.7 +    off_t const loc_next = iter->loc_next;
     1.8 +    off_t const loc_children = iter->loc_children;
     1.9 +
    1.10      // TODO: support mutating iterator
    1.11 +    // TODO: support visit_on_exit
    1.12  
    1.13 -    // TODO: implement
    1.14 +    void *children = tree_children(iter->node);
    1.15 +    if (children == NULL) {
    1.16 +        // search for the next node
    1.17 +        void *current = iter->node;
    1.18 +        do {
    1.19 +            // check if there is a sibling
    1.20 +            void *next = tree_next(current);
    1.21 +            if (next == NULL) {
    1.22 +                // no sibling, check again for parent node
    1.23 +                --iter->depth;
    1.24 +                if (iter->depth == 0) {
    1.25 +                    // there is no parent - we have iterated the entire tree
    1.26 +                    // invalidate the iterator and free the node stack
    1.27 +                    iter->node = NULL;
    1.28 +                    current = NULL;
    1.29 +                    iter->stack_capacity = 0;
    1.30 +                    free(iter->stack);
    1.31 +                    iter->stack = NULL;
    1.32 +                } else {
    1.33 +                    // the parent node can be obtained from the top of stack
    1.34 +                    // this way we can avoid the loc_parent in the iterator
    1.35 +                    current = iter->stack[iter->depth - 1];
    1.36 +                }
    1.37 +            } else {
    1.38 +                // move to the sibling and break the loop
    1.39 +                current = NULL;
    1.40 +                iter->counter++;
    1.41 +                iter->node = next;
    1.42 +                // new top of stack is the sibling
    1.43 +                iter->stack[iter->depth - 1] = next;
    1.44 +            }
    1.45 +        } while (current != NULL);
    1.46 +    } else {
    1.47 +        // node has children, push the first child onto the stack and enter it
    1.48 +        cx_array_simple_add(iter->stack, children);
    1.49 +        iter->node = children;
    1.50 +        iter->counter++;
    1.51 +    }
    1.52  }
    1.53  
    1.54  CxTreeIterator cx_tree_iterator(

     2.1 --- a/tests/test_tree.c	Mon Feb 19 22:08:09 2024 +0100
     2.2 +++ b/tests/test_tree.c	Mon Feb 19 22:09:16 2024 +0100
     2.3 @@ -250,7 +250,7 @@
     2.4      }
     2.5  }
     2.6  
     2.7 -CX_TEST(test_tree_iterator_create) {
     2.8 +CX_TEST(test_tree_iterator_create_and_dispose) {
     2.9      tree_node root;
    2.10      CX_TEST_DO {
    2.11          CxTreeIterator iter = cx_tree_iterator(&root, false, tree_child_list);
    2.12 @@ -266,6 +266,58 @@
    2.13          CX_TEST_ASSERT(iter.depth == 1);
    2.14          CX_TEST_ASSERT(iter.loc_next == offsetof(tree_node, next));
    2.15          CX_TEST_ASSERT(iter.loc_children == offsetof(tree_node, children));
    2.16 +        cxTreeIteratorDispose(&iter);
    2.17 +        CX_TEST_ASSERT(iter.stack == NULL);
    2.18 +    }
    2.19 +}
    2.20 +
    2.21 +CX_TEST(test_tree_iterator_basic_test_only_enter) {
    2.22 +    tree_node root = {0};
    2.23 +    tree_node a = {0};
    2.24 +    tree_node b = {0};
    2.25 +    tree_node c = {0};
    2.26 +    tree_node aa = {0};
    2.27 +    tree_node ab = {0};
    2.28 +    tree_node ba = {0};
    2.29 +    tree_node ca = {0};
    2.30 +    tree_node cb = {0};
    2.31 +    tree_node cc = {0};
    2.32 +    tree_node cba = {0};
    2.33 +
    2.34 +    cx_tree_link(&root, &a, tree_node_layout);
    2.35 +    cx_tree_link(&root, &b, tree_node_layout);
    2.36 +    cx_tree_link(&root, &c, tree_node_layout);
    2.37 +    cx_tree_link(&a, &aa, tree_node_layout);
    2.38 +    cx_tree_link(&a, &ab, tree_node_layout);
    2.39 +    cx_tree_link(&b, &ba, tree_node_layout);
    2.40 +    cx_tree_link(&c, &ca, tree_node_layout);
    2.41 +    cx_tree_link(&c, &cb, tree_node_layout);
    2.42 +    cx_tree_link(&c, &cc, tree_node_layout);
    2.43 +    cx_tree_link(&cb, &cba, tree_node_layout);
    2.44 +    CX_TEST_DO {
    2.45 +        CxTreeIterator iter = cx_tree_iterator(&root, false, tree_child_list);
    2.46 +        unsigned chk = 0;
    2.47 +        cx_foreach(tree_node*, node, iter) {
    2.48 +            CX_TEST_ASSERT(node->data == 0);
    2.49 +            node->data++;
    2.50 +            chk++;
    2.51 +            CX_TEST_ASSERT(node == iter.node);
    2.52 +            CX_TEST_ASSERT(!iter.exiting);
    2.53 +        }
    2.54 +        CX_TEST_ASSERT(iter.counter == 11);
    2.55 +        CX_TEST_ASSERT(chk == 11);
    2.56 +        CX_TEST_ASSERT(iter.stack == NULL);
    2.57 +        CX_TEST_ASSERT(root.data == 1);
    2.58 +        CX_TEST_ASSERT(a.data == 1);
    2.59 +        CX_TEST_ASSERT(b.data == 1);
    2.60 +        CX_TEST_ASSERT(c.data == 1);
    2.61 +        CX_TEST_ASSERT(aa.data == 1);
    2.62 +        CX_TEST_ASSERT(ab.data == 1);
    2.63 +        CX_TEST_ASSERT(ba.data == 1);
    2.64 +        CX_TEST_ASSERT(ca.data == 1);
    2.65 +        CX_TEST_ASSERT(cb.data == 1);
    2.66 +        CX_TEST_ASSERT(cc.data == 1);
    2.67 +        CX_TEST_ASSERT(cba.data == 1);
    2.68      }
    2.69  }
    2.70  
    2.71 @@ -277,7 +329,8 @@
    2.72      cx_test_register(suite, test_tree_link_move_to_other_parent);
    2.73      cx_test_register(suite, test_tree_unlink);
    2.74      cx_test_register(suite, test_tree_search);
    2.75 -    cx_test_register(suite, test_tree_iterator_create);
    2.76 +    cx_test_register(suite, test_tree_iterator_create_and_dispose);
    2.77 +    cx_test_register(suite, test_tree_iterator_basic_test_only_enter);
    2.78  
    2.79      return suite;
    2.80  }