Spécification d'un file manager et utilisation de GNAT.Directory_Operations.Iteration

Invité · 03/04/2008, 16h49

Bonjour,

Dans le cadre du développement d'un petit programme en mode console, je doit charger des fichiers sélectionnés par l'utilisateur au cours de l'exécution. Pour faciliter la tache de l'utilisateur, je souhaite lui présenter la liste des fichiers et répertoires présents dans le répertoire spécifié par l'utilisateur puis récupérer le fichier sélectionné afin de le charger. J'ai donc besoin d'écrire une petite bibliothèque pour assurer le service.

Selon vous à quoi peut ressembler la spécification d'une telle bibliothèque ?

Je n'ai aucune restriction particulière à formuler pour le moment si ce n'est que J'écris pour Gnu/Linux sur Gnu/LInux avec Gnat 4.1

Si la description ci-dessus vous semblait insuffisante, n'hésitez pas à poster ici.

Merci pour votre contribution.

Ou si il existe déjà un bibliothèque qui rend ce service, je suis preneur.

**Lowelace** · 03/04/2008, 17h33

Essaie GNAT.Directory_Operations. En fait, on gère un directory comme un fichier dans lequel les items sont les noms des fichiers du directory

.

Invité · 03/04/2008, 19h25

C'est pas pour dire ... enfin si

j'ai fait ça :

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
 
with Ada.Text_Io, Gnat.Directory_Operations;
 use Ada.Text_Io, Gnat.Directory_Operations;
