Bienvenue dans le premier TP de la partie III, c'est-à-dire le second TP de ce cours. Comme je vous le disais dans le précédent chapitre, nous allons cette fois créer un logiciel pour gérer votre collection de CD, DVD, VHS, BluRay… Plus précisément, notre programme permettra d'enregistrer un film, un album de musique, un jeu vidéo ou un autre type de donnée, mais aussi de consulter a posteriori la liste des œuvres. Je vous propose d'appeler notre programme Maktaba, ce qui signifie «Bibliothèque» en Swahili (pourquoi pas ? On a bien Ubuntu, Amarok…).
Cela nous permettra de réutiliser les types de données structurés (pour enregistrer un film, il faut indiquer son titre, le type de support, son genre…), les types énumérés (les supports CD, DVD…), les fichiers binaires ou texte (pour enregistrer notre liste d'œuvres ou exporter des informations sur une œuvre), les strings (pour enregistrer les titres des morceaux de musique par exemple) ou encore les packages (notre programme devrait être assez conséquent).
Cette fois encore, je commencerai ce TP en vous fournissant un cahier des charges : que veut-on comme fonctionnalités ? Comme données ? Quelle structure pour nos fichiers et notre code source ? Puis, je vous guiderai dans la conception du programme : nous ne réaliserons pas tout en seule fois, je commencerai par vous demander de réaliser un programme simple avant d'ajouter des fonctionnalités supplémentaires ou de prendre en charge des cas particuliers. Enfin, je vous transmettrai les sources et les spécifications d'une solution possible (bien entendu il n'y a pas qu'une seule solution mais plusieurs, chacune ayant ses avantages et inconvénients). En conclusion, comme pour le premier TP, je vous soumettrai quelques idées d'améliorations possibles de notre programme.
Prêt à démarrer ce nouveau challenge ? Alors au travail ! 
Cahier des charges
Quelles données pour quels types de données ?
Pour établir les types dont nous pourrions avoir besoin, nous devons lister les données nécessaires à notre programme pour l'enregistrement ou la lecture.
Le contenu d'une œuvre
Nous souhaitons enregistrer des œuvres, mais qu'est-ce qu'une œuvre ? C'est avant tout :
- un titre : «autant en emporte le vent», «Mario bros 3», «Nevermind»…
- une catégorie : FILM, JEU (VIDÉO), ALBUM (DE MUSIQUE), AUTRE…
- un support : CD, DVD, BLURAY, VHS, HDDVD…
- une note : de zéro à trois étoiles.
Ensuite, selon la catégorie de l'œuvre, d'autres informations peuvent être nécessaires. Pour un film, nous aurons besoin :
- du nom du réalisateur ;
- de savoir si le film est en VF.
Pour un jeu vidéo, nous aurons besoin :
- de la console : Nes, PS1, PC, Nintendo64…;
- de savoir si vous avez terminé le jeu.
Pour un album de musique, nous aurons besoin :
- du nom de l'artiste : «Nirvana», «ACDC», «Bob Marley»…
- D'une liste des morceaux dans l'ordre : «Come as you are», «Something in the way»…
Il serait bon également qu'un type d'oeuvre par défaut existe.
Des types en cascade
Suite à cela, vous avez du comprendre que nous aurons besoin d'un type T_oeuvre qui soit structuré et polymorphe (voire même mutable, ce serait encore mieux et je vous le conseille fortement). Ce type structuré devrait comprendre de nombreuses composantes de types aussi divers que du texte (string mais pas d'unbounded_string, je vous expliquerai plus tard pourquoi), des tableaux, des booléens, des types énumérés (pour les supports ou la catégorie)…
Rien que ça ? T'avais pas plus long ? 
C'est en effet beaucoup et en même temps bien peu ! Pensez que nous aurions pu enregistrer les durées des films ou des morceaux, si les films sont en VOSTFR, la pochette de l'album par exemple, l'emplacement où est sensé être rangé le CD (sur l'étagère, dans la tour, chez le voisin…) ou encore sa date d'achat ou de parution… Ayez en tête que la plupart des logiciels actuels sont bien plus complexes que cela, notre programme n'est que peu de chose à côté. Toutefois, il vous sera possible de le perfectionner plus tard.
Tout cela laisse supposer que nous devrions créer un package spécifique pour déclarer notre type T_Oeuvre afin de libérer notre code source principal. Enfin, dernière information, nos textes devant être enregistrés dans des fichiers, nous ne pourrons pas utiliser les unbounded_string, mais seulement les string. L'explication technique vous sera révélée à la fin de la partie III, lors du chapitre sur les listes. Mais cela implique donc que vos strings devront être suffisamment longs pour pouvoir accueillir des titres à rallonge comme celui-ci, extrait d'un album de Nirvana: «Frances Farmer will have her revenge on Seattle».
Les types de fichiers
Qui dit enregistrement, dit nécessairement fichiers. Aux vues de notre type structuré T_Oeuvre, cela signifie que nous aurions besoin d'un fichier binaire pour jouer le rôle de base de donnée (séquentiel ou à accès direct, c'est à vous de voir. Pour ma part, j'ai choisi les fichiers séquentiels dont la manipulation sera plus simple pour vous). Il serait même bon de séparer les bases de données (une pour les jeux, une pour la musique… ). Ces fichiers porteront par conséquent les noms de «ListeJeu.bdd», "ListeAlbum.bdd", «ListeFilm.bdd» et «ListeAutre.bdd» (bdd = Base De Données).
Quelle architecture pour les fichiers
Notre programme ayant besoin de divers types de fichiers, il serait judicieux de ne pas tout mélanger.
- Maktaba.exe devra se trouver dans un répertoire Maktaba, libre à vous de placer un raccourci sur le bureau si vous le souhaitez.
- Les bases de données ListeJeu.bdd et autres devront se trouver dans un sous-répertoire «data».
- Un sous-répertoire «Manual» permettra l'enregistrement d'un fichier texte.
Cela nous fait donc un répertoire principal et deux sous-répertoires.
Quelles fonctionnalités pour quelles fonctions et procédures ?
Maktaba.exe devra proposer les fonctionnalités suivantes :
- Saisie d'une nouvelle œuvre par l'utilisateur.
- Enregistrement d'une nouvelle œuvre par l'utilisateur (ajout dans la base de donnée).
- Modification par l'utilisateur d'une œuvre existante.
- Suppression par l'utilisateur d'une œuvre existante.
- Affichage de la base de donnée ou d'une oeuvre dans la console (sous la forme d'un tableau).
- Accès aux fonctionnalités par lignes de commande : l'utilisateur devra taper add, modify, delete, print pour accéder à une fonctionnalité. Le programme gèrera bien-sûr d'éventuelles erreurs de frappe commises par l'utilisateur.
- Possibilité d'accéder à un manuel en console par la commande manual. Ce manuel sera rédigé dans un fichier texte «manual.txt» placé dans le sous-répertoire «manual» évoqué précédemment et décrira les différentes commandes possibles.
Architecture du code source
Argh ! ! ! 
Mais jamais je ne parviendrai à faire tout ça ! Je savais bien que je n'aurais pas du me lancer dans cette galère ! 
Gardez espoir ! Ce ne sera pas aussi compliqué que cela peut paraître. En revanche, cela risque d'être long (notamment le codage des procédures de saisie et d'affichage), donc il sera nécessaire d'y aller étape par étape et d'adopter une approche par modules (tiens, ça devrait vous rappeler les packages ça). Nous aurons donc à créer les fichiers Ada suivants :
- Maktaba.adb : la procédure principale qui ne se chargera que de l'interface utilisateur, du cœur du logiciel.
- Maktaba_Types.ads : pour déclarer nos types et nos constantes.
- Maktaba_Functions.adb et Maktaba_Functions.ads : pour les différentes fonctionnalités liées à la base de données (lecture, saisie, enregistrement, affichage).
Conception du programme (suivez le guide)
Cette partie n'est pas obligatoire, elle permettra toutefois à ceux qui hésitent à se lancer ou qui ne voient pas comment faire, de trouver une méthode ou des voies pour programmer. Attention, il ne s'agit pas d'une solution toute faite (celle-ci sera fournie à la fin) mais plutôt d'un guide et je vous invite à essayer de réaliser ce TP par vous même, en recourant le moins possible à cette partie.
Création des types
Nous allons commencer par créer deux fichiers : Maktaba.adb et Maktaba_Types.ads. Notre fichier Maktaba.adb ne contiendra pour l'instant pas grand chose :
1 2 3 4 5 6 7 8 | WITH Maktaba_Types ; USE Maktaba_Types ; WITH Ada.Text_IO ; USE Ada.Text_IO ; PROCEDURE Maktaba IS Oeuvre : T_Oeuvre ; BEGIN END Maktaba ; |
Comme vous pouvez le constater il n'y a quasiment rien. Nous allons nous concentrer sur le fichier Maktaba_Types.ads et les différents types : nous devons créer un type structuré et polymorphe (et même mutable) T_Oeuvre. Ce type devra contenir différentes composantes :
- titre de l’œuvre, realisateur, console et artiste seront des strings (avec les contraintes que cela implique en terme de taille), mais surtout pas des unbounded_string (cela poserait problème pour l'enregistrement). Il serait bon que les strings soient initialisés.
- Categorie et support seront des types énumérés.
- VF et Termine seront des boolean (vrai ou faux).
- Note sera un sous-type natural de 0 à 3 ou Integer (voire modulaire).
- Morceaux sera un tableau de 30 strings (ou plus).
À vous donc de créer ce type T_Oeuvre ainsi que les types énumérés T_Categorie et T_Support et le sous-type T_Note. Pensez toutefois que, pour être polymorphe, T_Oeuvre doit dépendre de la catégorie de l'oeuvre et que pour être mutable, cette catégorie doit être initialisée :
1 2 3 4 5 6 7 8 | type T_Oeuvre(categorie : T_Categorie := #Une_Valeur#)is record ... case categorie is when FILM => ... ... end case ; end record ; |
Affichage d'une œuvre
Il est temps de créer nos fichiers Maktaba_Functions.adb et Maktaba_Functions.ads ! Nous aurons besoin à l'avenir d'afficher l'intégralité de notre base de données, mais avant d'afficher 300 œuvres, nous devrions créer une fonction ou procédure qui en affiche une et une seule. Cela nous permettra d'avoir dors et déjà un programme Maktaba.exe opérationnel qui saisirait une œuvre (arbitrairement pour l'instant) puis l'afficherait.
1 | procedure Affichage(oeuvre : T_Oeuvre) ; |
Pensez à faire un affichage compact et clair : il y aura à terme des dizaines d'oeuvres ! Pensez également à terminer l'affichage par un ou plusieurs new_line pour éviter les soucis d'affichage plus tard.
Saisie d'une oeuvre
La première chose à faire par la suite sera de créer une procédure ou une fonction de saisie d'une œuvre. Le sous-programme de saisie ne sera pas compliqué à mettre en oeuvre mais sera long à rédiger car il devra prévoir toutes les composantes. Mais avant de vous lancer dans la saisie d'une œuvre, je vous conseille d'implémenter une fonction de saisie de string. Il existe bien get_line ou get, mais si vous souhaitez saisir un string de taille 20, il ne faut pas que l'utilisateur saisisse un texte de 35 ou 3 caractères. Or l'utilisateur final n'aura généralement aucune connaissance de ces contraintes, donc je conseille de commencer par là :
1 | function get_text(taille : natural) return string ; |
Autre indication pour simplifier votre code, il serait bon que votre fonction de saisie d’œuvre (appelons-la Saisie_Oeuvre) ne s’occupe pas de la saisie de la catégorie. Ce travail sera effectué par une fonction tierce (Saisie_Categorie) qui fournira à la première la catégorie à saisir. Cela simplifiera grandement votre travail et votre réflexion. De manière générale, une grande partie de vos fonctions et procédures devraient avoir la catégorie de l'œuvre en paramètre.
1 2 | Function Saisie_Categorie return T_Categorie ; Function Saisie_Oeuvre(Cat : T_Categorie) return T_Oeuvre ; |
Les saisies de strings se feront avec notre fonction get_text. En revanche, les saisies d'entiers devront gérer les cas où l'utilisateur entrerait une note supérieure à 3 :
1 2 3 | TANT QUE choix>3 | Saisir(choix) FIN DE BOUCLE |
De même, pour saisir un booléen ou un type structuré, vous pourrez proposer à l'utilisateur un choix similaire à celui-ci :
1 2 3 4 5 | Votre film est enregistré sur : 1. un CD 2. un DVD 3. une VHS Votre film est-il en VF ? (O : oui / N : Non) _ |
Donc prévoyez les cas où l'utilisateur répondrait de travers pour limiter les plantages.
Gestion des fichiers
La plupart des opérations suivantes se feront uniquement sur les fichiers : sauvegarde dans la base de données (bdd), affichage d'une bdd, modification d'un élément d'une bdd, suppression d'un élément d'une bdd… Nous devrons créer un package pour manipuler des fichiers binaires. Comme dit précédemment, je vous invite à utiliser les fichiers séquentiels plutôt qu'à accès direct pour éviter de rajouter de la difficulté à la difficulté (bien sûr vous êtes libres de votre choix, le type de fichier binaire ne fait pas partie du cahier des charges).
Sauvegarde et affichage avec la BDD
L'implémentation de ces deux fonctionnalités ne devrait pas poser de problème. Il vous suffira d'ouvrir un fichier, de le fermer, en pensant entre temps à soit ajouter un élément (Append_File), soit parcourir le fichier pour le lire (In_file).
Mais si vous avez essayé d'implémenter ces fonctionnalités, vous avez du vous rendre compte qu'elles exigent toutes les deux de commencer par traiter une question toute bête : «Quel fichier dois-je ouvrir ? ». Et cette question, vous devrez vous la reposer à chaque fois. Il y a donc plusieurs façons de faire : soit on la joue gros bourrin et alors «Vive le copier-coller !», soit on est un peu plus futé et on rédige une procédure qui se charge d'ouvrir le bon fichier selon la catégorie fournie en paramètre. Ce paramètre peut être lui-même fourni par la fonction Saisie_categorie évoquée précédemment.
1 2 3 | procedure Ouvrir(cat : T_Categorie) ; procedure Affichage_BDD(cat : T_Categorie) ; procedure Sauvegarde(Oeuvre : T_Oeuvre) ; |
Modification et suppression d'un élément de la BDD
Le plus simple pour effectuer cette opération est de ne manipuler que des fichiers : pas la peine de se casser la tête à tenter de supprimer un élément du fichier. Voici une méthode pour supprimer l'élément numéro N d'un fichier F :
1 2 3 4 5 6 7 8 9 | Ouvrir le fichier F (Nom : truc) Ouvrir le fichier G (Nom : truc2) Copier les (N-1) premiers éléments de F dans G sauter le N-ème élément de F Copier le reste des éléments de F dans G Supprimer F Recreer F (Nom : Truc) comme une copie de G Fermer F Fermer G |
Un raisonnement similaire peut être effectué pour la modification de la BDD.
Affichage du manuel
Là, j'espère bien que vous n'avez pas besoin de moi ! 
Les commandes
Jusque là, notre fichier Maktaba.adb ne contient rien de bien sérieux, il ne nous sert qu'à tester nos procédures et fonctions. Mais puisque nous avons fini, nous allons pouvoir le rédiger correctement. L'idée ici est simple : si l'utilisateur tape un mot particulier, le programme réalise une opération particulière. Nous allons donc réutiliser notre fonction get_text pour la saisie des commandes. Le corps de la procédure principale sera simple : une boucle infinie qui se contente de demander de saisir du texte et qui, si le texte correspond à une commande connue, lance quelques sous-programmes déjà rédigés. L'un de ces strings entraînera bien entendu la sortie de la boucle (commande : quit ou exit par exemple). En cas d'erreur de l'utilisateur, le programme affichera toutefois une phrase du genre «Si vous ne comprenez rien, vous n'avez qu'à taper Manual pour lire ce #*§%\$€ de Manuel (RTFM)» (en plus aimable bien sûr 
) de façon à ne pas laisser l'utilisateur sans indications.
Solutions possibles
Comme promis, voici une solution possible à comparer avec votre travail.
Maktaba.adb :
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 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 | ------------------------------------------------------------------------------ -- -- -- PROJET MAKTABA -- -- -- -- MAKTABA.ADS -- -- -- -- -- -- AUTEUR : KAJI9 -- -- DATE : 13/11/2011 -- -- -- -- Contient la procédure principale du logiciel MAKTBA ainsi que les -- -- procédures d'affichage et de saisie. -- -- -- ------------------------------------------------------------------------------ --Retrouvez le tuto à l'adresse suivante http://www.siteduzero.com/tutoriel-3-558031-1-second-tp-un-logiciel-de-gestion-de-bibliotheque.html with Maktaba_Types ; use Maktaba_Types ; with Maktaba_Functions ; use Maktaba_Functions ; with Ada.Characters.Handling ; use Ada.Characters.Handling ; with Ada.Text_IO ; use Ada.Text_IO ; procedure Maktaba is oeuvre : T_Oeuvre ; reponse : string(1..6) ; begin loop Put("> ") ; reponse := Get_Text(6) ; reponse := To_Upper(Reponse) ; if reponse = "QUIT " or reponse = "EXIT " then exit ; elsif reponse = "NEW " then oeuvre := saisie(get_categorie) ; sauvegarde(oeuvre) ; elsif reponse = "MANUAL" then Affichage_Manuel ; elsif reponse = "INIT " or reponse = "ERASE " then creation(get_categorie) ; elsif reponse = "PRINT " then affichage_bdd(get_categorie) ; elsif reponse = "EDIT " then Edit_bdd(get_categorie) ; else put_line("Commande inconnue. Pour plus d'informations, tapez l'instruction MANUAL. ") ; end if ; end loop ; end Maktaba ; |
Maktaba_Types.ads :
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 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 | ------------------------------------------------------------------------------ -- -- -- PROJET MAKTABA -- -- -- -- MAKTABA_TYPES.ADS -- -- -- -- -- -- AUTEUR : KAJI9 -- -- DATE : 13/11/2011 -- -- -- -- Contient les différents types nécessaires au fonctionnement du logiciel -- -- MAKTABA. -- -- -- ------------------------------------------------------------------------------ --Retrouvez le tuto à l'adresse suivante http://www.siteduzero.com/tutoriel-3-558031-1-second-tp-un-logiciel-de-gestion-de-bibliotheque.html package Maktaba_Types is type T_Categorie is (FILM,JEU,ALBUM,AUTRE) ; type T_Support is (CD, DVD, BLURAY, VHS, HDDVD) ; type T_Morceaux is array(1..30) of string(1..50) ; type T_Oeuvre(categorie : T_Categorie := AUTRE) is record titre : string(1..50) := (others => ' ') ; support : T_Support := CD ; note : natural range 0..3 ; case categorie is when FILM => realisateur : string(1..20) := (others => ' ') ; VF : boolean := false ; when JEU => console : string(1..20) := (others => ' ') ; termine : boolean := false ; when ALBUM => artiste : string(1..20) := (others => ' ') ; morceaux : T_Morceaux := (others =>(others => ' ')) ; when AUTRE => null ; end case ; end record ; type T_Film is new T_Oeuvre(FILM) ; type T_Jeu is new T_Oeuvre(JEU) ; type T_Album is new T_Oeuvre(ALBUM) ; type T_Autre is new T_Oeuvre(AUTRE) ; end ; |
Maktaba_Functions.ads :
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 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 | ------------------------------------------------------------------------------ -- -- -- PROJET MAKTABA -- -- -- -- MAKTABA_FUNCTIONS.ADS -- -- -- -- -- -- AUTEUR : KAJI9 -- -- DATE : 13/11/2011 -- -- -- -- Contient les fonctions de saisie, d'affichage, de sauvegarde… du -- -- logiciel MAKTABA. -- -- -- ------------------------------------------------------------------------------ --Retrouvez le tuto à l'adresse suivante http://www.siteduzero.com/tutoriel-3-558031-1-second-tp-un-logiciel-de-gestion-de-bibliotheque.html with Maktaba_Types ; use Maktaba_Types ; WITH Ada.Sequential_IO ; package Maktaba_Functions is Package P_Fichier is new Ada.Sequential_IO(T_Oeuvre) ; use P_Fichier ; subtype T_Fichier is P_Fichier.File_type ; procedure sauvegarde(Oeuvre : in T_Oeuvre) ; procedure sauvegarde(oeuvre : in T_Oeuvre ; rang : natural) ; procedure creation(cat : T_categorie) ; procedure Ouvrir(F: in out T_Fichier ; mode : P_Fichier.File_Mode := P_Fichier.In_file ; cat : T_Categorie); procedure supprimer(cat : T_Categorie ; rang : natural) ; -- SAISIES function get_text(size : integer) return string ; function get_categorie return T_Categorie ; function saisie(cat : T_Categorie) return T_Oeuvre ; -- MANIPULATION DE LA BDD procedure affichage_oeuvre(Oeuvre : in T_Oeuvre) ; procedure affichage_bdd(cat : T_categorie) ; procedure Edit_bdd(cat : T_Categorie) ; -- Manuel procedure affichage_manuel ; end Maktaba_Functions ; |
Maktaba_Functions.adb :
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 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 | ------------------------------------------------------------------------------ -- -- -- PROJET MAKTABA -- -- -- -- MAKTABA_FUNCTIONS.ADB -- -- -- -- -- -- AUTEUR : KAJI9 -- -- DATE : 13/11/2011 -- -- -- -- Contient les fonctions de saisie, d'affichage, de sauvegarde ... du -- -- logiciel MAKTABA. -- -- -- ------------------------------------------------------------------------------ --Retrouvez le tuto à l'adresse suivante http://www.siteduzero.com/tutoriel-3-558031-1-second-tp-un-logiciel-de-gestion-de-bibliotheque.html with Ada.Text_IO ; use Ada.Text_IO ; with Ada.Integer_Text_IO ; use Ada.Integer_Text_IO ; with Ada.Characters.Handling ; use Ada.Characters.Handling ; with ada.Strings.Unbounded; Use ada.Strings.Unbounded ; package body Maktaba_Functions is ----------------------------------------------- -- GESTION DES FICHIERS -- ----------------------------------------------- procedure sauvegarde(Oeuvre : in T_Oeuvre) is F : T_Fichier ; begin ouvrir(F,Append_File,oeuvre.categorie) ; write(F,Oeuvre) ; close(F) ; end sauvegarde ; procedure sauvegarde(oeuvre : in T_Oeuvre ; rang : natural) is F,G : T_Fichier ; tmp : T_Oeuvre ; begin -- Ouverture de F en In et de G en Append ouvrir(F,In_File,oeuvre.categorie) ; create(G,Append_File,Name(F) & "2") ; -- copie de F+oeuvre dans G for i in 1..rang-1 loop read(F,tmp) ; write(G,tmp) ; end loop ; write(G,oeuvre) ; read(F,tmp) ; --lecture de l'élément à supprimer while not end_of_file(F) loop read(F,tmp) ; write(G,tmp) ; end loop ; -- Suppression de F / recréation de F -- fermeture de G / réouverture de G delete(F) ; creation(oeuvre.categorie) ; ouvrir(F,Append_File,oeuvre.categorie) ; close(G) ; open(G,In_File,Name(F) & "2") ; -- copie de G dans F while not end_of_file(G) loop read(G,tmp) ; write(F,tmp) ; end loop ; --Fermeture de F / Suppression de G close(F) ; delete(G) ; end sauvegarde ; procedure Creation(cat : T_categorie) is F : T_Fichier ; begin case cat is when FILM => create(F,out_file,"./data/ListeFilm.bdd") ; close(F) ; when JEU => create(F,out_file,"./data/ListeJeu.bdd") ; close(F) ; when ALBUM => create(F,out_file,"./data/ListeAlbum.bdd") ; close(F) ; when AUTRE => create(F,out_file,"./data/ListeAutre.bdd") ; close(F) ; end case ; end creation ; procedure Ouvrir(F: in out T_Fichier ; mode : P_Fichier.File_Mode := P_Fichier.In_file ; cat : T_Categorie) is begin case cat is when FILM => open(F,mode,"./data/ListeFilm.bdd") ; when JEU => open(F,mode,"./data/ListeJeu.bdd") ; when ALBUM => open(F,mode,"./data/ListeAlbum.bdd") ; when AUTRE => open(F,mode,"./data/ListeAutre.bdd") ; end case ; end Ouvrir; procedure supprimer(cat : T_Categorie ; rang : natural) is F,G : T_Fichier ; tmp : T_Oeuvre ; begin -- Ouverture de F en In et de G en Append ouvrir(F,In_File,cat) ; create(G,Append_File,Name(F) & "2") ; -- copie de F-1 oeuvre dans G for i in 1..rang-1 loop read(F,tmp) ; write(G,tmp) ; end loop ; read(F,tmp) ; while not end_of_file(F) loop read(F,tmp) ; write(G,tmp) ; end loop ; -- Suppression de F / recréation de F -- fermeture de G / réouverture de G delete(F) ; creation(cat) ; ouvrir(F,Append_File,cat) ; close(G) ; open(G,In_File,Name(F) & "2") ; -- copie de G dans F while not end_of_file(G) loop read(G,tmp) ; write(F,tmp) ; end loop ; --Fermeture de F / Suppression de G close(F) ; delete(G) ; end supprimer ; ---------------------------------- -- SAISIE -- ---------------------------------- function get_text(size : integer) return string is U : Unbounded_String := Null_Unbounded_String ; T : string(1..size) := (others => ' ') ; begin U := to_unbounded_string(get_line) ; if length(U) > size then T := to_string(U)(1..size) ; else T(1..length(U)) := to_string(U) ; for i in length(U)+1..size loop T(i) := ' ' ; end loop ; end if ; return T ; end get_text ; function get_categorie return T_Categorie is choix_cat : character ; begin Put_line("Choisissez la categorie desiree : ") ; Put_line("F-Film M-Album de Musique") ; Put_line("J-Jeu Video Autre ?") ; Get_Immediate(choix_cat) ; choix_cat := to_upper(choix_cat) ; case choix_cat is when 'F' => return FILM ; when 'M' => return ALBUM ; when 'J' => return JEU; when others => return AUTRE ; end case ; end get_categorie ; function saisie(cat : T_Categorie) return T_Oeuvre is oeuvre : T_Oeuvre(cat) ; choix : character ; note : integer ; begin -- SAISIE DES PARAMETRES COMMUNS Put_line("Quel est le titre de l'oeuvre ? ") ; oeuvre.titre := get_text(50) ; Put_line("Quelle note donneriez-vous ? (Entre 0 et 3) ") ; loop get(note) ; skip_line ; if note in 0..3 then oeuvre.note := note ; exit ; else Put_line("ERREUR ! La note doit être comprise entre 0 et 3 !") ; end if ; end loop ; Put_line("Sur quel type de support l'oeuvre est-elle enregistree ?") ; Put_line("1-VHS 2-CD 3-DVD") ; Put_Line("4-HDDVD 5-BLURAY") ; loop get_immediate(choix) ; choix := to_upper(choix) ; case choix is when '1' => oeuvre.support := VHS ; exit ; when '2' => oeuvre.support := CD ; exit ; when '3' => oeuvre.support := DVD ; exit ; when '4' => oeuvre.support := HDDVD ; exit ; when '5' => oeuvre.support := BLURAY ; exit ; when others => Put_line("Veuillez reconfirmer votre choix.") ; end case ; end loop ; -- SAISIE DES PARAMETRES SPECIFIQUES case cat is when FILM => Put_line("Quel est le realisateur ? ") ; oeuvre.realisateur:= get_text(20) ; Put_line("Le film est-il en VF ? (O : Oui / N : Non)") ; loop get_immediate(choix) ; choix := to_upper(choix) ; if choix = 'O' then oeuvre.vf := true ; exit ; elsif choix = 'N' then oeuvre.vf := false ; exit ; else Put_line("Veuillez appuyer sur O pour Oui ou sur N pour Non") ; end if ; end loop ; return oeuvre ; when ALBUM => Put_line("Quel est l'artiste ? ") ; oeuvre.artiste := get_text(20) ; for i in oeuvre.morceaux'range loop Put_line("Voulez-vous ajouter un morceau ? (O : Oui / N : Non)") ; get_immediate(choix) ; choix := to_upper(choix) ; if choix = 'O' then Put_line("Quel est le titre du morceau ? ") ; oeuvre.morceaux(i) := get_text(50) ; else exit ; end if ; end loop ; return oeuvre ; when JEU => Put_line("Quelle est la console ? ") ; oeuvre.console := get_text(20) ; Put_line("Avez-vous fini le jeu ? (O : Oui / N : Non)") ; loop get_immediate(choix) ; choix := to_upper(choix) ; if choix = 'O' then oeuvre.termine := true ; exit ; elsif choix = 'N' then oeuvre.termine := false ; exit ; else Put_line("Veuillez appuyer sur O pour Oui ou sur N pour Non") ; end if ; end loop ; return oeuvre ; when AUTRE => return oeuvre ; end case ; end Saisie ; ----------------------------------------------- -- AFFICHAGE D'UNE BDD -- ----------------------------------------------- procedure affichage_oeuvre(oeuvre : T_oeuvre) is --Affiche une seule oeuvre null_string : constant string(1..50) := (others => ' ') ; begin put(" >>>Titre : ") ; put(Oeuvre.titre) ; new_line ; put(" >>>Support : ") ; put(T_Support'image(Oeuvre.support)) ; new_line ; put(" >>>Note : ") ; put(Oeuvre.note,1) ; new_line ; case oeuvre.categorie is when FILM => put(" >>>Realisateur : ") ; put(Oeuvre.realisateur) ; new_line ; put(" >>>VF : ") ; if Oeuvre.vf then put("oui") ; else put("non") ; end if ; new_line(2) ; when JEU => put(" >>>Console : ") ; put(Oeuvre.console) ; new_line ; put(" >>>Termine : ") ; if Oeuvre.termine then put("oui") ; else put("non") ; end if ; new_line(2) ; when ALBUM => put(" >>>Artiste : ") ; put(Oeuvre.artiste) ; new_line ; put_line(" >>>Morceaux : ") ; for i in Oeuvre.morceaux'range loop exit when Oeuvre.morceaux(i) = null_string ; put(" ") ; put(i,2) ; put(" : ") ; Put(oeuvre.morceaux(I)); New_Line; end loop ; new_line(2) ; when AUTRE => new_line ; end case ; end affichage_oeuvre ; procedure affichage_bdd(cat : T_categorie) is --Affiche toute une base de données selon la catégorie demandée n : natural := 1 ; suite : character ; Oeuvre : T_Oeuvre(cat) ; F : T_Fichier ; begin ouvrir(F,In_File,cat) ; while not end_of_file(F) loop if n = 0 then put("Cliquez pour continuer") ; get_immediate(suite) ; new_line ; end if ; read(F,Oeuvre) ; Affichage_oeuvre(oeuvre) ; n := (n + 1) mod 5 ; end loop ; close(F) ; end Affichage_bdd ; ------------------------------------------------------ -- EDITION DE LA BASE DE DONNEES -- ------------------------------------------------------ procedure Edit_bdd(cat : T_Categorie) is --Edite une base de données pour modification ou suppression choix : character ; n : natural := 1 ; Oeuvre : T_Oeuvre(cat) ; F : T_Fichier ; begin ouvrir(F,In_File,cat) ; while not end_of_file(F) loop read(F,Oeuvre) ; Affichage_oeuvre(oeuvre) ; put_line("Que voulez-vous faire : Supprimer(S), Modifier(M), Quitter(Q) ou Continuer ?") ; Get_Immediate(choix) ; choix := to_upper(choix) ; if choix = 'M' then close(F) ; oeuvre := saisie(cat) ; sauvegarde(oeuvre,n) ; exit ; elsif choix = 'S' then close(F) ; Supprimer(cat,n) ; exit ; elsif choix = 'Q' then close(F) ; exit ; end if ; n := n + 1 ; end loop ; if Is_Open(F) then close(F) ; end if ; end Edit_bdd ; ------------------------------------------------------ -- EDITION DE LA BASE DE DONNEES -- ------------------------------------------------------ procedure affichage_manuel is F : Ada.text_IO.File_Type ; begin open(F,In_File,"./manual/manual.txt") ; while not end_of_file(F) loop put_line(get_line(F)) ; end loop ; close(F) ; end affichage_manuel ; end Maktaba_Functions ; |
Manual.txt :
1 2 3 4 5 6 7 | Commandes : Quitter : Quit / Exit Nouveau : New Manuel : Manual Réinitialiser une base : Init / Erase Afficher une base : Print Modifier une base : Edit |
Pistes d'amélioration :
- Fournir une interface graphique plutôt que cette vilaine console. Pour l'instant, vous ne pouvez pas encore le faire, mais cela viendra.
- Proposer de gérer d'autres types de supports : disque durs, clés USB…
- Proposer l'enregistrement de nouvelles informations : le genre de l’œuvre (film d'horreur ou d'aventure, album rock ou rap…), une description, les acteurs du film, les membres du groupe de musique, l'éditeur du jeu vidéo, la durée des morceaux…
- Proposer l'exportation de vos bases de données sous formes de fichiers textes consultables plus aisément ou l'importation d'une œuvre à partir d'un fichier texte.
- Permettre de compléter les instructions en ligne de commande par des options : modify -f modifierait un film par exemple.
- Implémenter un service de recherche d’œuvre par titre, par auteur ou même par mots-clés !
Encore une fois, ce ne sont pas les idées qui manquent pour développer un tel logiciel. J'espère toutefois que ce TP vous aura permis de faire un point sur les notions abordées depuis le début de la partie III car nous allons maintenant nous atteler à un type de données plus complexe : les pointeurs. Et, de la même manière que nous avons parlé, reparlé et rereparlé des tableaux, nous allons parler, reparler et rereparler des pointeurs dans les prochains chapitres.