+ Répondre à la discussion
Affichage des résultats 1 à 14 sur 14
  1. #1
    Membre éprouvé
    Homme Profil pro
    Inscrit en
    juin 2006
    Messages
    928
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44

    Informations forums :
    Inscription : juin 2006
    Messages : 928
    Points : 415
    Points
    415
    Billets dans le blog
    1

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

    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.

  2. #2
    Nouveau Membre du Club
    Inscrit en
    octobre 2010
    Messages
    21
    Détails du profil
    Informations forums :
    Inscription : octobre 2010
    Messages : 21
    Points : 29
    Points
    29

    Par défaut

    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.

  3. #3
    Membre éprouvé
    Homme Profil pro
    Inscrit en
    juin 2006
    Messages
    928
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44

    Informations forums :
    Inscription : juin 2006
    Messages : 928
    Points : 415
    Points
    415
    Billets dans le blog
    1

    Par défaut

    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.

  4. #4
    Membre éprouvé
    Homme Profil pro
    Inscrit en
    juin 2006
    Messages
    928
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44

    Informations forums :
    Inscription : juin 2006
    Messages : 928
    Points : 415
    Points
    415
    Billets dans le blog
    1

    Par défaut

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

    Merci pour vos réponse.

  5. #5
    Membre éprouvé
    Homme Profil pro
    Inscrit en
    juin 2006
    Messages
    928
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44

    Informations forums :
    Inscription : juin 2006
    Messages : 928
    Points : 415
    Points
    415
    Billets dans le blog
    1

    Par défaut

    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;

  6. #6
    Nouveau Membre du Club
    Inscrit en
    octobre 2010
    Messages
    21
    Détails du profil
    Informations forums :
    Inscription : octobre 2010
    Messages : 21
    Points : 29
    Points
    29

    Par défaut

    Citation Envoyé par jovalise Voir le message
    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.

    Citation 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.

  7. #7
    Membre éprouvé
    Homme Profil pro
    Inscrit en
    juin 2006
    Messages
    928
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44

    Informations forums :
    Inscription : juin 2006
    Messages : 928
    Points : 415
    Points
    415
    Billets dans le blog
    1

    Par défaut

    Citation Envoyé par Jaizu Voir le message

    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.

  8. #8
    Membre éprouvé
    Homme Profil pro
    Inscrit en
    juin 2006
    Messages
    928
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44

    Informations forums :
    Inscription : juin 2006
    Messages : 928
    Points : 415
    Points
    415
    Billets dans le blog
    1

    Par défaut implémentatiion hétérogène.

    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.

  9. #9
    Membre à l'essai
    Inscrit en
    mars 2011
    Messages
    25
    Détails du profil
    Informations forums :
    Inscription : mars 2011
    Messages : 25
    Points : 20
    Points
    20

    Par défaut

    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)


    Il est bien sûr possible d'automatiser la création de certains types d'objets descendant de Obj via des génériques.

    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 modifié ou plus radicalement 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).

  10. #10
    Membre éprouvé
    Homme Profil pro
    Inscrit en
    juin 2006
    Messages
    928
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44

    Informations forums :
    Inscription : juin 2006
    Messages : 928
    Points : 415
    Points
    415
    Billets dans le blog
    1

    Par défaut

    Emilie, merci pour l'effort d'édition et d'explication, mais je regrète de n'avoir rien compris à ce quez je devrais faire.

  11. #11
    Membre à l'essai
    Inscrit en
    mars 2011
    Messages
    25
    Détails du profil
    Informations forums :
    Inscription : mars 2011
    Messages : 25
    Points : 20
    Points
    20

    Par défaut Univers d'objets

    @Jovalise

    Je vous donne en illustration, le schéma simplifié d'héritage entre les types des objets de l'univers que je vous propose.
    Images attachées Images attachées

  12. #12
    Membre éprouvé
    Homme Profil pro
    Inscrit en
    juin 2006
    Messages
    928
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44

    Informations forums :
    Inscription : juin 2006
    Messages : 928
    Points : 415
    Points
    415
    Billets dans le blog
    1

    Par défaut

    Merci encore pour votre attention.

    Je pense pas avoir les compétence que vous croyez que j'ai.
    Je comprends un peu le langage Ada, extérieurement au reste.
    Pour faire une transition, français -> Ada, doit falloir avoir un bagage.
    Je passe même pas par les pseudo code.
    L'image c'est bien, mais ça me dis pas comment le spécifier et les limited_controlled, je me demande si c'est pareil ?
    Je comprends rien à la doc Ada non plus souvant in english text, ce qui me rebute.
    Bref, je pensais pas du tout que c'était si complelxe que ça de faire un gestionnaire étherogène.

  13. #13
    Membre éprouvé
    Homme Profil pro
    Inscrit en
    juin 2006
    Messages
    928
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44

    Informations forums :
    Inscription : juin 2006
    Messages : 928
    Points : 415
    Points
    415
    Billets dans le blog
    1

    Par défaut Nouvel essai.

    Bonjour,
    Je me re- penche sur le sujet, c'est pas simple mais j'ai une question, j'espère que vous comprendrez mon intérêt du sujet.

    J'écris tout de suite une nouvelle bibliothèque en prenant l'esprit de chacun des participants du sujet. Jaizu Emilie. Internet, et Ada.

    J'ai d'abord déclaré un paquetage Libmy, une bibliotèque vide.
    J'ai ensuite déclaré un paquetage en Libmy.Virtual qui déclre une classe abstraite de garde pour une corection éventuelle du niveau d'abstraction quelle représente, soit la classe parente de tout les objets.
    En suite j'ai déclaré une classe abstraite objet dérivé de virtual parce que je pense à ce niveau pouvoir ajouter d'autre classe enfant de virtual qui ne seront pas des objets.
    Enfin, j'ai déclaré un paquetage générique generic element qui doit me permettre de gérer grâce à un gestionnaire de donnée, tous les elements de classe objets.


    Ce qui donne ceci :
    Code ada :
    1
    2
    3
    4
    package Libmy is
          
    end Libmy;
    Code ada :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    package Libmy.virtual is
       
       type Virtual_Type is abstract tagged private;
       
    private
       
       type Virtual_Type is abstract tagged null record;
       
    end Libmy.Virtual;
    Code ada :
    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    
    package Libmy.Virtual.Objects is
       
       type Object_Type is abstract new Virtual_Type with private;      
    private
       
       type Object_Type is abstract new Virtual_Type with null record;
       
    end Libmy.Virtual.Objects;
    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 Ada.Finalization;
    generic      
       
       type Element_Type(<>) is new Object_Type with private;
       
       Default_Value : Element_Type;
       
       with function "+"(Element : in Element_Type) return Element_Type is <>;
    		  
    		  
    package Libmy.Virtual.Objects.Generic_Elements is
       
       type Element_Access is access all Element_Type'Class;
       
       
       type Element_Handle is private;
       
       function "+" (Handle : Element_Handle) return Element_Access;      
       
    private
          
       type Element_Handle is new Ada.Finalization.Controlled with
          record
    	 Element : Element_Access;
          end record;
       
    end Libmy.Virtual.Objects.Generic_Elements;

    Je cherche maintenant, comment organiser ma bibliothèque pour déclarer mon paquetage de gestion de données (d'objet virtuel).

    Merci pour vos conseil.

    Peut-être serait-il judicieux de vous dire où je veux en venir ?
    Je m'attarde de temps à autre l'analyse du système général, et j'espère un jour modéliser celui ci au mieux.

  14. #14
    Membre éprouvé
    Homme Profil pro
    Inscrit en
    juin 2006
    Messages
    928
    Détails du profil
    Informations personnelles :
    Sexe : Homme
    Âge : 44

    Informations forums :
    Inscription : juin 2006
    Messages : 928
    Points : 415
    Points
    415
    Billets dans le blog
    1

    Par défaut

    C'est le béa-bat de la création d'une donnée en faite.
    Ou je, je sais plus. Je suis fatigué.

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •