Next: , Previous: 12.7, Up: 12


12.8 Example of a Generic Package

1
The following example provides a possible formulation of stacks by means of a generic package. The size of each stack and the type of the stack elements are provided as generic formal parameters.

Examples

2/1
This paragraph was deleted.

3

     generic
        Size Positive;
        type Item is private;
     package Stack is
        procedure Push(E in  Item);
        procedure Pop (E out Item);
        Overflow, Underflow exception;
     end Stack;

4

     package body Stack is

5

        type Table is array (Positive range <>) of Item;
        Space Table(1 .. Size);
        Index Natural := 0;

6

        procedure Push(E in Item) is
        begin
           if Index >= Size then
              raise Overflow;
           end if;
           Index := Index 1;
           Space(Index) := E;
        end Push;

7

        procedure Pop(E out Item) is
        begin
           if Index then
              raise Underflow;
           end if;
           := Space(Index);
           Index := Index − 1;
        end Pop;

8

     end Stack;

9
Instances of this generic package can be obtained as follows:

10

     package Stack_Int  is new Stack(Size => 200, Item => Integer);
     package Stack_Bool is new Stack(100, Boolean);

11
Thereafter, the procedures of the instantiated packages can be called as follows:

12

     Stack_Int.Push(N);
     Stack_Bool.Push(True);

13
Alternatively, a generic formulation of the type Stack can be given as follows (package body omitted):

14

     generic
        type Item is private;
     package On_Stacks is
        type Stack(Size Positive) is limited private;
        procedure Push(S in out Stack; in  Item);
        procedure Pop (S in out Stack; out Item);
        Overflow, Underflow exception;
     private
        type Table is array (Positive range <>) of Item;
        type Stack(Size Positive) is
           record
              Space Table(1 .. Size);
              Index Natural := 0;
           end record;
     end On_Stacks;

15
In order to use such a package, an instance has to be created and thereafter stacks of the corresponding type can be declared:

16

     declare
        package Stack_Real is new On_Stacks(Real); use Stack_Real;
        Stack(100);
     begin
        ...
        Push(S, 2.54);
        ...
     end;