Discussion :

[Invité]

Bonjour,
J'écris un compositeur virtuel interactif.
Je souhaite écrire une partie de mon programme grâce à la modélisation orienté objet.

Pour le moment, j'ai défini :

Un type Category_Type : (défini la classe d'instrument)

Code ada :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
 type Category_Type is (Off, Drums_Kit, Global,
                          Bass, Lead, Synth_Hard, Synth_Soft,
                          Motion, Strings_N_Pads, Keyboard, Guitare_N_Pluck,
                          Bell_N_Decay, Hit_N_Drum, S_E, Arp_Seq,
                          Split, Audio_In, Vocoder, User);

Un type Form_Type : (défini la forme musicale)

Code ada :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
type Form_Type is (Null_Item,
                      Classical, Electro, Jazz,
                      Acid, Techno, Hardtech, Tribe,
                      Hardcore, Trance, Minimal, DnB);

Un type Num_Type : (défini le nombre de temps dans une mesure)

Code ada :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
subtype Num_Type is Positive range 1..16;

Un type Den_Type : (défini la résolution d'un temps, si on joue à la croche ou autre)

Code ada :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
 
subtype Den_Type is Positive range 1..16;

Un type Step_Seq_Type : défini un tableau de vecteur de C.long)

Code ada :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
package Longs_Vectors is new Ada.Containers.Vectors(positive,
                                                       long,
                                                       "=");
use Longs_Vectors;
 
type Step_Seq_Type is array (Natural range <>) of Vector;
type Step_Seq_Access is access Step_Seq_Type;

Ce que je voudrais, c'est écrire autant de fonction ou procédure que de forme*Catégorie pour composer une séquence de pas en fonction des caractéristique de mon objet (forme*Catégorie)

Comment procéderiez vous ?

[Jaizu]

Bonjour,

S'il fallait utiliser de l'objet, je proposerais quelque chose comme un type "instrument jouable" qui aurait un Category_Type et un Form_Type en disciminant. Les types fils de cet "instrument jouable" auraient alors tout le loisir d'ajouter une contrainte au discriminant du type père.

Cependant, s'il y a un unique comportement par couple (Forme * Catégorie), faire des méthodes qui contiendraient juste un case qui se contenterait d'appeler la "bonne" méthode à chaque fois me paraît plus approprié. En effet, si le type n'est pas tagged, il est toujours possible de créer un type dérivé qui pourra tout autant ajouter des contraintes au discriminant, tout en assurant un comportement unique pour chaque (Forme * Catégorie).

[Invité]

Bonjour,

S'il fallait utiliser de l'objet, je proposerais quelque chose comme un type "instrument jouable" qui aurait un Category_Type et un Form_Type en disciminant. Les types fils de cet "instrument jouable" auraient alors tout le loisir d'ajouter une contrainte au discriminant du type père.

Bonsoir, merci d'abord, jaizu.

En effet j'ai implémenté une pseudo solution, parce qu'elle ne fonctionne pas avec des méthode utilisable pour plusieur tuple (fome * catégorie)

Avec Ada ça donnerait quoi ta soluce ?

[Jaizu]

En Ada, ça donnerait :

Code ada :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
type Instrument(Form : Form_Type; Category : Category_Type) is abstract tagged null record; -- pas forcé d'être abstrait et "null record"
 
type Bidule is new Instrument(Form => Null_Item, Category => Off) with null record;

Et ainsi de suite, avec à chaque fois la surcharge des méthodes à surcharger bien sûr.

[Invité]

Je vais peut-être faire quelque chose comme ça cette fois, la dernière fois j'avais avancé avec d'autres solutions ou pas, parce que je recommence donc.

J'avais oublié de te dire merci, alors un grand merci jaizu !

[Invité]

bonjour à tous, bonjour Jaizu si tu est parmi les lecteurs.

Je crois que j'ai fait une grosse bêtise, mais j'espère en venant ici que vous allez me sortir de mon ignorance plutôt que de me dire que je me suis lamentablement planté.

Voilà, j'ai écrit ceci pour le moment :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 type Composer_Type;
 
 
   task type Compositor_Type (Composer : access Composer_Type;
                              Form     : Form_Type;
                              Category : Valid_Category_type) is
      pragma Storage_Size (16777216);
      entry Initialize(Samples_Set : in Samples_Set_Type);
      entry Train(Converged : in Real);
      entry Start(Date : in Time; Tempo : in Long_Float);
      entry Stop;
      entry Halt;
      entry Respond(Text : in String; Feedback : out String_access; Channel : in Channel_Type; sequence : out Seq_Vectors.vector);
   end Compositor_Type;
 
   type Composer_Type (Form     : Form_Type;
                       Category : Valid_Category_Type) is limited
 
      record
 
         Network                : Network_Type(Form, Category);
         Compositor             : Compositor_Type(Composer_Type'Access, Form, Category);
      end record;
 
   type Composer_Access is access all Composer_Type;

Donc, je me trouve avec une tache paramétrée dans laquelle j'aimerai appeler une fonction "compose" pour chacune des combinaison Form*category.

Mais je me trouve devant une erreur.

J'aurais aimer à présent pouvoir utiliser un type dans le genre de celui décrit par Jaizu.

Voici ce que j'ai écrit dans un paquetage Arche

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package Mal.Arche is
 
   type Arche_Type(Form : Form_Type; Category : Category_Type) is tagged null record;
 
   type CLASSICAL_BASS_Type is new Arche_Type(Form => CLASSICAL, Category => BASS) with null record;
   type CLASSICAL_LEAD_Type is new Arche_Type(Form => CLASSICAL, Category => LEAD) with null record;
   type CLASSICAL_SYNTH_HARD_Type is new Arche_Type(Form => CLASSICAL, Category => SYNTH_HARD) with null record;
   type CLASSICAL_SYNTH_SOFT_Type is new Arche_Type(Form => CLASSICAL, Category => SYNTH_SOFT) with null record;
   type CLASSICAL_MOTION_Type is new Arche_Type(Form => CLASSICAL, Category => MOTION) with null record;
 
   function Compose (Arche : in CLASSICAL_BASS_Type'Class) return Seq_Vectors.Vector;
   function Compose (Arche : in CLASSICAL_LEAD_Type'Class) return Seq_Vectors.Vector;
   function Compose (Arche : in CLASSICAL_SYNTH_HARD_Type'Class) return Seq_Vectors.Vector;
   function Compose (Arche : in CLASSICAL_SYNTH_SOFT_Type'Class) return Seq_Vectors.Vector;
   function Compose (Arche : in CLASSICAL_MOTION_Type'Class) return Seq_Vectors.Vector;

Mais Gnat me dis clairement :

mal-rhetorica.adb:396:49: no candidate interpretations match the actuals:
mal-rhetorica.adb:396:57: expected type "JAZZ_DRUMS_KIT_Type'Class" defined at mal-arche.ads:55
mal-rhetorica.adb:396:57: found type "Arche_Type" defined at mal-arche.ads:3
mal-rhetorica.adb:396:57: ==> in call to "Compose" at mal-arche.ads:107
mal-rhetorica.adb:396:57: ==> in call to "Compose" at mal-arche.ads:106
mal-rhetorica.adb:396:57: ==> in call to "Compose" at mal-arche.ads:105

J'ai déclaré ma variable dans mal-rhetorica ainsi :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

Arche : Arche_Type(Form, Category);

J'ai aussi essayer de spécifier des sous-type à la place de type dérivé, mais j'obtiens également une erreur.


Comment faire, si vous avez une idée, je suis preneur. Merci dans tout les cas.

[Invité]

Je viens d'essayer également de passer une type access Arche_Type'class à mon composer, que j'initialise avec le type dérivé mais j'obtiens encore une erreur.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 type Composer_Type;
 
 
   task type Compositor_Type (Composer : access Composer_Type;
                              Arche : access Arche_Type'class) is
      pragma Storage_Size (16777216);
      entry Initialize(Samples_Set : in Samples_Set_Type);
      entry Train(Converged : in Real);
      entry Start(Date : in Time; Tempo : in Long_Float);
      entry Stop;
      entry Halt;
      entry Respond(Text : in String; Feedback : out String_access; Channel : in Channel_Type; sequence : out Seq_Vectors.vector);
   end Compositor_Type;
 
   type Composer_Type (Arche : access Arche_Type'class) is limited
 
      record
 
         Network                : Network_Type;
         Compositor             : Compositor_Type(Composer_Type'Access, Arche);
      end record;
 
   type Composer_Access is access all Composer_Type;

Puis à l'initialisation :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 for Form in Form_Type loop
            for Category in Valid_Category_Type loop
               case Form is
                  when CLASSICAL =>
                     case Category is
                        when BASS =>
                           BandMaster.Orchester(Form, Category) := new Composer_Type(new CLASSICAL_BASS_Type);
                        when LEAD =>
                           BandMaster.Orchester(Form, Category) := new Composer_Type(new CLASSICAL_LEAD_Type);
                        when SYNTH_HARD =>
                           BandMaster.Orchester(Form, Category) := new Composer_Type(new CLASSICAL_SYNTH_HARD_Type);
                        when SYNTH_SOFT =>
                           BandMaster.Orchester(Form, Category) := new Composer_Type(new CLASSICAL_SYNTH_SOFT_Type);
                        when MOTION =>
                           BandMaster.Orchester(Form, Category) := new Composer_Type(new CLASSICAL_MOTION_Type);

Mais à l'appel de compose Gnat me dit :

no candidate interpretations match the actuals:
mal-rhetorica.adb:396:63: expected type "JAZZ_DRUMS_KIT_Type" defined at mal-arche.ads:55
mal-rhetorica.adb:396:63: found type "Arche_Type'Class" defined at mal-arche.ads:3
mal-rhetorica.adb:396:63:

Je crois que je suis planté là.

[Invité]

Pour le moment j'ai casté mon type Arche avec un gros case.
Je suis certain de m'être planté quand même.

Mais je vais résoudre cette discussion, on reviendra peut-être sur le sujet demain ou lus tard.

Merci pour votre aide.