void
_gtk_rbtree_remove (GtkRBTree *tree)
{
#ifdef G_ENABLE_DEBUG
GtkRBTree *tmp_tree;
if (gtk_get_debug_flags () & GTK_DEBUG_TREE)
_gtk_rbtree_test (G_STRLOC, tree);
#endif
/* ugly hack to make _fixup_validation work in the first iteration of the
* loop below */
GTK_RBNODE_UNSET_FLAG (tree->root, GTK_RBNODE_DESCENDANTS_INVALID);
gtk_rbnode_adjust (tree->parent_tree,
tree->parent_node,
0,
- (int) tree->root->total_count,
- tree->root->offset);
#ifdef G_ENABLE_DEBUG
tmp_tree = tree->parent_tree;
#endif
_gtk_rbtree_free (tree);
#ifdef G_ENABLE_DEBUG
if (gtk_get_debug_flags () & GTK_DEBUG_TREE)
_gtk_rbtree_test (G_STRLOC, tmp_tree);
#endif
}
static void
test_remove_node (void)
{
GtkRBTree *tree;
tree = create_rbtree (3, 16, g_test_thorough ());
while (tree->root->count > 1)
{
GtkRBTree *find_tree;
GtkRBNode *find_node;
guint i;
i = g_test_rand_int_range (0, tree->root->total_count);
if (!_gtk_rbtree_find_index (tree, i, &find_tree, &find_node))
{
/* We search an available index, so we mustn't fail. */
g_assert_not_reached ();
}
_gtk_rbtree_test (find_tree);
if (find_tree->root->count == 1)
{
_gtk_rbtree_remove (find_tree);
}
else
_gtk_rbtree_remove_node (find_tree, find_node);
_gtk_rbtree_test (tree);
}
_gtk_rbtree_free (tree);
}
static void
test_reorder (void)
{
guint n = g_test_perf () ? 1000000 : 100;
GtkRBTree *tree;
GtkRBNode *node;
gint *reorder;
guint i;
double elapsed;
reorder = fisher_yates_shuffle (n);
tree = create_unsorted_tree (reorder, n);
g_test_timer_start ();
_gtk_rbtree_reorder (tree, reorder, n);
elapsed = g_test_timer_elapsed ();
if (g_test_perf ())
g_test_minimized_result (elapsed, "reordering rbtree with %u items: %gsec", n, elapsed);
_gtk_rbtree_test (tree);
for (node = _gtk_rbtree_first (tree), i = 0;
node != NULL;
node = _gtk_rbtree_next (tree, node), i++)
{
g_assert (GTK_RBNODE_GET_HEIGHT (node) == i);
}
g_assert (i == n);
_gtk_rbtree_free (tree);
}
static GtkRBTree *
create_unsorted_tree (gint *order,
guint n)
{
GtkRBTree *tree;
GtkRBNode *node;
guint i;
tree = _gtk_rbtree_new ();
node = NULL;
for (i = 0; i < n; i++)
{
node = _gtk_rbtree_insert_after (tree, node, 0, TRUE);
}
for (i = 0; i < n; i++)
{
node = _gtk_rbtree_find_count (tree, order[i] + 1);
_gtk_rbtree_node_set_height (tree, node, i);
}
_gtk_rbtree_test (tree);
return tree;
}
static guint
append_elements (GtkRBTree *tree,
guint depth,
guint elements_per_depth,
gboolean check,
guint height)
{
GtkRBNode *node;
guint i;
g_assert (depth > 0);
node = NULL;
depth--;
for (i = 0; i < elements_per_depth; i++)
{
node = _gtk_rbtree_insert_after (tree, node, ++height, TRUE);
if (depth)
{
node->children = _gtk_rbtree_new ();
node->children->parent_tree = tree;
node->children->parent_node = node;
height = append_elements (node->children, depth, elements_per_depth, check, height);
}
if (check)
_gtk_rbtree_test (tree);
}
return height;
}
void
_gtk_rbtree_node_set_height (GtkRBTree *tree,
GtkRBNode *node,
gint height)
{
gint diff = height - GTK_RBNODE_GET_HEIGHT (node);
GtkRBNode *tmp_node = node;
GtkRBTree *tmp_tree = tree;
if (diff == 0)
return;
while (tmp_tree && tmp_node && tmp_node != tmp_tree->nil)
{
tmp_node->offset += diff;
tmp_node = tmp_node->parent;
if (tmp_node == tmp_tree->nil)
{
tmp_node = tmp_tree->parent_node;
tmp_tree = tmp_tree->parent_tree;
}
}
#ifdef G_ENABLE_DEBUG
if (gtk_debug_flags & GTK_DEBUG_TREE)
_gtk_rbtree_test (G_STRLOC, tree);
#endif
}
void
_gtk_rbtree_remove (GtkRBTree *tree)
{
GtkRBTree *tmp_tree;
GtkRBNode *tmp_node;
gint height = tree->root->offset;
#ifdef G_ENABLE_DEBUG
if (gtk_debug_flags & GTK_DEBUG_TREE)
_gtk_rbtree_test (G_STRLOC, tree);
#endif
tmp_tree = tree->parent_tree;
tmp_node = tree->parent_node;
/* ugly hack to make _fixup_validation work in the first iteration of the
* loop below */
GTK_RBNODE_UNSET_FLAG (tree->root, GTK_RBNODE_DESCENDANTS_INVALID);
while (tmp_tree && tmp_node && tmp_node != tmp_tree->nil)
{
_fixup_validation (tmp_tree, tmp_node);
tmp_node->offset -= height;
/* If the removed tree was odd, flip all parents */
if (tree->root->parity)
tmp_node->parity = !tmp_node->parity;
tmp_node = tmp_node->parent;
if (tmp_node == tmp_tree->nil)
{
tmp_node = tmp_tree->parent_node;
tmp_tree = tmp_tree->parent_tree;
}
}
tmp_tree = tree->parent_tree;
tmp_node = tree->parent_node;
_gtk_rbtree_free (tree);
#ifdef G_ENABLE_DEBUG
if (gtk_debug_flags & GTK_DEBUG_TREE)
_gtk_rbtree_test (G_STRLOC, tmp_tree);
#endif
}
static GtkRBTree *
create_rbtree (guint depth,
guint elements_per_depth,
gboolean check)
{
GtkRBTree *tree;
tree = _gtk_rbtree_new ();
append_elements (tree, depth, elements_per_depth, check, 0);
_gtk_rbtree_test (tree);
return tree;
}
void
_gtk_rbtree_node_set_height (GtkRBTree *tree,
GtkRBNode *node,
gint height)
{
gint diff = height - GTK_RBNODE_GET_HEIGHT (node);
if (diff == 0)
return;
gtk_rbnode_adjust (tree, node, 0, 0, diff);
#ifdef G_ENABLE_DEBUG
if (gtk_get_debug_flags () & GTK_DEBUG_TREE)
_gtk_rbtree_test (G_STRLOC, tree);
#endif
}
static void
test_insert_before (void)
{
guint i;
GtkRBTree *tree;
GtkRBNode *node;
tree = _gtk_rbtree_new ();
node = NULL;
for (i = 1; i <= 100; i++)
{
node = _gtk_rbtree_insert_before (tree, node, i, TRUE);
_gtk_rbtree_test (tree);
g_assert (tree->root->count == i);
g_assert (tree->root->total_count == i);
g_assert (tree->root->offset == i * (i + 1) / 2);
}
_gtk_rbtree_free (tree);
}
GtkRBNode *
_gtk_rbtree_insert_before (GtkRBTree *tree,
GtkRBNode *current,
gint height,
gboolean valid)
{
GtkRBNode *node;
gboolean left = TRUE;
#ifdef G_ENABLE_DEBUG
if (gtk_get_debug_flags () & GTK_DEBUG_TREE)
{
g_print ("\n\n_gtk_rbtree_insert_before: %p\n", current);
_gtk_rbtree_debug_spew (tree);
_gtk_rbtree_test (G_STRLOC, tree);
}
#endif /* G_ENABLE_DEBUG */
if (current != NULL && !_gtk_rbtree_is_nil (current->left))
{
current = current->left;
while (!_gtk_rbtree_is_nil (current->right))
current = current->right;
left = FALSE;
}
/* setup new node */
node = _gtk_rbnode_new (tree, height);
/* insert node in tree */
if (current)
{
node->parent = current;
if (left)
current->left = node;
else
current->right = node;
gtk_rbnode_adjust (tree, node->parent,
1, 1, height);
}
else
{
g_assert (_gtk_rbtree_is_nil (tree->root));
tree->root = node;
gtk_rbnode_adjust (tree->parent_tree, tree->parent_node,
0, 1, height);
}
if (valid)
_gtk_rbtree_node_mark_valid (tree, node);
else
_gtk_rbtree_node_mark_invalid (tree, node);
_gtk_rbtree_insert_fixup (tree, node);
#ifdef G_ENABLE_DEBUG
if (gtk_get_debug_flags () & GTK_DEBUG_TREE)
{
g_print ("_gtk_rbtree_insert_before finished...\n");
_gtk_rbtree_debug_spew (tree);
g_print ("\n\n");
_gtk_rbtree_test (G_STRLOC, tree);
}
#endif /* G_ENABLE_DEBUG */
return node;
}
void
_gtk_rbtree_remove_node (GtkRBTree *tree,
GtkRBNode *node)
{
GtkRBNode *x, *y;
gint y_height;
guint y_total_count;
g_return_if_fail (tree != NULL);
g_return_if_fail (node != NULL);
#ifdef G_ENABLE_DEBUG
if (gtk_get_debug_flags () & GTK_DEBUG_TREE)
{
g_print ("\n\n_gtk_rbtree_remove_node: %p\n", node);
_gtk_rbtree_debug_spew (tree);
_gtk_rbtree_test (G_STRLOC, tree);
}
#endif /* G_ENABLE_DEBUG */
/* make sure we're deleting a node that's actually in the tree */
for (x = node; !_gtk_rbtree_is_nil (x->parent); x = x->parent)
;
g_return_if_fail (x == tree->root);
#ifdef G_ENABLE_DEBUG
if (gtk_get_debug_flags () & GTK_DEBUG_TREE)
_gtk_rbtree_test (G_STRLOC, tree);
#endif
if (_gtk_rbtree_is_nil (node->left) ||
_gtk_rbtree_is_nil (node->right))
{
y = node;
}
else
{
y = node->right;
while (!_gtk_rbtree_is_nil (y->left))
y = y->left;
}
y_height = GTK_RBNODE_GET_HEIGHT (y)
+ (y->children ? y->children->root->offset : 0);
y_total_count = 1 + (y->children ? y->children->root->total_count : 0);
/* x is y's only child, or nil */
if (!_gtk_rbtree_is_nil (y->left))
x = y->left;
else
x = y->right;
/* remove y from the parent chain */
if (!_gtk_rbtree_is_nil (x))
x->parent = y->parent;
if (!_gtk_rbtree_is_nil (y->parent))
{
if (y == y->parent->left)
y->parent->left = x;
else
y->parent->right = x;
}
else
{
tree->root = x;
}
/* We need to clean up the validity of the tree.
*/
gtk_rbnode_adjust (tree, y, -1, - y_total_count, - y_height);
if (GTK_RBNODE_GET_COLOR (y) == GTK_RBNODE_BLACK)
_gtk_rbtree_remove_node_fixup (tree, x, y->parent);
if (y != node)
{
gint node_height, node_total_count;
/* We want to see how much we remove from the aggregate values.
* This is all the children we remove plus the node's values.
*/
node_height = GTK_RBNODE_GET_HEIGHT (node)
+ (node->children ? node->children->root->offset : 0);
node_total_count = 1
+ (node->children ? node->children->root->total_count : 0);
/* Move the node over */
if (GTK_RBNODE_GET_COLOR (node) != GTK_RBNODE_GET_COLOR (y))
y->flags ^= (GTK_RBNODE_BLACK | GTK_RBNODE_RED);
y->left = node->left;
if (!_gtk_rbtree_is_nil (y->left))
y->left->parent = y;
y->right = node->right;
if (!_gtk_rbtree_is_nil (y->right))
y->right->parent = y;
y->parent = node->parent;
if (!_gtk_rbtree_is_nil (y->parent))
{
if (y->parent->left == node)
y->parent->left = y;
else
y->parent->right = y;
}
else
{
tree->root = y;
}
y->count = node->count;
y->total_count = node->total_count;
y->offset = node->offset;
gtk_rbnode_adjust (tree, y,
0,
y_total_count - node_total_count,
y_height - node_height);
}
_gtk_rbnode_free (node);
#ifdef G_ENABLE_DEBUG
if (gtk_get_debug_flags () & GTK_DEBUG_TREE)
{
g_print ("_gtk_rbtree_remove_node finished...\n");
_gtk_rbtree_debug_spew (tree);
g_print ("\n\n");
_gtk_rbtree_test (G_STRLOC, tree);
}
#endif /* G_ENABLE_DEBUG */
}
GtkRBNode *
_gtk_rbtree_insert_before (GtkRBTree *tree,
GtkRBNode *current,
gint height,
gboolean valid)
{
GtkRBNode *node;
gboolean left = TRUE;
#ifdef G_ENABLE_DEBUG
if (GTK_DEBUG_CHECK (TREE))
{
GString *s;
s = g_string_new ("");
g_string_append_printf (s, "_gtk_rbtree_insert_before: %p\n", current);
_gtk_rbtree_debug_spew (tree, s);
g_message ("%s", s->str);
g_string_free (s, TRUE);
_gtk_rbtree_test (G_STRLOC, tree);
}
#endif
if (current != NULL && !_gtk_rbtree_is_nil (current->left))
{
current = current->left;
while (!_gtk_rbtree_is_nil (current->right))
current = current->right;
left = FALSE;
}
/* setup new node */
node = _gtk_rbnode_new (tree, height);
/* insert node in tree */
if (current)
{
node->parent = current;
if (left)
current->left = node;
else
current->right = node;
gtk_rbnode_adjust (tree, node->parent,
1, 1, height);
}
else
{
g_assert (_gtk_rbtree_is_nil (tree->root));
tree->root = node;
gtk_rbnode_adjust (tree->parent_tree, tree->parent_node,
0, 1, height);
}
if (valid)
_gtk_rbtree_node_mark_valid (tree, node);
else
_gtk_rbtree_node_mark_invalid (tree, node);
_gtk_rbtree_insert_fixup (tree, node);
#ifdef G_ENABLE_DEBUG
if (GTK_DEBUG_CHECK (TREE))
{
GString *s;
s = g_string_new ("_gtk_rbtree_insert_before finished...\n");
_gtk_rbtree_debug_spew (tree, s);
g_message ("%s", s->str);
g_string_free (s, TRUE);
_gtk_rbtree_test (G_STRLOC, tree);
}
#endif
return node;
}
GtkRBNode *
_gtk_rbtree_insert_before (GtkRBTree *tree,
GtkRBNode *current,
gint height,
gboolean valid)
{
GtkRBNode *node;
gboolean left = TRUE;
GtkRBNode *tmp_node;
GtkRBTree *tmp_tree;
#ifdef G_ENABLE_DEBUG
if (gtk_debug_flags & GTK_DEBUG_TREE)
{
g_print ("\n\n_gtk_rbtree_insert_before: %p\n", current);
_gtk_rbtree_debug_spew (tree);
_gtk_rbtree_test (G_STRLOC, tree);
}
#endif /* G_ENABLE_DEBUG */
if (current != NULL && current->left != tree->nil)
{
current = current->left;
while (current->right != tree->nil)
current = current->right;
left = FALSE;
}
/* setup new node */
node = _gtk_rbnode_new (tree, height);
node->parent = (current?current:tree->nil);
/* insert node in tree */
if (current)
{
if (left)
current->left = node;
else
current->right = node;
tmp_node = node->parent;
tmp_tree = tree;
}
else
{
tree->root = node;
tmp_node = tree->parent_node;
tmp_tree = tree->parent_tree;
}
while (tmp_tree && tmp_node && tmp_node != tmp_tree->nil)
{
/* We only want to propagate the count if we are in the tree we
* started in. */
if (tmp_tree == tree)
tmp_node->count++;
tmp_node->parity += 1;
tmp_node->offset += height;
tmp_node = tmp_node->parent;
if (tmp_node == tmp_tree->nil)
{
tmp_node = tmp_tree->parent_node;
tmp_tree = tmp_tree->parent_tree;
}
}
if (valid)
_gtk_rbtree_node_mark_valid (tree, node);
else
_gtk_rbtree_node_mark_invalid (tree, node);
_gtk_rbtree_insert_fixup (tree, node);
#ifdef G_ENABLE_DEBUG
if (gtk_debug_flags & GTK_DEBUG_TREE)
{
g_print ("_gtk_rbtree_insert_before finished...\n");
_gtk_rbtree_debug_spew (tree);
g_print ("\n\n");
_gtk_rbtree_test (G_STRLOC, tree);
}
#endif /* G_ENABLE_DEBUG */
return node;
}
void
_gtk_rbtree_remove_node (GtkRBTree *tree,
GtkRBNode *node)
{
GtkRBNode *x, *y;
GtkRBTree *tmp_tree;
GtkRBNode *tmp_node;
gint y_height;
g_return_if_fail (tree != NULL);
g_return_if_fail (node != NULL);
#ifdef G_ENABLE_DEBUG
if (gtk_debug_flags & GTK_DEBUG_TREE)
{
g_print ("\n\n_gtk_rbtree_remove_node: %p\n", node);
_gtk_rbtree_debug_spew (tree);
_gtk_rbtree_test (G_STRLOC, tree);
}
#endif /* G_ENABLE_DEBUG */
/* make sure we're deleting a node that's actually in the tree */
for (x = node; x->parent != tree->nil; x = x->parent)
;
g_return_if_fail (x == tree->root);
#ifdef G_ENABLE_DEBUG
if (gtk_debug_flags & GTK_DEBUG_TREE)
_gtk_rbtree_test (G_STRLOC, tree);
#endif
if (node->left == tree->nil || node->right == tree->nil)
{
y = node;
}
else
{
y = node->right;
while (y->left != tree->nil)
y = y->left;
}
/* adjust count only beneath tree */
for (x = y; x != tree->nil; x = x->parent)
{
x->count--;
}
/* offsets and parity adjust all the way up through parent trees */
y_height = GTK_RBNODE_GET_HEIGHT (y);
tmp_tree = tree;
tmp_node = y;
while (tmp_tree && tmp_node && tmp_node != tmp_tree->nil)
{
tmp_node->offset -= (y_height + (y->children?y->children->root->offset:0));
_fixup_validation (tmp_tree, tmp_node);
_fixup_parity (tmp_tree, tmp_node);
tmp_node = tmp_node->parent;
if (tmp_node == tmp_tree->nil)
{
tmp_node = tmp_tree->parent_node;
tmp_tree = tmp_tree->parent_tree;
}
}
/* x is y's only child, or nil */
if (y->left != tree->nil)
x = y->left;
else
x = y->right;
/* remove y from the parent chain */
x->parent = y->parent;
if (y->parent != tree->nil)
{
if (y == y->parent->left)
y->parent->left = x;
else
y->parent->right = x;
}
else
{
tree->root = x;
}
/* We need to clean up the validity of the tree.
*/
tmp_tree = tree;
tmp_node = x;
do
{
/* We skip the first time, iff x is nil */
if (tmp_node != tmp_tree->nil)
{
_fixup_validation (tmp_tree, tmp_node);
_fixup_parity (tmp_tree, tmp_node);
}
tmp_node = tmp_node->parent;
if (tmp_node == tmp_tree->nil)
{
tmp_node = tmp_tree->parent_node;
tmp_tree = tmp_tree->parent_tree;
}
}
while (tmp_tree != NULL);
if (y != node)
{
gint diff;
/* Copy the node over */
if (GTK_RBNODE_GET_COLOR (node) == GTK_RBNODE_BLACK)
node->flags = ((y->flags & (GTK_RBNODE_NON_COLORS)) | GTK_RBNODE_BLACK);
else
node->flags = ((y->flags & (GTK_RBNODE_NON_COLORS)) | GTK_RBNODE_RED);
node->children = y->children;
if (y->children)
{
node->children = y->children;
node->children->parent_node = node;
}
else
{
node->children = NULL;
}
_fixup_validation (tree, node);
_fixup_parity (tree, node);
/* We want to see how different our height is from the previous node.
* To do this, we compare our current height with our supposed height.
*/
diff = y_height - GTK_RBNODE_GET_HEIGHT (node);
tmp_tree = tree;
tmp_node = node;
while (tmp_tree && tmp_node && tmp_node != tmp_tree->nil)
{
tmp_node->offset += diff;
_fixup_validation (tmp_tree, tmp_node);
_fixup_parity (tmp_tree, tmp_node);
tmp_node = tmp_node->parent;
if (tmp_node == tmp_tree->nil)
{
tmp_node = tmp_tree->parent_node;
tmp_tree = tmp_tree->parent_tree;
}
}
}
if (GTK_RBNODE_GET_COLOR (y) == GTK_RBNODE_BLACK)
_gtk_rbtree_remove_node_fixup (tree, x);
_gtk_rbnode_free (y);
#ifdef G_ENABLE_DEBUG
if (gtk_debug_flags & GTK_DEBUG_TREE)
{
g_print ("_gtk_rbtree_remove_node finished...\n");
_gtk_rbtree_debug_spew (tree);
g_print ("\n\n");
_gtk_rbtree_test (G_STRLOC, tree);
}
#endif /* G_ENABLE_DEBUG */
}
