Re: liages divers

Le 26 Mar, Thomas De Contes écrit :
> priorité faible
> 
> [...]
> 
> 1 ere chose :
> 
> dictionnaire a une procedure clear (dans la partie publique de 
> dictionnaires),
> arbre aussi, ce qui fait que dictionnaire a récupéré le clear de
> arbre, dans la partie privé de dictionnaires mais ça ne suffit pas 
> comment faire ce liage ?

Si la procedure exportée par dictionnaires doit absolument s'appeler
« clear », alors la procedure « clear » héritée de arbre n'existe plus,
puisqu'on la redéfinit. Il faut alors que « clear » de dictionnaire
appelle « clear » de arbre dans le corps du paquetage :

   procedure clear (d : in out dictionnaire) is
   begin
      clear (arbre (d));
   end clear;

Une autre façon de s'en sortir sans que l'une appelle l'autre, juste
par des renommages, consiste à passer par un paquetage et un type
intermédiaire :

with arbres;
pragma Elaborate_All (arbres);
package dictionnaire is

   type dictionnaire is private;

   procedure clear (d : in out dictionnaires);

   ...

private

   package dico is new arbres (...);
   use dico;

   packages dics is
      type dic is new arbre;
      -- ici on herite de
      -- procedure clear (d : in out dic);
      -- on la renomme :
      procedure effacer (d : in out dic) renames clear;
   end dics;

   use dics;

   type dictionnaire is new dic;
   -- ici on herite de
   -- procedure clear (d : in out dictionnaire);
   -- mais on la redéfinit, donc on perd l'héritage
   -- on hérite aussi de
   -- procedure effacer (d : in out dictionnaire);
   -- on la renomme :

   procedure clear (d : in out dictionnaire) renames effacer;

end dictionnaires;

Dans ce cas, on ne met évidemment pas de corps pour « clear »
dans le corps de dictionnaire.

Le plus simple est quand-même que la procédure exportée par dictionnaire
ne s'appelle pas « clear » :

with arbres;
pragma Elaborate_All (arbres);
package dictionnaire is

   type dictionnaire is private;

   procedure effacer (d : in out dictionnaires);

   ...

private

   package dico is new arbres (...);
   use dico;

   type dictionnaire is new arbre;
   -- ici on herite de
   -- procedure clear (d : in out dictionnaire);
   -- on la renomme :

   procedure effacer (d : in out dictionnaire) renames clear;

end dictionnaires;

> 2 eme chose :
> 
> package body dictionnaires is
> 
>    procedure ajouter (d : in out dictionnaire; mot : in String) is
> 
>       procedure inc (nbMot : in out Natural) is
>       begin
>          nbMot:=nbMot+1;
>       end inc;
> 
>       procedure incNoeud is new modifierNoeud(inc);
> 
>    begin
>       incNoeud(arbre(d),mot);
>    end ajouter;
> 
> end dictionnaires;
> 
> 
> au moment de faire new modifierNoeud(inc); , peut on choisir le 
> modifierNoeud de dictionnaire, plutôt que celui de arbre ?
> vu qu'ils ont tous les 2 cette procédure et que ce sont des types 
> incompatibles sans conversion explicite

Non, modifierNoeud étant une procédure générique, ce n'est pas
une primitive de arbre. Elle n'est donc pas héritée par dictionnaire.
Toute instanciation de modifierNoeud donnera toujours une procédure
dont le paramètre est de type arbre.

> parce que ça m'agace de devoir faire cette conversion explicite à 
> chaque fois que j'utilise une procédure générique : 
> incNoeud(arbre(d),mot);

Il me semble que c'est pourtant la seule solution.

-- 
| Xavier NICOLLIN (mailto:Xavier.Nicollin@xxxxxxx) -- INPG (ENSIMAG)
| VERIMAG -- Centre Equation -- 2, ave. de Vignate -- F-38610 Gières



_______________________________________________
Site WWW de l'association Ada-France: http://www.ada-france.org/
Ada-France@xxxxxxxxxxxxxx
http://www.ada-france.org/mailman/listinfo/ada-france