Res SplayTreeDelete(SplayTree tree, SplayNode node, void *key) {
SplayNode rightHalf, del, leftLast;
Bool found;
AVERT(SplayTree, tree);
AVERT(SplayNode, node);
found = SplaySplay(&del, tree, key, tree->compare);
AVER(!found || del == node);
if (!found) {
return ResFAIL;
} else if (SplayNodeLeftChild(node) == NULL) {
SplayTreeSetRoot(tree, SplayNodeRightChild(node));
} else if (SplayNodeRightChild(node) == NULL) {
SplayTreeSetRoot(tree, SplayNodeLeftChild(node));
} else {
rightHalf = SplayNodeRightChild(node);
SplayTreeSetRoot(tree, SplayNodeLeftChild(node));
if (SplaySplay(&leftLast, tree, key, tree->compare)) {
return ResFAIL;
} else {
AVER(SplayNodeRightChild(leftLast) == NULL);
SplayNodeSetRightChild(leftLast, rightHalf);
if (tree->updateNode != NULL) {
SplayNodeUpdate(tree, leftLast);
}
}
}
SplayNodeFinish(node);
return ResOK;
}
Bool SplayFindFirst(Tree *nodeReturn, SplayTree splay,
SplayTestNodeFunction testNode,
SplayTestTreeFunction testTree,
void *closureP, Size closureS)
{
SplayFindClosureStruct closureStruct;
Bool found;
AVER(nodeReturn != NULL);
AVERT(SplayTree, splay);
AVER(FUNCHECK(testNode));
AVER(FUNCHECK(testTree));
if (SplayTreeIsEmpty(splay) ||
!testTree(splay, SplayTreeRoot(splay), closureP, closureS))
return FALSE; /* no suitable nodes in tree */
closureStruct.p = closureP;
closureStruct.s = closureS;
closureStruct.testNode = testNode;
closureStruct.testTree = testTree;
closureStruct.splay = splay;
closureStruct.found = FALSE;
found = SplaySplay(splay, &closureStruct,
SplayFindFirstCompare) == CompareEQUAL &&
closureStruct.found;
while (!found) {
Tree oldRoot, newRoot;
/* FIXME: Rename to "seen" and "not yet seen" or something. */
oldRoot = SplayTreeRoot(splay);
newRoot = TreeRight(oldRoot);
if (newRoot == TreeEMPTY || !(*testTree)(splay, newRoot, closureP, closureS))
return FALSE; /* no suitable nodes in the rest of the tree */
/* Temporarily chop off the left half-tree, inclusive of root,
so that the search excludes any nodes we've seen already. */
SplayTreeSetRoot(splay, newRoot);
TreeSetRight(oldRoot, TreeEMPTY);
found = SplaySplay(splay, &closureStruct,
SplayFindFirstCompare) == CompareEQUAL &&
closureStruct.found;
/* Restore the left tree, then rotate left so that the node we
just splayed is at the root. Update both. */
newRoot = SplayTreeRoot(splay);
TreeSetRight(oldRoot, newRoot);
SplayTreeSetRoot(splay, oldRoot);
TreeRotateLeft(&splay->root);
splay->updateNode(splay, oldRoot);
splay->updateNode(splay, newRoot);
}
*nodeReturn = SplayTreeRoot(splay);
return TRUE;
}
Bool SplayFindLast(Tree *nodeReturn, SplayTree splay,
SplayTestNodeFunction testNode,
SplayTestTreeFunction testTree,
void *testClosure)
{
SplayFindClosureStruct closureStruct;
Bool found;
AVER_CRITICAL(nodeReturn != NULL);
AVERT_CRITICAL(SplayTree, splay);
AVER_CRITICAL(FUNCHECK(testNode));
AVER_CRITICAL(FUNCHECK(testTree));
if (SplayTreeIsEmpty(splay) ||
!testTree(splay, SplayTreeRoot(splay), testClosure))
return FALSE; /* no suitable nodes in tree */
closureStruct.testClosure = testClosure;
closureStruct.testNode = testNode;
closureStruct.testTree = testTree;
closureStruct.splay = splay;
found = SplaySplay(splay, &closureStruct,
SplayFindLastCompare) == CompareEQUAL &&
closureStruct.found;
while (!found) {
Tree oldRoot, newRoot;
oldRoot = SplayTreeRoot(splay);
newRoot = TreeLeft(oldRoot);
if (newRoot == TreeEMPTY || !(*testTree)(splay, newRoot, testClosure))
return FALSE; /* no suitable nodes in the rest of the tree */
/* Temporarily chop off the right half-tree, inclusive of root,
so that the search excludes any nodes we've seen already. */
SplayTreeSetRoot(splay, newRoot);
TreeSetLeft(oldRoot, TreeEMPTY);
found = SplaySplay(splay, &closureStruct,
SplayFindLastCompare) == CompareEQUAL &&
closureStruct.found;
/* Restore the right tree, then rotate right so that the node we
just splayed is at the root. Update both. */
newRoot = SplayTreeRoot(splay);
TreeSetLeft(oldRoot, newRoot);
SplayTreeSetRoot(splay, oldRoot);
TreeRotateRight(&splay->root);
splay->updateNode(splay, oldRoot);
splay->updateNode(splay, newRoot);
}
*nodeReturn = SplayTreeRoot(splay);
return TRUE;
}
static Tree SplayTreeSuccessor(SplayTree splay)
{
Tree oldRoot, newRoot;
AVERT(SplayTree, splay);
AVER(!SplayTreeIsEmpty(splay));
oldRoot = SplayTreeRoot(splay);
if (!TreeHasRight(oldRoot))
return TreeEMPTY; /* No successor */
/* temporarily chop off the left half-tree, inclusive of root */
SplayTreeSetRoot(splay, TreeRight(oldRoot));
TreeSetRight(oldRoot, TreeEMPTY);
(void)SplaySplay(splay, NULL, compareLess);
newRoot = SplayTreeRoot(splay);
AVER(newRoot != TreeEMPTY);
AVER(TreeLeft(newRoot) == TreeEMPTY);
TreeSetLeft(newRoot, oldRoot);
splay->updateNode(splay, oldRoot);
splay->updateNode(splay, newRoot);
return newRoot;
}
Bool SplayFindLast(SplayNode *nodeReturn, SplayTree tree,
SplayTestNodeMethod testNode,
SplayTestTreeMethod testTree,
void *closureP, unsigned long closureS)
{
SplayNode node;
SplayFindClosureStruct closureStruct;
AVER(nodeReturn != NULL);
AVERT(SplayTree, tree);
AVER(FUNCHECK(testNode));
AVER(FUNCHECK(testTree));
node = SplayTreeRoot(tree);
if (node == NULL || !(*testTree)(tree, node, closureP, closureS))
return FALSE; /* no suitable nodes in tree */
closureStruct.p = closureP;
closureStruct.s = closureS;
closureStruct.testNode = testNode;
closureStruct.testTree = testTree;
closureStruct.tree = tree;
if (SplaySplay(&node, tree, (void *)&closureStruct,
&SplayFindLastCompare)) {
*nodeReturn = node;
return TRUE;
} else {
return FALSE;
}
}
static SplayNode SplayTreeSuccessor(SplayTree tree, void *key) {
SplayNode oldRoot, newRoot;
AVERT(SplayTree, tree);
oldRoot = SplayTreeRoot(tree);
AVERT(SplayNode, oldRoot);
if (SplayNodeRightChild(oldRoot) == NULL) {
newRoot = NULL; /* No successor */
} else {
/* temporarily chop off the left half-tree, inclusive of root */
SplayTreeSetRoot(tree, SplayNodeRightChild(oldRoot));
SplayNodeSetRightChild(oldRoot, NULL);
if (SplaySplay(&newRoot, tree, key, tree->compare)) {
NOTREACHED; /* Another matching node found */
} else {
AVER(SplayNodeLeftChild(newRoot) == NULL);
SplayNodeSetLeftChild(newRoot, oldRoot);
}
if (tree->updateNode != NULL) {
SplayNodeUpdate(tree, oldRoot);
SplayNodeUpdate(tree, newRoot);
}
}
return newRoot;
}
Bool SplayTreeDelete(SplayTree splay, Tree node)
{
Tree leftLast;
Compare cmp;
AVERT(SplayTree, splay);
AVERT(Tree, node);
if (SplayTreeIsEmpty(splay))
return FALSE;
cmp = SplaySplay(splay, splay->nodeKey(node), splay->compare);
AVER(cmp != CompareEQUAL || SplayTreeRoot(splay) == node);
if (cmp != CompareEQUAL) {
return FALSE;
} else if (!TreeHasLeft(node)) {
SplayTreeSetRoot(splay, TreeRight(node));
TreeClearRight(node);
} else if (!TreeHasRight(node)) {
SplayTreeSetRoot(splay, TreeLeft(node));
TreeClearLeft(node);
} else {
Tree rightHalf = TreeRight(node);
TreeClearRight(node);
SplayTreeSetRoot(splay, TreeLeft(node));
TreeClearLeft(node);
(void)SplaySplay(splay, NULL, compareGreater);
leftLast = SplayTreeRoot(splay);
AVER(leftLast != TreeEMPTY);
AVER(!TreeHasRight(leftLast));
TreeSetRight(leftLast, rightHalf);
splay->updateNode(splay, leftLast);
}
TreeFinish(node);
return TRUE;
}
Bool SplayTreeFind(Tree *nodeReturn, SplayTree splay, TreeKey key) {
AVERT(SplayTree, splay);
AVER(nodeReturn != NULL);
if (SplayTreeIsEmpty(splay))
return FALSE;
if (SplaySplay(splay, key, splay->compare) != CompareEQUAL)
return FALSE;
*nodeReturn = SplayTreeRoot(splay);
return TRUE;
}
void SplayNodeRefresh(SplayTree splay, Tree node)
{
Compare cmp;
AVERT(SplayTree, splay);
AVERT(Tree, node);
AVER(!SplayTreeIsEmpty(splay)); /* must contain node, at least */
cmp = SplaySplay(splay, splay->nodeKey(node), splay->compare);
AVER(cmp == CompareEQUAL);
AVER(SplayTreeRoot(splay) == node);
splay->updateNode(splay, node);
}
SplayNode SplayTreeNext(SplayTree tree, SplayNode oldNode, void *oldKey) {
Bool b;
SplayNode node;
AVERT(SplayTree, tree);
AVERT(SplayNode, oldNode);
/* Make old node the root. Probably already is. */
b = SplaySplay(&node, tree, oldKey, tree->compare);
AVER(b);
AVER(node == oldNode);
return SplayTreeSuccessor(tree, oldKey);
}
SplayNode SplayTreeFirst(SplayTree tree, void *zeroKey) {
SplayNode node;
AVERT(SplayTree, tree);
if (SplayTreeRoot(tree) == NULL) {
node = NULL;
} else if (SplaySplay(&node, tree, zeroKey, tree->compare)) {
NOTREACHED;
} else {
AVER(SplayNodeLeftChild(node) == NULL);
}
return node;
}
Res SplayTreeSearch(SplayNode *nodeReturn, SplayTree tree, void *key) {
SplayNode node;
AVERT(SplayTree, tree);
AVER(nodeReturn != NULL);
if (SplaySplay(&node, tree, key, tree->compare)) {
*nodeReturn = node;
} else {
return ResFAIL;
}
return ResOK;
}
void SplayNodeRefresh(SplayTree tree, SplayNode node, void *key)
{
Bool b;
SplayNode node2;
AVERT(SplayTree, tree);
AVERT(SplayNode, node);
b = SplaySplay(&node2, tree, key, tree->compare);
AVER(b);
AVER(node == node2);
(*tree->updateNode)(tree, node, SplayNodeLeftChild(node),
SplayNodeRightChild(node));
}
Tree SplayTreeFirst(SplayTree splay) {
Tree node;
AVERT(SplayTree, splay);
if (SplayTreeIsEmpty(splay))
return TreeEMPTY;
(void)SplaySplay(splay, NULL, compareLess);
node = SplayTreeRoot(splay);
AVER(node != TreeEMPTY);
AVER(TreeLeft(node) == TreeEMPTY);
return node;
}
Res SplayTreeInsert(SplayTree tree, SplayNode node, void *key) {
SplayNode neighbour;
AVERT(SplayTree, tree);
AVERT(SplayNode, node);
AVER(SplayNodeLeftChild(node) == NULL);
AVER(SplayNodeRightChild(node) == NULL);
if (SplayTreeRoot(tree) == NULL) {
SplayTreeSetRoot(tree, node);
} else if (SplaySplay(&neighbour, tree, key, tree->compare)) {
return ResFAIL;
} else {
AVER(SplayTreeRoot(tree) == neighbour);
switch(SplayCompare(tree, key, neighbour)) {
case CompareGREATER: { /* left neighbour */
SplayTreeSetRoot(tree, node);
SplayNodeSetRightChild(node, SplayNodeRightChild(neighbour));
SplayNodeSetLeftChild(node, neighbour);
SplayNodeSetRightChild(neighbour, NULL);
}
break;
case CompareLESS: { /* right neighbour */
SplayTreeSetRoot(tree, node);
SplayNodeSetLeftChild(node, SplayNodeLeftChild(neighbour));
SplayNodeSetRightChild(node, neighbour);
SplayNodeSetLeftChild(neighbour, NULL);
}
break;
case CompareEQUAL:
default: {
NOTREACHED;
}
break;
}
if (tree->updateNode != NULL) {
SplayNodeUpdate(tree, neighbour);
SplayNodeUpdate(tree, node);
}
}
return ResOK;
}
Bool SplayTreeInsert(SplayTree splay, Tree node)
{
Tree neighbour;
AVERT(SplayTree, splay);
AVERT(Tree, node);
AVER(TreeLeft(node) == TreeEMPTY);
AVER(TreeRight(node) == TreeEMPTY);
if (SplayTreeIsEmpty(splay)) {
SplayTreeSetRoot(splay, node);
return TRUE;
}
switch (SplaySplay(splay, splay->nodeKey(node), splay->compare)) {
default:
NOTREACHED;
/* fall through */
case CompareEQUAL: /* duplicate node */
return FALSE;
case CompareGREATER: /* left neighbour is at root */
neighbour = SplayTreeRoot(splay);
SplayTreeSetRoot(splay, node);
TreeSetRight(node, TreeRight(neighbour));
TreeSetLeft(node, neighbour);
TreeSetRight(neighbour, TreeEMPTY);
break;
case CompareLESS: /* right neighbour is at root */
neighbour = SplayTreeRoot(splay);
SplayTreeSetRoot(splay, node);
TreeSetLeft(node, TreeLeft(neighbour));
TreeSetRight(node, neighbour);
TreeSetLeft(neighbour, TreeEMPTY);
break;
}
splay->updateNode(splay, neighbour);
splay->updateNode(splay, node);
return TRUE;
}
Tree SplayTreeNext(SplayTree splay, TreeKey oldKey) {
AVERT(SplayTree, splay);
if (SplayTreeIsEmpty(splay))
return TreeEMPTY;
/* Make old node the root. Probably already is. We don't mind if the
node has been deleted, or replaced by a node with the same key. */
switch (SplaySplay(splay, oldKey, splay->compare)) {
default:
NOTREACHED;
/* defensive fall-through */
case CompareLESS:
return SplayTreeRoot(splay);
case CompareGREATER:
case CompareEQUAL:
return SplayTreeSuccessor(splay);
}
}
Res SplayTreeNeighbours(SplayNode *leftReturn, SplayNode *rightReturn,
SplayTree tree, void *key) {
SplayNode neighbour;
AVERT(SplayTree, tree);
AVER(leftReturn != NULL);
AVER(rightReturn != NULL);
if (SplaySplay(&neighbour, tree, key, tree->compare)) {
return ResFAIL;
} else if (neighbour == NULL) {
*leftReturn = *rightReturn = NULL;
} else {
switch(SplayCompare(tree, key, neighbour)) {
case CompareLESS: {
*rightReturn = neighbour;
*leftReturn = SplayTreePredecessor(tree, key);
}
break;
case CompareGREATER: {
*leftReturn = neighbour;
*rightReturn = SplayTreeSuccessor(tree, key);
}
break;
case CompareEQUAL:
default: {
NOTREACHED;
}
break;
}
}
return ResOK;
}
