| ------------------------------------------------------------------------------ |
| -- -- |
| -- GNAT LIBRARY COMPONENTS -- |
| -- -- |
| -- ADA.CONTAINERS.RED_BLACK_TREES.GENERIC_KEYS -- |
| -- -- |
| -- B o d y -- |
| -- -- |
| -- Copyright (C) 2004-2013, Free Software Foundation, Inc. -- |
| -- -- |
| -- GNAT is free software; you can redistribute it and/or modify it under -- |
| -- terms of the GNU General Public License as published by the Free Soft- -- |
| -- ware Foundation; either version 3, or (at your option) any later ver- -- |
| -- sion. GNAT is distributed in the hope that it will be useful, but WITH- -- |
| -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY -- |
| -- or FITNESS FOR A PARTICULAR PURPOSE. -- |
| -- -- |
| -- As a special exception under Section 7 of GPL version 3, you are granted -- |
| -- additional permissions described in the GCC Runtime Library Exception, -- |
| -- version 3.1, as published by the Free Software Foundation. -- |
| -- -- |
| -- You should have received a copy of the GNU General Public License and -- |
| -- a copy of the GCC Runtime Library Exception along with this program; -- |
| -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see -- |
| -- <http://www.gnu.org/licenses/>. -- |
| -- -- |
| -- This unit was originally developed by Matthew J Heaney. -- |
| ------------------------------------------------------------------------------ |
| |
| package body Ada.Containers.Red_Black_Trees.Generic_Keys is |
| |
| package Ops renames Tree_Operations; |
| |
| ------------- |
| -- Ceiling -- |
| ------------- |
| |
| -- AKA Lower_Bound |
| |
| function Ceiling (Tree : Tree_Type; Key : Key_Type) return Node_Access is |
| B : Natural renames Tree'Unrestricted_Access.Busy; |
| L : Natural renames Tree'Unrestricted_Access.Lock; |
| |
| Y : Node_Access; |
| X : Node_Access; |
| |
| begin |
| -- If the container is empty, return a result immediately, so that we do |
| -- not manipulate the tamper bits unnecessarily. |
| |
| if Tree.Root = null then |
| return null; |
| end if; |
| |
| -- Per AI05-0022, the container implementation is required to detect |
| -- element tampering by a generic actual subprogram. |
| |
| B := B + 1; |
| L := L + 1; |
| |
| X := Tree.Root; |
| while X /= null loop |
| if Is_Greater_Key_Node (Key, X) then |
| X := Ops.Right (X); |
| else |
| Y := X; |
| X := Ops.Left (X); |
| end if; |
| end loop; |
| |
| B := B - 1; |
| L := L - 1; |
| |
| return Y; |
| |
| exception |
| when others => |
| B := B - 1; |
| L := L - 1; |
| |
| raise; |
| end Ceiling; |
| |
| ---------- |
| -- Find -- |
| ---------- |
| |
| function Find (Tree : Tree_Type; Key : Key_Type) return Node_Access is |
| B : Natural renames Tree'Unrestricted_Access.Busy; |
| L : Natural renames Tree'Unrestricted_Access.Lock; |
| |
| Y : Node_Access; |
| X : Node_Access; |
| |
| Result : Node_Access; |
| |
| begin |
| -- If the container is empty, return a result immediately, so that we do |
| -- not manipulate the tamper bits unnecessarily. |
| |
| if Tree.Root = null then |
| return null; |
| end if; |
| |
| -- Per AI05-0022, the container implementation is required to detect |
| -- element tampering by a generic actual subprogram. |
| |
| B := B + 1; |
| L := L + 1; |
| |
| X := Tree.Root; |
| while X /= null loop |
| if Is_Greater_Key_Node (Key, X) then |
| X := Ops.Right (X); |
| else |
| Y := X; |
| X := Ops.Left (X); |
| end if; |
| end loop; |
| |
| if Y = null then |
| Result := null; |
| |
| elsif Is_Less_Key_Node (Key, Y) then |
| Result := null; |
| |
| else |
| Result := Y; |
| end if; |
| |
| B := B - 1; |
| L := L - 1; |
| |
| return Result; |
| |
| exception |
| when others => |
| B := B - 1; |
| L := L - 1; |
| |
| raise; |
| end Find; |
| |
| ----------- |
| -- Floor -- |
| ----------- |
| |
| function Floor (Tree : Tree_Type; Key : Key_Type) return Node_Access is |
| B : Natural renames Tree'Unrestricted_Access.Busy; |
| L : Natural renames Tree'Unrestricted_Access.Lock; |
| |
| Y : Node_Access; |
| X : Node_Access; |
| |
| begin |
| -- If the container is empty, return a result immediately, so that we do |
| -- not manipulate the tamper bits unnecessarily. |
| |
| if Tree.Root = null then |
| return null; |
| end if; |
| |
| -- Per AI05-0022, the container implementation is required to detect |
| -- element tampering by a generic actual subprogram. |
| |
| B := B + 1; |
| L := L + 1; |
| |
| X := Tree.Root; |
| while X /= null loop |
| if Is_Less_Key_Node (Key, X) then |
| X := Ops.Left (X); |
| else |
| Y := X; |
| X := Ops.Right (X); |
| end if; |
| end loop; |
| |
| B := B - 1; |
| L := L - 1; |
| |
| return Y; |
| |
| exception |
| when others => |
| B := B - 1; |
| L := L - 1; |
| |
| raise; |
| end Floor; |
| |
| -------------------------------- |
| -- Generic_Conditional_Insert -- |
| -------------------------------- |
| |
| procedure Generic_Conditional_Insert |
| (Tree : in out Tree_Type; |
| Key : Key_Type; |
| Node : out Node_Access; |
| Inserted : out Boolean) |
| is |
| X : Node_Access; |
| Y : Node_Access; |
| |
| -- Per AI05-0022, the container implementation is required to detect |
| -- element tampering by a generic actual subprogram. |
| |
| B : Natural renames Tree.Busy; |
| L : Natural renames Tree.Lock; |
| |
| Compare : Boolean; |
| |
| begin |
| -- This is a "conditional" insertion, meaning that the insertion request |
| -- can "fail" in the sense that no new node is created. If the Key is |
| -- equivalent to an existing node, then we return the existing node and |
| -- Inserted is set to False. Otherwise, we allocate a new node (via |
| -- Insert_Post) and Inserted is set to True. |
| |
| -- Note that we are testing for equivalence here, not equality. Key must |
| -- be strictly less than its next neighbor, and strictly greater than |
| -- its previous neighbor, in order for the conditional insertion to |
| -- succeed. |
| |
| -- Handle insertion into an empty container as a special case, so that |
| -- we do not manipulate the tamper bits unnecessarily. |
| |
| if Tree.Root = null then |
| Insert_Post (Tree, null, True, Node); |
| Inserted := True; |
| return; |
| end if; |
| |
| -- We search the tree to find the nearest neighbor of Key, which is |
| -- either the smallest node greater than Key (Inserted is True), or the |
| -- largest node less or equivalent to Key (Inserted is False). |
| |
| begin |
| B := B + 1; |
| L := L + 1; |
| |
| X := Tree.Root; |
| Y := null; |
| Inserted := True; |
| while X /= null loop |
| Y := X; |
| Inserted := Is_Less_Key_Node (Key, X); |
| X := (if Inserted then Ops.Left (X) else Ops.Right (X)); |
| end loop; |
| |
| L := L - 1; |
| B := B - 1; |
| |
| exception |
| when others => |
| L := L - 1; |
| B := B - 1; |
| |
| raise; |
| end; |
| |
| if Inserted then |
| |
| -- Key is less than Y. If Y is the first node in the tree, then there |
| -- are no other nodes that we need to search for, and we insert a new |
| -- node into the tree. |
| |
| if Y = Tree.First then |
| Insert_Post (Tree, Y, True, Node); |
| return; |
| end if; |
| |
| -- Y is the next nearest-neighbor of Key. We know that Key is not |
| -- equivalent to Y (because Key is strictly less than Y), so we move |
| -- to the previous node, the nearest-neighbor just smaller or |
| -- equivalent to Key. |
| |
| Node := Ops.Previous (Y); |
| |
| else |
| -- Y is the previous nearest-neighbor of Key. We know that Key is not |
| -- less than Y, which means either that Key is equivalent to Y, or |
| -- greater than Y. |
| |
| Node := Y; |
| end if; |
| |
| -- Key is equivalent to or greater than Node. We must resolve which is |
| -- the case, to determine whether the conditional insertion succeeds. |
| |
| begin |
| B := B + 1; |
| L := L + 1; |
| |
| Compare := Is_Greater_Key_Node (Key, Node); |
| |
| L := L - 1; |
| B := B - 1; |
| |
| exception |
| when others => |
| L := L - 1; |
| B := B - 1; |
| |
| raise; |
| end; |
| |
| if Compare then |
| |
| -- Key is strictly greater than Node, which means that Key is not |
| -- equivalent to Node. In this case, the insertion succeeds, and we |
| -- insert a new node into the tree. |
| |
| Insert_Post (Tree, Y, Inserted, Node); |
| Inserted := True; |
| return; |
| end if; |
| |
| -- Key is equivalent to Node. This is a conditional insertion, so we do |
| -- not insert a new node in this case. We return the existing node and |
| -- report that no insertion has occurred. |
| |
| Inserted := False; |
| end Generic_Conditional_Insert; |
| |
| ------------------------------------------ |
| -- Generic_Conditional_Insert_With_Hint -- |
| ------------------------------------------ |
| |
| procedure Generic_Conditional_Insert_With_Hint |
| (Tree : in out Tree_Type; |
| Position : Node_Access; |
| Key : Key_Type; |
| Node : out Node_Access; |
| Inserted : out Boolean) |
| is |
| -- Per AI05-0022, the container implementation is required to detect |
| -- element tampering by a generic actual subprogram. |
| |
| B : Natural renames Tree.Busy; |
| L : Natural renames Tree.Lock; |
| |
| Test : Node_Access; |
| Compare : Boolean; |
| |
| begin |
| -- The purpose of a hint is to avoid a search from the root of |
| -- tree. If we have it hint it means we only need to traverse the |
| -- subtree rooted at the hint to find the nearest neighbor. Note |
| -- that finding the neighbor means merely walking the tree; this |
| -- is not a search and the only comparisons that occur are with |
| -- the hint and its neighbor. |
| |
| -- Handle insertion into an empty container as a special case, so that |
| -- we do not manipulate the tamper bits unnecessarily. |
| |
| if Tree.Root = null then |
| Insert_Post (Tree, null, True, Node); |
| Inserted := True; |
| return; |
| end if; |
| |
| -- If Position is null, this is interpreted to mean that Key is large |
| -- relative to the nodes in the tree. If Key is greater than the last |
| -- node in the tree, then we're done; otherwise the hint was "wrong" and |
| -- we must search. |
| |
| if Position = null then -- largest |
| begin |
| B := B + 1; |
| L := L + 1; |
| |
| Compare := Is_Greater_Key_Node (Key, Tree.Last); |
| |
| L := L - 1; |
| B := B - 1; |
| |
| exception |
| when others => |
| L := L - 1; |
| B := B - 1; |
| |
| raise; |
| end; |
| |
| if Compare then |
| Insert_Post (Tree, Tree.Last, False, Node); |
| Inserted := True; |
| else |
| Conditional_Insert_Sans_Hint (Tree, Key, Node, Inserted); |
| end if; |
| |
| return; |
| end if; |
| |
| pragma Assert (Tree.Length > 0); |
| |
| -- A hint can either name the node that immediately follows Key, |
| -- or immediately precedes Key. We first test whether Key is |
| -- less than the hint, and if so we compare Key to the node that |
| -- precedes the hint. If Key is both less than the hint and |
| -- greater than the hint's preceding neighbor, then we're done; |
| -- otherwise we must search. |
| |
| -- Note also that a hint can either be an anterior node or a leaf |
| -- node. A new node is always inserted at the bottom of the tree |
| -- (at least prior to rebalancing), becoming the new left or |
| -- right child of leaf node (which prior to the insertion must |
| -- necessarily be null, since this is a leaf). If the hint names |
| -- an anterior node then its neighbor must be a leaf, and so |
| -- (here) we insert after the neighbor. If the hint names a leaf |
| -- then its neighbor must be anterior and so we insert before the |
| -- hint. |
| |
| begin |
| B := B + 1; |
| L := L + 1; |
| |
| Compare := Is_Less_Key_Node (Key, Position); |
| |
| L := L - 1; |
| B := B - 1; |
| |
| exception |
| when others => |
| L := L - 1; |
| B := B - 1; |
| |
| raise; |
| end; |
| |
| if Compare then |
| Test := Ops.Previous (Position); -- "before" |
| |
| if Test = null then -- new first node |
| Insert_Post (Tree, Tree.First, True, Node); |
| |
| Inserted := True; |
| return; |
| end if; |
| |
| begin |
| B := B + 1; |
| L := L + 1; |
| |
| Compare := Is_Greater_Key_Node (Key, Test); |
| |
| L := L - 1; |
| B := B - 1; |
| |
| exception |
| when others => |
| L := L - 1; |
| B := B - 1; |
| |
| raise; |
| end; |
| |
| if Compare then |
| if Ops.Right (Test) = null then |
| Insert_Post (Tree, Test, False, Node); |
| else |
| Insert_Post (Tree, Position, True, Node); |
| end if; |
| |
| Inserted := True; |
| |
| else |
| Conditional_Insert_Sans_Hint (Tree, Key, Node, Inserted); |
| end if; |
| |
| return; |
| end if; |
| |
| -- We know that Key isn't less than the hint so we try again, this time |
| -- to see if it's greater than the hint. If so we compare Key to the |
| -- node that follows the hint. If Key is both greater than the hint and |
| -- less than the hint's next neighbor, then we're done; otherwise we |
| -- must search. |
| |
| begin |
| B := B + 1; |
| L := L + 1; |
| |
| Compare := Is_Greater_Key_Node (Key, Position); |
| |
| L := L - 1; |
| B := B - 1; |
| |
| exception |
| when others => |
| L := L - 1; |
| B := B - 1; |
| |
| raise; |
| end; |
| |
| if Compare then |
| Test := Ops.Next (Position); -- "after" |
| |
| if Test = null then -- new last node |
| Insert_Post (Tree, Tree.Last, False, Node); |
| |
| Inserted := True; |
| return; |
| end if; |
| |
| begin |
| B := B + 1; |
| L := L + 1; |
| |
| Compare := Is_Less_Key_Node (Key, Test); |
| |
| L := L - 1; |
| B := B - 1; |
| |
| exception |
| when others => |
| L := L - 1; |
| B := B - 1; |
| |
| raise; |
| end; |
| |
| if Compare then |
| if Ops.Right (Position) = null then |
| Insert_Post (Tree, Position, False, Node); |
| else |
| Insert_Post (Tree, Test, True, Node); |
| end if; |
| |
| Inserted := True; |
| |
| else |
| Conditional_Insert_Sans_Hint (Tree, Key, Node, Inserted); |
| end if; |
| |
| return; |
| end if; |
| |
| -- We know that Key is neither less than the hint nor greater than the |
| -- hint, and that's the definition of equivalence. There's nothing else |
| -- we need to do, since a search would just reach the same conclusion. |
| |
| Node := Position; |
| Inserted := False; |
| end Generic_Conditional_Insert_With_Hint; |
| |
| ------------------------- |
| -- Generic_Insert_Post -- |
| ------------------------- |
| |
| procedure Generic_Insert_Post |
| (Tree : in out Tree_Type; |
| Y : Node_Access; |
| Before : Boolean; |
| Z : out Node_Access) |
| is |
| begin |
| if Tree.Length = Count_Type'Last then |
| raise Constraint_Error with "too many elements"; |
| end if; |
| |
| if Tree.Busy > 0 then |
| raise Program_Error with |
| "attempt to tamper with cursors (container is busy)"; |
| end if; |
| |
| Z := New_Node; |
| pragma Assert (Z /= null); |
| pragma Assert (Ops.Color (Z) = Red); |
| |
| if Y = null then |
| pragma Assert (Tree.Length = 0); |
| pragma Assert (Tree.Root = null); |
| pragma Assert (Tree.First = null); |
| pragma Assert (Tree.Last = null); |
| |
| Tree.Root := Z; |
| Tree.First := Z; |
| Tree.Last := Z; |
| |
| elsif Before then |
| pragma Assert (Ops.Left (Y) = null); |
| |
| Ops.Set_Left (Y, Z); |
| |
| if Y = Tree.First then |
| Tree.First := Z; |
| end if; |
| |
| else |
| pragma Assert (Ops.Right (Y) = null); |
| |
| Ops.Set_Right (Y, Z); |
| |
| if Y = Tree.Last then |
| Tree.Last := Z; |
| end if; |
| end if; |
| |
| Ops.Set_Parent (Z, Y); |
| Ops.Rebalance_For_Insert (Tree, Z); |
| Tree.Length := Tree.Length + 1; |
| end Generic_Insert_Post; |
| |
| ----------------------- |
| -- Generic_Iteration -- |
| ----------------------- |
| |
| procedure Generic_Iteration |
| (Tree : Tree_Type; |
| Key : Key_Type) |
| is |
| procedure Iterate (Node : Node_Access); |
| |
| ------------- |
| -- Iterate -- |
| ------------- |
| |
| procedure Iterate (Node : Node_Access) is |
| N : Node_Access; |
| begin |
| N := Node; |
| while N /= null loop |
| if Is_Less_Key_Node (Key, N) then |
| N := Ops.Left (N); |
| elsif Is_Greater_Key_Node (Key, N) then |
| N := Ops.Right (N); |
| else |
| Iterate (Ops.Left (N)); |
| Process (N); |
| N := Ops.Right (N); |
| end if; |
| end loop; |
| end Iterate; |
| |
| -- Start of processing for Generic_Iteration |
| |
| begin |
| Iterate (Tree.Root); |
| end Generic_Iteration; |
| |
| ------------------------------- |
| -- Generic_Reverse_Iteration -- |
| ------------------------------- |
| |
| procedure Generic_Reverse_Iteration |
| (Tree : Tree_Type; |
| Key : Key_Type) |
| is |
| procedure Iterate (Node : Node_Access); |
| |
| ------------- |
| -- Iterate -- |
| ------------- |
| |
| procedure Iterate (Node : Node_Access) is |
| N : Node_Access; |
| begin |
| N := Node; |
| while N /= null loop |
| if Is_Less_Key_Node (Key, N) then |
| N := Ops.Left (N); |
| elsif Is_Greater_Key_Node (Key, N) then |
| N := Ops.Right (N); |
| else |
| Iterate (Ops.Right (N)); |
| Process (N); |
| N := Ops.Left (N); |
| end if; |
| end loop; |
| end Iterate; |
| |
| -- Start of processing for Generic_Reverse_Iteration |
| |
| begin |
| Iterate (Tree.Root); |
| end Generic_Reverse_Iteration; |
| |
| ---------------------------------- |
| -- Generic_Unconditional_Insert -- |
| ---------------------------------- |
| |
| procedure Generic_Unconditional_Insert |
| (Tree : in out Tree_Type; |
| Key : Key_Type; |
| Node : out Node_Access) |
| is |
| Y : Node_Access; |
| X : Node_Access; |
| |
| Before : Boolean; |
| |
| begin |
| Y := null; |
| Before := False; |
| |
| X := Tree.Root; |
| while X /= null loop |
| Y := X; |
| Before := Is_Less_Key_Node (Key, X); |
| X := (if Before then Ops.Left (X) else Ops.Right (X)); |
| end loop; |
| |
| Insert_Post (Tree, Y, Before, Node); |
| end Generic_Unconditional_Insert; |
| |
| -------------------------------------------- |
| -- Generic_Unconditional_Insert_With_Hint -- |
| -------------------------------------------- |
| |
| procedure Generic_Unconditional_Insert_With_Hint |
| (Tree : in out Tree_Type; |
| Hint : Node_Access; |
| Key : Key_Type; |
| Node : out Node_Access) |
| is |
| begin |
| -- There are fewer constraints for an unconditional insertion |
| -- than for a conditional insertion, since we allow duplicate |
| -- keys. So instead of having to check (say) whether Key is |
| -- (strictly) greater than the hint's previous neighbor, here we |
| -- allow Key to be equal to or greater than the previous node. |
| |
| -- There is the issue of what to do if Key is equivalent to the |
| -- hint. Does the new node get inserted before or after the hint? |
| -- We decide that it gets inserted after the hint, reasoning that |
| -- this is consistent with behavior for non-hint insertion, which |
| -- inserts a new node after existing nodes with equivalent keys. |
| |
| -- First we check whether the hint is null, which is interpreted |
| -- to mean that Key is large relative to existing nodes. |
| -- Following our rule above, if Key is equal to or greater than |
| -- the last node, then we insert the new node immediately after |
| -- last. (We don't have an operation for testing whether a key is |
| -- "equal to or greater than" a node, so we must say instead "not |
| -- less than", which is equivalent.) |
| |
| if Hint = null then -- largest |
| if Tree.Last = null then |
| Insert_Post (Tree, null, False, Node); |
| elsif Is_Less_Key_Node (Key, Tree.Last) then |
| Unconditional_Insert_Sans_Hint (Tree, Key, Node); |
| else |
| Insert_Post (Tree, Tree.Last, False, Node); |
| end if; |
| |
| return; |
| end if; |
| |
| pragma Assert (Tree.Length > 0); |
| |
| -- We decide here whether to insert the new node prior to the |
| -- hint. Key could be equivalent to the hint, so in theory we |
| -- could write the following test as "not greater than" (same as |
| -- "less than or equal to"). If Key were equivalent to the hint, |
| -- that would mean that the new node gets inserted before an |
| -- equivalent node. That wouldn't break any container invariants, |
| -- but our rule above says that new nodes always get inserted |
| -- after equivalent nodes. So here we test whether Key is both |
| -- less than the hint and equal to or greater than the hint's |
| -- previous neighbor, and if so insert it before the hint. |
| |
| if Is_Less_Key_Node (Key, Hint) then |
| declare |
| Before : constant Node_Access := Ops.Previous (Hint); |
| begin |
| if Before = null then |
| Insert_Post (Tree, Hint, True, Node); |
| elsif Is_Less_Key_Node (Key, Before) then |
| Unconditional_Insert_Sans_Hint (Tree, Key, Node); |
| elsif Ops.Right (Before) = null then |
| Insert_Post (Tree, Before, False, Node); |
| else |
| Insert_Post (Tree, Hint, True, Node); |
| end if; |
| end; |
| |
| return; |
| end if; |
| |
| -- We know that Key isn't less than the hint, so it must be equal |
| -- or greater. So we just test whether Key is less than or equal |
| -- to (same as "not greater than") the hint's next neighbor, and |
| -- if so insert it after the hint. |
| |
| declare |
| After : constant Node_Access := Ops.Next (Hint); |
| begin |
| if After = null then |
| Insert_Post (Tree, Hint, False, Node); |
| elsif Is_Greater_Key_Node (Key, After) then |
| Unconditional_Insert_Sans_Hint (Tree, Key, Node); |
| elsif Ops.Right (Hint) = null then |
| Insert_Post (Tree, Hint, False, Node); |
| else |
| Insert_Post (Tree, After, True, Node); |
| end if; |
| end; |
| end Generic_Unconditional_Insert_With_Hint; |
| |
| ----------------- |
| -- Upper_Bound -- |
| ----------------- |
| |
| function Upper_Bound |
| (Tree : Tree_Type; |
| Key : Key_Type) return Node_Access |
| is |
| Y : Node_Access; |
| X : Node_Access; |
| |
| begin |
| X := Tree.Root; |
| while X /= null loop |
| if Is_Less_Key_Node (Key, X) then |
| Y := X; |
| X := Ops.Left (X); |
| else |
| X := Ops.Right (X); |
| end if; |
| end loop; |
| |
| return Y; |
| end Upper_Bound; |
| |
| end Ada.Containers.Red_Black_Trees.Generic_Keys; |
