public static MemoryTreeNode FindLastLeaf(TreeFile TreeFile, MemoryTreeNode currentNode = null)
        {
            if (currentNode == null)
            {
                currentNode = TreeFile.RootCache;
            }

            NodePointer pointer = new NodePointer();
            var         key     = KeyFinder.FindLastKey(currentNode.TreeNode.KeyArray, TreeFile.comparer);

            if (key == null)
            {
                pointer.PointerBytes = currentNode.TreeNode.PreviousPointer;
            }
            else
            {
                pointer = currentNode.TreeNode.FindPointer(key);
            }


            if (pointer.PositionPointer > 0 && pointer.Indicator != EnumValues.TypeIndicator.leaf)
            {
                MemoryTreeNode newcachenode = GetOrLoadNode(TreeFile, currentNode, pointer);
                return(FindLastLeaf(TreeFile, newcachenode));
            }

            ///find the leaf that contains the key.
            if (pointer.PointerBytes != null && pointer.PositionPointer > 0 && pointer.Indicator == EnumValues.TypeIndicator.leaf)
            {
                MemoryTreeNode newcacheleaf = GetOrLoadNode(TreeFile, currentNode, pointer);
                return(newcacheleaf);
            }
            return(null);
        }
Exemple #2
0
        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);
        }