int Node_Delete (root_t* tree, tree_t* node)
{
TREE_CHECK (tree);
NODE_CHECK (node);
if (node->left)
{
TEC (Node_Delete (tree, node->left), node->left);
}
if (node->right)
{
TEC (Node_Delete (tree, node->right), node->right);
}
if (node->parent->left == node) node->parent->left = NULL;
if (node->parent->right == node) node->parent->right = NULL;
Tree_Update_Sizes (tree, node->parent, -1);
TEC (Node_Destruct (node), node);
TREE_CHECK (tree);
return TREE_OK;
}
int Tree_Destruct (root_t* tree)
{
TREE_CHECK (tree);
if (tree->root->left) TEC (Node_Delete (tree, tree->root->left), tree);
if (tree->root->right) TEC (Node_Delete (tree, tree->root->right), tree);
ISERR (Node_Destruct (tree->root), tree);
tree->size = Poison;
free (tree);
return TREE_OK;
}
void Group_DeleteAll(Group *inGroup)
{
Node *child = inGroup->mHead;
while (child) {
Node *next = child->mNext;
child->mPrev = child->mNext = 0;
child->mParent = 0;
Node_Delete(child);
child = next;
}
inGroup->mHead = inGroup->mTail = 0;
}
SCErr meth_n_free(World *inWorld, int inSize, char *inData, ReplyAddress* /*inReply*/)
{
sc_msg_iter msg(inSize, inData);
while (msg.remain()) {
Node *node = Msg_GetNode(inWorld, msg);
if (!node) return kSCErr_NodeNotFound;
Node_Delete(node);
}
return kSCErr_None;
}
void Group_DeepFreeGraphs(Group *inGroup)
{
Node *child = inGroup->mHead;
while (child) {
Node *next = child->mNext;
if (child->mIsGroup) {
Group_DeepFreeGraphs((Group*)child);
} else {
Node_Remove(child);
Node_Delete(child);
}
child = next;
}
}
int Tree_Replace_Right (node* tree)
{
int err_index;
ASSERT_NODE_OK (tree);
if (tree -> left) Tree_Delete (tree -> left);
node* new_tree = tree -> right;
node* tmp_tree = tree -> prev;
if (tree == tree -> prev -> left )
{
Node_Delete (tree);
Tree_Add_Left (tmp_tree, new_tree);
}
else
{
Node_Delete (tree);
Tree_Add_Right (tmp_tree, new_tree);
}
ASSERT_NODE_OK (new_tree);
return HAPPY;
}
void Graph_RemoveID(World* inWorld, Graph *inGraph)
{
if (!World_RemoveNode(inWorld, &inGraph->mNode)) {
int err = kSCErr_Failed; // shouldn't happen..
throw err;
}
HiddenWorld* hw = inWorld->hw;
int id = hw->mHiddenID = (hw->mHiddenID - 8) | 0x80000000;
inGraph->mNode.mID = id;
inGraph->mNode.mHash = Hash(id);
if (!World_AddNode(inWorld, &inGraph->mNode)) {
scprintf("mysterious failure in Graph_RemoveID\n");
Node_Delete(&inGraph->mNode);
// enums are uncatchable. must throw an int.
int err = kSCErr_Failed; // shouldn't happen..
throw err;
}
//inWorld->hw->mRecentID = id;
}
void Node_Replace(Node* s, Node *replaceThisOne)
{
//scprintf("->Node_Replace\n");
Group *group = replaceThisOne->mParent;
if (!group) return; // failed
if (s->mID == 0) return;
s->mParent = group;
s->mPrev = replaceThisOne->mPrev;
s->mNext = replaceThisOne->mNext;
if (s->mPrev) s->mPrev->mNext = s;
else group->mHead = s;
if (s->mNext) s->mNext->mPrev = s;
else group->mTail = s;
replaceThisOne->mPrev = replaceThisOne->mNext = 0;
replaceThisOne->mParent = 0;
Node_Delete(replaceThisOne);
//scprintf("<-Node_Replace\n");
}
void Node_RemoveID(Node *inNode)
{
if (inNode->mID == 0) return; // failed
World* world = inNode->mWorld;
if (!World_RemoveNode(world, inNode)) {
int err = kSCErr_Failed; // shouldn't happen..
throw err;
}
HiddenWorld* hw = world->hw;
int id = hw->mHiddenID = (hw->mHiddenID - 8) | 0x80000000;
inNode->mID = id;
inNode->mHash = Hash(id);
if (!World_AddNode(world, inNode)) {
scprintf("mysterious failure in Node_RemoveID\n");
Node_Delete(inNode);
// enums are uncatchable. must throw an int.
int err = kSCErr_Failed; // shouldn't happen..
throw err;
}
//inWorld->hw->mRecentID = id;
}
