Directories

The package Directories provides operations for manipulating files and directories, and their names.

with Ada.IO_Exceptions;
with Ada.Calendar;

package Ada.Directories 
   with Global => in out synchronized is

   -- Directory and file operations:
   function Current_Directory return String;

   procedure Set_Directory   (Directory    : String);
   procedure Create_Directory(New_Directory: String; Form: String := "");
   procedure Delete_Directory(Directory    : String);
   procedure Create_Path     (New_Directory: String; Form: String := "");
   procedure Delete_Tree     (Directory    : String);

   procedure Delete_File(Name: String);
   procedure Rename     (Old_Name, New_Name: String);
   procedure Copy_File  (Source_Name, Target_Name: String; Form: String := "");

   -- File and directory name operations:
   function Full_Name           (Name: String) return String with Nonblocking;
   function Simple_Name         (Name: String) return String with Nonblocking;
   function Containing_Directory(Name: String) return String with Nonblocking;
   function Extension           (Name: String) return String with Nonblocking;
   function Base_Name           (Name: String) return String with Nonblocking;
   function Compose(Containing_Directory: String := "";
                    Name                : String;
                    Extension           : String := "") return String
      with Nonblocking;

   type Name_Case_Kind is (Unknown, Case_Sensitive, Case_Insensitive, Case_Preserving);

   function Name_Case_Equivalence(Name: String) return Name_Case_Kind;

   -- File and directory queries:
   type File_Kind is (Directory, Ordinary_File, Special_File);
   type File_Size is range 0 .. <implementation-defined>;

   function Exists           (Name: String) return Boolean;
   function Kind             (Name: String) return File_Kind;
   function Size             (Name: String) return File_Size;
   function Modification_Time(Name: String) return Ada.Calendar.Time;

   -- Directory searching:
   type Directory_Entry_Type is limited private;
   type Filter_Type is array(File_Kind) of Boolean;
   type Search_Type is limited private;

   procedure Start_Search(Search   : in out Search_Type;
                          Directory: String;
                          Pattern  : String;
                          Filter   : Filter_Type := (others => True));
   procedure End_Search    (Search: in out Search_Type);
   procedure Get_Next_Entry(Search: in out Search_Type; Directory_Entry: out Directory_Entry_Type);

   function More_Entries(Search: Search_Type) return Boolean;

   procedure Search(Directory: String;
                    Pattern  : String;
                    Filter   : Filter_Type := (others => True);
                    Process  : not null access procedure(Directory_Entry: Directory_Entry_Type))
      with Allows_Exit;

   -- Operations on Directory Entries:
   function Simple_Name      (Directory_Entry: Directory_Entry_Type) return String;
   function Full_Name        (Directory_Entry: Directory_Entry_Type) return String;
   function Kind             (Directory_Entry: Directory_Entry_Type) return File_Kind;
   function Size             (Directory_Entry: Directory_Entry_Type) return File_Size;
   function Modification_Time(Directory_Entry: Directory_Entry_Type) return Ada.Calendar.Time;

   Status_Error: exception renames Ada.IO_Exceptions.Status_Error;
   Name_Error  : exception renames Ada.IO_Exceptions.Name_Error;
   Use_Error   : exception renames Ada.IO_Exceptions.Use_Error;
   Device_Error: exception renames Ada.IO_Exceptions.Device_Error;
end Ada.Directories;

Wide Directories and Wide Wide Directories

The packages Wide_Directories and Wide_Wide_Directories provide operations for manipulating files and directories, and their names.

• The specification of package Wide_Directories is the same as for Directories (including its optional child packages Information and Hierarchical_File_Names), except that each occurrence of String is replaced by Wide_String.
• The specification of package Wide_Wide_Directories is the same as for Directories (including its optional child packages Information and Hierarchical_File_Names), except that each occurrence of String is replaced by Wide_Wide_String.

Hierarchical File Names

The library package Directories.Hierarchical_File_Names is an optional package providing operations for file name construction and decomposition for targets with hierarchical file naming.

package Ada.Directories.Hierarchical_File_Names
   with Nonblocking, Global => in out synchronized is

   function Is_Simple_Name           (Name: String) return Boolean;
   function Is_Root_Directory_Name   (Name: String) return Boolean;
   function Is_Parent_Directory_Name (Name: String) return Boolean;
   function Is_Current_Directory_Name(Name: String) return Boolean;
   function Is_Full_Name             (Name: String) return Boolean;
   function Is_Relative_Name         (Name: String) return Boolean;
   function Simple_Name              (Name: String) return String renames Ada.Directories.Simple_Name;
   function Containing_Directory     (Name: String) return String renames Ada.Directories.Containing_Directory;
   function Initial_Directory        (Name: String) return String;
   function Relative_Name            (Name: String) return String;
   function Compose(Directory    : String := "";
                    Relative_Name: String;
                    Extension    : String := "") return String;
end Ada.Directories.Hierarchical_File_Names;