Règles du forum

Le langage Ada uniquement, pas les compilateurs. Les questions de sémantique et de langage et les questions techniques liées à une application en particulier, son deux choses différentes. Si nécessaire, un forum sur GNAT et les autres compilateurs, tel JanusAda, sera ouvert.

Auteur Message
Emmanuel Sens
Beau Parleur
Avatar de l’utilisateur
Bonjour, bonjour à tous, bonjour Hibou.

Comme je dis dans la catégorie Création perso, cette année (2018) je travaille sur mon projet de compositeur virtuel pour instruments MIDI.

J'en suis à mon 5ieme essai qui réussi cette fin d'année à me faire recommencer en apportant les améliorations qui s'imposent.

Déjà, ces derniers jours j'ai ré-écrit les base pour partager une unique instance de drivers de périphériques. Ce qui permet de jouer plusieur fichier à la fois.

J'ai également implementté un mode play list en boucle eventuellement.

Cette fois je viens ici pour spécifier une nouvelle hiérachie d'objet spécifique à un timbre, ou à un plugin.

En fait un timbre peut avoir plusieurs plugins.

Voici ma specification pour le moment ; Juste deux class de plugin.

Source ada : 

with Ada.Finalization;                  use Ada.Finalization;
package Libultrason.Work_Class is

   type Work_Record is new Limited_Controlled with private;

   procedure Initialize(Work : in out Work_Record);
   procedure Finalize(Work : in out Work_Record);
   type Work_Access is access all Work_Record'Class;

   type Plugin_Class is (Genetical, Neural);

