private void foundNodeToUpdate(BPlusTreeNode node, int keywordOffset, object additionalData)
 {
     node.ChildrenByteOffsets[keywordOffset] = (long)additionalData;
     // we know it won't split or relocate so we don't care about the parent...
     node.Write(null);
 }
        private void relocate(BPlusTreeNode parentNode)
        {
            // this node has outgrown its allotted space.
            // we need to move it to the end of the file and update everybody who points to it

            // so have to update the following:
            // 1. Parent node's pointer
            // 2. Left sibling's pointer
            // 3. Right sibling's pointer
            // 4. All children's parent pointer (which points at this node)

            _tree.Log("------------ BEGIN Relocating node ------------");
            _tree.Log("BEGIN Relocating node -> ".PadRight(50) + ToString());

            // get an abandoned node (or the end of the file, whichever comes first)
            BPlusAbandonedNode abandonedNode = _tree.GetNextAvailableNodeLocation(this);

            // mark this node as abandoned in the file (and remove from cache)
            _tree.AbandonNode(this);

            //if (this.IsRoot) {
            //    // we're relocating the root.
            //    _tree.Log("TODO: what to do here, if anything?");
            //}

            if (!IsLeaf)
            {
                // only leaf nodes should track left/right siblings.
                LeftSiblingFileOffset  = -1;
                RightSiblingFileOffset = -1;
            }

            if (LeftSiblingFileOffset > -1)
            {
                BPlusTreeNode originalLeftSibling = BPlusTreeNode.Read(_tree, this.LeftSiblingFileOffset, true);
                originalLeftSibling.RightSiblingFileOffset = originalLeftSibling.IsLeaf ? abandonedNode.FileOffset : -1;
                _tree.Log(("Updating left sibling node @ " + originalLeftSibling.FileOffset + " -> ").PadRight(50) + originalLeftSibling.ToString());
                originalLeftSibling.Write(null);
            }
            if (RightSiblingFileOffset > -1)
            {
                BPlusTreeNode originalRightSibling = BPlusTreeNode.Read(_tree, this.RightSiblingFileOffset, true);
                originalRightSibling.LeftSiblingFileOffset = originalRightSibling.IsLeaf ? abandonedNode.FileOffset : -1;
                _tree.Log(("Updating right sibling node @ " + originalRightSibling.FileOffset + " -> ").PadRight(50) + originalRightSibling.ToString());
                originalRightSibling.Write(null);
            }

            if (this.IsRoot)
            {
                // special case!  no parent means this is the root node.
                // update the int at the very beginning of the file to point at the new root node
                _tree.WriteRootNodeOffset(abandonedNode.FileOffset);
            }
            else
            {
                if (parentNode != null)
                {
                    for (int i = 0; i < parentNode.KeywordCount + 1; i++)
                    {
                        if (parentNode.ChildrenByteOffsets[i] == FileOffset)
                        {
                            parentNode.ChildrenByteOffsets[i] = abandonedNode.FileOffset;
                            _tree.Log(("Updating parent node @ " + parentNode.FileOffset + " -> ").PadRight(50) + parentNode.ToString());
                            parentNode.Write(null);
                            // the Root node is cached in the tree object -- udpate it if need be
                            if (parentNode.IsRoot)
                            {
                                _tree.Root = parentNode;
                            }
                            break;
                        }
                    }
                }
            }


            _tree.Writer.BaseStream.Position = abandonedNode.FileOffset;
            FileOffset = abandonedNode.FileOffset;
            //_chunkSize = abandonedNode.ByteCount;

            _tree.Log("END Relocating node (not written yet) -> ".PadRight(50) + ToString());
            _tree.Log("------------ END Relocating node ------------");
        }
        internal BPlusTreeNode SplitChild(int childOffset, BPlusTreeNode originalChild, BPlusTreeNode grandParent)
        {
            // Split the current node into two nodes:
            //   a. Left node contains all pointers/keywords to the left of the median
            //   b. Right node contains all pointers/keywords to the right of the median
            //   c. Parent node gets median keyword pushed into it
            //
            // Disk-wise: the originalChild is always written back to its original position.
            //            the newChild is placed into either an available abandoned node or tacked on the end of the file.
            //            the parent node is written back to its original position IF IT FITS.  Since we're coyping a keyword
            //               up into the parent node, it may cause it to outgrow its allocated size in the file.  If this occurs,
            //               the call to this.Write() implicitly calls relocate().  relocate() will then either write the parent to
            //               an abandoned node or tack it onto the end of the file.

            _tree.Log("------------ BEGIN Splitting node ------------");
            _tree.Log("BEGIN Splitting node parent -> ".PadRight(50) + ToString());
            _tree.Log("BEGIN Splitting node child -> ".PadRight(50) + originalChild.ToString());

            BPlusTreeNode newChild = BPlusTreeNode.CreateNode(_tree);

            newChild.IsLeaf = originalChild.IsLeaf;

            newChild.KeywordCount = _tree.Fanout - _tree.MinimumChildren;

            // assign items left of median
            for (int i = 0; i < newChild.KeywordCount; i++)
            {
                // Left half of original child already has appropriate values
                // However, left half of new child needs data from right half of original child
                newChild.ChildrenByteOffsets[i] = originalChild.ChildrenByteOffsets[i + _tree.Median + 1];
                newChild.Keywords[i]            = originalChild.Keywords[i + _tree.Median + 1];
            }
            newChild.ChildrenByteOffsets[newChild.KeywordCount] = originalChild.ChildrenByteOffsets[_tree.Fanout];

            // adjust the new child's relative info as needed (we always add to the right)
            if (originalChild.IsLeaf)
            {
                // only leaves should track siblings
                newChild.LeftSiblingFileOffset  = originalChild.FileOffset;
                newChild.RightSiblingFileOffset = originalChild.RightSiblingFileOffset;
            }
            else
            {
                newChild.LeftSiblingFileOffset  = -1;
                newChild.RightSiblingFileOffset = -1;
            }


            // make room in parent for the median values
            // (copy all those above the childOffset over one)

            for (int i = KeywordCount; i > childOffset; i--)
            {
                ChildrenByteOffsets[i + 1] = ChildrenByteOffsets[i];
                Keywords[i] = Keywords[i - 1];
            }
            KeywordCount++;

            Keywords[childOffset] = originalChild.Keywords[_tree.Median];
            // just set byterange that points at our new child to the default for now.  we'll assign it the proper value later (once we know the true file offsets)
            ChildrenByteOffsets[childOffset + 1] = 0;

            // if we're splitting a leaf node, we must copy up the median value.
            // if we're splitting an index node, we must simply push it up (i.e. do not leave a copy in the original child)
            int startErasingAt = _tree.MinimumChildren;

            if (!originalChild.IsLeaf)
            {
                // index node, erase the keyword (as we essentially want to push it up)
                startErasingAt--;
            }

            // assign items right of median (note this effectively means we copy up the median value, not move it up)
            for (int i = startErasingAt; i < _tree.Fanout; i++)
            {
                // Left half of newChild already has proper values (nulls/defaults)
                // However, right half of originalChild still has the values we just copied to the left half of newChild.
                // null/default those values.
                if (originalChild.IsLeaf || i > startErasingAt)
                {
                    originalChild.ChildrenByteOffsets[i] = 0;
                }
                originalChild.Keywords[i] = String.Empty;
            }
            // there's always one more child than keyword...
            originalChild.ChildrenByteOffsets[_tree.Fanout] = 0;
            originalChild.KeywordCount = startErasingAt;

            // determine where to put this new child (in an abandoned node or tack onto end of file)
            BPlusAbandonedNode abandonedNode = _tree.GetNextAvailableNodeLocation(newChild);

            //newChild._chunkSize = abandonedNode.ByteCount;
            newChild.FileOffset = abandonedNode.FileOffset;

            newChild.Write(this);


            // the original child's right sibling must be updated to point at the new child instead
            if (originalChild.RightSiblingFileOffset > 0 && originalChild.IsLeaf)
            {
                BPlusTreeNode originalRightSibling = BPlusTreeNode.Read(_tree, originalChild.RightSiblingFileOffset, true);
                originalRightSibling.LeftSiblingFileOffset = newChild.FileOffset;
                originalRightSibling.Write(null);
            }



            // now that we've written the new child out,
            // we know what to set the originalChild's right sibling to...
            if (originalChild.IsLeaf)
            {
                originalChild.RightSiblingFileOffset = newChild.FileOffset;
            }
            originalChild.Write(this);


            // we now know all the offsets we need to update in the parent...
            ChildrenByteOffsets[childOffset]     = originalChild.FileOffset;
            ChildrenByteOffsets[childOffset + 1] = newChild.FileOffset;

            // this node may relocate because we're adding a keyword to it.
            // if it does, we have to be sure our direct parent knows about it (so it can update its child file offset that points to us)
            // hence the "grandParentNode".  Write() handles updating things correctly if we give it our parent (which is our children's grandparent) :)
            if (Write(grandParent))
            {
                //Debug.WriteLine("would have missed this before");
            }

            _tree.Log("END Splitting node parent -> ".PadRight(50) + ToString());
            _tree.Log("END Splitting node. original child -> ".PadRight(50) + originalChild.ToString());
            _tree.Log("END Splitting node. new child -> ".PadRight(50) + newChild.ToString());
            _tree.Log("------------ END Splitting node ------------");

            return(newChild);



            /*
             * newChild <- Allocate-Node()
             * leaf[newChild] <- leaf[parent]
             * n[newChild] <- t - 1
             * for j <- 1 to t - 1
             *       do keyj[newChild] <- keyj+t[parent]
             * if not leaf[parent]
             *       then for j <- 1 to t
             *                do cj[newChild] <- cj+t[parent]
             * n[parent] <- t - 1
             * for j <- n[originalChild] + 1 downto i + 1
             *       do cj+1[originalChild] <- cj[originalChild]
             * ci+1 <- newChild
             * for j <- n[originalChild] downto i
             *       do keyj+1[originalChild] <- keyj[originalChild]
             * keyi[originalChild] <- keyt[parent]
             * n[originalChild] <- n[originalChild] + 1
             * Disk-Write(parent)
             * Disk-Write(newChild)
             * Disk-Write(originalChild)
             *
             */
        }
        // here's the vernacular:
        // The _keywords array represents all the keywords in this node.
        // The _byteRanges array represents all the file offsets in this node for either (a) a keyword or (b) the data itself.
        //   a. If it is located in an index node (i.e. non-Leaf), the byte range represents the start/end offsets in the index file (used for traversing to other nodes)
        //   b. If it is located in a Leaf node, the byte range represents the start/end offsets in the data file (for looking up associated hit(s))


        // Think ByteRange = pointer to next node or data, Keyword = item we're searching by
        // So we always have 1 more pointer (or byterange, BR) than search item (or keyword, K):
        //
        // |-------- Node ---------|
        // |      go       pi      |
        // |  /   |    |   |    \  |
        // | BR1  K1  BR2  K2  BR3 |
        // |-----------------------|


        /// <summary>
        /// Creates a new root node for the tree and makes the original root the first child of the new root.
        /// </summary>
        /// <param name="tree"></param>
        /// <returns></returns>
        internal static BPlusTreeNode ReplaceRoot(BPlusTree tree, BPlusTreeNode originalRoot, string keyword, long dataByteOffset)
        {
            // NOTE: This is a very special case.
            // replacing the root involves creating 2 new nodes:
            //  1. the new root node
            //  2. splitting the existing root node into 2 nodes, one of which is a new one

            BPlusTreeNode newRoot = null;

            // create a new root node, mark it as not a leaf, put it in exact same spot as original root
            newRoot = new BPlusTreeNode {
                IsLeaf                 = false,
                _tree                  = tree,
                Keywords               = new string[tree.Fanout],
                ChildrenByteOffsets    = new long[tree.Fanout + 1],
                KeywordCount           = 0,
                FileOffset             = -1,
                LeftSiblingFileOffset  = -1,
                RightSiblingFileOffset = -1,
            };

            tree.Log("------------ BEGIN Replacing root ------------");
            tree.Log("BEGIN Replacing root. original node -> ".PadRight(50) + originalRoot.ToString());
            tree.Log("BEGIN Replacing root. new node -> ".PadRight(50) + newRoot.ToString());


            // add our new root to file, update the root node pointer
            BPlusAbandonedNode abandoned = tree.GetNextAvailableNodeLocation(originalRoot);

            newRoot.FileOffset = abandoned.FileOffset;
            newRoot.Write(null);
            tree.WriteRootNodeOffset(newRoot.FileOffset);


            // trickle-down insert the new keyword/data
            if (!String.IsNullOrEmpty(keyword))
            {
                // split the original
                BPlusTreeNode newChild = newRoot.SplitChild(0, originalRoot, null);

                tree.Log("CONTINUE Replacing root. new child node -> ".PadRight(50) + originalRoot.ToString());


                if (newRoot.Insert(keyword, dataByteOffset, null))
                {
                    // the new root was relocated during insertion (outgrew its allotted space)
                    // the insert should take care of it

                    // re-read it in just in case
                    newRoot = BPlusTreeNode.Read(tree, newRoot.FileOffset, true);
                }
            }
            else
            {
                newRoot = BPlusTreeNode.Read(tree, newRoot.FileOffset, true);
            }


            tree.Log("END Replacing root. original node -> ".PadRight(50) + originalRoot.ToString());
            //			_tree.Log("END Replacing root. new child node -> ".PadRight(50) + newChild.ToString());
            tree.Log("END Replacing root. new root -> ".PadRight(50) + newRoot.ToString());
            tree.Log("------------ END Replacing root ------------");

            return(newRoot);
        }