/*
* D E L _ F R O M _ P R I O Q ( )
*
*/
void del_from_prioq (struct vertex *vp)
{
BU_CKMAG(vp, VERTEX_MAGIC, "vertex");
BU_CKMAG(vp -> v_bridge, BRIDGE_MAGIC, "bridge");
if (debug)
bu_log("del_from_prioq(<x%x>... bridge <x%x> %d)\n",
vp, vp -> v_bridge, vp -> v_bridge -> b_index);
if (bu_rb_search(prioq, PRIOQ_INDEX, (void *) (vp -> v_bridge)) == NULL)
{
bu_exit(1, "del_from_prioq: Cannot find bridge <x%x>.", vp -> v_bridge);
}
bu_rb_delete(prioq, PRIOQ_INDEX);
}
int
bu_rb_insert(struct bu_rb_tree *tree, void *data)
{
int nm_orders;
int order;
int result = 0;
struct bu_rb_node *node;
struct bu_rb_package *package;
struct bu_rb_list *rblp;
BU_CKMAG(tree, BU_RB_TREE_MAGIC, "red-black tree");
nm_orders = tree->rbt_nm_orders;
/*
* Enforce uniqueness
*
* NOTE: The approach is that for each order that requires
* uniqueness, we look for a match. This is not the most
* efficient way to do things, since _rb_insert() is just going to
* turn around and search the tree all over again.
*/
for (order = 0; order < nm_orders; ++order) {
if (RB_GET_UNIQUENESS(tree, order) &&
(bu_rb_search(tree, order, data) != NULL))
{
if (UNLIKELY(tree->rbt_debug & BU_RB_DEBUG_UNIQ))
bu_log("bu_rb_insert(<%p>, <%p>, TBD) will return %d\n",
(void*)tree, (void*)data, -(order + 1));
return -(order + 1);
}
}
/*
* Make a new package and add it to the list of all packages.
*/
BU_ALLOC(package, struct bu_rb_package);
package->rbp_node = (struct bu_rb_node **)
bu_malloc(nm_orders * sizeof(struct bu_rb_node *),
"red-black package nodes");
BU_ALLOC(rblp, struct bu_rb_list);
rblp->rbl_magic = BU_RB_LIST_MAGIC;
rblp->rbl_package = package;
BU_LIST_PUSH(&(tree->rbt_packages.l), rblp);
package->rbp_list_pos = rblp;
/*
* Make a new node and add it to the list of all nodes.
*/
node = (struct bu_rb_node *)
bu_malloc(sizeof(struct bu_rb_node), "red-black node");
node->rbn_parent = (struct bu_rb_node **)
bu_malloc(nm_orders * sizeof(struct bu_rb_node *),
"red-black parents");
node->rbn_left = (struct bu_rb_node **)
bu_malloc(nm_orders * sizeof(struct bu_rb_node *),
"red-black left children");
node->rbn_right = (struct bu_rb_node **)
bu_malloc(nm_orders * sizeof(struct bu_rb_node *),
"red-black right children");
node->rbn_color = (char *)
bu_malloc((size_t) lrint(ceil((double) (nm_orders / 8.0))),
"red-black colors");
node->rbn_size = (int *)
bu_malloc(nm_orders * sizeof(int),
"red-black subtree sizes");
node->rbn_package = (struct bu_rb_package **)
bu_malloc(nm_orders * sizeof(struct bu_rb_package *),
"red-black packages");
BU_ALLOC(rblp, struct bu_rb_list);
rblp->rbl_magic = BU_RB_LIST_MAGIC;
rblp->rbl_node = node;
BU_LIST_PUSH(&(tree->rbt_nodes.l), rblp);
node->rbn_list_pos = rblp;
/*
* Fill in the package
*/
package->rbp_magic = BU_RB_PKG_MAGIC;
package->rbp_data = data;
for (order = 0; order < nm_orders; ++order)
(package->rbp_node)[order] = node;
/*
* Fill in the node
*/
node->rbn_magic = BU_RB_NODE_MAGIC;
node->rbn_tree = tree;
for (order = 0; order < nm_orders; ++order)
(node->rbn_package)[order] = package;
node->rbn_pkg_refs = nm_orders;
/*
* If the tree was empty, install this node as the root and give
* it a null parent and null children
*/
if (RB_ROOT(tree, 0) == RB_NULL(tree)) {
for (order = 0; order < nm_orders; ++order) {
RB_ROOT(tree, order) = node;
RB_PARENT(node, order) =
RB_LEFT_CHILD(node, order) =
RB_RIGHT_CHILD(node, order) = RB_NULL(tree);
RB_SET_COLOR(node, order, RB_BLK);
RB_SIZE(node, order) = 1;
if (UNLIKELY(tree->rbt_debug & BU_RB_DEBUG_OS))
bu_log("bu_rb_insert(<%p>, <%p>, <%p>): size(%p, %d)=%d\n",
(void*)tree, (void*)data, (void*)node, (void*)node, order, RB_SIZE(node, order));
}
} else {
/* Otherwise, insert the node into the tree */
for (order = 0; order < nm_orders; ++order)
result += _rb_insert(tree, order, node);
if (UNLIKELY(tree->rbt_debug & BU_RB_DEBUG_UNIQ))
bu_log("bu_rb_insert(<%p>, <%p>, <%p>) will return %d\n",
(void*)tree, (void*)data, (void*)node, result);
}
++(tree->rbt_nm_nodes);
RB_CURRENT(tree) = node;
return result;
}
