TP-programmation-imperative/tp07/utiliser_piles.adb

with Piles;
with Ada.Text_IO;            use Ada.Text_IO;
with Ada.Integer_Text_IO;    use Ada.Integer_Text_IO;
with Ada.Characters.Latin_1;  -- des constantes comme Apostrophe (Latin1 ?!?!)
use Ada.Characters.Latin_1;

-- Programme de test du module Pile.
procedure Utiliser_Piles is


    -- Utiliser la pile pour en montrer les possibilités sur un exemples.
    --! Attention, même si on utiliser « pragma Assert », on ne peut pas
    --! vraiment considérer cette procédure comme un programme de tests.
    --! Il est souhaitables que chaque programmes de test soit court,
    --! indépendant des autres et teste un aspect.
    procedure Utiliser_Pile_Caractere is

        package Pile_Caractere_3 is
            new Piles (Capacite => 3, T_Element => Character);
            --! On a nommé les paramètres de généricité.  On peut ne pas les
            --! nommer à condition de respecter l'ordre
            --!
            --! package Pile_Caractere_3 is
            --!         new Piles (3, Character);

        use Pile_Caractere_3;

        procedure Afficher_Pile is new Afficher (Afficher_Element => Put);

        Pile : T_Pile;
    begin
        Put_Line ("Tester_Pile_Caractere");
        -- initilaiser la pile
        Initialiser (Pile);
        pragma Assert (Est_Vide (Pile));

        -- empiler un premier élément
        Empiler (Pile, 'A');
        pragma Assert (not Est_Vide (Pile));
        pragma Assert (not Est_Pleine (Pile));
        pragma Assert ('A' = Sommet (Pile));

        -- remplir la pile
        Empiler (Pile, 'B');
        pragma Assert ('B' = Sommet (Pile));
        Empiler (Pile, 'C');
        pragma Assert ('C' = Sommet (Pile));
        pragma Assert (not Est_Vide (Pile));
        pragma Assert (Est_Pleine (Pile));

        -- Afficher la pile
        Afficher_Pile (Pile);  New_Line;

        -- supprimer un éléments
        Depiler (Pile);
        pragma Assert (not Est_Pleine (Pile));
        pragma Assert ('B' = Sommet (Pile));

        -- ajouter un élément
        Empiler (Pile, 'D');
        pragma Assert ('D' = Sommet (Pile));
        pragma Assert (Est_Pleine (Pile));

        -- Afficher la pile
        Afficher_Pile (Pile);  New_Line;

        -- vider la pile
        Depiler (Pile);
        pragma Assert (not Est_Vide (Pile));
        pragma Assert ('B' = Sommet (Pile));
        Depiler (Pile);
        pragma Assert (not Est_Vide (Pile));
        pragma Assert ('A' = Sommet (Pile));
        Depiler (Pile);
        pragma Assert (Est_Vide (Pile));

        -- Afficher la pile
        Afficher_Pile (Pile);  New_Line;
    end Utiliser_Pile_Caractere;



    procedure Utiliser_Pile_Entier is
        -- Capacite de la pile de test.
        Capacite : constant Integer := 10;

        package Pile_Integer is
            new Piles(Capacite, Integer);
        use Pile_Integer;

        -- Afficher un entier.
        --! On ne peut pas directement utliser Put car cette procédure ne
        --! prend pas qu'un seul paramètre.  Elle n'a donc pas la bonne
        --! signature.
        --! Pour éviter de devoir définir cette procédure plusieurs fois, on
        --! pourrait la définir dans un autre module ou unité, par exemple
        --! afficher_un_entier.ads/.adb.
        procedure Afficher_Entier (N: in Integer) is
        begin
            Put (N, 1);
        end Afficher_Entier;

        procedure Afficher is new Pile_Integer.Afficher (Afficher_Entier);
        --! On pourrait ne pas mettre Pile_Integer et
        --! nommer Afficher_Entier simplement Afficher.

        P1 : T_Pile;
    begin
        Put_Line ("Tester_Pile_Entier");
        -- initilaiser la pile
        Initialiser (P1);
        pragma Assert (Est_Vide (P1));

        -- remplir la pile
        for I in 1..Capacite loop
            Empiler (P1, I);
        end loop;
        pragma Assert (Est_Pleine (P1));

        -- Afficher la pile
        Afficher (P1); New_Line;

        -- vider la pile
        for I in reverse 1..Capacite loop
            pragma Assert (I = Sommet (P1));
            Depiler (P1);
        end loop;
        pragma Assert (Est_Vide (P1));
    end Utiliser_Pile_Entier;



    procedure Illustrer_Surcharge is
        package Pile_Integer is
            new Piles(10, Integer);
        use Pile_Integer;

        procedure Afficher (N: in Integer) is
        begin
            Put (N, 1);
        end Afficher;

        procedure Afficher is new Pile_Integer.Afficher (Afficher);

        --! Il y a deux procédures qui s'appelle Afficher :
        --! 1. Afficher (Integer),
        --!    2. Afficher (Pile_Integer.T_Pile) : instance de la 1.
        --!
        --! Ceci ne pose pas de problème car en fonction du paramètre
        --! effectif fourni : Integer ou T_Pile, le compilateur saura
        --! laquelle choisir.
        --! 
        --! Remarque : on doit mettre Pile_Integer.Afficher parce que
        --! Ada ne veut pas que l'instance Afficher (T_Pile) porte le même nom
        --! que la procédure générique (risque de masquage).

        P : T_Pile;
    begin
        Put_Line ("Illustrer_Surcharge");
        Initialiser (P);
        Empiler (P, 5);
        Put ("5 = "); Afficher (5); New_Line;   --! la 1 : afficher entier
        Put ("P = "); Afficher (P); New_Line;   --! la 2 : afficher pile
        --! Décommenter la ligne suivante et compiler pour voir l'erreur
        --! signalée par le compilateur et les versions de Afficher qu'il
        --! connait.
        -- Afficher("XXX");
        --! utiliser_piles.adb:167:18: expected private type "T_Pile" defined at piles.ads:9, instance at line 134
        --! utiliser_piles.adb:167:18: found a string type
        --! utiliser_piles.adb:167:18:   ==> in call to "Afficher" at line 143
        --! utiliser_piles.adb:167:18:   ==> in call to "Afficher" at line 138

    end Illustrer_Surcharge;


    -- Afficher le caractère C entre apostrophes.
    procedure Afficher(C : in Character) is
    begin
        Put (Apostrophe & C & Apostrophe);
    end Afficher;

    procedure Illustrer_Plusieurs_Afficher_Pour_Meme_Pile is
        package PPC3 is
            new Piles (Capacite => 3, T_Element => Character);
        use PPC3;

        procedure Afficher is new PPC3.Afficher (Put);
        procedure Afficher_Apostrophe is new PPC3.Afficher (Afficher);
        --! Ici, il faut un nom différent pour les deux procédures car
        --! elles ont la même signature : une T_Pile de PPC3.

        P: T_Pile;
    begin
        Put_Line ("Illustrer_Plusieurs_Afficher_Pour_Meme_Pile");
        Initialiser (P);
        Empiler (P, 'A');
        Put ("P = "); Afficher (P); New_Line;
        Put ("P = "); Afficher_Apostrophe (P); New_Line;
    end Illustrer_Plusieurs_Afficher_Pour_Meme_Pile;

    -- Montrer deux instances du même module dans le même sous-programme.
    procedure Illustrer_Plusieurs_Piles is

        package PPC1 is
            new Piles(3, Character);
        use PPC1;
        procedure Afficher is new PPC1.Afficher (Put);

        package PPC2 is
            new Piles(10, Character);
        use PPC2;
        procedure Afficher is new PPC2.Afficher (Put);
        procedure Afficher_Apostrophe is new PPC2.Afficher (Afficher);

        PC1 : PPC1.T_Pile;
        PC2 : PPC2.T_Pile;
    begin
        Put_Line ("Illustrer_Plusieurs_Piles");

        --! Décommenter la ligne suivante et compiler pour voir l'erreur
        --! signalée par le compilateur et les versions de Afficher qu'il
        --! connait.
        -- Afficher("XXX");
        --! utiliser_piles.adb:220:09: no candidate interpretations match the actuals:
        --! utiliser_piles.adb:220:18: expected private type "T_Pile" defined at piles.ads:9, instance at line 206
        --! utiliser_piles.adb:220:18: found a string type
        --! utiliser_piles.adb:220:18:   ==> in call to "Afficher" at line 212
        --! utiliser_piles.adb:220:18:   ==> in call to "Afficher" at line 207
        --! utiliser_piles.adb:220:18:   ==> in call to "Afficher" at line 177
        
        -- Initialiser les piles
        Initialiser (PC1);
        Initialiser (PC2);

        -- Ajouter des éléments dans les piles
        for C in Character range 'A'..'C' loop
            Empiler (PC1, C);
            Empiler (PC2, C);
        end loop;

        -- Afficher les piles
        Put ("PC1 = "); Afficher (PC1); New_Line;
        Put ("PC2 = "); Afficher (PC2); New_Line;
        Put ("PC2 = "); Afficher_Apostrophe (PC2); New_Line;

        -- Ne pas respecter un contrat
        for C in Character range 'A'..'Z' loop
            Empiler (PC1, C);
        end loop;
        Afficher (PC1);
    end Illustrer_Plusieurs_Piles;


begin
    Utiliser_Pile_Caractere;
    Utiliser_Pile_Entier;
    Illustrer_Surcharge;
    Illustrer_Plusieurs_Afficher_Pour_Meme_Pile;
    Illustrer_Plusieurs_Piles;
end Utiliser_Piles;