Annotated Ada Reference Manual (Ada 202y Draft 1) — Legal Information

A.18.28 The Generic Package Containers.Unbounded_Synchronized_Queues

Static Semantics

1/3

{AI05-0159-1} The language-defined generic package Containers.Unbounded_Synchronized_Queues provides type Queue, which implements the interface type Containers.Synchronized_Queue_Interfaces.Queue.

2/5

{AI12-0112-1} with System;
with Ada.Containers.Synchronized_Queue_Interfaces;
generic
   with package Queue_Interfaces is
      new Ada.Containers.Synchronized_Queue_Interfaces (<>);
   Default_Ceiling : System.Any_Priority := System.Priority'Last;
package Ada.Containers.Unbounded_Synchronized_Queues
   with Preelaborate,
        Nonblocking, Global => in out synchronized is

2.a/5

Discussion: {AI12-0112-1} For discussion on the reasons and meaning of the specifications of the Global and Nonblocking aspects of this generic package, see the notes on the specification of the Containers.Vectors package (see A.18.2).

3/3

   package Implementation is
      ... -- not specified by the language
   end Implementation;

4/3

   protected type Queue
        (Ceiling : System.Any_Priority := Default_Ceiling)
           with Priority => Ceiling is
        new Queue_Interfaces.Queue with

5/3

      overriding
      entry Enqueue (New_Item : in Queue_Interfaces.Element_Type);
      overriding
      entry Dequeue (Element : out Queue_Interfaces.Element_Type);

6/5

{AI12-0112-1}       overriding
      function Current_Use return Count_Type
         with Nonblocking, Global => null, Use_Formal => null;
      overriding
      function Peak_Use return Count_Type
         with Nonblocking, Global => null, Use_Formal => null;

7/3

   private
      ... -- not specified by the language
   end Queue;

8/3

private

9/3

... -- not specified by the language

10/3

end Ada.Containers.Unbounded_Synchronized_Queues;

11/3

{AI05-0159-1} The type Queue is used to represent task-safe queues.

12/3

{AI05-0159-1} The capacity for instances of type Queue is unbounded.

12.a/3

Ramification: Enqueue never blocks; if more storage is needed for a new element, it is allocated dynamically. We don't need to explicitly specify that Queue needs finalization, because it is visibly protected.

12.b/3

Discussion: Nested package Implementation can be used to declare the types needed to implement the protected type Queue. This nested package is necessary as types cannot be declared in the private part of a protected type, and the types have to be declared within the generic unit in order to depend on the types imported with package Queue_Interfaces. Clients should never depend on the contents of nested package Implementation.

Extensions to Ada 2005

12.c/3

{AI05-0159-1} The generic package Containers.Unbounded_Synchronized_Queues is new.

Ada 2005 and 2012 Editions sponsored in part by Ada-Europe