Modélisation objet (éléments musicaux)

[jovalise]

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 :

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 :

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 :

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 :

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 :

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

[jovalise]

Envoyé par 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.

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 :

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.