Cours 7: Paquetage.

Objectif: Unité de programme. Paquetage. Spécification de paquetage. Corps.
Exemples: nombres rationnels. Visibilité. Portée. Clause Use. Clause With.

En plus des sous-programmes (procédures et fonctions), Ada offre une autre unité de programme: le paquetage.
Un paquetage se compose d'une spécification et d'un corps.

Extrait du manuel de référence (RM95):

       package_declaration ::= package_specification;

       package_specification ::=
           package defining_program_unit_name is
             {basic_declarative_item}
          [private
             {basic_declarative_item}]
           end [[parent_unit_name.]identifier]

       package_body ::=
           package body defining_program_unit_name is
              declarative_part
          [begin
               handled_sequence_of_statements]
           end [[parent_unit_name.]identifier];

Un paquetage représente le plus souvent un type abstrait, c'est-à-dire un type et des opérations sur les objets (constants ou variables) de ce type.
La spécification de paquetage regroupe la déclaration du type et les spécifications des opérations.

Extrait du manuel de référence (RM95):

       package Rational_Numbers is

          type Rational is
             record
                Numerator   : Integer;
                Denominator : Positive;
             end record;

          function "="(X,Y : Rational) return Boolean;

          function "/"  (X,Y : Integer)  return Rational;  --  to construct a rational number

          function "+"  (X,Y : Rational) return Rational;
          function "-"  (X,Y : Rational) return Rational;
          function "*"  (X,Y : Rational) return Rational;
          function "/"  (X,Y : Rational) return Rational;

       end Rational_Numbers;

       package body Rational_Numbers is

          procedure Same_Denominator (X,Y : in out Rational) is
          begin
             --  reduces X and Y to the same denominator:
             ...
          end Same_Denominator;

          function "="(X,Y : Rational) return Boolean is
             U : Rational := X;
             V : Rational := Y;
          begin
             Same_Denominator (U,V);
             return U.Numerator = V.Numerator;
          end "=";

          function "/" (X,Y : Integer) return Rational is
          begin
             if Y > 0 then
                return (Numerator => X,  Denominator => Y);
             else
                return (Numerator => -X, Denominator => -Y);
             end if;
          end "/";

          function "+" (X,Y : Rational) return Rational is ...  end "+";
          function "-" (X,Y : Rational) return Rational is ...  end "-";
          function "*" (X,Y : Rational) return Rational is ...  end "*";
          function "/" (X,Y : Rational) return Rational is ...  end "/";

       end Rational_Numbers;

Pour employer les ressources d'un paquetage P au sein d'une autre unité de programme U, on emploie la clause With P.
Seules les entités déclarées dans la partie visible de la spécification de P sont visibles dans U (dans l'exemple précédent, la procédure Same_Denominator n'est pas visible).
La visibilité de la partie déclarative d'une spécification de paquetage est indirecte (dans U, on désigne l'entité E déclarée dans P par P.E).
La visibilité de la partie déclarative d'une spécification de paquetage P peut être rendue directe dans une unité U par une clause Use P.

Exemple:

       With Ada.Text_IO.Integer_IO; Use Ada.Text_IO.Integer_IO;
       With Rational_Numbers; Use Rational_Numbers;
       Procedure Test_Rational_Numbers is
        X,Y: Rational;
       begin
         X:= 1/2; --division des rationnels car X de type Rational
         Y:= 1/3;
         Z:= X + Y;
         Put(Z.Numerator); --il serait mieux d'avoir Put(Rational)
         Put(Z.Denominator);
       end Test_Rational_Numbers;