private
   task type Work_Processing(Work : access Work_Record) is
      entry Init;
   end Work_Processing;

   type Abstract_Plugin_Class(Class : Plugin_Class) is abstract tagged limited null record;

   type Abstract_Plugin_Access is access all Abstract_Plugin_Class'Class;

   type Genetical_Record;
   task type Genetical_Processing(Genetical : access Genetical_Record) is
      entry Init;
   end Genetical_Processing;

   type Genetical_Record is new Abstract_Plugin_Class(Class => Genetical) with
      record
         Process : Genetical_Processing(Genetical_Record'Access);
      end record;

   type Neural_Record;
   task type Neural_Processing(Neural : access Neural_Record) is
      entry Init;
   end Neural_Processing;

   type Neural_Record is new Abstract_Plugin_Class(Class => Neural) with
      record
         Process : Neural_Processing(Neural_Record'Access);
      end record;

   type Plugin_Set is array (Positive range <>) of Abstract_Plugin_Access;


   type Work_Record is new Limited_Controlled with
      record
         Plugins : Plugin_Set(1..2) := (1 => new Genetical_Record, 2 => new Neural_Record);
         Process : Work_Processing(Work_Record'Access);
      end record;
end Libultrason.Work_Class;


La classe Work_Record enveloppe un tableau d'access à la classe Abstract_Plugin_Class pour maintenir un tableau héthérogène de plugin.

J'ai en réalité deux classe à l'échele Class_Wide à spécifier, l'une étant celle qui implémente la class concrète des divers plugins ; L'autre étant cette qui va présenter l'interface de ces plugins à l'utilisateur.

J'ai en fait besoin d'un coup de main pour commencer ou pour discuter de l'architecture des objets relatif à la musique et au instrument de musique.

Bienvenue. Merci.
Profil
Emmanuel Sens
Beau Parleur
Avatar de l’utilisateur
Si je calcule un peut ce que j'ai fait, il y a un paquet d'endroit ou je vais caster les objet.

J'avais une ou deux question à propos cu cast, est-ce possible de l'évité, si non est-ce normale d'avoir à caster un objet ?
Profil
Emmanuel Sens
Beau Parleur
Avatar de l’utilisateur
Bonjour,

J'ai fait un peu différement, mais j'ai un problème d'aiguillage automatique.

Dans le main, j'appelle la procédure print pour chacun des plugins contenu dans un work_record mais le compilateur me dit qu'il attends un type implémentant la procedure print, mais que je lui passe un type Abstrait de la classe supérieur.

le code :

le type abstait de mes plugins :

Source ada : 

package Libsens.Virtual.Plugins is


   type Abstract_Plugin_Class is abstract tagged null record;



   type Plugin_Class(Class : Plugin_Enum) is abstract new Abstract_Plugin_Class with
      record

         Id        : Plugin_Num := 1;

         Device_ID : Device_Num := 1;
         Ch_ID     : Channel_Num := 1;

         Form_ID   : Form_Index_Type := 1;
         Cat_ID    : Category_Index_Type := 1;

         Printed   : Boolean := True;
         Mutted    : Boolean := False;
         Opened    : Boolean := False;
      end record;
   procedure Print(Plug : in Plugin_Class) is abstract;
end Libsens.Virtual.Plugins;



un plugin parmis d'autre :

Source ada : 

with Libsens.Virtual.Plugins;           use Libsens.Virtual.Plugins;
package Libsens.Virtual.CC_Change is
   type CC_Change_Plugin_Record is
     new Plugin_Class(CC_List) with
      record
         null;
      end record;
   procedure Print (Plug : in CC_Change_Plugin_Record);
end Libsens.Virtual.CC_Change;


le cord de la classe Work_Class : ou je fait un test d'initialization.

Source ada : 

with Libsens.Virtual.Cc_Change;         use Libsens.Virtual.Cc_Change;
with Libsens.Virtual.Prgm_Change;       use Libsens.Virtual.Prgm_Change;
with Libsens.Virtual.NN_Plugin;         use Libsens.Virtual.NN_Plugin;
with Libsens.Virtual.Gen_Plugin;        use Libsens.Virtual.Gen_Plugin;
with Libsens.Virtual.Nl_Network;        use Libsens.Virtual.Nl_Network;


with Gnat.OS_Lib;                       use Gnat;
package body Libsens.Virtual.Work_Class is

   procedure Test(Work : in out Work_Record'class) is
   begin
      Work.Plugins(1) := new Nn_Mono_Plugin_Record;
      Work.Plugins(2) := new NL_Network_Plugin_Record;
      Work.Plugins(3) := new Gen_Bass_Plugin_Record;
      Work.Plugins(4) := new CC_Change_Plugin_Record;
      Work.Plugins(5) := new Prgm_Change_Plugin_Record;
   end Test;


   procedure Initialize(Work : in out Work_Record; Filename : in String) is
   begin
      if Os_Lib.Is_Regular_File(Filename) then
         null;
      end if;
      Work.Filename := new String ' (Filename);
      Work.Test;
   end Initialize;

   procedure Finalize(Work : in out Work_Record) is
   begin
      null;
   end Finalize;

end Libsens.Virtual.Work_Class;


Le main :

Source ada : 

with GNAT.Command_Line;                 use GNAT.Command_Line;
with Libsens.Exceptions;                use Libsens.Exceptions;
with Libsens.Virtual.Work_Class;        use Libsens.Virtual.Work_Class;
with Libsens.Virtual.Cc_Change;         use Libsens.Virtual.Cc_Change;
with Libsens.Virtual.Prgm_Change;       use Libsens.Virtual.Prgm_Change;
with Libsens.Virtual.Gen_Plugin;        use Libsens.Virtual.Gen_Plugin;
with Libsens.Virtual.Nl_Network;        use Libsens.Virtual.Nl_Network;
with Text_Io;                           use Text_Io;
procedure Main is

   Works : Work_Array;
   Work_Id : Natural := 0;
   Auto_Play : Boolean := False;
   In_Loop   : Boolean := False;
   Verbose   : Boolean := False;
   Help      : Boolean := False;
begin

   begin

      begin

         loop
            case Getopt ("a l v h") is
               -- Accept :=                                                                
               -- v ::= verbose ;                                                          
               -- h help ;                                                                 
               -- D debug ;                                                                
               when ASCII.NUL => exit;

               when 'a' =>
                  if Full_Switch = "a" then
                     Put_Line ("Got auto play");
                     Auto_Play := True;
                  end if;
               when 'l' =>
                  if Full_Switch = "l" then
                     In_Loop := True;
                     Put_Line ("Got in loop");
                  end if;
               when 'v' =>
                  if Full_Switch = "v" then
                     Verbose := True;
                     Put_Line ("Got verbose");
                  end if;
               when 'h' =>
                  if Full_Switch = "h" then
                     Help := True;
                     Put_Line ("Got help");
                  end if;
                  -- Put_Line ("Got b + " & Parameter);                                    
               when others =>
                  raise Program_Error; -- cannot occur                                     
            end case;
         end loop;

         declare

         begin

            loop
               declare
                  S : constant String := Get_Argument (Do_Expansion => True);
               begin
                  exit when S'Length = 0;
                  Put_Line ("Adding work for " & S);
                  Works(Work_Num(Work_Id+1)) := new Work_Record;
                  Works(Work_Num(Work_Id+1)).Initialize(S);
                  Work_Id := Work_Id + 1;
               end;
            end loop;
            if Help then

               Put_Line("ultrason : usage : ultarson [ -a ] [ -l ] [ -h ] [ -v ]");
               return;
            end if;

         end;
      exception
         when Invalid_Switch    => Put_Line ("Invalid Switch " & Full_Switch);
            raise Spec_Error;
         when Invalid_Parameter => Put_Line ("No parameter for " & Full_Switch);
            raise Spec_Error;
      end;
   end;
   if Work_Id = 0 then
      Works(Work_Num(Work_Id+1)) := new Work_Record;
      Works(Work_Num(Work_Id+1)).Initialize("");
      Work_Id := Work_Id + 1;
   end if;
   if Auto_Play then
      loop
         for Id in 1..Work_Num(Work_Id) loop
            declare
               Work : constant Work_Access := Works(Id);
            begin
               Put_line("Current Work is [" & Work.Filename.all & "]");
               for Plug_Id in Work.Plugins'Range loop
                  if Work.Plugins(Plug_Id) /= null then
                     Put_line("Plugin num" & Plugin_Num'Image(Plug_Id));
                     declare
                        Plugin : constant Abstract_Plugin_Access := Work.Plugins(Plug_Id);

                     begin

                        Print(Plugin.all);

                     end;
                  end if;
               end loop;
            end;
         end loop;
         exit when not In_Loop;
      end loop;
   end if;
end Main;


Le message de gnatmake :

Citation : 
main.adb:105:25: no candidate interpretations match the actuals:
main.adb:105:38: expected type "NL_Network_Plugin_Record" defined at libsens-virtual-nl_network.ads:4
main.adb:105:38: found type "Plugin_Class'Class" defined at libsens-virtual-plugins.ads:8
main.adb:105:38: ==> in call to "Print" at libsens-virtual-nl_network.ads:9
main.adb:105:38: ==> in call to "Print" at libsens-virtual-gen_plugin.ads:22
main.adb:105:38: ==> in call to "Print" at libsens-virtual-gen_plugin.ads:15
main.adb:105:38: ==> in call to "Print" at libsens-virtual-gen_plugin.ads:8
main.adb:105:38: ==> in call to "Print" at libsens-virtual-prgm_change.ads:9
main.adb:105:38: ==> in call to "Print" at libsens-virtual-cc_change.ads:8
main.adb:112:24: warning: variable "In_Loop" is not modified in loop body
main.adb:112:24: warning: possible infinite loop
gnatmake: "src/main.adb" compilation error



Je suis un peu en retard por l'objet et j'aurais besoin d'un coup de main pour comprendre mon erreur. S'il vous plait !! Merci.
Profil
Emmanuel Sens
Beau Parleur
Avatar de l’utilisateur
Ohp !!!!!

J'ai trouvé : j'ai implémenté une procedure print dans WorkClass comme suit :

Source ada : 

procedure Print (Plugin : in Abstract_Plugin_Access) is
   begin
      Print(Plugin.all);
   end Print;


Dans le main, j'ai enlevée les With de mes bibliothèques de plugins et j'appel print : Print(Plugin):

Et ça fonctionne. Merci, a moins que vous ayez mieux à proposer.

Bonne fin d'année.
Profil
Emmanuel Sens
Beau Parleur
Avatar de l’utilisateur
Bonjour,

Bonne année.


J'ai une petit problème, que j'espère temporaire.

Je déclare une classe abstraite de laquelle je dérive une sous-classe mais je ne parviens pas à spécifier la procedure initialize qui va avec la sous-classe.

Voici mon code : la specification :

Source ada : 

type Abstract_Plugin_Specifications(Class : Plugin_Enum) is abstract tagged
      record
         Specifications_Frame : Gtk_Frame;
      end record;

   procedure Initialize (Spec : in out Abstract_Plugin_Specifications;
                         Plugin : in Abstract_Plugin_Class) is abstract;

   type Plugin_Specifications_Access is
     access all Abstract_Plugin_Specifications'Class;

   function Initialize (Class : Plugin_Enum;
                        Plugin : Abstract_Plugin_Class)
                       return Plugin_Specifications_Access;

   type Step_Seq_Specifications is
     new Abstract_Plugin_Specifications(Step_Seq) with
      record
         Sequencer_Model        : Gtk_Tree_Store;
         Sequencer_Tree         : Gtk_Tree_View;
      end record;

   procedure Initialize (Spec : in out Step_Seq_Specifications;
                         Plugin : in Step_Seq_Plugin_Record);


l'implémentation :

Source ada : 

--------------------------------------------------------------------------------                                                                                                                                                                                       
   --                                                                            --                                                                                                                                                                                       
   --               Plugins Specifications initializations                       --                                                                                                                                                                                       
   --                                                                            --                                                                                                                                                                                       
   --------------------------------------------------------------------------------                                                                                                                                                                                       



   function Initialize (Class : Plugin_Enum;
                        Plugin : Abstract_Plugin_Class)
                       return Plugin_Specifications_Access is
      Spec : Plugin_Specifications_Access;
   begin
      case Class is
         when Null_Plugin =>
            null;
         when Step_Seq =>
            Spec := new Step_Seq_Specifications;
         when others =>
            null;
      end case;
      Spec.Initialize(Plugin);
      return Spec;
   end Initialize;


   --------------------                                                                                                                                                                                                                                                   
   -- step sequencer --                                                                                                                                                                                                                                                   
   --------------------                                                                                                                                                                                                                                                   

   procedure Initialize (Spec : in out Step_Seq_Specifications;
                         Plugin : in Step_Seq_Plugin_Record) is
   begin
      Gtk_New(Spec.Specifications_Frame, "Step sequencer : ");
   end Initialize;



Le message d'erreur est le suivant : (que je pige pas tellement je suis null en POO. (bref),
Citation : 
libsens-applications-windows.ads:50:04: type must be declared abstract or "Initialize" overridden
libsens-applications-windows.ads:50:04: "Initialize" has been inherited at line 50
libsens-applications-windows.ads:50:04: "Initialize" has been inherited from subprogram at line 40


Voilà le problème, j'ai cherché, je trouve pas. Merci pour votre aide.
Profil
Emmanuel Sens
Beau Parleur
Avatar de l’utilisateur
Bonjour,

Je suis sortie d'affaire à présent pour ce problème pour ce projet.

J'en suis à la version 6.5.11a avec le plugin step sequenceur pouvant être sauvegardé et charger sur la ligne de commande.

j'ai aussi implementé des bout de code pour les générateur génétique.

J'ai encore 38 fichiers à compléter, et ce sont pas les plus simple.

A oui, j'ai fait les sequenceur pour les Ctrl change et prgm change.
Dans les Pgrm change, les paramètres MSB select et LSB select ne sont pas utilisé.

Mais c'est pas sauvegardable.
Profil
Emmanuel Sens
Beau Parleur
Avatar de l’utilisateur
Bonjour,

J'allais dire, j'ai terminé mais non, il me reste en réalité encore un peux de travail pour l'ouverture des fichier à partire d'une fenêtre principale, c'est l'operation "open", à faire et peut-être inverser certaine contruction de patterns.

Si non la "première" étape est "quasi" achevé.
J'ai un paquet de warning mais ça fonctionne quand même.

je me suis planté à un endroit. dans le Arp_sequenceur j'ai déclaré step comme un dérivé de note alors que ce son deux type distinct normalement.

Je me suis aussi planté dans la hiérachisation de mes objets dérivé de plugin dont 2 classes contiennent 3 sous classe, alors que j'ai simplement fait 6 sous classe de plugin.

Une bonne raison pour recommencer. bref. Aujourd'hui j'ai publié la version 6.7.3b. qui maintiens une version de fichiers de réseau de neurones artificiels par fichiers ultrason et par plugin.

Si vous utiliser 3 plugins NL_Mod vous trouverez 3 * 3 fichier de réseau dans data/networks/

Si vous souhaitez des présisions, je reviens.
Merci pour votre aide et votre contribution.
Profil
  1. Index du forum
  2. Sciences
  3. Sciences Classiques
  4. Ada