-- --
-- GNAT LIBRARY COMPONENTS --
-- --
--- ADA.CONTAINERS.HASHED_MAPS --
+-- A D A . C O N T A I N E R S . H A S H E D _ M A P S --
-- --
-- B o d y --
-- --
--- Copyright (C) 2004 Free Software Foundation, Inc. --
--- --
--- This specification is derived from the Ada Reference Manual for use with --
--- GNAT. The copyright notice above, and the license provisions that follow --
--- apply solely to the contents of the part following the private keyword. --
+-- Copyright (C) 2004-2009, 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 2, or (at your option) any later ver- --
+-- 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. See the GNU General Public License --
--- for more details. You should have received a copy of the GNU General --
--- Public License distributed with GNAT; see file COPYING. If not, write --
--- to the Free Software Foundation, 59 Temple Place - Suite 330, Boston, --
--- MA 02111-1307, USA. --
+-- 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. --
-- --
--- As a special exception, if other files instantiate generics from this --
--- unit, or you link this unit with other files to produce an executable, --
--- this unit does not by itself cause the resulting executable to be --
--- covered by the GNU General Public License. This exception does not --
--- however invalidate any other reasons why the executable file might be --
--- covered by the GNU Public License. --
+-- 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.Hashed_Maps is
- type Node_Type is limited record
- Key : Key_Type;
- Element : Element_Type;
- Next : Node_Access;
- end record;
-
-----------------------
-- Local Subprograms --
-----------------------
(Source : Node_Access) return Node_Access;
pragma Inline (Copy_Node);
- function Equivalent_Keys
+ function Equivalent_Key_Node
(Key : Key_Type;
Node : Node_Access) return Boolean;
- pragma Inline (Equivalent_Keys);
+ pragma Inline (Equivalent_Key_Node);
+
+ procedure Free (X : in out Node_Access);
function Find_Equal_Key
- (R_Map : Map;
+ (R_HT : Hash_Table_Type;
L_Node : Node_Access) return Boolean;
function Hash_Node (Node : Node_Access) return Hash_Type;
pragma Inline (Next);
function Read_Node
- (Stream : access Root_Stream_Type'Class) return Node_Access;
+ (Stream : not null access Root_Stream_Type'Class) return Node_Access;
pragma Inline (Read_Node);
procedure Set_Next (Node : Node_Access; Next : Node_Access);
pragma Inline (Set_Next);
+ function Vet (Position : Cursor) return Boolean;
+
procedure Write_Node
- (Stream : access Root_Stream_Type'Class;
+ (Stream : not null access Root_Stream_Type'Class;
Node : Node_Access);
pragma Inline (Write_Node);
-- Local Instantiations --
--------------------------
- procedure Free is
- new Ada.Unchecked_Deallocation (Node_Type, Node_Access);
-
- package HT_Ops is
- new Hash_Tables.Generic_Operations
- (HT_Types => HT_Types,
- Hash_Table_Type => Map,
- Null_Node => null,
- Hash_Node => Hash_Node,
- Next => Next,
- Set_Next => Set_Next,
- Copy_Node => Copy_Node,
- Free => Free);
-
- package Key_Ops is
- new Hash_Tables.Generic_Keys
- (HT_Types => HT_Types,
- HT_Type => Map,
- Null_Node => null,
- Next => Next,
- Set_Next => Set_Next,
- Key_Type => Key_Type,
- Hash => Hash,
- Equivalent_Keys => Equivalent_Keys);
+ package HT_Ops is new Hash_Tables.Generic_Operations
+ (HT_Types => HT_Types,
+ Hash_Node => Hash_Node,
+ Next => Next,
+ Set_Next => Set_Next,
+ Copy_Node => Copy_Node,
+ Free => Free);
+
+ package Key_Ops is new Hash_Tables.Generic_Keys
+ (HT_Types => HT_Types,
+ Next => Next,
+ Set_Next => Set_Next,
+ Key_Type => Key_Type,
+ Hash => Hash,
+ Equivalent_Keys => Equivalent_Key_Node);
function Is_Equal is new HT_Ops.Generic_Equal (Find_Equal_Key);
-- "=" --
---------
- function "=" (Left, Right : Map) return Boolean renames Is_Equal;
+ function "=" (Left, Right : Map) return Boolean is
+ begin
+ return Is_Equal (Left.HT, Right.HT);
+ end "=";
------------
-- Adjust --
------------
- procedure Adjust (Container : in out Map) renames HT_Ops.Adjust;
+ procedure Adjust (Container : in out Map) is
+ begin
+ HT_Ops.Adjust (Container.HT);
+ end Adjust;
--------------
-- Capacity --
--------------
- function Capacity (Container : Map) return Count_Type
- renames HT_Ops.Capacity;
+ function Capacity (Container : Map) return Count_Type is
+ begin
+ return HT_Ops.Capacity (Container.HT);
+ end Capacity;
-----------
-- Clear --
-----------
- procedure Clear (Container : in out Map) renames HT_Ops.Clear;
+ procedure Clear (Container : in out Map) is
+ begin
+ HT_Ops.Clear (Container.HT);
+ end Clear;
--------------
-- Contains --
X : Node_Access;
begin
- Key_Ops.Delete_Key_Sans_Free (Container, Key, X);
+ Key_Ops.Delete_Key_Sans_Free (Container.HT, Key, X);
if X = null then
- raise Constraint_Error;
+ raise Constraint_Error with "attempt to delete key not in map";
end if;
Free (X);
procedure Delete (Container : in out Map; Position : in out Cursor) is
begin
- if Position = No_Element then
- return;
+ if Position.Node = null then
+ raise Constraint_Error with
+ "Position cursor of Delete equals No_Element";
end if;
- if Position.Container /= Map_Access'(Container'Unchecked_Access) then
- raise Program_Error;
+ if Position.Container /= Container'Unrestricted_Access then
+ raise Program_Error with
+ "Position cursor of Delete designates wrong map";
end if;
- HT_Ops.Delete_Node_Sans_Free (Container, Position.Node);
- Free (Position.Node);
+ if Container.HT.Busy > 0 then
+ raise Program_Error with
+ "Delete attempted to tamper with elements (map is busy)";
+ end if;
+
+ pragma Assert (Vet (Position), "bad cursor in Delete");
+
+ HT_Ops.Delete_Node_Sans_Free (Container.HT, Position.Node);
+ Free (Position.Node);
Position.Container := null;
end Delete;
-------------
function Element (Container : Map; Key : Key_Type) return Element_Type is
- C : constant Cursor := Find (Container, Key);
+ Node : constant Node_Access := Key_Ops.Find (Container.HT, Key);
+
begin
- return C.Node.Element;
+ if Node = null then
+ raise Constraint_Error with
+ "no element available because key not in map";
+ end if;
+
+ return Node.Element;
end Element;
function Element (Position : Cursor) return Element_Type is
begin
+ if Position.Node = null then
+ raise Constraint_Error with
+ "Position cursor of function Element equals No_Element";
+ end if;
+
+ pragma Assert (Vet (Position), "bad cursor in function Element");
+
return Position.Node.Element;
end Element;
- ---------------------
- -- Equivalent_Keys --
- ---------------------
+ -------------------------
+ -- Equivalent_Key_Node --
+ -------------------------
- function Equivalent_Keys
+ function Equivalent_Key_Node
(Key : Key_Type;
Node : Node_Access) return Boolean is
begin
return Equivalent_Keys (Key, Node.Key);
- end Equivalent_Keys;
+ end Equivalent_Key_Node;
---------------------
-- Equivalent_Keys --
function Equivalent_Keys (Left, Right : Cursor)
return Boolean is
begin
+ if Left.Node = null then
+ raise Constraint_Error with
+ "Left cursor of Equivalent_Keys equals No_Element";
+ end if;
+
+ if Right.Node = null then
+ raise Constraint_Error with
+ "Right cursor of Equivalent_Keys equals No_Element";
+ end if;
+
+ pragma Assert (Vet (Left), "Left cursor of Equivalent_Keys is bad");
+ pragma Assert (Vet (Right), "Right cursor of Equivalent_Keys is bad");
+
return Equivalent_Keys (Left.Node.Key, Right.Node.Key);
end Equivalent_Keys;
function Equivalent_Keys (Left : Cursor; Right : Key_Type) return Boolean is
begin
+ if Left.Node = null then
+ raise Constraint_Error with
+ "Left cursor of Equivalent_Keys equals No_Element";
+ end if;
+
+ pragma Assert (Vet (Left), "Left cursor in Equivalent_Keys is bad");
+
return Equivalent_Keys (Left.Node.Key, Right);
end Equivalent_Keys;
function Equivalent_Keys (Left : Key_Type; Right : Cursor) return Boolean is
begin
+ if Right.Node = null then
+ raise Constraint_Error with
+ "Right cursor of Equivalent_Keys equals No_Element";
+ end if;
+
+ pragma Assert (Vet (Right), "Right cursor of Equivalent_Keys is bad");
+
return Equivalent_Keys (Left, Right.Node.Key);
end Equivalent_Keys;
procedure Exclude (Container : in out Map; Key : Key_Type) is
X : Node_Access;
begin
- Key_Ops.Delete_Key_Sans_Free (Container, Key, X);
+ Key_Ops.Delete_Key_Sans_Free (Container.HT, Key, X);
Free (X);
end Exclude;
-- Finalize --
--------------
- procedure Finalize (Container : in out Map) renames HT_Ops.Finalize;
+ procedure Finalize (Container : in out Map) is
+ begin
+ HT_Ops.Finalize (Container.HT);
+ end Finalize;
----------
-- Find --
----------
function Find (Container : Map; Key : Key_Type) return Cursor is
- Node : constant Node_Access := Key_Ops.Find (Container, Key);
+ Node : constant Node_Access := Key_Ops.Find (Container.HT, Key);
begin
if Node = null then
--------------------
function Find_Equal_Key
- (R_Map : Map;
+ (R_HT : Hash_Table_Type;
L_Node : Node_Access) return Boolean
is
- R_Index : constant Hash_Type := Key_Ops.Index (R_Map, L_Node.Key);
- R_Node : Node_Access := R_Map.Buckets (R_Index);
+ R_Index : constant Hash_Type := Key_Ops.Index (R_HT, L_Node.Key);
+ R_Node : Node_Access := R_HT.Buckets (R_Index);
begin
while R_Node /= null loop
-----------
function First (Container : Map) return Cursor is
- Node : constant Node_Access := HT_Ops.First (Container);
+ Node : constant Node_Access := HT_Ops.First (Container.HT);
begin
if Node = null then
return Cursor'(Container'Unchecked_Access, Node);
end First;
+ ----------
+ -- Free --
+ ----------
+
+ procedure Free (X : in out Node_Access) is
+ procedure Deallocate is
+ new Ada.Unchecked_Deallocation (Node_Type, Node_Access);
+ begin
+ if X /= null then
+ X.Next := X; -- detect mischief (in Vet)
+ Deallocate (X);
+ end if;
+ end Free;
+
-----------------
-- Has_Element --
-----------------
function Has_Element (Position : Cursor) return Boolean is
begin
- return Position /= No_Element;
+ pragma Assert (Vet (Position), "bad cursor in Has_Element");
+ return Position.Node /= null;
end Has_Element;
---------------
Insert (Container, Key, New_Item, Position, Inserted);
if not Inserted then
+ if Container.HT.Lock > 0 then
+ raise Program_Error with
+ "Include attempted to tamper with cursors (map is locked)";
+ end if;
+
Position.Node.Key := Key;
Position.Node.Element := New_Item;
end if;
--------------
function New_Node (Next : Node_Access) return Node_Access is
- Node : Node_Access := new Node_Type; -- Ada 2005 aggregate possible?
-
begin
- Node.Key := Key;
- Node.Next := Next;
-
- return Node;
-
- exception
- when others =>
- Free (Node);
- raise;
+ return new Node_Type'(Key => Key,
+ Element => <>,
+ Next => Next);
end New_Node;
+ HT : Hash_Table_Type renames Container.HT;
+
-- Start of processing for Insert
begin
- HT_Ops.Ensure_Capacity (Container, Container.Length + 1);
- Local_Insert (Container, Key, Position.Node, Inserted);
+ if HT_Ops.Capacity (HT) = 0 then
+ HT_Ops.Reserve_Capacity (HT, 1);
+ end if;
+
+ Local_Insert (HT, Key, Position.Node, Inserted);
+
+ if Inserted
+ and then HT.Length > HT_Ops.Capacity (HT)
+ then
+ HT_Ops.Reserve_Capacity (HT, HT.Length);
+ end if;
+
Position.Container := Container'Unchecked_Access;
end Insert;
--------------
function New_Node (Next : Node_Access) return Node_Access is
- Node : constant Node_Access := new Node_Type'(Key, New_Item, Next);
begin
- return Node;
+ return new Node_Type'(Key, New_Item, Next);
end New_Node;
+ HT : Hash_Table_Type renames Container.HT;
+
-- Start of processing for Insert
begin
- HT_Ops.Ensure_Capacity (Container, Container.Length + 1);
- Local_Insert (Container, Key, Position.Node, Inserted);
+ if HT_Ops.Capacity (HT) = 0 then
+ HT_Ops.Reserve_Capacity (HT, 1);
+ end if;
+
+ Local_Insert (HT, Key, Position.Node, Inserted);
+
+ if Inserted
+ and then HT.Length > HT_Ops.Capacity (HT)
+ then
+ HT_Ops.Reserve_Capacity (HT, HT.Length);
+ end if;
+
Position.Container := Container'Unchecked_Access;
end Insert;
New_Item : Element_Type)
is
Position : Cursor;
+ pragma Unreferenced (Position);
+
Inserted : Boolean;
begin
Insert (Container, Key, New_Item, Position, Inserted);
if not Inserted then
- raise Constraint_Error;
+ raise Constraint_Error with
+ "attempt to insert key already in map";
end if;
end Insert;
function Is_Empty (Container : Map) return Boolean is
begin
- return Container.Length = 0;
+ return Container.HT.Length = 0;
end Is_Empty;
-------------
Process (Cursor'(Container'Unchecked_Access, Node));
end Process_Node;
+ B : Natural renames Container'Unrestricted_Access.HT.Busy;
+
-- Start of processing for Iterate
begin
- Local_Iterate (Container);
+ B := B + 1;
+
+ begin
+ Local_Iterate (Container.HT);
+ exception
+ when others =>
+ B := B - 1;
+ raise;
+ end;
+
+ B := B - 1;
end Iterate;
---------
function Key (Position : Cursor) return Key_Type is
begin
+ if Position.Node = null then
+ raise Constraint_Error with
+ "Position cursor of function Key equals No_Element";
+ end if;
+
+ pragma Assert (Vet (Position), "bad cursor in function Key");
+
return Position.Node.Key;
end Key;
function Length (Container : Map) return Count_Type is
begin
- return Container.Length;
+ return Container.HT.Length;
end Length;
----------
procedure Move
(Target : in out Map;
- Source : in out Map) renames HT_Ops.Move;
+ Source : in out Map)
+ is
+ begin
+ HT_Ops.Move (Target => Target.HT, Source => Source.HT);
+ end Move;
----------
-- Next --
function Next (Position : Cursor) return Cursor is
begin
- if Position = No_Element then
+ if Position.Node = null then
return No_Element;
end if;
+ pragma Assert (Vet (Position), "bad cursor in function Next");
+
declare
- M : Map renames Position.Container.all;
- Node : constant Node_Access := HT_Ops.Next (M, Position.Node);
+ HT : Hash_Table_Type renames Position.Container.HT;
+ Node : constant Node_Access := HT_Ops.Next (HT, Position.Node);
begin
if Node = null then
procedure Query_Element
(Position : Cursor;
- Process : not null access procedure (Element : Element_Type))
+ Process : not null access
+ procedure (Key : Key_Type; Element : Element_Type))
is
begin
- Process (Position.Node.Key, Position.Node.Element);
+ if Position.Node = null then
+ raise Constraint_Error with
+ "Position cursor of Query_Element equals No_Element";
+ end if;
+
+ pragma Assert (Vet (Position), "bad cursor in Query_Element");
+
+ declare
+ M : Map renames Position.Container.all;
+ HT : Hash_Table_Type renames M.HT'Unrestricted_Access.all;
+
+ B : Natural renames HT.Busy;
+ L : Natural renames HT.Lock;
+
+ begin
+ B := B + 1;
+ L := L + 1;
+
+ declare
+ K : Key_Type renames Position.Node.Key;
+ E : Element_Type renames Position.Node.Element;
+
+ begin
+ Process (K, E);
+ exception
+ when others =>
+ L := L - 1;
+ B := B - 1;
+ raise;
+ end;
+
+ L := L - 1;
+ B := B - 1;
+ end;
end Query_Element;
----------
----------
procedure Read
- (Stream : access Root_Stream_Type'Class;
- Container : out Map) renames Read_Nodes;
+ (Stream : not null access Root_Stream_Type'Class;
+ Container : out Map)
+ is
+ begin
+ Read_Nodes (Stream, Container.HT);
+ end Read;
+
+ procedure Read
+ (Stream : not null access Root_Stream_Type'Class;
+ Item : out Cursor)
+ is
+ begin
+ raise Program_Error with "attempt to stream map cursor";
+ end Read;
---------------
-- Read_Node --
---------------
function Read_Node
- (Stream : access Root_Stream_Type'Class) return Node_Access
+ (Stream : not null access Root_Stream_Type'Class) return Node_Access
is
Node : Node_Access := new Node_Type;
Key : Key_Type;
New_Item : Element_Type)
is
- Node : constant Node_Access := Key_Ops.Find (Container, Key);
+ Node : constant Node_Access := Key_Ops.Find (Container.HT, Key);
begin
if Node = null then
- raise Constraint_Error;
+ raise Constraint_Error with
+ "attempt to replace key not in map";
+ end if;
+
+ if Container.HT.Lock > 0 then
+ raise Program_Error with
+ "Replace attempted to tamper with cursors (map is locked)";
end if;
Node.Key := Key;
-- Replace_Element --
---------------------
- procedure Replace_Element (Position : Cursor; By : Element_Type) is
+ procedure Replace_Element
+ (Container : in out Map;
+ Position : Cursor;
+ New_Item : Element_Type)
+ is
begin
- Position.Node.Element := By;
+ if Position.Node = null then
+ raise Constraint_Error with
+ "Position cursor of Replace_Element equals No_Element";
+ end if;
+
+ if Position.Container /= Container'Unrestricted_Access then
+ raise Program_Error with
+ "Position cursor of Replace_Element designates wrong map";
+ end if;
+
+ if Position.Container.HT.Lock > 0 then
+ raise Program_Error with
+ "Replace_Element attempted to tamper with cursors (map is locked)";
+ end if;
+
+ pragma Assert (Vet (Position), "bad cursor in Replace_Element");
+
+ Position.Node.Element := New_Item;
end Replace_Element;
----------------------
procedure Reserve_Capacity
(Container : in out Map;
- Capacity : Count_Type) renames HT_Ops.Ensure_Capacity;
+ Capacity : Count_Type)
+ is
+ begin
+ HT_Ops.Reserve_Capacity (Container.HT, Capacity);
+ end Reserve_Capacity;
--------------
-- Set_Next --
--------------------
procedure Update_Element
- (Position : Cursor;
- Process : not null access procedure (Element : in out Element_Type))
+ (Container : in out Map;
+ Position : Cursor;
+ Process : not null access procedure (Key : Key_Type;
+ Element : in out Element_Type))
is
begin
- Process (Position.Node.Key, Position.Node.Element);
+ if Position.Node = null then
+ raise Constraint_Error with
+ "Position cursor of Update_Element equals No_Element";
+ end if;
+
+ if Position.Container /= Container'Unrestricted_Access then
+ raise Program_Error with
+ "Position cursor of Update_Element designates wrong map";
+ end if;
+
+ pragma Assert (Vet (Position), "bad cursor in Update_Element");
+
+ declare
+ HT : Hash_Table_Type renames Container.HT;
+ B : Natural renames HT.Busy;
+ L : Natural renames HT.Lock;
+
+ begin
+ B := B + 1;
+ L := L + 1;
+
+ declare
+ K : Key_Type renames Position.Node.Key;
+ E : Element_Type renames Position.Node.Element;
+
+ begin
+ Process (K, E);
+
+ exception
+ when others =>
+ L := L - 1;
+ B := B - 1;
+ raise;
+ end;
+
+ L := L - 1;
+ B := B - 1;
+ end;
end Update_Element;
+ ---------
+ -- Vet --
+ ---------
+
+ function Vet (Position : Cursor) return Boolean is
+ begin
+ if Position.Node = null then
+ return Position.Container = null;
+ end if;
+
+ if Position.Container = null then
+ return False;
+ end if;
+
+ if Position.Node.Next = Position.Node then
+ return False;
+ end if;
+
+ declare
+ HT : Hash_Table_Type renames Position.Container.HT;
+ X : Node_Access;
+
+ begin
+ if HT.Length = 0 then
+ return False;
+ end if;
+
+ if HT.Buckets = null
+ or else HT.Buckets'Length = 0
+ then
+ return False;
+ end if;
+
+ X := HT.Buckets (Key_Ops.Index (HT, Position.Node.Key));
+
+ for J in 1 .. HT.Length loop
+ if X = Position.Node then
+ return True;
+ end if;
+
+ if X = null then
+ return False;
+ end if;
+
+ if X = X.Next then -- to prevent endless loop
+ return False;
+ end if;
+
+ X := X.Next;
+ end loop;
+
+ return False;
+ end;
+ end Vet;
+
-----------
-- Write --
-----------
procedure Write
- (Stream : access Root_Stream_Type'Class;
- Container : Map) renames Write_Nodes;
+ (Stream : not null access Root_Stream_Type'Class;
+ Container : Map)
+ is
+ begin
+ Write_Nodes (Stream, Container.HT);
+ end Write;
+
+ procedure Write
+ (Stream : not null access Root_Stream_Type'Class;
+ Item : Cursor)
+ is
+ begin
+ raise Program_Error with "attempt to stream map cursor";
+ end Write;
----------------
-- Write_Node --
----------------
procedure Write_Node
- (Stream : access Root_Stream_Type'Class;
+ (Stream : not null access Root_Stream_Type'Class;
Node : Node_Access)
is
begin
OSDN Git Service
