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)); }