private static MemoryTreeNode FindContainerLastLeaf(TreeFile TreeFile, MemoryTreeNode ContainerNode)
{
if (ContainerNode == null)
{
return(null);
}
if (ContainerNode.TreeNode.TypeIndicator == EnumValues.TypeIndicator.leaf)
{
return(ContainerNode);
}
// did not get return, try one key by one key.
byte[] key = KeyFinder.FindLastKey(ContainerNode.TreeNode.KeyArray, TreeFile.comparer);
while (key != null)
{
var nodepointer = ContainerNode.TreeNode.FindPointer(key);
if (nodepointer != null && nodepointer.PositionPointer > 0)
{
var keynode = GetOrLoadNode(TreeFile, ContainerNode, nodepointer);
if (keynode != null)
{
var result = FindContainerFirstLeaf(TreeFile, keynode);
if (result != null)
{
return(result);
}
}
}
key = KeyFinder.FindBiggestSmallerKey(key, ContainerNode.TreeNode.KeyArray, TreeFile.comparer);
}
NodePointer pointer = new NodePointer();
pointer.PointerBytes = ContainerNode.TreeNode.PreviousPointer;
if (pointer.PositionPointer > 0)
{
var subnode = GetOrLoadNode(TreeFile, ContainerNode, pointer);
if (subnode != null)
{
var result = FindContainerFirstLeaf(TreeFile, subnode);
if (result != null)
{
return(result);
}
}
}
return(null);
}
private static MemoryTreeNode GetUpLinkLastLeaf(TreeFile TreeFile, MemoryTreeNode ParentNode)
{
if (ParentNode.TreeNode.TypeIndicator == EnumValues.TypeIndicator.root)
{
return(null);
}
MemoryTreeNode siblingNode;
byte[] siblingkey = KeyFinder.FindBiggestSmallerKey(ParentNode.ParentNodeKey, ParentNode.Parent.TreeNode.KeyArray, TreeFile.comparer);
while (siblingkey != null)
{
var pointer = ParentNode.Parent.TreeNode.FindPointer(siblingkey);
if (pointer != null && pointer.PositionPointer > 0)
{
siblingNode = GetOrLoadNode(TreeFile, ParentNode.Parent, pointer);
var result = FindContainerLastLeaf(TreeFile, siblingNode);
if (result != null)
{
return(result);
}
}
siblingkey = KeyFinder.FindBiggestSmallerKey(siblingkey, ParentNode.Parent.TreeNode.KeyArray, TreeFile.comparer);
}
/// need to check the first previous pointer after process all key arrays.
NodePointer previousPointer = new NodePointer();
previousPointer.PointerBytes = ParentNode.Parent.TreeNode.PreviousPointer;
var PreviousPointerNode = GetOrLoadNode(TreeFile, ParentNode.Parent, previousPointer);
//parentNode.Parent.PreviousPointerNode can't be the same with ParentNode,otherwise it will cause a dead cycle.
if (PreviousPointerNode != null && ParentNode != PreviousPointerNode)
{
var result = FindContainerLastLeaf(TreeFile, PreviousPointerNode);
if (result != null)
{
return(result);
}
}
return(GetUpLinkLastLeaf(TreeFile, ParentNode.Parent));
}
public static MemoryTreeNode FindPreviousLeaf(TreeFile TreeFile, MemoryTreeNode CurrentLeaf)
{
if (CurrentLeaf.TreeNode.TypeIndicator != EnumValues.TypeIndicator.leaf)
{
throw new Exception("this method only accept leaf");
}
if (CurrentLeaf.IsParentPreviousPointer && CurrentLeaf.ParentNodeKey == null)
{
return(GetUpLinkLastLeaf(TreeFile, CurrentLeaf.Parent));
}
byte[] key = KeyFinder.FindBiggestSmallerKey(CurrentLeaf.ParentNodeKey, CurrentLeaf.Parent.TreeNode.KeyArray, TreeFile.comparer);
while (key != null)
{
var pointer = CurrentLeaf.Parent.TreeNode.FindPointer(key);
if (pointer != null && pointer.PositionPointer > 0)
{
var nextleaf = GetOrLoadNode(TreeFile, CurrentLeaf.Parent, pointer);
if (nextleaf != null && nextleaf.TreeNode.TypeIndicator == EnumValues.TypeIndicator.leaf)
{
return(nextleaf);
}
}
key = KeyFinder.FindBiggestSmallerKey(key, CurrentLeaf.Parent.TreeNode.KeyArray, TreeFile.comparer);
}
// check the previous pointer.
NodePointer previousPointer = new NodePointer();
previousPointer.PointerBytes = CurrentLeaf.Parent.TreeNode.PreviousPointer;
var PreviousPointerLeaf = GetOrLoadNode(TreeFile, CurrentLeaf.Parent, previousPointer);
if (PreviousPointerLeaf != null && PreviousPointerLeaf.TreeNode.TypeIndicator == EnumValues.TypeIndicator.leaf)
{
return(PreviousPointerLeaf);
}
return(GetUpLinkLastLeaf(TreeFile, CurrentLeaf.Parent));
}
