Ejemplo n.º 1
0
        internal LeafNode HigherNode(uint key)
        {
            XFastNode ancestor = Bottom(key);

            if (ancestor == null)
            {
                return(null);
            }
            LeafNode leaf = ancestor.left as LeafNode;

            if (leaf != null && leaf.key > key)
            {
                return(leaf);
            }
            leaf = ancestor.right as LeafNode;
            if (leaf != null && leaf.key > key)
            {
                return(leaf);
            }
            leaf = ancestor.right.right as LeafNode;
            if (leaf != null && leaf.key > key)
            {
                return(leaf);
            }
            return(null);
        }
Ejemplo n.º 2
0
 private void InsertLeafAfter(XFastNode marker, LeafNode newLeaf)
 {
     if (marker == null)
     {
         if (leafList == null)
         {
             leafList      = newLeaf;
             newLeaf.left  = newLeaf;
             newLeaf.right = newLeaf;
         }
         else
         {
             XFastNode rightNode = leafList;
             leafList.left.right = newLeaf;
             newLeaf.left        = leafList.left;
             newLeaf.right       = leafList;
             leafList.left       = newLeaf;
             leafList            = newLeaf;
         }
     }
     else
     {
         XFastNode rightNode = marker.right;
         marker.right   = newLeaf;
         newLeaf.left   = marker;
         newLeaf.right  = rightNode;
         rightNode.left = newLeaf;
     }
 }
Ejemplo n.º 3
0
        private XFastNode Bottom(uint key)
        {
            int       l = 0;
            int       h = width;
            XFastNode tempNode;
            XFastNode correctNode = null;

            do
            {
                int  j        = (l + h) / 2;
                uint ancestor = key >> (width - 1 - j) >> 1;
                if (table[j].TryGetValue(ancestor, out tempNode))
                {
                    l           = j + 1;
                    correctNode = tempNode;
                }
                else
                {
                    h = j;
                }
            }while (l < h);
            return(correctNode);
        }
Ejemplo n.º 4
0
        private LeafNode LowerNodeFromBottom(XFastNode bottom, uint key)
        {
            if (bottom == null)
            {
                return(null);
            }
            LeafNode leaf = bottom.right as LeafNode;

            if (leaf != null && leaf.key < key)
            {
                return(leaf);
            }
            leaf = bottom.left as LeafNode;
            if (leaf != null && leaf.key < key)
            {
                return(leaf);
            }
            leaf = bottom.left.left as LeafNode;
            if (leaf != null && leaf.key < key)
            {
                return(leaf);
            }
            return(null);
        }
Ejemplo n.º 5
0
        public override bool Remove(uint key)
        {
            var bottom = Bottom(key);

            if (bottom == null)
            {
                return(false);
            }
            // get the leaf node in endNode
            LeafNode endNode = bottom.left as LeafNode;

            if (endNode == null || endNode.key != key)
            {
                endNode = bottom.right as LeafNode;
                if (endNode == null || endNode.key != key)
                {
                    return(false);
                }
            }
            // get pointers to node elft and right from endNode
            XFastNode leftLeaf  = endNode.left;
            XFastNode rightLeaf = endNode.right;

            // remove bottom node from the table and leaf node from the list
            //table[width - 1].Remove(key >> 1);
            RemoveLeaf(endNode);
            // iterate levels
            bool single = true;

            for (int i = width - 1; i >= 0; i--)
            {
                XFastNode current;
                uint      id          = key >> (width - 1 - i) >> 1;
                bool      isFromRight = ((key >> (width - 1 - i)) & 1) == 1;
                table[i].TryGetValue(id, out current);
                // remove the node
                if (single)
                {
                    if (isFromRight && (!(current.left is LeafNode) || (i == (width - 1) && ((LeafNode)current.left).key != key)))
                    {
                        current.right = leftLeaf;
                        single        = false;
                    }
                    else if (!isFromRight && (!(current.right is LeafNode) || (i == (width - 1) && ((LeafNode)current.right).key != key)))
                    {
                        current.left = rightLeaf;
                        single       = false;
                    }
                    else
                    {
                        table[i].Remove(id);
                    }
                }
                // fix jump pointers
                else
                {
                    if (current.left == endNode)
                    {
                        current.left = rightLeaf;
                    }
                    else if (current.right == endNode)
                    {
                        current.right = leftLeaf;
                    }
                }
            }
            count--;
            version++;
            return(true);
        }
Ejemplo n.º 6
0
        private void AddChecked(uint key, T value, bool overwrite)
        {
            // Insert node in linked list
            XFastNode bottom      = Bottom(key);
            LeafNode  predecessor = LowerNodeFromBottom(bottom, key);
            // check for overwrite
            LeafNode predRight;

            if (predecessor != null)
            {
                predRight = (LeafNode)predecessor.right;
            }
            else
            {
                predRight = leafList;
            }
            if (predRight != null && predRight.key == key)
            {
                if (!overwrite)
                {
                    throw new ArgumentException();
                }
                else
                {
                    predRight.value = value;
                    return;
                }
            }
            count++;
            version++;
            // merrily continue
            LeafNode endNode = new LeafNode()
            {
                key = key, value = value
            };

            InsertLeafAfter(predecessor, endNode);
            // Fix the jump path
            if (bottom == null)
            {
                bottom = new XFastNode();
                table[0].Add(0, bottom);
                bottom.left  = endNode;
                bottom.right = endNode;
            }

            XFastNode oldNode = null;
            XFastNode current;

            for (int i = 0; i < width; i++)
            {
                uint id = key >> (width - 1 - i) >> 1;
                if (table[i].TryGetValue(id, out current))
                {
                    // fix the jump path
                    LeafNode leaf = current.left as LeafNode;
                    if (leaf != null && leaf.key > key)
                    {
                        current.left = endNode;
                    }
                    else
                    {
                        leaf = current.right as LeafNode;
                        if (leaf != null && leaf.key < key)
                        {
                            current.right = endNode;
                        }
                    }
                }
                else
                {
                    // insert new node
                    current = new XFastNode()
                    {
                        left = endNode, right = endNode
                    };
                    table[i].Add(id, current);
                    // fix link between old and new node
                    if ((id & 1) > 0)
                    {
                        oldNode.right = current;
                    }
                    else
                    {
                        oldNode.left = current;
                    }
                }
                oldNode = current;
            }
        }
Ejemplo n.º 7
0
        internal LeafNode LowerNode(uint key)
        {
            XFastNode ancestor = Bottom(key);

            return(LowerNodeFromBottom(ancestor, key));
        }