Question package enfant

[DrPi]

Bonjour,

Un package enfant a accès aux éléments des packages parents.
Mais un package parent peut-il avoir accès aux éléments des packages
enfants ? Apparemment non. En tout cas, je n'ai pas trouvé comment faire.

Disons que j'ai un driver (ou autre) avec :
- 1 package qui définit l'interface (type, procédures de haut niveau...)
- 1 package qui implémente les fonctionnalités (types internes,
procedures internes, interruptions...)

Je pensais créer les packages suivants :
- mon_driver
- mon_driver.core

Mais apparemment un package enfant n'a pas accès au package parent.
Du coup, comment fait t-on en Ada ?

note : Je sais que je peux faire un seul package avec une partie
publique et une partie privée. Mais ce n'est pas ce que je veux ici.

Nicolas

[Ludovic Brenta]

Post by DrPi
Bonjour,
Un package enfant a accès aux éléments des packages parents.
Mais un package parent peut-il avoir accès aux éléments des packages
enfants ? Apparemment non. En tout cas, je n'ai pas trouvé comment faire.
- 1 package qui définit l'interface (type, procédures de haut niveau...)
- 1 package qui implémente les fonctionnalités (types internes,
procedures internes, interruptions...)
- mon_driver
- mon_driver.core
Mais apparemment un package enfant n'a pas accès au package parent.
Du coup, comment fait t-on en Ada ?
note : Je sais que je peux faire un seul package avec une partie
publique et une partie privée. Mais ce n'est pas ce que je veux ici.

Le corps d'un paquet parent peut voir les spécifications des paquets
enfants, même et en particulier s'ils sont privés. Le petit exemple
suivant illustre mais je n'ai pas essayé de le compiler, les éventuels
bugs sont donc intentionnels:

package Parent is
-- visible to everyone.
type T is private;
procedure Public_Proc (Value : in out T);
private
-- visible to body and child packages.
type T is record
A : Integer;
end record;
end Parent;

private package Parent.Internal_Implementation is
procedure Hardware_Dependent_Proc (Value : in out T);
end Parent.Internal_Implementation;

with Parent.Internal_Implementation;
package body Parent is
procedure Public_Proc (Value : in out T)
renames Parent.Internal_Implementation.Hardware_Dependent_Proc;
end Parent;

package body Parent.Internal_Implementation is
Hardware_Dependent_Constant : constant := 42;
procedure Hardware_Dependent_Proc (Value : in out T) is
begin
Value.A := Hardware_Dependent_Constant;
end Hardware_Dependent_Proc;
end Parent.Internal_Implementation;

[DrPi]

Post by Ludovic Brenta

Post by DrPi
Bonjour,
Un package enfant a accès aux éléments des packages parents.
Mais un package parent peut-il avoir accès aux éléments des packages
enfants ? Apparemment non. En tout cas, je n'ai pas trouvé comment faire.
- 1 package qui définit l'interface (type, procédures de haut niveau...)
- 1 package qui implémente les fonctionnalités (types internes,
procedures internes, interruptions...)
- mon_driver
- mon_driver.core
Mais apparemment un package enfant n'a pas accès au package parent.
Du coup, comment fait t-on en Ada ?
note : Je sais que je peux faire un seul package avec une partie
publique et une partie privée. Mais ce n'est pas ce que je veux ici.

Le corps d'un paquet parent peut voir les spécifications des paquets
enfants, même et en particulier s'ils sont privés. Le petit exemple
suivant illustre mais je n'ai pas essayé de le compiler, les éventuels
package Parent is
-- visible to everyone.
type T is private;
procedure Public_Proc (Value : in out T);
private
-- visible to body and child packages.
type T is record
A : Integer;
end record;
end Parent;
private package Parent.Internal_Implementation is
procedure Hardware_Dependent_Proc (Value : in out T);
end Parent.Internal_Implementation;
with Parent.Internal_Implementation;
package body Parent is
procedure Public_Proc (Value : in out T)
renames Parent.Internal_Implementation.Hardware_Dependent_Proc;
end Parent;
package body Parent.Internal_Implementation is
Hardware_Dependent_Constant : constant := 42;
procedure Hardware_Dependent_Proc (Value : in out T) is
begin
Value.A := Hardware_Dependent_Constant;
end Hardware_Dependent_Proc;
end Parent.Internal_Implementation;

Merci pour l'exemple qui m'a permis de comprendre mon erreur.
Je mettais le "with Parent.Internal_Implementation;" dans le fichier de
spécification ce qui génère l'erreur "circular unit dependency".
En y repensant maintenant, l'erreur est évidente.

Est-ce que "private with Parent.Internal_Implementation;" serait plus
adapté ?

Je ne savais pas non plus qu'un "renames" peut être utilisé comme dans
l'exemple. Encore une chose apprise :)

Merci Ludovic