File: gnatcoll-io.ads

package info (click to toggle)
libgnatcoll 18-4
  • links: PTS, VCS
  • area: main
  • in suites: bullseye, buster, sid
  • size: 5,068 kB
  • sloc: ada: 40,393; python: 354; ansic: 310; makefile: 245; sh: 31
file content (238 lines) | stat: -rw-r--r-- 9,651 bytes parent folder | download
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
------------------------------------------------------------------------------
--                             G N A T C O L L                              --
--                                                                          --
--                     Copyright (C) 2009-2017, AdaCore                     --
--                                                                          --
-- This library is free software;  you can redistribute it and/or modify it --
-- under terms of the  GNU General Public License  as published by the Free --
-- Software  Foundation;  either version 3,  or (at your  option) any later --
-- version. This library is distributed in the hope that it will be useful, --
-- but WITHOUT ANY WARRANTY;  without even the implied warranty of MERCHAN- --
-- TABILITY or FITNESS FOR A PARTICULAR PURPOSE.                            --
--                                                                          --
--                                                                          --
--                                                                          --
--                                                                          --
--                                                                          --
-- You should have received a copy of the GNU General Public License and    --
-- a copy of the GCC Runtime Library Exception along with this program;     --
-- see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see    --
-- <http://www.gnu.org/licenses/>.                                          --
--                                                                          --
------------------------------------------------------------------------------

with Ada.Calendar;
with GNAT.OS_Lib;
with GNAT.Strings;
with GNATCOLL.Strings;   use GNATCOLL.Strings;
with GNATCOLL.VFS_Types; use GNATCOLL.VFS_Types;

