static void _gtk_rbtree_test_dirty (GtkRBTree *tree, GtkRBNode *node, gint expected_dirtyness) { if (expected_dirtyness) { g_assert (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID) || GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID) || GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID) || GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID) || (node->children && GTK_RBNODE_FLAG_SET (node->children->root, GTK_RBNODE_DESCENDANTS_INVALID))); } else { g_assert (! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID) && ! GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID)); if (!_gtk_rbtree_is_nil (node->left)) g_assert (! GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID)); if (!_gtk_rbtree_is_nil (node->right)) g_assert (! GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID)); if (node->children != NULL) g_assert (! GTK_RBNODE_FLAG_SET (node->children->root, GTK_RBNODE_DESCENDANTS_INVALID)); } if (!_gtk_rbtree_is_nil (node->left)) _gtk_rbtree_test_dirty (tree, node->left, GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID)); if (!_gtk_rbtree_is_nil (node->right)) _gtk_rbtree_test_dirty (tree, node->right, GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID)); if (node->children != NULL && !_gtk_rbtree_is_nil (node->children->root)) _gtk_rbtree_test_dirty (node->children, node->children->root, GTK_RBNODE_FLAG_SET (node->children->root, GTK_RBNODE_DESCENDANTS_INVALID)); }
guint _gtk_rbtree_node_get_index (GtkRBTree *tree, GtkRBNode *node) { GtkRBNode *last; guint retval; g_assert (node); g_assert (node->left); retval = node->left->total_count; while (tree && node && !_gtk_rbtree_is_nil (node)) { last = node; node = node->parent; /* Add left branch, plus children, iff we came from the right */ if (node->right == last) retval += node->total_count - node->right->total_count; if (_gtk_rbtree_is_nil (node)) { node = tree->parent_node; tree = tree->parent_tree; /* Add the parent node, plus the left branch. */ if (node) retval += node->left->total_count + 1; /* 1 == GTK_RBNODE_GET_PARITY() */ } } return retval; }
static void _gtk_rbtree_test_structure_helper (GtkRBTree *tree, GtkRBNode *node) { g_assert (!_gtk_rbtree_is_nil (node)); g_assert (node->left != NULL); g_assert (node->right != NULL); g_assert (node->parent != NULL); if (!_gtk_rbtree_is_nil (node->left)) { g_assert (node->left->parent == node); _gtk_rbtree_test_structure_helper (tree, node->left); } if (!_gtk_rbtree_is_nil (node->right)) { g_assert (node->right->parent == node); _gtk_rbtree_test_structure_helper (tree, node->right); } if (node->children != NULL) { g_assert (node->children->parent_tree == tree); g_assert (node->children->parent_node == node); _gtk_rbtree_test_structure (node->children); } }
GtkRBNode * _gtk_rbtree_prev (GtkRBTree *tree, GtkRBNode *node) { g_return_val_if_fail (tree != NULL, NULL); g_return_val_if_fail (node != NULL, NULL); /* Case 1: the node's below us. */ if (!_gtk_rbtree_is_nil (node->left)) { node = node->left; while (!_gtk_rbtree_is_nil (node->right)) node = node->right; return node; } /* Case 2: it's an ancestor */ while (!_gtk_rbtree_is_nil (node->parent)) { if (node->parent->left == node) node = node->parent; else return (node->parent); } /* Case 3: There is no next node */ return NULL; }
static void gtk_rbtree_print_node (GtkRBTree *tree, GtkRBNode *node, gint depth) { gint i; for (i = 0; i < depth; i++) g_print ("\t"); g_print ("(%p - %s) (Offset %d) (Parity %d) (Validity %d%d%d)\n", node, (GTK_RBNODE_GET_COLOR (node) == GTK_RBNODE_BLACK)?"BLACK":" RED ", node->offset, node->total_count, (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_DESCENDANTS_INVALID))?1:0, (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID))?1:0, (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))?1:0); if (node->children != NULL) { g_print ("Looking at child.\n"); gtk_rbtree_print_node (node->children, node->children->root, depth + 1); g_print ("Done looking at child.\n"); } if (!_gtk_rbtree_is_nil (node->left)) { gtk_rbtree_print_node (tree, node->left, depth+1); } if (!_gtk_rbtree_is_nil (node->right)) { gtk_rbtree_print_node (tree, node->right, depth+1); } }
gint _gtk_rbtree_node_find_offset (GtkRBTree *tree, GtkRBNode *node) { GtkRBNode *last; gint retval; g_assert (node); g_assert (node->left); retval = node->left->offset; while (tree && node && !_gtk_rbtree_is_nil (node)) { last = node; node = node->parent; /* Add left branch, plus children, iff we came from the right */ if (node->right == last) retval += node->offset - node->right->offset; if (_gtk_rbtree_is_nil (node)) { node = tree->parent_node; tree = tree->parent_tree; /* Add the parent node, plus the left branch. */ if (node) retval += node->left->offset + GTK_RBNODE_GET_HEIGHT (node); } } return retval; }
static void _gtk_rbtree_debug_spew_helper (GtkRBTree *tree, GtkRBNode *node, GString *s, gint depth) { gint i; for (i = 0; i < depth; i++) g_string_append (s, "\t"); g_string_append_printf (s, "(%p - %s) (Offset %d) (Parity %d) (Validity %d%d%d)\n", node, (GTK_RBNODE_GET_COLOR (node) == GTK_RBNODE_BLACK)?"BLACK":" RED ", node->offset, node->total_count, (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_DESCENDANTS_INVALID))?1:0, (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID))?1:0, (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))?1:0); if (node->children != NULL) { g_string_append (s, "Looking at child.\n"); _gtk_rbtree_debug_spew (node->children, s); g_string_append (s, "Done looking at child.\n"); } if (!_gtk_rbtree_is_nil (node->left)) { _gtk_rbtree_debug_spew_helper (tree, node->left, s, depth + 1); } if (!_gtk_rbtree_is_nil (node->right)) { _gtk_rbtree_debug_spew_helper (tree, node->right, s, depth + 1); } }
static void _gtk_rbtree_test_structure (GtkRBTree *tree) { g_assert (tree->root); if (_gtk_rbtree_is_nil (tree->root)) return; g_assert (_gtk_rbtree_is_nil (tree->root->parent)); _gtk_rbtree_test_structure_helper (tree, tree->root); }
static void _gtk_rbnode_rotate_right (GtkRBTree *tree, GtkRBNode *node) { gint node_height, left_height; GtkRBNode *left; g_return_if_fail (!_gtk_rbtree_is_nil (node)); g_return_if_fail (!_gtk_rbtree_is_nil (node->left)); left = node->left; node_height = GTK_RBNODE_GET_HEIGHT (node); left_height = GTK_RBNODE_GET_HEIGHT (left); node->left = left->right; if (!_gtk_rbtree_is_nil (left->right)) left->right->parent = node; left->parent = node->parent; if (!_gtk_rbtree_is_nil (node->parent)) { if (node == node->parent->right) node->parent->right = left; else node->parent->left = left; } else { tree->root = left; } /* link node and left */ left->right = node; node->parent = left; node->count = 1 + node->left->count + node->right->count; left->count = 1 + left->left->count + left->right->count; node->offset = node_height + node->left->offset + node->right->offset + (node->children ? node->children->root->offset : 0); left->offset = left_height + left->left->offset + left->right->offset + (left->children?left->children->root->offset:0); _fixup_validation (tree, node); _fixup_validation (tree, left); _fixup_total_count (tree, node); _fixup_total_count (tree, left); }
gboolean _gtk_rbtree_find_index (GtkRBTree *tree, guint index, GtkRBTree **new_tree, GtkRBNode **new_node) { GtkRBNode *tmp_node; g_assert (tree); tmp_node = tree->root; while (!_gtk_rbtree_is_nil (tmp_node)) { if (tmp_node->left->total_count > index) { tmp_node = tmp_node->left; } else if (tmp_node->total_count - tmp_node->right->total_count <= index) { index -= tmp_node->total_count - tmp_node->right->total_count; tmp_node = tmp_node->right; } else { index -= tmp_node->left->total_count; break; } } if (_gtk_rbtree_is_nil (tmp_node)) { *new_tree = NULL; *new_node = NULL; return FALSE; } if (index > 0) { g_assert (tmp_node->children); return _gtk_rbtree_find_index (tmp_node->children, index - 1, new_tree, new_node); } *new_tree = tree; *new_node = tmp_node; return TRUE; }
GtkRBNode * _gtk_rbtree_first (GtkRBTree *tree) { GtkRBNode *node; node = tree->root; if (_gtk_rbtree_is_nil (node)) return NULL; while (!_gtk_rbtree_is_nil (node->left)) node = node->left; return node; }
void _gtk_rbtree_prev_full (GtkRBTree *tree, GtkRBNode *node, GtkRBTree **new_tree, GtkRBNode **new_node) { g_return_if_fail (tree != NULL); g_return_if_fail (node != NULL); g_return_if_fail (new_tree != NULL); g_return_if_fail (new_node != NULL); *new_tree = tree; *new_node = _gtk_rbtree_prev (tree, node); if (*new_node == NULL) { *new_node = (*new_tree)->parent_node; *new_tree = (*new_tree)->parent_tree; } else { while ((*new_node)->children) { *new_tree = (*new_node)->children; *new_node = (*new_tree)->root; while (!_gtk_rbtree_is_nil ((*new_node)->right)) *new_node = (*new_node)->right; } } }
void _gtk_rbtree_next_full (GtkRBTree *tree, GtkRBNode *node, GtkRBTree **new_tree, GtkRBNode **new_node) { g_return_if_fail (tree != NULL); g_return_if_fail (node != NULL); g_return_if_fail (new_tree != NULL); g_return_if_fail (new_node != NULL); if (node->children) { *new_tree = node->children; *new_node = (*new_tree)->root; while (!_gtk_rbtree_is_nil ((*new_node)->left)) *new_node = (*new_node)->left; return; } *new_tree = tree; *new_node = _gtk_rbtree_next (tree, node); while ((*new_node == NULL) && (*new_tree != NULL)) { *new_node = (*new_tree)->parent_node; *new_tree = (*new_tree)->parent_tree; if (*new_tree) *new_node = _gtk_rbtree_next (*new_tree, *new_node); } }
void _gtk_rbtree_node_mark_valid (GtkRBTree *tree, GtkRBNode *node) { if ((!GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID)) && (!GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID))) return; GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_INVALID); GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_COLUMN_INVALID); do { if ((GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID)) || (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_COLUMN_INVALID)) || (node->children && GTK_RBNODE_FLAG_SET (node->children->root, GTK_RBNODE_DESCENDANTS_INVALID)) || (GTK_RBNODE_FLAG_SET (node->left, GTK_RBNODE_DESCENDANTS_INVALID)) || (GTK_RBNODE_FLAG_SET (node->right, GTK_RBNODE_DESCENDANTS_INVALID))) return; GTK_RBNODE_UNSET_FLAG (node, GTK_RBNODE_DESCENDANTS_INVALID); node = node->parent; if (_gtk_rbtree_is_nil (node)) { node = tree->parent_node; tree = tree->parent_tree; } } while (node); }
static void _gtk_rbtree_test (GtkRBTree *tree) { GtkRBTree *tmp_tree; if (tree == NULL) return; /* Test the entire tree */ tmp_tree = tree; while (tmp_tree->parent_tree) tmp_tree = tmp_tree->parent_tree; if (_gtk_rbtree_is_nil (tmp_tree->root)) return; _gtk_rbtree_test_structure (tmp_tree); g_assert ((_count_nodes (tmp_tree, tmp_tree->root->left) + _count_nodes (tmp_tree, tmp_tree->root->right) + 1) == tmp_tree->root->count); _gtk_rbtree_test_height (tmp_tree, tmp_tree->root); _gtk_rbtree_test_dirty (tmp_tree, tmp_tree->root, GTK_RBNODE_FLAG_SET (tmp_tree->root, GTK_RBNODE_DESCENDANTS_INVALID)); g_assert (count_total (tmp_tree, tmp_tree->root) == tmp_tree->root->total_count); }
static void _gtk_rbnode_rotate_left (GtkRBTree *tree, GtkRBNode *node) { gint node_height, right_height; GtkRBNode *right; g_return_if_fail (!_gtk_rbtree_is_nil (node)); g_return_if_fail (!_gtk_rbtree_is_nil (node->right)); right = node->right; node_height = GTK_RBNODE_GET_HEIGHT (node); right_height = GTK_RBNODE_GET_HEIGHT (right); node->right = right->left; if (!_gtk_rbtree_is_nil (right->left)) right->left->parent = node; right->parent = node->parent; if (!_gtk_rbtree_is_nil (node->parent)) { if (node == node->parent->left) node->parent->left = right; else node->parent->right = right; } else { tree->root = right; } right->left = node; node->parent = right; node->count = 1 + node->left->count + node->right->count; right->count = 1 + right->left->count + right->right->count; node->offset = node_height + node->left->offset + node->right->offset + (node->children ? node->children->root->offset : 0); right->offset = right_height + right->left->offset + right->right->offset + (right->children ? right->children->root->offset : 0); _fixup_validation (tree, node); _fixup_validation (tree, right); _fixup_total_count (tree, node); _fixup_total_count (tree, right); }
void gtk_rbtree_print (GtkRBTree *tree) { g_return_if_fail (tree != NULL); if (_gtk_rbtree_is_nil (tree->root)) g_print ("Empty tree...\n"); else gtk_rbtree_print_node (tree, tree->root, 0); }
static void _gtk_rbtree_debug_spew (GtkRBTree *tree) { g_return_if_fail (tree != NULL); if (_gtk_rbtree_is_nil (tree->root)) g_print ("Empty tree...\n"); else _gtk_rbtree_debug_spew_helper (tree, tree->root, 0); }
static void _gtk_rbtree_debug_spew (GtkRBTree *tree, GString *s) { g_return_if_fail (tree != NULL); if (_gtk_rbtree_is_nil (tree->root)) g_string_append (s, "Empty tree..."); else _gtk_rbtree_debug_spew_helper (tree, tree->root, s, 0); }
GtkRBNode * _gtk_rbtree_find_count (GtkRBTree *tree, gint count) { GtkRBNode *node; node = tree->root; while (!_gtk_rbtree_is_nil (node) && (node->left->count + 1 != count)) { if (node->left->count >= count) node = node->left; else { count -= (node->left->count + 1); node = node->right; } } if (_gtk_rbtree_is_nil (node)) return NULL; return node; }
static void _gtk_rbtree_test_height (GtkRBTree *tree, GtkRBNode *node) { gint computed_offset = 0; /* This whole test is sort of a useless truism. */ if (!_gtk_rbtree_is_nil (node->left)) computed_offset += node->left->offset; if (!_gtk_rbtree_is_nil (node->right)) computed_offset += node->right->offset; if (node->children && !_gtk_rbtree_is_nil (node->children->root)) computed_offset += node->children->root->offset; if (GTK_RBNODE_GET_HEIGHT (node) + computed_offset != node->offset) g_error ("node has broken offset\n"); if (!_gtk_rbtree_is_nil (node->left)) _gtk_rbtree_test_height (tree, node->left); if (!_gtk_rbtree_is_nil (node->right)) _gtk_rbtree_test_height (tree, node->right); if (node->children && !_gtk_rbtree_is_nil (node->children->root)) _gtk_rbtree_test_height (node->children, node->children->root); }
static guint _gtk_rbtree_test_structure_helper (GtkRBTree *tree, GtkRBNode *node) { guint left_blacks, right_blacks; g_assert (!_gtk_rbtree_is_nil (node)); g_assert (node->left != NULL); g_assert (node->right != NULL); g_assert (node->parent != NULL); if (!_gtk_rbtree_is_nil (node->left)) { g_assert (node->left->parent == node); left_blacks = _gtk_rbtree_test_structure_helper (tree, node->left); } else left_blacks = 0; if (!_gtk_rbtree_is_nil (node->right)) { g_assert (node->right->parent == node); right_blacks = _gtk_rbtree_test_structure_helper (tree, node->right); } else right_blacks = 0; if (node->children != NULL) { g_assert (node->children->parent_tree == tree); g_assert (node->children->parent_node == node); _gtk_rbtree_test_structure (node->children); } g_assert (left_blacks == right_blacks); return left_blacks + (GTK_RBNODE_GET_COLOR (node) == GTK_RBNODE_BLACK ? 1 : 0); }
static void _gtk_rbtree_traverse_post_order (GtkRBTree *tree, GtkRBNode *node, GtkRBTreeTraverseFunc func, gpointer data) { if (_gtk_rbtree_is_nil (node)) return; _gtk_rbtree_traverse_post_order (tree, node->left, func, data); _gtk_rbtree_traverse_post_order (tree, node->right, func, data); (* func) (tree, node, data); }
static void gtk_rbnode_adjust (GtkRBTree *tree, GtkRBNode *node, int count_diff, int total_count_diff, int offset_diff) { while (tree && node && !_gtk_rbtree_is_nil (node)) { _fixup_validation (tree, node); node->offset += offset_diff; node->count += count_diff; node->total_count += total_count_diff; node = node->parent; if (_gtk_rbtree_is_nil (node)) { node = tree->parent_node; tree = tree->parent_tree; count_diff = 0; } } }
static void reorder_copy_node (GtkRBTree *tree, GtkRBNode *to, GtkRBNode *from) { to->flags = (to->flags & GTK_RBNODE_NON_COLORS) | GTK_RBNODE_GET_COLOR (from); to->left = from->left; if (!_gtk_rbtree_is_nil (to->left)) to->left->parent = to; to->right = from->right; if (!_gtk_rbtree_is_nil (to->right)) to->right->parent = to; to->parent = from->parent; if (_gtk_rbtree_is_nil (to->parent)) tree->root = to; else if (to->parent->left == from) to->parent->left = to; else if (to->parent->right == from) to->parent->right = to; }
/* Draconian version. */ void _gtk_rbtree_node_mark_invalid (GtkRBTree *tree, GtkRBNode *node) { GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_INVALID); do { _fixup_validation (tree, node); node = node->parent; if (_gtk_rbtree_is_nil (node)) { node = tree->parent_node; tree = tree->parent_tree; } } while (node); }
static gint _count_nodes (GtkRBTree *tree, GtkRBNode *node) { gint res; if (_gtk_rbtree_is_nil (node)) return 0; g_assert (node->left); g_assert (node->right); res = (_count_nodes (tree, node->left) + _count_nodes (tree, node->right) + 1); if (res != node->count) g_print ("Tree failed\n"); return res; }
void _gtk_rbtree_node_mark_invalid (GtkRBTree *tree, GtkRBNode *node) { if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_INVALID)) return; GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_INVALID); do { if (GTK_RBNODE_FLAG_SET (node, GTK_RBNODE_DESCENDANTS_INVALID)) return; GTK_RBNODE_SET_FLAG (node, GTK_RBNODE_DESCENDANTS_INVALID); node = node->parent; if (_gtk_rbtree_is_nil (node)) { node = tree->parent_node; tree = tree->parent_tree; } } while (node); }
static guint count_total (GtkRBTree *tree, GtkRBNode *node) { guint res; if (_gtk_rbtree_is_nil (node)) return 0; res = count_total (tree, node->left) + count_total (tree, node->right) + (guint)1 + (node->children ? count_total (node->children, node->children->root) : 0); if (res != node->total_count) g_print ("total count incorrect for node\n"); if (get_total_count (node) != node->total_count) g_error ("Node has incorrect total count %u, should be %u", node->total_count, get_total_count (node)); return res; }
static gint gtk_rbtree_real_find_offset (GtkRBTree *tree, gint height, GtkRBTree **new_tree, GtkRBNode **new_node) { GtkRBNode *tmp_node; g_assert (tree); if (height < 0) { *new_tree = NULL; *new_node = NULL; return 0; } tmp_node = tree->root; while (!_gtk_rbtree_is_nil (tmp_node) && (tmp_node->left->offset > height || (tmp_node->offset - tmp_node->right->offset) < height)) { if (tmp_node->left->offset > height) tmp_node = tmp_node->left; else { height -= (tmp_node->offset - tmp_node->right->offset); tmp_node = tmp_node->right; } } if (_gtk_rbtree_is_nil (tmp_node)) { *new_tree = NULL; *new_node = NULL; return 0; } if (tmp_node->children) { if ((tmp_node->offset - tmp_node->right->offset - tmp_node->children->root->offset) > height) { *new_tree = tree; *new_node = tmp_node; return (height - tmp_node->left->offset); } return gtk_rbtree_real_find_offset (tmp_node->children, height - tmp_node->left->offset - (tmp_node->offset - tmp_node->left->offset - tmp_node->right->offset - tmp_node->children->root->offset), new_tree, new_node); } *new_tree = tree; *new_node = tmp_node; return (height - tmp_node->left->offset); }