POO Bibliothèque permettant de crée des objet de tous les types Ada

[jovalise]

bonjour à tous. Merci de me lire.
Dans le cadre de recherches sur le développement de l'intelligence artificielle, je souhaite écrire un programme pour manipulera des objets et des fonctions pour tous les types Ada.

Je souhaite donc écrire un bibliothèque pour créer des objets de tous les types qui doivent tous être stocké dans un même gestionnaire de données.

Je voudrais savoir s'il vous plaît :
Si c'est possible à votre avis ?
Si ce que j'ai commencé à faire est viable ? est-ce pas trop mal organisé ?
Comment faire mieux ?
C'est la première fois que je programme orienté objet, j'aurais voulus savoir si pour faire un gestionnaire de données hétérogènes, je vais pas être embêté quelque part ?
Voici ce que j'ai fait...

j'ai d'abord une classe abstraite Object_Type dans le fichier "mos-objetc.ads".

Code ada :

1
2
3
4
5
6
7
8
9
10
11
12

with Ada.Finalization;                   use Ada.Finalization;

package Mos.objects is
   type Object_Type is abstract new Limited_Controlled with null record;
   type Object_Type_Access is access all Object_Type'class;
   procedure Initialize(Cible : in out Object_Type) is abstract;
   procedure Finalize(Cible : in out Object_Type'class) is abstract;
   procedure Make(cible : in out Object_Type'class) is abstract;

end Mos.objects;

J'ai ensuite 11 dérivation de la classe Object_Type, une pour chacun des types de base Ada dans des fichiers distincts dont voici l'éxtrait des Real dérivé du type Object_Type.

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

package Mos.Objects.Real is

   type Real_Object_Type is
     new Object_Type with
      record
         Real : Float := 0.0;
      end record;

   type Real_Object_Access is access all Real_Object_Type'Class;
      type Action_Type is
     access procedure (Cible : in out Real_Object_Type'class);
   procedure Make(cible : in out Real_Object_Type);

   procedure Initialize(Cible : in out Real_Object_Type);
   procedure Finalize(Cible : in out Real_Object_Type);

end Mos.Objects.Real;

Voici le début de specification du manager:

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
with Graph_Handler;                      use Graph_Handler;
with Mos.Types;                          use Mos.Types;
with Mos.Objects;                        use Mos.Objects;
with Mos.Objects.enum;                   use Mos.Objects.enum;
with Mos.Objects.signed;                 use Mos.Objects.signed;
with Mos.Objects.modulo;                 use Mos.Objects.modulo;
with Mos.Objects.real;                   use Mos.Objects.real;
with Mos.Objects.decimal;                use Mos.Objects.decimal;
with Mos.Objects.ordinary;               use Mos.Objects.ordinary;
with Mos.Objects.table;                  use Mos.Objects.table;
with Mos.Objects.article;                use Mos.Objects.article;
with Mos.Objects.protect;                use Mos.Objects.protect;
with Mos.Objects.tasking;                use Mos.Objects.tasking;
package Mos.Objects.Manager is
   type Node_Type;
   type Node_Access is access all Node_Type;
   type Connector_Type is array ( Positive range <> ) of Node_Access;
   type Connector_Access is access all Connector_Type;
   type Node_Type is
      record
         Connector       : Connector_Access;
         Info            : Info_Type;
         Vertex_Of_Graph : Vertex;
         Object          : Object_Type_Access;
      end record;
   type Manager_Type is
      record
         Root : Node_Access;
         Graph : Graph_Handler.Graph;
      end record;
end Mos.Objects.Manager;

Bon, à vrai dire je suis plus embêté que ça puisque j'aurais aimé pouvoir déclarer des types. Mais je suis encore aussi embêté pour les Record, les tableaux, les point-fixes, les enumération, les task, les protected, enfin, je suis très embêté.. Comment faire.

Voici l'état du projet (c'est un peu gros de par les donnée embarquées et lesbibliotèques externe) : http://www.toofiles.com/fr/oip/docum...ta_001tar.html
Le projet s'appelle "Mos"


Merci.

[Jaizu]

Bonjour Jovalise.

Tout d'abord, je vous conseillerai cet article (pour ada 95) et ce "rationale for ada 2005". Ils parlent des fabriques (patron de conception) en Ada, qui semblent bien correspondre à vos besoins.

Si vous souhaitez plutôt faire votre fabrique à la main, dans l'idée de "déclarer un type à la volée" (avec toutes ses opérations), la solution la plus simple et proche me venant en tête serait quelque chose comme :

Code ada :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
generic
   type Any_Concrete_Type(<>) is limited private;
   -- n'importe quel type concret, même tagged ou "task type".

   Default_Value : Any_Type;
   -- valeur par défaut si nécessaire.

   with function "+"(A_C_T : Any_Concrete_Type) return Any_Concrete_Type is <>;
   -- fonction d'identité.

package Mos.Objects.generic_implementation is

   -- ne fonctionne pas car le type est non contraint, c'est juste pour donner l'esprit
   type Generic_Object is new Mos.Objects.Object_Type with
      record
         value : Any_Concrete_Type;
      end record;

   -- [...]

end Mos.Objects.generic_implementation;

p.s. : je ne sais pas si ça vient de moi, mais il semblerait que toofiles n'ait plus votre archive.

[jovalise]

Code :

1
2
type Any_Concrete_Type(<>) is limited private;
   -- n'importe quel type concret, même tagged ou "task type".

Henn, c'est merveilleux. La généricité C'est très élégant !
Je vais tenter une interprétation des références, mais je suis anglophobe

Merci Jaizu !


Pour l'archive ell n'est plus disponible pour moi non plus.

[jovalise]

Si je met un type accès à Any_Conrete_Type dans mon type Generic_Object, C'est bon ?

Merci pour vos réponse.

[jovalise]

Je n'ai pas compris l'utilité de la démarche en fait.
J'ai un peu tourné mon code dans tout les sens.
Je ne sais pas si ce que je suis parvenu à faire est correct et représentatif de ma solution.
Bon, la bibliothèque s'appelle cnnc.ads
Je me demande si j'ai pas un peu tout confondu ce coir.
Au résultat, je doit pourvoir appliquer des opération sur des objets qui son la propriété d'utilisateurs. Ici, on ne se préoccupe pas des utilisateurs.

Voici ce que j'ai fait :

Code :

1
2
3
4
5
--                                 Root lib unit                               --
--                                (Specification)                              --
package CNNC is

end CNNC;

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
--                                  Objects unit                               --
--                                (Specification)                              --
with Ada.Finalization;                   use Ada.Finalization;

package CNNC.objects is
   type Object_Type is abstract tagged null record;
   type Object_Access is access all Object_Type'Class;
   procedure Initialize(Cible : in out Object_Type'Class) is abstract;
   procedure Finalize(Cible : in out Object_Type'Class) is abstract;
   procedure Make(cible : in out Object_Type'Class) is abstract;

end CNNC.objects;

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
--                                  Actions unit                               --
--                                (Specification)                              --
with CNNC.Objects;                       use CNNC.Objects;

package CNNC.Actions is

   type Process_Type is access procedure (Object : in out Object_Access);
   type Action_Type is tagged
      record
         Process : Process_Type;
      end record;
   type Action_Access is access all Action_Type'class;
end CNNC.Actions;

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
--                            Object_Id_1Type unit                        --
--                                (Specification)                              --
with CNNC.Actions;                       use CNNC.Actions;
with CNNC.Objects.Generic_Implementation;
package CNNC.Objects.Object_Id_1 is

   package Object_1 is
      new CNNC.Objects.Generic_Implementation(Object_Type'Class);
   use Object_1;

   type Object_Id_1_type is new Generic_Object_Type with
      record
         Num : Integer := 0;
      end record;

   procedure Action_Id_1(Object : in out Object_Access);
   procedure Action_Id_2(Object : in out Object_Access);
   procedure Action_Id_3(Object : in out Object_Access);
   procedure Action_Id_4(Object : in out Object_Access);

Je me retrouve avec un type dérivé de Generic_Object sans savoir pourquoi au final !
C'est à dire j'ai pasé la journé à étudier d'autre piste. 2

Le main pour la forme :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
--                                   Main Unit                                 --
--                                (implementation)                             --
with CNNC.Objects;                       use CNNC.Objects;
with CNNC.Objects.Object_Id_1;           use CNNC.Objects.Object_Id_1;
with CNNC.Actions;                       use CNNC.Actions;

procedure Main is

   Action_1 : Action_access := new Action_Type ' (Process => Action_Id_1'Access);
   Action_2 : Action_access := new Action_Type ' (Process => Action_Id_2'Access);
   Action_3 : Action_access := new Action_Type ' (Process => Action_Id_3'Access);
   Action_4 : Action_access := new Action_Type ' (Process => Action_Id_4'Access);
   Object : Object_Access;
begin

   Action_1.process(Object);
   Action_3.process(Object);
   Action_4.process(Object);
   Action_4.process(Object);
   Action_3.process(Object);

end Main;

[Jaizu]

Envoyé par jovalise

Si je met un type accès à Any_Conrete_Type dans mon type Generic_Object, C'est bon ?

Merci pour vos réponse.

Oui, c'était ça l'idée en effet.

Envoyé par jovalise

Je n'ai pas compris l'utilité de la démarche en fait.

Au moins c'est très clair.

Dans ce cas, je vais donc m'enfoncer dans détailler mon idée de départ. Vous parlez bien de déclarer un nouveau fils d'Object_Type sans avoir à réécrire un ads et un adb, comme on le ferait pour les listes ou des tables de hachage ?

Comme je n'ai malheureusement pas pu vérifier, j'ai fait les suppositions suivantes de ce que j'ai vu : les méthodes initialize / make / finalize vont faire la même chose modulo le type. De plus, il y a un pointeur de classe pour chaque type dérivé. Voilà ce à quoi je pensais pour l'implémentation générique :

Code ada :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
generic
   type Any_Concrete_Type(<>) is limited private;
   -- n'importe quel type concret, même tagged ou "task type".

package CNNC.Objects.generic_implementation is

   type Access_Current_Type is access Any_Concrete_Type;

   type Object_Type is new CNNC.Objects.Object_Type with
      record
         value : Access_Current_Type;
      end record;

   type Object_Access is access all Object_Type'Class;

   type Action_Type is
     access procedure (Cible : in out Object_Type'class);
   -- est-ce encore utile avec CNNC.actions ?
   -- dans le doute je le mets quand même.

   procedure Initialize(Cible : in out Object_Type);
   procedure Finalize(Cible : in out Object_Type);
   procedure Make(cible : in out Object_Type);

end CNNC.Objects.generic_implementation;

Ce qui permet ensuite d'écrire :

Code ada :

1
2
3
4
with CNNC.Objects.generic_implementation;

package CNNC.Objects.Real is
new CNNC.Objects.generic_implementation(Any_Concrete_Type => Float);

On aurait alors quelque chose de fortement similaire au paquetage real du premier post en théorie. Ada fournit aussi de quoi manipuler les types :

Code ada :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
with CNNC.Objects;                       use CNNC.Objects;
with CNNC.objects.Real;

with Ada.Text_IO; use ada.Text_IO;

procedure Exemple is
   package Boolean_IO is new Ada.Text_IO.Enumeration_IO(Boolean);

   pointeur : Object_Access;
begin
   pointeur := new Real.Object_Type;

   Put_Line("dans la classe d'Object_Type ?");
   Boolean_IO.put(pointeur.all in Object_Type'class);
   -- dans la classe d'Object_Type ?
   -- TRUE

   New_Line;
   Put_Line("dans le type Object_Type ?");
   Boolean_IO.put(pointeur.all in Object_Type);
   -- dans le type Object_Type ?
   -- FALSE

   New_Line;
   Put_Line("dans le type Real.Object_Type ?");
   Boolean_IO.put(pointeur.all in Real.Object_Type);
   -- dans le type Real.Object_Type ?
   -- TRUE
end Exemple;

Il y a aussi le paquetage Ada.Tags qui devrait se montrer intéressant ainsi que l'attribut 'tag.

En espérant que ça vous sera utile.

[jovalise]

Envoyé par Jaizu

Il y a aussi le paquetage Ada.Tags qui devrait se montrer intéressant ainsi que l'attribut 'tag.

En espérant que ça vous sera utile.

Bonjour Jaizu, merci pour l'exemple d'utilisation, j'avais fini par me faire à l'idée que c'était ça l'idée. Je m'étais un peu embrouillé. j'avais compris au premier coup mais ça collais pas avec ce que je venais de faire.
Merci encore Jaizu.

[jovalise]

Bonjour, bonjour Jaizu,

J'en suis toujours au même point, à réfléchir.
Le problème de l'implémentation que vous me proposez est que je ne peut pas mettre tout les type d'objets dans un seul est unique gestionnaire de données.

Existe t-il une solution, je suis au mieux bloquer par la séparation des types limités et les autres.

Si vous aviez une réponse, est t-il possible de mettre tous les objets dans une même gestionnaire de donnée. Un gestionnaire hétérogène quoi ?
Merci pour vos réponses.

[Emile8]

Bonjour,

Je vous donne schématiquement mon idée pour construire et gérer un univers d'objets qui peuvent être très généraux à travers leur encapsulation dans les dérivés d'un type d'objet racine Père.

1. Définir un type d'objet racine abstrait Obj avec une relation d'ordre locale qui aura vocation à être surchargée et une relation d'ordre globale qui est la combinaison d'une relation d'ordre entre types basée sur leurs positions relatives dans l'arbre d'héritage (Si un type est dynamiquement évalué plus bas dans la l'arbre d'héritage qu'un autre , on dit qu'il est plus petit. Si les profondeurs sont les mêmes, on dit que le plus petit est celui qui a le Tag le plus petit après une conversion des Tags en nombres) et d'une relation d'ordre locale. Pour trouver le plus grand de deux objets, s'ils ont le même type, on prend le plus grand par une comparaison locale sinon on prend celui qui a le type le plus grand.
   
   
2. Dériver de ce type d'objet Obj autant de types d'objets élémentaires que vous désirez pour représenter les "atomes" de votre univers (un entier, un string, un tableau etc). Redéfinir pour chacun de ces types d'objets une relation d'ordre locale.
   
   
3. Dériver de ce type d'objet Obj un type d'objet "couple" qui sera composé de deux pointeurs vers des objets quelconques. Définir une relation d'ordre locale sur ces couples (l'ordre lexicographique semble naturel). Cela vous permettra d'avoir la notion de paire à votre disposition pour vos modélisations.
   
   
4. Dériver de ce type d'objet Obj un type d'objet "liste" qui sera composé d'une liste de pointeurs vers des objets quelconques descendants de Obj. Définir une relation d'ordre locale sur ces listes (l'ordre lexicographique semble naturel). Cela vous permettra d'avoir la notion de liste à votre disposition pour vos modélisations.
   
   
5. Vous pouvez définir aussi des Piles, des Tas (Heap) et d'autres structures de données de pointeurs vers des objets de type descendant d'Obj. Pensez à redéfinir leur relation d'ordre locale.
   
   
6. Dériver de ce type d'objet Obj un type d'objet "ensemble" (type Red-black-tree) qui peut contenir sous forme de pointeurs tout élément dérivé de Obj et dont la relation d'ordre sera la relation d'ordre générale de Obj. Définir une relation d'ordre locale entre ces ensembles. Cela vous permettra d'avoir la notion d'ensemble à votre disposition pour modéliser votre environnement. (attention vous ne pourrez pas construire un ensemble contenant un objet utilisant ce même ensemble dans sa définition, par contre vous pourrez avoir un ensemble hétérogène ayant par exemple 4 éléments à savoir un autre ensemble de 17 éléments, une liste, une paire (ensemble, nombre) et une chaine de caractères)

Créer à part un container ordonné qui sera l'univers de vos objets (atomes, couples, listes, ensembles...) avec pour relation d'ordre la relation d'ordre générale du type Obj.
Attention ce container de doit pas être d'un type descendant du type Obj.

Bien sûr il faudra savoir gérer cet univers d'objets lors de leurs créations, modifications et disparitions.

Par exemple à sa création on peut faire en sorte que tout objet soit inséré dans le container univers. Cela permettra d'ailleurs d'éviter les doublons.

On peut aussi associer à chaque objet O de l'Univers un container d'objets amis (pas un objet ensemble descendant du type Obj ! sinon on aura des problèmes de cohérence) qui rassemble tous les autres objets de l'univers dans lesquels O intervient. Si O venait à être finalisé avant disparition, son container d'amis donnerait tous les autres objets à mettre à jour (il y a un joli tri topologique dans le graphe des relations entre objets à mettre en œuvre pour que l'univers puisse évoluer en douceur).