private package GNATCOLL.IO is

   type Item_Type is
     (Unknown,
      --  File is not determined
      File,
      --  Regular file
      Directory
      --  Directory
     );
   --  Item_Type is used to cache the calls to Is_Regular_File or Is_Directory
   --  that can be pretty time consuming, and that are performed pretty often.

   type File_Record is abstract tagged record
      Ref_Count  : Natural := 0;
      Full       : FS_String_Access;
      --  The file's full path

      Normalized : FS_String_Access;
      --  The file's normalized form ('..' and '.' directories removed)

      Normalized_And_Resolved : FS_String_Access;
      --  The normalized form with resolved symlinks.
      --  This points to the same value as Normalized if these have the same
      --  value.

      Kind       : Item_Type := Unknown;
      --  The kind of file represented by this object
   end record;

   type File_Access is access all File_Record'Class;
   type File_Array is array (Natural range <>) of File_Access;

   procedure Ref (File : File_Access);
   procedure Unref (File : in out File_Access);
   procedure Destroy (File : in out File_Record);

   function Dispatching_Create
     (Ref : not null access File_Record;
      Full_Path : FS_String) return File_Access is abstract;
   --  Create a new file using the same tagged type is Ref

   function To_UTF8
     (Ref : not null access File_Record;
      Path : FS_String) return String is abstract;
   function From_UTF8
     (Ref : not null access File_Record;
      Path : String) return FS_String is abstract;
   --  Translate a path to/from UTF8 encoded strings, according to the
   --  Filesystem's charset.

   function Is_Local (File : File_Record) return Boolean is abstract;
   --  Tell if IO denotes a local file or directory

   function Get_FS
     (File : not null access File_Record) return FS_Type is abstract;
   --  Return the kind of FS the file is on

   procedure Resolve_Symlinks (File : not null access File_Record) is abstract;
   --  Resolve all potential symlinks present in the IO path.
   --  Does nothing if this computation has already been done.

   ----------------------
   -- Queries on files --
   ----------------------

   function Is_Regular_File
     (File : not null access File_Record) return Boolean is abstract;
   --  Return True if Local_Full_Name exists on the remote host

   function Size
     (File : not null access File_Record) return Long_Integer is abstract;
   --  Return the size of the file in bytes.

   function Is_Directory
     (File : not null access File_Record) return Boolean is abstract;
   --  Return True if File is in fact a directory

   function Is_Symbolic_Link
     (File : not null access File_Record) return Boolean is abstract;
   --  Whether the file is a symbolic link

   function File_Time_Stamp
     (File : not null access File_Record) return Ada.Calendar.Time is abstract;
   --  Return the timestamp for this file.
   --  If the Connection doesn't support this operation, or the file
   --  doesn't exists, it should return a date of No_Time, so as to force, when
   --  possible, a read operation from the caller.

   function Is_Writable
     (File : not null access File_Record) return Boolean is abstract;
   --  Return True if File is writable

   procedure Set_Writable
     (File  : not null access File_Record;
      State : Boolean) is abstract;
   --  If Writable is True, make the file writable, otherwise make the file
   --  unwritable.

   function Is_Readable
     (File : not null access File_Record) return Boolean is abstract;
   --  Return True if File is readable

   procedure Set_Readable
     (File  : not null access File_Record;
      State : Boolean) is abstract;
   --  If Readable is True, make the file readable, otherwise make the file
   --  unreadable.

   ----------------------
   --  File operations --
   ----------------------

   procedure Rename
     (From    : not null access File_Record;
      Dest    : not null access File_Record;
      Success : out Boolean) is abstract;
   --  Rename From_Local_Name on the host to To_Local_Name on the same host.
   --  Return False if the renaming could not be performed.

   procedure Copy
     (From    : not null access File_Record;
      Dest    : FS_String;
      Success : out Boolean) is abstract;
   --  Copy a file into another one.
   --  To_Local_Name can be the name of the directory in which to copy the
   --  file, or the name of a file to be created.

   procedure Delete
     (File    : not null access File_Record;
      Success : out Boolean) is abstract;
   --  Sends host a delete command for file

   function Read_Whole_File
     (File : not null access File_Record) return GNAT.Strings.String_Access
      is abstract;
   function Read_Whole_File
     (File : not null access File_Record) return GNATCOLL.Strings.XString
      is abstract;
   --  Return the contents of an entire file.
   --  If the file cannot be found, return null.
   --  The caller is responsible for freeing the returned memory.
   --  No special encoding/decoding for charsets is done on the file.

   procedure Open_Write
     (File    : not null access File_Record;
      Append  : Boolean := False;
      FD      : out GNAT.OS_Lib.File_Descriptor) is abstract;
   --  Opens a file for writing. Return a file descriptor used to actually
   --  write.
   --  /!\ Do not call close directly on FD, but use the method below instead.

   procedure Close
     (File    : not null access File_Record;
      FD      : GNAT.OS_Lib.File_Descriptor;
      Success : out Boolean) is abstract;
   --  Closes FD and actually flushes the content to File if needed

   procedure Copy_File_Permissions
      (From, To : not null access File_Record;
       Success  : out Boolean) is abstract;
   --  Copy all permissions (read, write, exec) from one file to the other,
   --  so that To ends up with the same permissions. This does not change
   --  the owner of the file.

   --------------------------
   -- Directory management --
   --------------------------

   function Change_Dir (Dir : not null access File_Record) return Boolean
                        is abstract;
   --  Change the current directory.
   --  This operation might not make sense for some remote file systems if a
   --  new connection is opened for every operation, since the context would
   --  be lost. However, it does make sense when the connection is permanent.

   function Read_Dir
     (Dir            : not null access File_Record;
      Dirs_Only      : Boolean := False;
      Files_Only     : Boolean := False)
      return GNAT.Strings.String_List is abstract;
   --  Read the specified directory and returns a list of filenames
   --  (base names). If Dirs_Only is set, then the files returned are directory
   --  only. Same for Files_Only, concerning regular files.
   --  This does *not* return the two special directories "." and ".."

   function Make_Dir (Dir : not null access File_Record;
                      Recursive : Boolean) return Boolean
                      is abstract;
   --  Create a new directory on remote named Local_Dir_Name.
   --  Return the creation status.

   procedure Remove_Dir
     (Dir       : not null access File_Record;
      Recursive : Boolean;
      Success   : out Boolean)
      is abstract;
   --  Delete a directory. Recursive allow to remove included files or
   --  subdirectories.

   procedure Copy_Dir
     (From    : not null access File_Record;
      Dest    : FS_String;
      Success : out Boolean) is abstract;
   --  From_Local_Name is the name of a directory. All its files are copied
   --  into the directory To_Local_Name. The target directory is created if
   --  needed.

end GNATCOLL.IO;