GCC Code Coverage Report

Directory: src/gate/
File: src/gate/cxx_files.cpp
Date: 2026-08-06 22:46:24
Exec Total Coverage
Lines: 382 408 93.6%
Functions: 98 103 95.1%
Branches: 118 258 45.7%
Line Branch Exec Source
1 /* GATE PROJECT LICENSE:
2 +----------------------------------------------------------------------------+
3 | Copyright (c) 2018-2026, Stefan Meislinger <sm@opengate.at> |
4 | All rights reserved. |
5 | |
6 | Redistribution and use in source and binary forms, with or without |
7 | modification, are permitted provided that the following conditions are met:|
8 | |
9 | 1. Redistributions of source code must retain the above copyright notice, |
10 | this list of conditions and the following disclaimer. |
11 | 2. Redistributions in binary form must reproduce the above copyright |
12 | notice, this list of conditions and the following disclaimer in the |
13 | documentation and/or other materials provided with the distribution. |
14 | |
15 | THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"|
16 | AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
17 | IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
18 | ARE DISCLAIMED.IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE |
19 | LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
20 | CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
21 | SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
22 | INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
23 | CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
24 | ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF |
25 | THE POSSIBILITY OF SUCH DAMAGE. |
26 +----------------------------------------------------------------------------+
27 */
28
29 #include "gate/files.hpp"
30 #include "gate/results.h"
31 #include "gate/utilities.h"
32 #include "gate/utilities.hpp"
33 #include "gate/exceptions.hpp"
34 #include "gate/strings.hpp"
35
36 namespace gate
37 {
38 enumint_t const File::Open_Read = GATE_STREAM_OPEN_READ;
39 enumint_t const File::Open_Write = GATE_STREAM_OPEN_WRITE;
40 enumint_t const File::Open_ReadWrite = GATE_STREAM_OPEN_READWRITE;
41 enumint_t const File::Open_Append = GATE_STREAM_OPEN_APPEND;
42 enumint_t const File::Open_AppendWrite = GATE_STREAM_OPEN_APPENDWRITE;
43 enumint_t const File::Open_AppendReadWrite = GATE_STREAM_OPEN_APPENDREADWRITE;
44 enumint_t const File::Open_CreateOwnerRestricted = GATE_FILE_OPEN_CREATEOWNERRESTRICTED;
45 enumint_t const File::Open_CreateGroupRestricted = GATE_FILE_OPEN_CREATEGROUPRESTRICTED;
46 enumint_t const File::Open_CreateUnrestricted = GATE_FILE_OPEN_CREATEUNRESTRICTED;
47 enumint_t const File::Open_CreateExecutable = GATE_FILE_OPEN_CREATEEXECUTABLE;
48 enumint_t const File::Open_Shared = GATE_FILE_OPEN_SHARED;
49
50 13 static gate_controlstream_t* open_filestream(String const& filepath, enumint_t flags)
51 {
52 13 gate_controlstream_t* ret = NULL;
53
1/2
✓ Branch 2 taken 13 times.
✗ Branch 3 not taken.
 13 result_t res = gate_file_openstream(filepath.c_impl(), flags, &ret);
54
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 13 GATEXX_CHECK_EXCEPTION(res);
55 13 return ret;
56 }
57
58 13 FileStream::FileStream(String const& filepath, enumint_t flags)
59 13 : ControlStream(open_filestream(filepath, flags))
60 {
61 13 }
62 1 FileStream::FileStream(FileStream const& src)
63 1 : ControlStream(src)
64 {
65
66 1 }
67 1 FileStream& FileStream::operator=(FileStream const& src)
68 {
69 1 Stream::operator=(src);
70 1 return *this;
71 }
72 14 FileStream::~FileStream()
73 {
74
75 14 }
76
77
78
79
80
81
82 10 String File::buildPath(String const& parent, String const& subitem)
83 {
84 gate_string_t tmp;
85
2/4
✓ Branch 3 taken 10 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
✓ Branch 6 taken 10 times.
 10 if (NULL == gate_file_build_path_string(&tmp, parent.c_impl(), subitem.c_impl()))
86 {
87 ✗ GATEXX_RAISE_ERROR(results::OutOfMemory);
88 }
89 10 String ret(String::duplicate(tmp));
90
1/2
✓ Branch 1 taken 10 times.
✗ Branch 2 not taken.
 10 gate_string_release(&tmp);
91 20 return ret;
92 }
93 3 bool File::splitPath(String const& path, String& parent, String& subitem)
94 {
95 3 gate_string_t parent_str = GATE_STRING_INIT_EMPTY;
96 3 gate_string_t subitem_str = GATE_STRING_INIT_EMPTY;
97
1/2
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
 3 gate_result_t result = gate_file_split_path(path.c_impl(), &parent_str, &subitem_str);
98
2/2
✓ Branch 0 taken 2 times.
✓ Branch 1 taken 1 times.
 3 if (GATE_SUCCEEDED(result))
99 {
100 2 parent = String::createFrom(parent_str);
101 2 subitem = String::createFrom(subitem_str);
102 2 return true;
103 }
104 else
105 {
106 1 parent = String::createFrom(parent_str);
107
1/2
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 1 subitem = path.clone();
108 1 return false;
109 }
110 }
111 1 void File::extractPath(String const& path, char* name, size_t nameCapacity, char* parent, size_t parentCapacity)
112 {
113 1 result_t result = gate_file_extract_path(path.c_str(), path.length(), name, nameCapacity, parent, parentCapacity);
114
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 GATEXX_CHECK_EXCEPTION(result);
115 1 }
116 1 void File::extractPath(String const& path, String* name, String* parent)
117 {
118 gate_string_t str_name;
119 gate_string_t str_parent;
120
3/6
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
 1 result_t result = gate_file_extract_path_string(
121 path.c_impl(),
122 name ? &str_name : NULL,
123 parent ? &str_parent : NULL);
124
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 1 GATEXX_CHECK_EXCEPTION(result);
125
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (name)
126 {
127 1 *name = String::createFrom(str_name);
128 }
129
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (parent)
130 {
131 1 *parent = String::createFrom(str_parent);
132 }
133 1 }
134
135
136 2 bool_t File::getParent(String const& path, String& parent)
137 {
138 2 gate_string_t parent_str = GATE_STRING_INIT_EMPTY;
139
1/2
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
 2 gate_result_t result = gate_file_split_path(path.c_impl(), &parent_str, NULL);
140
1/2
✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
 2 if (GATE_SUCCEEDED(result))
141 {
142 2 parent = String::createFrom(parent_str);
143 2 return true;
144 }
145 ✗ return false;
146 }
147 3 bool_t File::getName(String const& path, String& name)
148 {
149 3 gate_string_t name_str = GATE_STRING_INIT_EMPTY;
150
1/2
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
 3 gate_result_t result = gate_file_split_path(path.c_impl(), NULL, &name_str);
151
1/2
✓ Branch 0 taken 3 times.
✗ Branch 1 not taken.
 3 if (GATE_SUCCEEDED(result))
152 {
153 3 name = String::createFrom(name_str);
154 3 return true;
155 }
156 ✗ return false;
157 }
158
159 2 String File::baseName(String const& path)
160 {
161 2 String ret;
162
1/2
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
 2 File::getName(path, ret);
163 2 return ret;
164 }
165
166 1 String File::dirName(String const& path)
167 {
168 1 String ret;
169
1/2
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 1 File::getParent(path, ret);
170 1 return ret;
171 }
172
173 1 String File::realPath(String const& path)
174 {
175 1 gate_string_t ret = GATE_STRING_INIT_EMPTY;
176
1/2
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 result_t result = gate_file_real_path(path.c_impl(), &ret);
177
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 1 GATEXX_CHECK_EXCEPTION(result);
178 2 return String::createFrom(ret);
179 }
180
181 1 ControlStream File::open(String const& path, enumint_t openFlags)
182 {
183 1 gate_controlstream_t* stream = NULL;
184
1/2
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 result_t result = gate_file_openstream(path.c_impl(), openFlags, &stream);
185
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 1 GATEXX_CHECK_EXCEPTION(result);
186
1/2
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 2 return ControlStream(stream);
187 }
188
189
190 25 bool File::exists(String const& filepath)
191 {
192 25 return GATE_SUCCEEDED(gate_file_exists(filepath.c_impl()));
193 }
194 2 void File::copy(String const& srcfilepath, String const& dstfilepath, CopyEnum flags)
195 {
196 2 result_t const res = gate_file_copy(srcfilepath.c_impl(), dstfilepath.c_impl(), (gate_uint32_t)flags);
197
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 GATEXX_CHECK_EXCEPTION(res);
198 2 }
199
200 1 static gate_bool_t GATE_CALL File_copyList_callback(char const* source_path, char const* dest_path, gate_result_t result, void* user_param)
201 {
202 1 File::CopyListCallback const* const ptrCb = static_cast<File::CopyListCallback const*>(user_param);
203
1/2
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 2 String const source(source_path);
204
1/2
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 1 String const dest(dest_path);
205
1/2
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 1 ptrCb->invoke(source, dest, result);
206 2 return true;
207 }
208
209 1 void File::copyList(Map<String, String> const& fileMapping, CopyListCallback const& callback, enumint_t flags)
210 {
211 1 result_t const result = gate_file_copy_list(
212 fileMapping.c_impl(), flags,
213 &File_copyList_callback, const_cast<File::CopyListCallback*>(&callback));
214
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 GATEXX_CHECK_EXCEPTION(result);
215 1 }
216
217
218 1 void File::move(String const& srcfilepath, String const& dstfilepath)
219 {
220 1 result_t res = gate_file_move(srcfilepath.c_impl(), dstfilepath.c_impl());
221
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 GATEXX_CHECK_EXCEPTION(res);
222 1 }
223 6 void File::removeFile(String const& filepath)
224 {
225 6 result_t res = gate_file_delete(filepath.c_impl());
226
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
 6 GATEXX_CHECK_EXCEPTION(res);
227 6 }
228 1 void File::createLink(String const& targetpath, String const& linkfile)
229 {
230 1 result_t res = gate_file_create_link(targetpath.c_impl(), linkfile.c_impl());
231
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 GATEXX_CHECK_EXCEPTION(res);
232 1 }
233 1 void File::createHardLink(String const& targetpath, String const& newlinkpath)
234 {
235 1 result_t res = gate_file_create_hardlink(targetpath.c_impl(), newlinkpath.c_impl());
236
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 GATEXX_CHECK_EXCEPTION(res);
237 1 }
238 1 String File::readLink(String const& linkfilepath)
239 {
240 gate_string_t realpath;
241
1/2
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 result_t res = gate_file_read_link(linkfilepath.c_impl(), &realpath);
242
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 1 GATEXX_CHECK_EXCEPTION(res);
243 2 return String::createFrom(realpath);
244 }
245
246 struct GATE_API_LOCAL gate_directory_list_entries_struct
247 {
248 File::callback_t delegate_cb;
249 void* user_param;
250
251 2 gate_directory_list_entries_struct(File::callback_t const& cb, void* param)
252 2 : delegate_cb(cb), user_param(param)
253 {
254 2 }
255 };
256
257 20 File::Entry::Entry()
258 {
259 20 gate_mem_clear(static_cast<gate_file_entry_t*>(this), sizeof(gate_file_entry_t));
260 20 }
261
262 33 File::Entry::Entry(gate_file_entry_t const& entry)
263 {
264 33 gate_mem_copy(static_cast<gate_file_entry_t*>(this), &entry, sizeof(gate_file_entry_t));
265 33 }
266 1 File::Entry::Entry(Entry const& src)
267 {
268 1 gate_mem_copy(static_cast<gate_file_entry_t*>(this),
269 static_cast<gate_file_entry_t const*>(&src),
270 sizeof(gate_file_entry_t));
271 1 }
272 1 File::Entry& File::Entry::operator=(Entry const& src)
273 {
274
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (this != &src)
275 {
276 1 gate_mem_copy(static_cast<gate_file_entry_t*>(this),
277 static_cast<gate_file_entry_t const*>(&src),
278 sizeof(gate_file_entry_t));
279 }
280 1 return *this;
281 }
282
283 54 File::Entry::~Entry() noexcept
284 {
285 54 }
286
287 19 String File::Entry::getName() const
288 {
289 19 return String(this->name, gate_str_length(this->name));
290 }
291 25 String File::Entry::getPath() const
292 {
293 25 return String(this->path, gate_str_length(this->path));
294 }
295 2 uint64_t File::Entry::getSize() const
296 {
297 2 return this->props.size;
298 }
299 1 enumint_t File::Entry::getAttributes() const
300 {
301 1 return this->props.attribs;
302 }
303 1 enumint_t File::Entry::getAccessBits() const
304 {
305 1 return this->props.access;
306 }
307
308 1 DateTime File::Entry::getTimeCreated(bool_t addSystemBias) const
309 {
310 1 return DateTime(this->props.time_created, addSystemBias);
311 }
312 1 DateTime File::Entry::getTimeModified(bool_t addSystemBias) const
313 {
314 1 return DateTime(this->props.time_modified, addSystemBias);
315 }
316 1 DateTime File::Entry::getTimeAccessed(bool_t addSystemBias) const
317 {
318 1 return DateTime(this->props.time_accessed, addSystemBias);
319 }
320
321
322 2 bool_t File::Entry::isDirectory() const
323 {
324 2 return GATE_FLAG_ENABLED(this->props.attribs, GATE_FILEENTRY_ATTRIB_DIRECTORY);
325 }
326 2 bool_t File::Entry::isVolume() const
327 {
328 2 return GATE_FLAG_ENABLED(this->props.attribs, GATE_FILEENTRY_ATTRIB_VOLUME);
329 }
330 2 bool_t File::Entry::isExecutable() const
331 {
332 2 return 0 != (this->props.access & (GATE_FILEENTRY_ACCESS_OWNEREXECUTE | GATE_FILEENTRY_ACCESS_GROUPEXECUTE | GATE_FILEENTRY_ACCESS_ALLEXECUTE));
333 }
334
335
336 19 File::Properties::Properties(gate_file_properties_t const& props)
337 {
338 19 gate_mem_copy(static_cast<gate_file_properties_t*>(this),
339 static_cast<gate_file_properties_t const*>(&props),
340 sizeof(gate_file_properties_t));
341 19 }
342 18 File::Properties::Properties(Properties const& src)
343 {
344 18 gate_mem_copy(static_cast<gate_file_properties_t*>(this),
345 static_cast<gate_file_properties_t const*>(&src),
346 sizeof(gate_file_properties_t));
347
348 18 }
349 2 File::Properties& File::Properties::operator=(Properties const& src)
350 {
351 2 gate_mem_copy(static_cast<gate_file_properties_t*>(this),
352 static_cast<gate_file_properties_t const*>(&src),
353 sizeof(gate_file_properties_t));
354 2 return *this;
355 }
356 37 File::Properties::~Properties()
357 {
358
359 37 }
360
361 3 uint64_t File::Properties::getSize() const
362 {
363 3 return this->size;
364 }
365 1 enumint_t File::Properties::getAttributes() const
366 {
367 1 return this->attribs;
368 }
369 1 enumint_t File::Properties::getAccessBits() const
370 {
371 1 return this->access;
372 }
373 1 DateTime File::Properties::getTimeCreated(bool_t addSystemBias) const
374 {
375 1 return DateTime(this->time_created, addSystemBias);
376 }
377 1 DateTime File::Properties::getTimeModified(bool_t addSystemBias) const
378 {
379 1 return DateTime(this->time_modified, addSystemBias);
380 }
381 1 DateTime File::Properties::getTimeAccessed(bool_t addSystemBias) const
382 {
383 1 return DateTime(this->time_accessed, addSystemBias);
384 }
385
386 1 bool_t File::Properties::isDirectory() const
387 {
388 1 return GATE_FLAG_ENABLED(this->attribs, GATE_FILEENTRY_ATTRIB_DIRECTORY);
389 }
390 1 bool_t File::Properties::isVolume() const
391 {
392 1 return GATE_FLAG_ENABLED(this->attribs, GATE_FILEENTRY_ATTRIB_VOLUME);
393 }
394 1 bool_t File::Properties::isExecutable() const
395 {
396 1 return 0 != (this->access &
397 1 (GATE_FILEENTRY_ACCESS_ALLEXECUTE | GATE_FILEENTRY_ACCESS_GROUPEXECUTE | GATE_FILEENTRY_ACCESS_OWNEREXECUTE));
398 }
399
400
401
402
403
404 2 static bool_t GATE_CALL gate_file_list_entries(gate_file_entry_t const* ptr, void* userparam)
405 {
406 2 gate_directory_list_entries_struct* param = (gate_directory_list_entries_struct*)userparam;
407
1/2
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
 2 File::Entry entry(*ptr);
408 2 bool_t continue_listing = true;
409
1/2
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
 2 param->delegate_cb(&entry, param->user_param, &continue_listing);
410 4 return continue_listing;
411 }
412
413 1 void File::listEntries(String const& dirpath, callback_t const& callback, void* userparam)
414 {
415 2 gate_directory_list_entries_struct param(callback, userparam);
416
1/2
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 gate_result_t result = gate_file_list(dirpath.c_impl(), &gate_file_list_entries, &param);
417
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 1 GATEXX_CHECK_EXCEPTION(result);
418 1 }
419 2 static bool_t GATE_CALL gate_file_list_entries_in_map(gate_file_entry_t const* ptr, void* userparam)
420 {
421 2 File::pathmap_t* mapping = static_cast<File::pathmap_t*>(userparam);
422
1/2
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
 4 String path(ptr->path);
423
1/2
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
 2 String name(ptr->name);
424 2 mapping->tryAdd(path, name);
425 4 return true;
426 }
427
428 1 File::pathmap_t File::listEntryPaths(String const& dirpath)
429 {
430 1 File::pathmap_t paths;
431
1/2
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 result_t result = gate_file_list(dirpath.c_impl(), &gate_file_list_entries_in_map, &paths);
432
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 1 GATEXX_CHECK_EXCEPTION(result);
433 1 return paths;
434 }
435
436 1 void File::listRootEntries(callback_t const& callback, void* userparam)
437 {
438 2 gate_directory_list_entries_struct param(callback, userparam);
439
1/2
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 1 gate_result_t result = gate_file_root_list(&gate_file_list_entries, &param);
440
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 1 GATEXX_CHECK_EXCEPTION(result);
441 1 }
442
443
444 1 File::pathmap_t File::listRootEntryPaths()
445 {
446 1 File::pathmap_t paths;
447
1/2
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 1 result_t result = gate_file_root_list(&gate_file_list_entries_in_map, &paths);
448
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 1 GATEXX_CHECK_EXCEPTION(result);
449 1 return paths;
450 }
451
452
453 1 File::Entry File::getEntry(String const& filepath)
454 {
455 gate_file_entry_t direntry;
456
1/2
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 gate_result_t res = gate_file_get_entry(filepath.c_impl(), &direntry);
457
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 1 GATEXX_CHECK_EXCEPTION(res);
458
1/2
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 2 return File::Entry(direntry);
459 }
460 3 void File::createDirectory(String const& dirpath, CreateDirEnum mode)
461 {
462 3 result_t res = gate_file_dir_create(dirpath.c_impl(), static_cast<gate_enumint_t>(mode));
463
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 3 times.
 3 GATEXX_CHECK_EXCEPTION(res);
464 3 }
465 1 void File::createAllDirectories(String const& dirpath, CreateDirEnum mode)
466 {
467 1 result_t res = gate_file_dir_create_all(dirpath.c_impl(), static_cast<gate_enumint_t>(mode));
468
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 GATEXX_CHECK_EXCEPTION(res);
469 1 }
470
471 1 void File::removeDirectory(String const& dirpath)
472 {
473 1 result_t res = gate_file_dir_delete(dirpath.c_impl());
474
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 GATEXX_CHECK_EXCEPTION(res);
475 1 }
476 2 void File::removeDirectoryRecursive(String const& dirpath)
477 {
478 2 result_t res = gate_file_dir_delete_recursive(dirpath.c_impl());
479
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 GATEXX_CHECK_EXCEPTION(res);
480 2 }
481
482
483 2 bool_t File::isDirectory(String const& dirpath)
484 {
485 2 result_t res = gate_file_dir_exists(dirpath.c_impl());
486 2 return GATE_SUCCEEDED(res);
487 }
488 1 bool_t File::isHidden(String const& path)
489 {
490 1 bool_t ret = false;
491 1 gate_enumint_t attrib = 0;
492 1 gate_enumint_t accessbits = 0;
493
1/2
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 result_t result = gate_file_get_attributes(path.c_impl(), &attrib, &accessbits);
494
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (GATE_SUCCEEDED(result))
495 {
496 1 ret = GATE_FLAG_ENABLED(attrib, GATE_FILEENTRY_ATTRIB_HIDDEN);
497 }
498 1 return ret;
499 }
500 1 bool_t File::isExecutable(String const& filepath)
501 {
502 1 bool_t ret = false;
503 1 gate_enumint_t attrib = 0;
504 1 gate_enumint_t accessbits = 0;
505
1/2
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 result_t result = gate_file_get_attributes(filepath.c_impl(), &attrib, &accessbits);
506
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (GATE_SUCCEEDED(result))
507 {
508
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (!GATE_FLAG_ENABLED(attrib, GATE_FILEENTRY_ATTRIB_DIRECTORY))
509 {
510 1 ret = (0 != (accessbits &
511 (GATE_FILEENTRY_ACCESS_OWNEREXECUTE
512 | GATE_FILEENTRY_ACCESS_GROUPEXECUTE
513 | GATE_FILEENTRY_ACCESS_ALLEXECUTE))
514 );
515 }
516 }
517 1 return ret;
518 }
519
520
521 2 String File::getContent(String const& filePath)
522 {
523 2 gate_string_t buffer = GATE_STRING_INIT_EMPTY;
524
1/2
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
 2 result_t result = gate_file_get_content(filePath.c_impl(), &buffer);
525
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 2 GATEXX_CHECK_EXCEPTION(result);
526 4 return String::createFrom(buffer);
527 }
528 1 size_t File::getContent(String const& filePath, char* buffer, size_t buffer_len)
529 {
530 1 result_t result = gate_file_get_content_buffer(filePath.c_impl(), buffer, &buffer_len);
531
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 GATEXX_CHECK_EXCEPTION(result);
532 1 return buffer_len;
533 }
534 1 ArrayList<String> File::getContentLines(String const& filePath)
535 {
536
1/2
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 1 ArrayList<String> ret;
537
2/4
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
 2 GenericArrayList list(gate_util_stringarray_create());
538
2/4
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 1 times.
 1 if (!list.c_impl())
539 {
540 ✗ GATEXX_RAISE_ERROR(results::OutOfMemory);
541 }
542
2/4
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 5 taken 1 times.
✗ Branch 6 not taken.
 1 result_t result = gate_file_get_content_lines(filePath.c_impl(), list.c_impl());
543
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (GATE_SUCCEEDED(result))
544 {
545
2/4
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 4 taken 1 times.
✗ Branch 5 not taken.
 1 ret = util::convertStringArray(list.c_impl());
546 }
547 2 return ret;
548 }
549 1 void File::setContent(String const& filePath, String const& content)
550 {
551 1 result_t result = gate_file_set_content(filePath.c_impl(), content.c_impl());
552
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 GATEXX_CHECK_EXCEPTION(result);
553 1 }
554 1 void File::setContent(String const& filePath, char const* buffer, size_t buffer_len)
555 {
556 1 result_t result = gate_file_set_content_buffer(filePath.c_impl(), buffer, buffer_len);
557
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 GATEXX_CHECK_EXCEPTION(result);
558 1 }
559 1 void File::setContentLines(String const& filePath, ArrayList<String> const& lines)
560 {
561 1 gate_arraylist_t list = util::convertStringArray(lines);
562
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 if (!list)
563 {
564 ✗ GATEXX_RAISE_ERROR(results::OutOfMemory);
565 }
566 1 result_t result = gate_file_set_content_lines(filePath.c_impl(), list);
567 1 gate_arraylist_release(list);
568
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
 1 GATEXX_CHECK_EXCEPTION(result);
569 1 }
570
571 1 File::SearchFilter::SearchFilter(String const& pattern, bool_t recursive,
572 uint64_t fromSize, uint64_t toSize,
573 1 timestamp_t fromModified, timestamp_t toModified)
574 {
575 1 gate_string_duplicate(&this->pattern, pattern.c_impl());
576 1 this->recursive = recursive;
577 1 this->from_size = fromSize;
578 1 this->to_size = toSize;
579 1 this->from_modified = fromModified;
580 1 this->to_modified = toModified;
581 1 }
582 2 File::SearchFilter::~SearchFilter() noexcept
583 {
584 1 gate_string_release(&this->pattern);
585 1 }
586
587 ✗ void File::SearchFilter::setPattern(String const& pattern)
588 {
589 ✗ String::assign(this->pattern, pattern);
590 ✗ }
591 ✗ String File::SearchFilter::getPattern() const
592 {
593 ✗ return String::clone(this->pattern);
594 }
595
596 struct GATE_API_LOCAL File_find_dispatcher_param
597 {
598 File::callback_t const* ptr_cb;
599 void* user_param;
600 Exception user_error;
601
602 1 File_find_dispatcher_param()
603 1 : ptr_cb(NULL),
604 user_param(NULL),
605 1 user_error(results::Ok)
606 {
607 1 }
608 };
609
610 30 static gate_bool_t GATE_CALL File_find_dispatcher(gate_file_entry_t const* ptr_entry, void* userparam)
611 {
612 30 File_find_dispatcher_param* ptr_param = static_cast<File_find_dispatcher_param*>(userparam);
613 30 bool_t continueSearch = true;
614
1/2
✓ Branch 0 taken 30 times.
✗ Branch 1 not taken.
 30 if (ptr_entry)
615 {
616
1/2
✓ Branch 1 taken 30 times.
✗ Branch 2 not taken.
 60 File::Entry entry(*ptr_entry);
617 #if defined(GATEXX_NO_EXCEPTIONS)
618 VoidResult result = ptr_param->ptr_cb->tryInvoke(&entry, ptr_param->user_param, &continueSearch);
619 if (result.hasError())
620 {
621 ptr_param->user_error = Exception(result.error(), NULL, "File_find_dispatcher");
622 continueSearch = false;
623 }
624 #else
625 try
626 {
627
1/2
✓ Branch 1 taken 30 times.
✗ Branch 2 not taken.
 30 ptr_param->ptr_cb->invoke(&entry, ptr_param->user_param, &continueSearch);
628 }
629 ✗ catch(Throwable const& xcpt)
630 {
631 ✗ ptr_param->user_error = Exception(xcpt.getResult(), xcpt.getMessage(), xcpt.getSource(), xcpt.getErrorCode());
632 ✗ continueSearch = false;
633 }
634 ✗ catch(...)
635 {
636 ✗ ptr_param->user_error = Exception(results::UnknownException, NULL, "File::find_dispatcher");
637 ✗ continueSearch = false;
638 }
639 #endif
640 }
641 30 return continueSearch;
642 }
643
644 1 void File::find(String const& path, SearchFilter const& filter, callback_t const& callback, void* userparam)
645 {
646 2 File_find_dispatcher_param param;
647 1 param.ptr_cb = &callback;
648 1 param.user_param = userparam;
649
1/2
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 result_t result = gate_file_find(path.c_impl(), &filter, &File_find_dispatcher, &param);
650
1/4
✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
 1 GATEXX_CHECK_EXCEPTION(result);
651
652 1 Exception const& xcpt = param.user_error;
653
1/2
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
 1 if (GATE_FAILED(xcpt.getResult()))
654 {
655 ✗ gate::raiseException(
656 xcpt.getResult(), xcpt.getMessage(),
657 xcpt.getSource(), xcpt.getErrorCode());
658 }
659 1 }
660
661
662
663 char const FilePath::SeparatorChar = gate_file_path_separator_character();;
664
665 2 String const& FilePath::Separator()
666 {
667 static char const chrs[2] = {
668 2 gate_file_path_separator_character(),
669 0
670
4/8
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
✓ Branch 3 taken 1 times.
✗ Branch 4 not taken.
✓ Branch 6 taken 1 times.
✗ Branch 7 not taken.
✗ Branch 9 not taken.
✗ Branch 10 not taken.
 2 };
671 #if defined(GATE_COMPILER_MSVC) && !defined(GATE_COMPILER_MSVC03)
672 static StaticString const sep(&chrs[0], gate_size_t(1));
673 #else
674
3/4
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
✓ Branch 3 taken 1 times.
✗ Branch 4 not taken.
 2 static StaticString const sep = StaticString(&chrs[0], gate_size_t(1));
675 #endif
676 2 return sep;
677 }
678
679 ✗ FilePath::FilePath()
680 {
681 ✗ }
682 2 FilePath::FilePath(FilePath const& src)
683 2 : value(src.value)
684 {
685 2 }
686 15 FilePath::FilePath(String const& path)
687 15 : value(path)
688 {
689 15 }
690 ✗ FilePath& FilePath::operator=(FilePath const& src)
691 {
692 ✗ this->value = src.value;
693 ✗ return *this;
694 }
695 17 FilePath::~FilePath()
696 {
697 17 }
698
699 7 FilePath FilePath::build(String const& parent, String const& child)
700 {
701 7 return FilePath(File::buildPath(parent, child));
702 }
703
704 1 ArrayList<String> FilePath::split(String const& path, char pathSeparator)
705 {
706 gate_string_t components[512];
707
708
1/2
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 1 gate_mem_clear(&components[0], sizeof(components));
709
1/2
✓ Branch 0 taken 1 times.
✗ Branch 1 not taken.
 1 if (pathSeparator == 0)
710 {
711
1/2
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 1 pathSeparator = gate_file_path_separator_character();
712 }
713
1/2
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 2 String basePath = path.clone();
714
1/2
✓ Branch 2 taken 1 times.
✗ Branch 3 not taken.
 1 size_t used = gate_file_split_path_components(basePath.c_impl(), pathSeparator, components, sizeof(components) / sizeof(components[0]));
715
716
1/2
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 1 ArrayList<String> ret(used);
717
2/2
✓ Branch 0 taken 3 times.
✓ Branch 1 taken 1 times.
 4 for (size_t ndx = 0; ndx != used; ++ndx)
718 {
719
1/2
✓ Branch 2 taken 3 times.
✗ Branch 3 not taken.
 3 ret.add(String::createFrom(components[ndx]));
720 }
721
722 2 return ret;
723 }
724
725 1 ArrayList<String> FilePath::split(String const& path)
726 {
727 static char const defaultPathSeparator = 0;
728 1 return FilePath::split(path, defaultPathSeparator);
729 }
730
731
732
733 1 FilePath FilePath::getParent() const
734 {
735 2 String parent;
736
2/4
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
✗ Branch 4 not taken.
 1 if (File::getParent(this->value, parent))
737 {
738 1 return FilePath(parent);
739 }
740 else
741 {
742 ✗ return FilePath();
743 }
744 }
745 1 FilePath FilePath::getName() const
746 {
747 2 String name;
748
2/4
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 1 times.
✗ Branch 4 not taken.
 1 if (File::getName(this->value, name))
749 {
750 1 return FilePath(name);
751 }
752 else
753 {
754 ✗ return FilePath();
755 }
756 }
757 14 String FilePath::toString() const
758 {
759 14 return this->value;
760 }
761
762 2 FilePath& FilePath::append(FilePath const& path)
763 {
764
1/2
✓ Branch 2 taken 2 times.
✗ Branch 3 not taken.
 2 String newPath = File::buildPath(this->value, path.toString());
765 2 this->value = newPath;
766 4 return *this;
767 }
768
769 1 FilePath& FilePath::operator/=(FilePath const& path)
770 {
771 1 return this->append(path);
772 }
773 1 FilePath& FilePath::operator/=(char const* path)
774 {
775
1/2
✓ Branch 3 taken 1 times.
✗ Branch 4 not taken.
 1 return this->append(FilePath(String::createStatic(path)));
776 }
777
778 2 FilePath FilePath::operator/(FilePath const& path) const
779 {
780 2 return FilePath::build(this->value, path.value);
781 }
782 5 FilePath FilePath::operator/(char const* path) const
783 {
784
1/2
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
 5 return FilePath::build(this->value, String::createStatic(path));
785 }
786
787
788 ✗ FilePath::operator String() const
789 {
790 ✗ return this->toString();
791 }
792
793
794 2 FileDirReader::FileDirReader(String const& dirpath)
795 {
796 2 result_t result = gate_file_dir_open(dirpath.c_impl(), &this->impl);
797
1/2
✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
 2 GATEXX_CHECK_EXCEPTION(result);
798 2 }
799
800 2 String FileDirReader::nextFilename()
801 {
802 char pathBuffer[GATE_MAX_FILEPATH_LENGTH];
803
1/2
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
 2 size_t pathLength = gate_file_dir_read(&this->impl, pathBuffer, sizeof(pathBuffer), true);
804
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
 2 if (pathLength)
805 {
806
1/2
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 1 return String(pathBuffer, pathLength);
807 }
808 1 return String();
809 }
810 2 String FileDirReader::nextPath()
811 {
812 char pathBuffer[GATE_MAX_FILEPATH_LENGTH];
813
1/2
✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
 2 size_t pathLength = gate_file_dir_read(&this->impl, pathBuffer, sizeof(pathBuffer), false);
814
2/2
✓ Branch 0 taken 1 times.
✓ Branch 1 taken 1 times.
 2 if (pathLength)
815 {
816
1/2
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
 1 return String(pathBuffer, pathLength);
817 }
818 1 return String();
819 }
820
821 4 FileDirReader::~FileDirReader()
822 {
823 2 gate_file_dir_close(&this->impl);
824 2 }
825
826
827
828 } // end of namespace gate
829