procedure Main is
 
   Current_Dir_Type : Dir_Type;
   Readed_Dir : String(1..4096) := (others => Character'Val(32));
   Last : Natural := 0;
 
begin
 
   Open(Current_Dir_Type, Get_Current_Dir);
   Read(Dir   => Current_Dir_Type,
        Str   => Readed_Dir,
        Last  => Last);
   Put_Line(Readed_Dir(1..Last));
   Close(Current_Dir_Type);
end Main;

C'est puissant .... ça me retourne '.' , point, c'est bleuffant quand même

Je poursuis ...

Invité · 03/04/2008, 19h28

A ben non, y a plus rien ...

C'est quoi l'astuce là ?

Invité · 03/04/2008, 20h01

A y est, j'ai compris .. enfin, j'avais zappé la spec de read entre temps ...

Read est itératif entre un open et un close si je comprend bien .....

Donc, oui, c'est pas la bonne abstarction ...

Il faut que je face une biblio ....

Donc .. d'après vous ... la spec .. à quoi elle ressemble ?

Je vais bien y arriver ... mais j'aurais aimé des avis extérieur

**Lowelace** · 03/04/2008, 22h29

Et si tu essaie ça :

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
with Ada.Text_Io, Gnat.Directory_Operations;
 use Ada.Text_Io, Gnat.Directory_Operations;
procedure Main is

   Current_Dir_Type : Dir_Type;
   Readed_Dir : String(1..4096) := (others => Character'Val(32));
   Last : Natural := 0;

begin

   Open(Current_Dir_Type, Get_Current_Dir);

 loop
   Read(Dir   => Current_Dir_Type,
        Str   => Readed_Dir,
        Last  => Last);
exit when Last = 0;
   Put_Line(Readed_Dir(1..Last));
end loop;

   Close(Current_Dir_Type);
end Main;

Dans la spécification, il est dit qu'il y a toujours dans le répertoire "." (le répertoire courant) et ".." (le répertoire parent).

Invité · 03/04/2008, 23h32

Yep !

Ca y est j'ai pigé. Merci Lowelace.

Invité · 04/04/2008, 10h46

Voici ma spécification.

Une procédure qui retourne toutes les occurrences match dans une pile.

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
with Pg_Pile;
with Ada.Strings.Unbounded;
with Gnat.Os_Lib;
package Files_Managment is

   function Is_Regular_File(Filename : in String) return boolean;

   Package String_Access_Stack is
      new Pg_Pile(Ada.Strings.Unbounded.String_Access, 1024);
   use String_Access_Stack;

   procedure Free(Stack : in out T_Pile);

   procedure Completed_Content(Pattern : in String;
                               Content : out T_Pile);


private

   function Is_Regular_File(Filename : in String) return Boolean renames Gnat.Os_Lib.Is_Regular_File;

end Files_Managment;

Invité · 04/04/2008, 19h43

Bonsoir,

je ne comprend rien au commentaire de GNAT.Directory_Operations.Iteration et j'en aurais besoin ... j'aurais besoin d'un coup de main pour l'instanciation et l'utilisation de Find

Un petit exemple serait le bien venu.

Merci.

Bonsoir.

**Lowelace** · 04/04/2008, 21h09

Que veux-tu faire exactement ? Comment veux-tu utiliser le Find ?

Invité · 04/04/2008, 21h14

Envoyé par Lowelace

Que veux-tu faire exactement ? Comment veux-tu utiliser le Find ?

Bonsoir Lowelace

Pardon,

Je souhaite sortir la listes des fichiers commencent par le chemin spécifié.

Invité · 04/04/2008, 21h25

C'est à dire,

Si je rentre "/home/fichier", je souhaiterais retourner la liste des fichiers commencent par "fichier"

fichier_1
fichier_2

etc

**Lowelace** · 04/04/2008, 21h26

Et le bout de programme précédent ne te suffit pas ? Pourquoi t'embêter avec Find ?

Invité · 04/04/2008, 21h36

Envoyé par Lowelace

Et le bout de programme précédent ne te suffit pas ? Pourquoi t'embêter avec Find ?

Pour faire de la complétion ..

Présenter uniquement la liste des fichiers correspondant au pattern saisi.

**Lowelace** · 04/04/2008, 21h40

Ok, j'ai un début de réponse :

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
procedure Affiche_Fichier(Item  :        String;
         Index :        Positive;
         Quit  : in out Boolean) is
begin
    put_Line(String);
end;

procedure Ls is new Find(Action => Affiche_Fichier);

-- variante avec Wildcard_Iterator, peut-être plus naturel
procedure Ls_Bis is new Wildcard_Iterator(Action => Affiche_Fichier);

procedure Main is
 My_Dir : constant String := "/home";
My_File_Root : Constant String := "fichier";
begin
     Ls(My_Dir, My_File_Root); -- équivalent Unix : ls /home/fichier*.

     Ls_Bis(My_Dir & "/" & My_File_Root & "*");
end;

Invité · 04/04/2008, 22h07

Merci Lowelace,

je vais plancher là dessus,

Si je comprends, ça m'aide pas vraiment pour compléter la ligne de saisi du nom de fichier.

Invité · 04/04/2008, 22h20

Mon implémentation de File_Managment, à l'heure qu'il est

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
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
 
with Gnat.Directory_Operations;
 use Gnat.Directory_Operations;
with Ada.Strings.Unbounded;
 use Ada.Strings.Unbounded;
 
with Compare_Strings_access;
use Compare_Strings_access;
with Ada.Containers.Generic_Array_Sort;
package body Files_Managment is
 
   type T_Content_Tab is array (Integer range <>) of
     Ada.Strings.Unbounded.String_Access;
 
   procedure Dir_Sort is new Ada.Containers.Generic_Array_Sort
     (Integer, Ada.Strings.Unbounded.String_Access, T_Content_Tab, Compare_Strings_Access."<");
 
   function Expand_Path(Path_Name : in String) return String is
   begin
      return Gnat.Directory_Operations.Expand_Path(Path_Name);
   end Expand_Path;
 
 
   procedure Completed_Content(Pattern : in String;
                               Content : out T_Pile) is
      Directory_Type : Dir_Type;
      Readed_Filename : String(1..1024) :=
        (others => Character'Val(32));
      Last_Readed_Filename : Natural := 0;
      Ptr_Readed_Filename : Ada.Strings.Unbounded.String_Access;
      Developped_Pattern : String(1..1030);
 
   begin
      if Pattern(1) = '~' then
         Developped_Pattern(1..Pattern'Length+4) := "$HOME" & Pattern(2..Pattern'Length);
      else
         Developped_Pattern(1..Pattern'Length) := Pattern;
      end if;
      --if Base_Name(Expanded_Path(Pattern)) / "" then
      -- find;
      if Is_Directory(Dir_Name
         (Gnat.Directory_Operations.Expand_Path(Developped_Pattern))) then
         Open
           (Directory_Type,Dir_Name
              (Gnat.Directory_Operations.Expand_Path(Developped_Pattern)));
         Read(Directory_Type, Readed_Filename, Last_Readed_Filename);
         Read(Directory_Type, Readed_Filename, Last_Readed_Filename);
         loop
            Read(Directory_Type, Readed_Filename, Last_Readed_Filename);
            exit when Last_Readed_Filename = 0;
            Ptr_Readed_Filename := new String ' (Readed_Filename(1..Last_Readed_Filename));
            Empiler(Ptr_Readed_Filename, content);
         end loop;
         if Haut_De_Pile(Content) > 1 then
            declare
               Content_Tab : T_Content_Tab(1..Haut_De_Pile(Content));
            begin
               for I in 1..Haut_De_Pile(Content) loop
                  Depiler(Content_Tab(I), Content);
               end loop;
               Dir_Sort(Content_Tab);
               for I in 1..Content_Tab'Length loop
                  empiler(Content_Tab(I), Content);
               end loop;
            end;
         end if;
      end if;
   end Completed_Content;
 
 
   procedure Free(Stack : in out T_Pile) is
      Temp : Ada.Strings.Unbounded.String_Access;
   begin
      while Haut_De_Pile(Stack) /= 0 loop
         Depiler(Temp, Stack);
         Ada.Strings.Unbounded.Free(Temp);
      end loop;
   end Free;
 
 
end Files_Managment;

Invité · 04/04/2008, 22h56

Lowelace !!

Laissez tombé pour la complétion ... C'est un peu complexe, et je souhaiterais parvenir à l'objet de ce programme le plus rapidement possible.

Ca attendra.

(Pardon)

Spécification d'un file manager et utilisation de GNAT.Directory_Operations.Iteration

Ada

Discussions similaires

Partager

Partager