------------------------------------------------------------------------------ -- -- -- 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 -- -- . -- -- -- -- 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;