CVS difference for ai05s/ai05-0084-1.txt

--- ai05s/ai05-0084-1.txt	2008/01/19 07:25:33	1.1
+++ ai05s/ai05-0084-1.txt	2008/03/07 06:15:19	1.2
@@ -1,5 +1,12 @@
-!standard A.18.2(6/2)                                           08-01-18    AI05-0084-1/01
+!standard A.18.2(6/2)                                           08-02-26    AI05-0084-1/02
+!standard A.18.3(5/2)
+!standard A.18.5(2/2)
+!standard A.18.6(2/2)
+!standard A.18.8(2/2)
+!standard A.18.9(2/2)
+!standard A.18.17(5/3)
 !class binding interpretation 08-01-18
+!status ARG Approved  6-0-2  08-02-25
 !status work item 08-01-18
 !status received 08-01-10
 !priority Low
@@ -15,8 +22,8 @@
 
 !question
 
-Should the language defined container packages support remote subprogram calls?
-(Yes.)
+Should the language defined container packages support remote subprogram
+calls? (Yes.)
 
 !recommendation
 
@@ -24,35 +31,178 @@
 
 !wording
 
-Add the pragma to the relevant packages, immediately after pragma Preelaborate.
+Add pragma Remote_Types to the following packages, immediately after
+pragma Preelaborate:
+Ada.Containers.Vectors (A.18.2(6/2)),
+Ada.Containers.Doubly_Linked_Lists (A.18.3(5/2)),
+Ada.Containers.Hashed_Maps (A.18.5(2/2)),
+Ada.Containers.Ordered_Maps (A.18.6(2/2)),
+Ada.Containers.Hashed_Sets (A.18.8(2/2)),
+Ada.Containers.Ordered_Sets (A.18.9(2/2)), and
+Ada.Containers.Indefinite_Holders (A.18.17(5/3)). [From AI05-0069-1.]
 
+Note that the other indefinite versions don't need a wording change, as
+they are copied from the definite versions.
+
 !discussion
 
 This means that containers (for example, objects of type Vector) can be used
-remotely.  The Cursor types, however, are defined to raise Program_Error when
+remotely. The Cursor types, however, are defined to raise Program_Error when
 the predefined streaming attributes are used.
 
-Note: This AI depends on another AI that clarifies which access types are
-remote access types.  None of the types in the container packages are intended
+Note: This AI depends on AI05-0060-1 that clarifies which access types are
+remote access types. None of the types in the container packages are intended
 to be remote access types.
 
-If the implementation does not support Annex E features, then pragma
-Remote_Types is semantically invisible.  Therefore, this AI cannot cause
-implementation difficulty for such implementations.  [If I'm wrong about that,
-then I recommend that we say so by fait -- that is, an Implementation
-Permission that allows a non-Annex-E implementation to completely ignore 
-pragma Remote_Types.  But I don't think such permission is actually
-necessary.]
+If the implementation does not support Annex E features, then pragma Remote_Types
+can be omitted by a permission added by AI05-0060-1.
 
 It has been suggested that containers can already be streamed "by hand".
 However, this is much less convenient for the Annex E user than
 making them full-fledged remote types packages.
 
+!corrigendum A.18.2(6/2)
 
