1 ------------------------------------------------------------------------------
3 -- GNAT LIBRARY COMPONENTS --
5 -- ADA.CONTAINERS.INDEFINITE_HASHED_MAPS --
9 -- Copyright (C) 2004-2019, Free Software Foundation, Inc. --
11 -- GNAT is free software; you can redistribute it and/or modify it under --
12 -- terms of the GNU General Public License as published by the Free Soft- --
13 -- ware Foundation; either version 3, or (at your option) any later ver- --
14 -- sion. GNAT is distributed in the hope that it will be useful, but WITH- --
15 -- OUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY --
16 -- or FITNESS FOR A PARTICULAR PURPOSE. --
18 -- As a special exception under Section 7 of GPL version 3, you are granted --
19 -- additional permissions described in the GCC Runtime Library Exception, --
20 -- version 3.1, as published by the Free Software Foundation. --
22 -- You should have received a copy of the GNU General Public License and --
23 -- a copy of the GCC Runtime Library Exception along with this program; --
24 -- see the files COPYING3 and COPYING.RUNTIME respectively. If not, see --
25 -- <http://www.gnu.org/licenses/>. --
27 -- This unit was originally developed by Matthew J Heaney. --
28 ------------------------------------------------------------------------------
30 with Ada.Containers.Hash_Tables.Generic_Operations;
31 pragma Elaborate_All (Ada.Containers.Hash_Tables.Generic_Operations);
33 with Ada.Containers.Hash_Tables.Generic_Keys;
34 pragma Elaborate_All (Ada.Containers.Hash_Tables.Generic_Keys);
36 with Ada.Containers.Helpers; use Ada.Containers.Helpers;
38 with Ada.Unchecked_Deallocation;
40 with System; use type System.Address;
42 package body Ada.Containers.Indefinite_Hashed_Maps is
44 pragma Warnings (Off, "variable ""Busy*"" is not referenced");
45 pragma Warnings (Off, "variable ""Lock*"" is not referenced");
46 -- See comment in Ada.Containers.Helpers
49 new Ada.Unchecked_Deallocation (Key_Type, Key_Access);
51 procedure Free_Element is
52 new Ada.Unchecked_Deallocation (Element_Type, Element_Access);
54 -----------------------
55 -- Local Subprograms --
56 -----------------------
58 function Copy_Node (Node : Node_Access) return Node_Access;
59 pragma Inline (Copy_Node);
61 function Equivalent_Key_Node
63 Node : Node_Access) return Boolean;
64 pragma Inline (Equivalent_Key_Node);
66 function Find_Equal_Key
67 (R_HT : Hash_Table_Type;
68 L_Node : Node_Access) return Boolean;
70 procedure Free (X : in out Node_Access);
71 -- pragma Inline (Free);
73 function Hash_Node (Node : Node_Access) return Hash_Type;
74 pragma Inline (Hash_Node);
76 function Next (Node : Node_Access) return Node_Access;
80 (Stream : not null access Root_Stream_Type'Class) return Node_Access;
82 procedure Set_Next (Node : Node_Access; Next : Node_Access);
83 pragma Inline (Set_Next);
85 function Vet (Position : Cursor) return Boolean;
88 (Stream : not null access Root_Stream_Type'Class;
91 --------------------------
92 -- Local Instantiations --
93 --------------------------
95 package HT_Ops is new Ada.Containers.Hash_Tables.Generic_Operations
96 (HT_Types => HT_Types,
97 Hash_Node => Hash_Node,
100 Copy_Node => Copy_Node,
103 package Key_Ops is new Hash_Tables.Generic_Keys
104 (HT_Types => HT_Types,
106 Set_Next => Set_Next,
107 Key_Type => Key_Type,
109 Equivalent_Keys => Equivalent_Key_Node);
115 function Is_Equal is new HT_Ops.Generic_Equal (Find_Equal_Key);
117 overriding function "=" (Left, Right : Map) return Boolean is
119 return Is_Equal (Left.HT, Right.HT);
126 procedure Adjust (Container : in out Map) is
128 HT_Ops.Adjust (Container.HT);
135 procedure Assign (Target : in out Map; Source : Map) is
136 procedure Insert_Item (Node : Node_Access);
137 pragma Inline (Insert_Item);
139 procedure Insert_Items is new HT_Ops.Generic_Iteration (Insert_Item);
145 procedure Insert_Item (Node : Node_Access) is
147 Target.Insert (Key => Node.Key.all, New_Item => Node.Element.all);
150 -- Start of processing for Assign
153 if Target'Address = Source'Address then
159 if Target.Capacity < Source.Length then
160 Target.Reserve_Capacity (Source.Length);
163 Insert_Items (Source.HT);
170 function Capacity (Container : Map) return Count_Type is
172 return HT_Ops.Capacity (Container.HT);
179 procedure Clear (Container : in out Map) is
181 HT_Ops.Clear (Container.HT);
184 ------------------------
185 -- Constant_Reference --
186 ------------------------
188 function Constant_Reference
189 (Container : aliased Map;
190 Position : Cursor) return Constant_Reference_Type
193 if Checks and then Position.Container = null then
194 raise Constraint_Error with
195 "Position cursor has no element";
198 if Checks and then Position.Container /= Container'Unrestricted_Access
200 raise Program_Error with
201 "Position cursor designates wrong map";
204 if Checks and then Position.Node.Element = null then
205 raise Program_Error with
206 "Position cursor has no element";
211 "Position cursor in Constant_Reference is bad");
214 M : Map renames Position.Container.all;
215 HT : Hash_Table_Type renames M.HT'Unrestricted_Access.all;
216 TC : constant Tamper_Counts_Access :=
217 HT.TC'Unrestricted_Access;
219 return R : constant Constant_Reference_Type :=
220 (Element => Position.Node.Element.all'Access,
221 Control => (Controlled with TC))
226 end Constant_Reference;
228 function Constant_Reference
229 (Container : aliased Map;
230 Key : Key_Type) return Constant_Reference_Type
232 HT : Hash_Table_Type renames Container'Unrestricted_Access.HT;
233 Node : constant Node_Access := Key_Ops.Find (HT, Key);
236 if Checks and then Node = null then
237 raise Constraint_Error with "key not in map";
240 if Checks and then Node.Element = null then
241 raise Program_Error with "key has no element";
245 TC : constant Tamper_Counts_Access :=
246 HT.TC'Unrestricted_Access;
248 return R : constant Constant_Reference_Type :=
249 (Element => Node.Element.all'Access,
250 Control => (Controlled with TC))
255 end Constant_Reference;
261 function Contains (Container : Map; Key : Key_Type) return Boolean is
263 return Find (Container, Key) /= No_Element;
272 Capacity : Count_Type := 0) return Map
277 if Capacity < Source.Length then
278 if Checks and then Capacity /= 0 then
280 with "Requested capacity is less than Source length";
288 return Target : Map do
289 Target.Reserve_Capacity (C);
290 Target.Assign (Source);
298 function Copy_Node (Node : Node_Access) return Node_Access is
299 K : Key_Access := new Key_Type'(Node.Key.all);
302 E := new Element_Type'(Node.Element.all);
303 return new Node_Type'(K, E, null);
315 procedure Delete (Container : in out Map; Key : Key_Type) is
319 Key_Ops.Delete_Key_Sans_Free (Container.HT, Key, X);
321 if Checks and then X = null then
322 raise Constraint_Error with "attempt to delete key not in map";
328 procedure Delete (Container : in out Map; Position : in out Cursor) is
330 if Checks and then Position.Node = null then
331 raise Constraint_Error with
332 "Position cursor of Delete equals No_Element";
335 if Checks and then Position.Container /= Container'Unrestricted_Access
337 raise Program_Error with
338 "Position cursor of Delete designates wrong map";
341 TC_Check (Container.HT.TC);
343 pragma Assert (Vet (Position), "bad cursor in Delete");
345 HT_Ops.Delete_Node_Sans_Free (Container.HT, Position.Node);
347 Free (Position.Node);
348 Position.Container := null;
355 function Element (Container : Map; Key : Key_Type) return Element_Type is
356 HT : Hash_Table_Type renames Container'Unrestricted_Access.HT;
357 Node : constant Node_Access := Key_Ops.Find (HT, Key);
360 if Checks and then Node = null then
361 raise Constraint_Error with
362 "no element available because key not in map";
365 return Node.Element.all;
368 function Element (Position : Cursor) return Element_Type is
370 if Checks and then Position.Node = null then
371 raise Constraint_Error with
372 "Position cursor of function Element equals No_Element";
375 if Checks and then Position.Node.Element = null then
376 raise Program_Error with
377 "Position cursor of function Element is bad";
380 pragma Assert (Vet (Position), "bad cursor in function Element");
382 return Position.Node.Element.all;
385 -------------------------
386 -- Equivalent_Key_Node --
387 -------------------------
389 function Equivalent_Key_Node
391 Node : Node_Access) return Boolean
394 return Equivalent_Keys (Key, Node.Key.all);
395 end Equivalent_Key_Node;
397 ---------------------
398 -- Equivalent_Keys --
399 ---------------------
401 function Equivalent_Keys (Left, Right : Cursor) return Boolean is
403 if Checks and then Left.Node = null then
404 raise Constraint_Error with
405 "Left cursor of Equivalent_Keys equals No_Element";
408 if Checks and then Right.Node = null then
409 raise Constraint_Error with
410 "Right cursor of Equivalent_Keys equals No_Element";
413 if Checks and then Left.Node.Key = null then
414 raise Program_Error with
415 "Left cursor of Equivalent_Keys is bad";
418 if Checks and then Right.Node.Key = null then
419 raise Program_Error with
420 "Right cursor of Equivalent_Keys is bad";
423 pragma Assert (Vet (Left), "bad Left cursor in Equivalent_Keys");
424 pragma Assert (Vet (Right), "bad Right cursor in Equivalent_Keys");
426 return Equivalent_Keys (Left.Node.Key.all, Right.Node.Key.all);
429 function Equivalent_Keys
431 Right : Key_Type) return Boolean
434 if Checks and then Left.Node = null then
435 raise Constraint_Error with
436 "Left cursor of Equivalent_Keys equals No_Element";
439 if Checks and then Left.Node.Key = null then
440 raise Program_Error with
441 "Left cursor of Equivalent_Keys is bad";
444 pragma Assert (Vet (Left), "bad Left cursor in Equivalent_Keys");
446 return Equivalent_Keys (Left.Node.Key.all, Right);
449 function Equivalent_Keys
451 Right : Cursor) return Boolean
454 if Checks and then Right.Node = null then
455 raise Constraint_Error with
456 "Right cursor of Equivalent_Keys equals No_Element";
459 if Checks and then Right.Node.Key = null then
460 raise Program_Error with
461 "Right cursor of Equivalent_Keys is bad";
464 pragma Assert (Vet (Right), "bad Right cursor in Equivalent_Keys");
466 return Equivalent_Keys (Left, Right.Node.Key.all);
473 procedure Exclude (Container : in out Map; Key : Key_Type) is
476 Key_Ops.Delete_Key_Sans_Free (Container.HT, Key, X);
484 procedure Finalize (Container : in out Map) is
486 HT_Ops.Finalize (Container.HT);
489 procedure Finalize (Object : in out Iterator) is
491 if Object.Container /= null then
492 Unbusy (Object.Container.HT.TC);
500 function Find (Container : Map; Key : Key_Type) return Cursor is
501 HT : Hash_Table_Type renames Container'Unrestricted_Access.HT;
502 Node : constant Node_Access := Key_Ops.Find (HT, Key);
509 return Cursor'(Container'Unrestricted_Access, Node, Hash_Type'Last);
516 function Find_Equal_Key
517 (R_HT : Hash_Table_Type;
518 L_Node : Node_Access) return Boolean
520 R_Index : constant Hash_Type := Key_Ops.Index (R_HT, L_Node.Key.all);
521 R_Node : Node_Access := R_HT.Buckets (R_Index);
524 while R_Node /= null loop
525 if Equivalent_Keys (L_Node.Key.all, R_Node.Key.all) then
526 return L_Node.Element.all = R_Node.Element.all;
529 R_Node := R_Node.Next;
539 function First (Container : Map) return Cursor is
541 Node : constant Node_Access := HT_Ops.First (Container.HT, Pos);
546 return Cursor'(Container'Unrestricted_Access, Node, Pos);
550 function First (Object : Iterator) return Cursor is
552 return Object.Container.First;
559 procedure Free (X : in out Node_Access) is
560 procedure Deallocate is
561 new Ada.Unchecked_Deallocation (Node_Type, Node_Access);
568 X.Next := X; -- detect mischief (in Vet)
578 Free_Element (X.Element);
589 Free_Element (X.Element);
600 ------------------------
601 -- Get_Element_Access --
602 ------------------------
604 function Get_Element_Access
605 (Position : Cursor) return not null Element_Access is
607 return Position.Node.Element;
608 end Get_Element_Access;
614 function Has_Element (Position : Cursor) return Boolean is
616 pragma Assert (Vet (Position), "bad cursor in Has_Element");
617 return Position.Node /= null;
624 function Hash_Node (Node : Node_Access) return Hash_Type is
626 return Hash (Node.Key.all);
634 (Container : in out Map;
636 New_Item : Element_Type)
645 Insert (Container, Key, New_Item, Position, Inserted);
648 TE_Check (Container.HT.TC);
650 K := Position.Node.Key;
651 E := Position.Node.Element;
653 Position.Node.Key := new Key_Type'(Key);
656 -- The element allocator may need an accessibility check in the
657 -- case the actual type is class-wide or has access discriminants
658 -- (see RM 4.8(10.1) and AI12-0035).
660 pragma Unsuppress (Accessibility_Check);
663 Position.Node.Element := new Element_Type'(New_Item);
681 (Container : in out Map;
683 New_Item : Element_Type;
684 Position : out Cursor;
685 Inserted : out Boolean)
687 function New_Node (Next : Node_Access) return Node_Access;
689 procedure Local_Insert is
690 new Key_Ops.Generic_Conditional_Insert (New_Node);
696 function New_Node (Next : Node_Access) return Node_Access is
697 K : Key_Access := new Key_Type'(Key);
700 -- The element allocator may need an accessibility check in the case
701 -- the actual type is class-wide or has access discriminants (see
702 -- RM 4.8(10.1) and AI12-0035).
704 pragma Unsuppress (Accessibility_Check);
707 E := new Element_Type'(New_Item);
708 return new Node_Type'(K, E, Next);
717 HT : Hash_Table_Type renames Container.HT;
719 -- Start of processing for Insert
722 if HT_Ops.Capacity (HT) = 0 then
723 HT_Ops.Reserve_Capacity (HT, 1);
726 Local_Insert (HT, Key, Position.Node, Inserted);
729 and then HT.Length > HT_Ops.Capacity (HT)
731 HT_Ops.Reserve_Capacity (HT, HT.Length);
734 Position.Container := Container'Unchecked_Access;
738 (Container : in out Map;
740 New_Item : Element_Type)
743 pragma Unreferenced (Position);
748 Insert (Container, Key, New_Item, Position, Inserted);
750 if Checks and then not Inserted then
751 raise Constraint_Error with
752 "attempt to insert key already in map";
760 function Is_Empty (Container : Map) return Boolean is
762 return Container.HT.Length = 0;
771 Process : not null access procedure (Position : Cursor))
773 procedure Process_Node (Node : Node_Access; Position : Hash_Type);
774 pragma Inline (Process_Node);
776 procedure Local_Iterate is
777 new HT_Ops.Generic_Iteration_With_Position (Process_Node);
783 procedure Process_Node (Node : Node_Access; Position : Hash_Type) is
785 Process (Cursor'(Container'Unrestricted_Access, Node, Position));
788 Busy : With_Busy (Container.HT.TC'Unrestricted_Access);
790 -- Start of processing for Iterate
793 Local_Iterate (Container.HT);
797 (Container : Map) return Map_Iterator_Interfaces.Forward_Iterator'Class
800 return It : constant Iterator :=
801 (Limited_Controlled with Container => Container'Unrestricted_Access)
803 Busy (Container.HT.TC'Unrestricted_Access.all);
811 function Key (Position : Cursor) return Key_Type is
813 if Checks and then Position.Node = null then
814 raise Constraint_Error with
815 "Position cursor of function Key equals No_Element";
818 if Checks and then Position.Node.Key = null then
819 raise Program_Error with
820 "Position cursor of function Key is bad";
823 pragma Assert (Vet (Position), "bad cursor in function Key");
825 return Position.Node.Key.all;
832 function Length (Container : Map) return Count_Type is
834 return Container.HT.Length;
842 (Target : in out Map;
846 HT_Ops.Move (Target => Target.HT, Source => Source.HT);
853 function Next (Node : Node_Access) return Node_Access is
858 procedure Next (Position : in out Cursor) is
860 Position := Next (Position);
863 function Next (Position : Cursor) return Cursor is
867 if Position.Node = null then
872 (Position.Node.Key = null or else Position.Node.Element = null)
874 raise Program_Error with "Position cursor of Next is bad";
877 pragma Assert (Vet (Position), "Position cursor of Next is bad");
879 Pos := Position.Position;
880 Node := HT_Ops.Next (Position.Container.HT, Position.Node, Pos);
885 return Cursor'(Position.Container, Node, Pos);
889 function Next (Object : Iterator; Position : Cursor) return Cursor is
891 if Position.Container = null then
895 if Checks and then Position.Container /= Object.Container then
896 raise Program_Error with
897 "Position cursor of Next designates wrong map";
900 return Next (Position);
903 ----------------------
904 -- Pseudo_Reference --
905 ----------------------
907 function Pseudo_Reference
908 (Container : aliased Map'Class) return Reference_Control_Type
910 TC : constant Tamper_Counts_Access :=
911 Container.HT.TC'Unrestricted_Access;
913 return R : constant Reference_Control_Type := (Controlled with TC) do
916 end Pseudo_Reference;
922 procedure Query_Element
924 Process : not null access procedure (Key : Key_Type;
925 Element : Element_Type))
928 if Checks and then Position.Node = null then
929 raise Constraint_Error with
930 "Position cursor of Query_Element equals No_Element";
934 (Position.Node.Key = null or else Position.Node.Element = null)
936 raise Program_Error with
937 "Position cursor of Query_Element is bad";
940 pragma Assert (Vet (Position), "bad cursor in Query_Element");
943 M : Map renames Position.Container.all;
944 HT : Hash_Table_Type renames M.HT'Unrestricted_Access.all;
945 Lock : With_Lock (HT.TC'Unrestricted_Access);
946 K : Key_Type renames Position.Node.Key.all;
947 E : Element_Type renames Position.Node.Element.all;
957 procedure Read_Nodes is new HT_Ops.Generic_Read (Read_Node);
960 (Stream : not null access Root_Stream_Type'Class;
964 Read_Nodes (Stream, Container.HT);
968 (Stream : not null access Root_Stream_Type'Class;
972 raise Program_Error with "attempt to stream map cursor";
976 (Stream : not null access Root_Stream_Type'Class;
977 Item : out Reference_Type)
980 raise Program_Error with "attempt to stream reference";
984 (Stream : not null access Root_Stream_Type'Class;
985 Item : out Constant_Reference_Type)
988 raise Program_Error with "attempt to stream reference";
996 (Stream : not null access Root_Stream_Type'Class) return Node_Access
998 Node : Node_Access := new Node_Type;
1002 Node.Key := new Key_Type'(Key_Type'Input (Stream));
1010 Node.Element := new Element_Type'(Element_Type'Input (Stream));
1013 Free_Key (Node.Key);
1026 (Container : aliased in out Map;
1027 Position : Cursor) return Reference_Type
1030 if Checks and then Position.Container = null then
1031 raise Constraint_Error with
1032 "Position cursor has no element";
1035 if Checks and then Position.Container /= Container'Unrestricted_Access
1037 raise Program_Error with
1038 "Position cursor designates wrong map";
1041 if Checks and then Position.Node.Element = null then
1042 raise Program_Error with
1043 "Position cursor has no element";
1048 "Position cursor in function Reference is bad");
1051 M : Map renames Position.Container.all;
1052 HT : Hash_Table_Type renames M.HT'Unrestricted_Access.all;
1053 TC : constant Tamper_Counts_Access :=
1054 HT.TC'Unrestricted_Access;
1056 return R : constant Reference_Type :=
1057 (Element => Position.Node.Element.all'Access,
1058 Control => (Controlled with TC))
1066 (Container : aliased in out Map;
1067 Key : Key_Type) return Reference_Type
1069 HT : Hash_Table_Type renames Container.HT;
1070 Node : constant Node_Access := Key_Ops.Find (HT, Key);
1073 if Checks and then Node = null then
1074 raise Constraint_Error with "key not in map";
1077 if Checks and then Node.Element = null then
1078 raise Program_Error with "key has no element";
1082 TC : constant Tamper_Counts_Access :=
1083 HT.TC'Unrestricted_Access;
1085 return R : constant Reference_Type :=
1086 (Element => Node.Element.all'Access,
1087 Control => (Controlled with TC))
1099 (Container : in out Map;
1101 New_Item : Element_Type)
1103 Node : constant Node_Access := Key_Ops.Find (Container.HT, Key);
1109 if Checks and then Node = null then
1110 raise Constraint_Error with
1111 "attempt to replace key not in map";
1114 TE_Check (Container.HT.TC);
1119 Node.Key := new Key_Type'(Key);
1122 -- The element allocator may need an accessibility check in the case
1123 -- the actual type is class-wide or has access discriminants (see
1124 -- RM 4.8(10.1) and AI12-0035).
1126 pragma Unsuppress (Accessibility_Check);
1129 Node.Element := new Element_Type'(New_Item);
1141 ---------------------
1142 -- Replace_Element --
1143 ---------------------
1145 procedure Replace_Element
1146 (Container : in out Map;
1148 New_Item : Element_Type)
1151 if Checks and then Position.Node = null then
1152 raise Constraint_Error with
1153 "Position cursor of Replace_Element equals No_Element";
1157 (Position.Node.Key = null or else Position.Node.Element = null)
1159 raise Program_Error with
1160 "Position cursor of Replace_Element is bad";
1163 if Checks and then Position.Container /= Container'Unrestricted_Access
1165 raise Program_Error with
1166 "Position cursor of Replace_Element designates wrong map";
1169 TE_Check (Position.Container.HT.TC);
1171 pragma Assert (Vet (Position), "bad cursor in Replace_Element");
1174 X : Element_Access := Position.Node.Element;
1176 -- The element allocator may need an accessibility check in the case
1177 -- the actual type is class-wide or has access discriminants (see
1178 -- RM 4.8(10.1) and AI12-0035).
1180 pragma Unsuppress (Accessibility_Check);
1183 Position.Node.Element := new Element_Type'(New_Item);
1186 end Replace_Element;
1188 ----------------------
1189 -- Reserve_Capacity --
1190 ----------------------
1192 procedure Reserve_Capacity
1193 (Container : in out Map;
1194 Capacity : Count_Type)
1197 HT_Ops.Reserve_Capacity (Container.HT, Capacity);
1198 end Reserve_Capacity;
1204 procedure Set_Next (Node : Node_Access; Next : Node_Access) is
1209 --------------------
1210 -- Update_Element --
1211 --------------------
1213 procedure Update_Element
1214 (Container : in out Map;
1216 Process : not null access procedure (Key : Key_Type;
1217 Element : in out Element_Type))
1220 if Checks and then Position.Node = null then
1221 raise Constraint_Error with
1222 "Position cursor of Update_Element equals No_Element";
1226 (Position.Node.Key = null or else Position.Node.Element = null)
1228 raise Program_Error with
1229 "Position cursor of Update_Element is bad";
1232 if Checks and then Position.Container /= Container'Unrestricted_Access
1234 raise Program_Error with
1235 "Position cursor of Update_Element designates wrong map";
1238 pragma Assert (Vet (Position), "bad cursor in Update_Element");
1241 HT : Hash_Table_Type renames Container.HT;
1242 Lock : With_Lock (HT.TC'Unrestricted_Access);
1243 K : Key_Type renames Position.Node.Key.all;
1244 E : Element_Type renames Position.Node.Element.all;
1254 function Vet (Position : Cursor) return Boolean is
1256 if Position.Node = null then
1257 return Position.Container = null;
1260 if Position.Container = null then
1264 if Position.Node.Next = Position.Node then
1268 if Position.Node.Key = null then
1272 if Position.Node.Element = null then
1277 HT : Hash_Table_Type renames Position.Container.HT;
1281 if HT.Length = 0 then
1285 if HT.Buckets = null
1286 or else HT.Buckets'Length = 0
1291 X := HT.Buckets (Key_Ops.Checked_Index (HT, Position.Node.Key.all));
1293 for J in 1 .. HT.Length loop
1294 if X = Position.Node then
1302 if X = X.Next then -- to prevent unnecessary looping
1317 procedure Write_Nodes is new HT_Ops.Generic_Write (Write_Node);
1320 (Stream : not null access Root_Stream_Type'Class;
1324 Write_Nodes (Stream, Container.HT);
1328 (Stream : not null access Root_Stream_Type'Class;
1332 raise Program_Error with "attempt to stream map cursor";
1336 (Stream : not null access Root_Stream_Type'Class;
1337 Item : Reference_Type)
1340 raise Program_Error with "attempt to stream reference";
1344 (Stream : not null access Root_Stream_Type'Class;
1345 Item : Constant_Reference_Type)
1348 raise Program_Error with "attempt to stream reference";
1355 procedure Write_Node
1356 (Stream : not null access Root_Stream_Type'Class;
1360 Key_Type'Output (Stream, Node.Key.all);
1361 Element_Type'Output (Stream, Node.Element.all);
1364 end Ada.Containers.Indefinite_Hashed_Maps;