A.18.11 The Generic Package Containers.Indefinite_Vectors
{
AI95-00302-03}
The language-defined generic package Containers.Indefinite_Vectors provides
a private type Vector and a set of operations. It provides the same operations
as the package Containers.Vectors (see
A.18.2),
with the difference that the generic formal Element_Type is indefinite.
Static Semantics
{
AI95-00302-03}
{
AI05-0092-1}
The declaration of the generic library package Containers.Indefinite_Vectors
has the same contents and semantics as Containers.Vectors except:
The generic formal Element_Type is indefinite.
The procedures with
the profiles:
procedure Insert (Container : in out Vector;
Before : in Extended_Index;
Count : in Count_Type := 1);
procedure Insert (Container : in out Vector;
Before : in Cursor;
Position : out Cursor;
Count : in Count_Type := 1);
are omitted.
Discussion: These procedures are omitted
because there is no way to create a default-initialized object of an
indefinite type. Note that Insert_Space can be used instead of this routine
in most cases. Omitting the routine completely allows any problems to
be diagnosed by the compiler when converting from a definite to indefinite
vector.
The actual Element parameter of access subprogram
Process of Update_Element may be constrained even if Element_Type is
unconstrained.
{
AI12-0035-1}
The operations "&", Append, Insert,
Prepend, Replace_Element, and To_Vector that have a formal parameter
of type Element_Type perform indefinite insertion (see A.18).Returns True if tampering
with elements is prohibited for Container, and False otherwise.
Reason: Complete
replacement of an element can cause its memory to be deallocated while
another operation is holding onto a reference to it. That can't be allowed.
However, a simple modification of (part of) an element is not a problem,
so Update_Element does not cause a problem.
{
AI12-0111-1}
{
AI12-0112-1}
Tampering_With_Cursors_Prohibited is replaced by
Tampering_With_Elements_Prohibited in the postcondition for the operations
Reference and Constant_Reference.{
AI12-0111-1}
The operations Replace_Element, Reverse_Elements,
and Swap, and the nested generic unit Generic_Sorting are omitted from
the nested package Stable.Extensions to Ada 95
{
AI95-00302-03}
The generic package Containers.Indefinite_Vectors
is new.
Inconsistencies With Ada 2012
{
AI12-0035-1}
Corrigendum: Defined
some routines to “perform indefinite insertion”. This could
mean that some calls to those routines would now raise Program_Error
where they previously worked. However, this is extremely unlikely, as
it would require that the package was not implemented in Ada (an Ada
allocator
would raise Program_Error in these circumstances), and that a program
inserted a more nested tagged type (or access discriminant) into a container,
and then used that object before its type or discriminant went out of
scope. All known implementations are implemented in Ada, so we believe
there is no practical incompatibility. As such, we mention this only
for completeness.{
AI12-0111-1}
Defined the Iterator_View aspect, so that the stable
view is used for container element iterators. This means that tampering
with elements is prohibited during the entire loop, rather than tampering
with cursors being prohibited during the loop, and tampering with elements
being prohibited only during the lifetimes of references to the loop
parameter. Thus, if a container element iterator does an operation that
tampers with elements on the iterated container, that operation will
fail a tampering check in Ada 2022 (and thus raise Program_Error), while
it would have worked in Ada 2012 so long as the loop parameter is not
involved. We believe this to be a dubious loop structure that should
be rare. Note that this issue only occurs for the indefinite container
form, the ordinary and bounded containers allow such operations at any
time in Ada 2022.
Ada 2005 and 2012 Editions sponsored in part by Ada-Europe