+@drepl
+@xcode<@b<generic>
+   @b<type> Index_Type @b<is range> <@>;
+   @b<type> Element_Type @b<is private>;
+   @b<with function> "=" (Left, Right : Element_Type)
+      @b<return> Boolean @b<is> <@>;
+@b<package> Ada.Containers.Vectors @b<is>
+   @b<pragma> Preelaborate(Vectors);>
+@dby
+@xcode<@b<generic>
+   @b<type> Index_Type @b<is range> <@>;
+   @b<type> Element_Type @b<is private>;
+   @b<with function> "=" (Left, Right : Element_Type)
+      @b<return> Boolean @b<is> <@>;
+@b<package> Ada.Containers.Vectors @b<is>
+   @b<pragma> Preelaborate(Vectors);
+   @b<pragma> Remote_Types(Vectors);>
+
+!corrigendum A.18.3(5/2)
+
+@drepl
+@xcode<@b<generic>
+   @b<type> Element_Type @b<is private>;
+   @b<with function> "=" (Left, Right : Element_Type) @b<return> Boolean @b<is> <@>;
+@b<package> Ada.Containers.Doubly_Linked_Lists @b<is>
+   @b<pragma> Preelaborate(Doubly_Linked_Lists);>
+@dby
+@xcode<@b<generic>
+   @b<type> Element_Type @b<is private>;
+   @b<with function> "=" (Left, Right : Element_Type) @b<return> Boolean @b<is> <@>;
+@b<package> Ada.Containers.Doubly_Linked_Lists @b<is>
+   @b<pragma> Preelaborate(Doubly_Linked_Lists);
+   @b<pragma> Remote_Types(Doubly_Linked_Lists);>
+
+!corrigendum A.18.5(2/2)
+
+@drepl
+@xcode<@b<generic>
+   @b<type> Key_Type @b<is private>;
+   @b<type> Element_Type @b<is private>;
+   @b<with function> Hash (Key : Key_Type) @b<return> Hash_Type;
+   @b<with function> Equivalent_Keys (Left, Right : Key_Type)
+      @b<return> Boolean;
+   @b<with function> "=" (Left, Right : Element_Type)
+      @b<return> Boolean is <@>;
+@b<package> Ada.Containers.Hashed_Maps @b<is>
+   @b<pragma> Preelaborate(Hashed_Maps);>
+@dby
+@xcode<@b<generic>
+   @b<type> Key_Type @b<is private>;
+   @b<type> Element_Type @b<is private>;
+   @b<with function> Hash (Key : Key_Type) @b<return> Hash_Type;
+   @b<with function> Equivalent_Keys (Left, Right : Key_Type)
+      @b<return> Boolean;
+   @b<with function> "=" (Left, Right : Element_Type)
+      @b<return> Boolean is <@>;
+@b<package> Ada.Containers.Hashed_Maps @b<is>
+   @b<pragma> Preelaborate(Hashed_Maps);
+   @b<pragma> Remote_Types(Hashed_Maps);>
+
+!corrigendum A.18.6(2/2)
+
+@drepl
+@xcode<@b<generic>
+   @b<type> Key_Type @b<is private>;
+   @b<type> Element_Type @b<is private>;
+   @b<with function> "<" (Left, Right : Key_Type) @b<return> Boolean @b<is> <@>;
+   @b<with function> "=" (Left, Right : Element_Type) @b<return> Boolean @b<is> <@>;
+@b<package> Ada.Containers.Ordered_Maps @b<is>
+   @b<pragma> Preelaborate(Ordered_Maps);>
+@dby
+@xcode<@b<generic>
+   @b<type> Key_Type @b<is private>;
+   @b<type> Element_Type @b<is private>;
+   @b<with function> "<" (Left, Right : Key_Type) @b<return> Boolean @b<is> <@>;
+   @b<with function> "=" (Left, Right : Element_Type) @b<return> Boolean @b<is> <@>;
+@b<package> Ada.Containers.Ordered_Maps @b<is>
+   @b<pragma> Preelaborate(Ordered_Maps);
+   @b<pragma> Remote_Types(Ordered_Maps);>
+
+!corrigendum A.18.8(2/2)
+
+@drepl
+@xcode<@b<generic>
+   @b<type> Element_Type @b<is private>;
+   @b<with function> Hash (Element : Element_Type) @b<return> Hash_Type;
+   @b<with function> Equivalent_Elements (Left, Right : Element_Type)
+                 @b<return> Boolean;
+   @b<with function> "=" (Left, Right : Element_Type) @b<return> Boolean @b<is> <@>;
+@b<package> Ada.Containers.Hashed_Sets @b<is>
+   @b<pragma> Preelaborate(Hashed_Sets);>
+@dby
+@xcode<@b<generic>
+   @b<type> Element_Type @b<is private>;
+   @b<with function> Hash (Element : Element_Type) @b<return> Hash_Type;
+   @b<with function> Equivalent_Elements (Left, Right : Element_Type)
+                 @b<return> Boolean;
+   @b<with function> "=" (Left, Right : Element_Type) @b<return> Boolean @b<is> <@>;
+@b<package> Ada.Containers.Hashed_Sets @b<is>
+   @b<pragma> Preelaborate(Hashed_Sets);
+   @b<pragma> Remote_Types(Hashed_Sets);>
+
+!corrigendum A.18.9(2/2)
+
+@drepl
+@xcode<@b<generic>
+   @b<type> Element_Type @b<is private>;
+   @b<with function> "<" (Left, Right : Element_Type) @b<return> Boolean @b<is> <@>;
+   @b<with function> "=" (Left, Right : Element_Type) @b<return> Boolean @b<is> <@>;
+@b<package> Ada.Containers.Ordered_Sets @b<is>
+   @b<pragma> Preelaborate(Ordered_Sets);>
+@dby
+@xcode<@b<generic>
+   @b<type> Element_Type @b<is private>;
+   @b<with function> "<" (Left, Right : Element_Type) @b<return> Boolean @b<is> <@>;
+   @b<with function> "=" (Left, Right : Element_Type) @b<return> Boolean @b<is> <@>;
+@b<package> Ada.Containers.Ordered_Sets @b<is>
+   @b<pragma> Preelaborate(Ordered_Sets);
+   @b<pragma> Remote_Types(Ordered_Sets);>
+
+!corrigendum A.18.17(5/3)
+
+@drepl
+@xcode<@b<generic>
+   @b<type> Element_Type (<>) @b<is private>;
+   @b<with function> "=" (Left, Right : Element_Type) @b<return> Boolean @b<is> <@>;
+@b<package> Ada.Containers.Indefinite_Holders @b<is>
+   @b<pragma> Preelaborate (Indefinite_Holders);>
+@dby
+@xcode<@b<generic>
+   @b<type> Element_Type (<>) @b<is private>;
+   @b<with function> "=" (Left, Right : Element_Type) @b<return> Boolean @b<is> <@>;
+@b<package> Ada.Containers.Indefinite_Holders @b<is>
+   @b<pragma> Preelaborate (Indefinite_Holders);
+   @b<pragma> Remote_Types (Indefinite_Holders);>
 
---!corrigendum 13.9(7)
 
 !ACATS Test
+
+Create an ACATS C-Test that tries remote streaming of containers.
 
 !appendix