public void SetupForPosition(Key key, long posit)
{
// If the current leaf is set
if (currentLeaf != null)
{
StackFrame frame = StackEnd(0);
long leafStart = frame.Offset;
long leafEnd = leafStart + currentLeaf.Length;
// If the position is at the leaf end, or if the keys aren't equal, we
// need to reset the stack. This ensures that we correctly place the
// pointer.
if (!key.Equals(Key.Tail) &&
(posit == leafEnd || !key.Equals(currentLeafKey)))
{
StackClear();
currentLeaf = null;
currentLeafKey = null;
}
else
{
// Check whether the position is within the bounds of the current leaf
// If 'posit' is within this leaf
if (posit >= leafStart && posit < leafEnd)
{
// If the position is within the current leaf, set up the internal
// vars as necessary.
leafOffset = (int)(posit - leafStart);
return;
}
// If it's not, we reset the stack and start fresh,
StackClear();
currentLeaf = null;
currentLeafKey = null;
}
}
// ISSUE: It appears looking at the code above, the stack will always be
// empty and current_leaf will always be null if we get here.
// If the stack is empty, push the root node,
if (StackEmpty)
{
// Push the root node onto the top of the stack.
StackPush(-1, 0, RootNodeId);
// Set up the current_leaf_key to the default value
currentLeafKey = Key.Head;
}
// Otherwise, we need to setup by querying the BTree.
while (true)
{
if (StackEmpty)
{
throw new ApplicationException("Position out of bounds. p = " + posit);
}
// Pop the last stack frame,
StackFrame frame = StackPop();
NodeId nodePointer = frame.NodeId;
long leftSideOffset = frame.Offset;
int nodeChildIndex = frame.ChildIndex;
// Relative offset within this node
long relativeOffset = posit - leftSideOffset;
// If the node is not on the heap,
if (!IsHeapNode(nodePointer))
{
// The node is not on the heap. We optimize here.
// If we know the node is going to be a leaf node, we set up a
// temporary leaf node object with as much information as we know.
// Check if we know this is a leaf
int treeHeight = TreeHeight;
if (treeHeight != -1 &&
(stackSize / StackFrameSize) + 1 == treeHeight)
{
// Fetch the parent node,
frame = StackEnd(0);
NodeId twigNodePointer = frame.NodeId;
TreeBranch twig = (TreeBranch)FetchNode(twigNodePointer);
long leafSize =
twig.GetChildLeafElementCount(nodeChildIndex);
// This object holds off fetching the contents of the leaf node
// unless it's absolutely required.
TreeLeaf leaf =
new PlaceholderLeaf(ts, nodePointer, (int)leafSize);
currentLeaf = leaf;
StackPush(nodeChildIndex, leftSideOffset, nodePointer);
// Set up the leaf offset and return
leafOffset = (int)relativeOffset;
return;
}
}
// Fetch the node
ITreeNode node = FetchNode(nodePointer);
if (node is TreeLeaf)
{
// Node is a leaf node
TreeLeaf leaf = (TreeLeaf)node;
currentLeaf = leaf;
StackPush(nodeChildIndex, leftSideOffset, nodePointer);
// Set up the leaf offset and return
leafOffset = (int)relativeOffset;
// Update the tree_height value,
TreeHeight = stackSize / StackFrameSize;
return;
}
// Node is a branch node
TreeBranch branch = (TreeBranch)node;
int childIndex = branch.IndexOfChild(key, relativeOffset);
if (childIndex != -1)
{
// Push the current details,
StackPush(nodeChildIndex, leftSideOffset, nodePointer);
// Found child so push the details
StackPush(childIndex,
branch.GetChildOffset(childIndex) + leftSideOffset,
branch.GetChild(childIndex));
// Set up the left key
if (childIndex > 0)
{
currentLeafKey = branch.GetKey(childIndex);
}
}
} // while (true)
}