acme
Foundational cross-platform layer of the ca2 framework
Loading...
Searching...
No Matches
path.h
1#pragma once
2
3
4#include "file_path.h"
5#include "acme/prototype/datetime/file_time_span.h"
6//#include "acme/prototype/datetime/file_time.h"
7#include "acme/prototype/prototype/particle.h"
8//#include "acme/prototype/prototype/pointer.h"
9#include "acme/prototype/string/_character_range.h"
10
11
12class windows_path;
13
14
15namespace file
16{
17
18
19 DECLARE_C_FLAG(e_type, enum_type);
20
21
22 struct path_meta :
23 public file_time_set
24 {
25
26 enum_path m_epath;
27
28 ::i64 m_iSize; // if negative, not set/calculated/retrieved the file i32_size(for directories would be all contained elements total sum i32_size)
29 e_type m_etype;
30 character_count m_iName; // if negative, not set/calculated/retrieved where name starts
31 character_count m_iBasePathLength; // if negative, not set/calculated/retrieved base path length in the path
32 ::pointer<::particle> m_pparticleOsPath;
33 ::file::e_flag m_flags;
34
35 path_meta(enum_path epath = e_path_none, ::i64 iSize = -1, e_type etype = e_type_unknown, ::i64 iName = -1, character_count iBasePathLength = -1, const ::file::e_flag & eflag = ::file::e_flag_none);
36
37 ~path_meta();
38
39
40 ::file::e_flag & flags() {return m_flags;}
41 const ::file::e_flag & flags() const {return m_flags;}
42
43
44
45 };
46
47
48 // not rigorous at all file::path ... more "ryg"orous with performance and like you should know what are you doing
49 class CLASS_DECL_ACME path :
50 public string,
51 public path_meta
52 {
53 public:
54
55
56 using BASE_RANGE = typename ::string::BASE_RANGE;
57 using CHARACTER = typename BASE_RANGE::CHARACTER;
58 using ITEM = CHARACTER;
59
60
61 path() { m_epath = e_path_file; }
62 path(enum_path epath) { m_epath = epath; }
63 path(no_initialize_t) : string(no_initialize_t{}) { }
64 path(nullptr_t) { }
65 //path(enum_for_moving) { }
66 //path(enum_get_buffer, character_count len) { get_buffer(len); }
67 path(const path & path) : string(path), path_meta(path) {}
68 path(path&& path) : string(::transfer(path)), path_meta(::transfer(path)) {}
69 //template < typename ITERATOR_TYPE, ::i32 t_size >
70 //path(const const_string_range_static_array < ITERATOR_TYPE, t_size >& a, enum_path epath = e_path_none, e_type etype = e_type_unknown, bool bNormalize = true, ::i64 iSize = -1);
71 //template < prototype_character_range RANGE >
72 //path(const RANGE & range, enum_path epath = e_path_none, e_type etype = e_type_unknown, bool bNormalize = true, ::i64 iSize = -1);
73 //
74 //
75 //
76 // template < prototype_character_range RANGE >
77 // inline path(const RANGE& range, enum_path epath = e_path_none, e_type etype = e_type_unknown, bool bNormalizePath = true, ::i64 iSize = -1)
78 // requires
79 // (!(::std::is_base_of_v < path, RANGE >
80 // || ::std::is_same_v < path, RANGE >)) :
81 // string(range)
82
83 template < prototype_character_range RANGE >
84 inline path(const RANGE& range, enum_path epath = e_path_none, e_type etype = e_type_unknown, bool bNormalizePath = true, ::i64 iSize = -1)
85 requires
86 (!(::std::is_base_of_v < path, RANGE >
87 || ::std::is_same_v < path, RANGE >)) :
88 string(range)
89 {
90
91 m_iSize = iSize;
92
93 if (etype == e_type_doesnt_exist)
94 {
95
96 m_etype = etype;
97
98 m_epath = epath;
99
100 }
101 else
102 {
103
104 if (epath == e_path_none)
105 {
106
107 m_epath = file_path_get_type(*this, epath);
108
109 }
110 else
111 {
112
113 m_epath = epath;
114
115 }
116
117 if (bNormalizePath)
118 {
119
120 bool bCertainlySyntathicallyDir = file_path_normalize_inline(*this, m_epath);
121
122 if (bCertainlySyntathicallyDir)
123 {
124
125 m_etype = ((etype | e_type_folder2) & ~e_type_file2);
126
127 }
128 else
129 {
130
131 m_etype = etype;
132
133 }
134
135 }
136 else
137 {
138
139 m_etype = etype;
140
141 }
142
143 }
144
145 }
146
147
148
149 //path(const ::wd16_string & str, enum_path epath = e_path_none, e_type etype = e_type_unknown, bool bNormalize = true, ::i64 iSize = -1);
150 //path(const ::wd32_string & str, enum_path epath = e_path_none, e_type etype = e_type_unknown, bool bNormalize = true, ::i64 iSize = -1);
151 //path(const_char_pointer pansisz, enum_path epath = e_path_none, e_type etype = e_type_unknown, bool bNormalize = true, ::i64 iSize = -1);
152 //path(const ::wd16_character * pansisz, enum_path epath = e_path_none, e_type etype = e_type_unknown, bool bNormalize = true, ::i64 iSize = -1);
153 //path(const ::wd32_character * pansisz, enum_path epath = e_path_none, e_type etype = e_type_unknown, bool bNormalize = true, ::i64 iSize = -1);
154 //template < prototype_character_range CHARACTER_RANGE >
155 //path(const CHARACTER_RANGE & range, enum_path epath = e_path_none, e_type etype = e_type_unknown, bool bNormalize = true, ::i64 iSize = -1);
156
157 //template<typed_range<::ansi_character *> RANGE>
158 //path(const RANGE & str) : NATURAL_POINTER(no_initialize_t{}) { construct2(str); }
159 //template<typed_range<const_char_pointer >RANGE>
160 //path(const RANGE & str) : NATURAL_POINTER(no_initialize_t{}) { construct2(str); }
161 //template<typed_range<::wd16_character *> RANGE>
162 //path(const RANGE & str) : NATURAL_POINTER(no_initialize_t{}) { construct2(str); }
163 //template<typed_range<const ::wd16_character *> RANGE>
164 //path(const RANGE & str) : NATURAL_POINTER(no_initialize_t{}) { construct2(str); }
165 //template<typed_range<::wd32_character *> RANGE>
166 //path(const RANGE & str) : NATURAL_POINTER(no_initialize_t{}) { construct2(str); }
167 //template<typed_range<const ::wd32_character *> RANGE>
168 //path(const RANGE & str) : NATURAL_POINTER(no_initialize_t{}) { construct2(str); }
169
170
171 //template<typed_range<::ansi_character *> RANGE>
172 //path(const RANGE & str, character_count count) : NATURAL_POINTER(no_initialize_t{}) { construct2(str, count); }
173 //template<typed_range<const_char_pointer >RANGE>
174 //path(const RANGE & str, character_count count) : NATURAL_POINTER(no_initialize_t{}) { construct2(str, count); }
175 //template<typed_range<::wd16_character *> RANGE>
176 //path(const RANGE & str, character_count count) : NATURAL_POINTER(no_initialize_t{}) { construct2(str, count); }
177 //template<typed_range<const ::wd16_character *> RANGE>
178 //path(const RANGE & str, character_count count) : NATURAL_POINTER(no_initialize_t{}) { construct2(str, count); }
179 //template<typed_range<::wd32_character *> RANGE>
180 //path(const RANGE & str, character_count count) : NATURAL_POINTER(no_initialize_t{}) { construct2(str, count); }
181 //template<typed_range<const ::wd32_character *> RANGE>
182 //path(const RANGE & str, character_count count) : NATURAL_POINTER(no_initialize_t{}) { construct2(str, count); }
183
184
185
186 //template<typed_range<::ansi_character *> RANGE>
187 //path(const RANGE & str, character_count start, character_count count) : NATURAL_POINTER(no_initialize_t{}) { construct2(str, start, count); }
188 //template<typed_range<const_char_pointer >RANGE>
189 //path(const RANGE & str, character_count start, character_count count) : NATURAL_POINTER(no_initialize_t{}) { construct2(str, start, count); }
190 //template<typed_range<::wd16_character *> RANGE>
191 //path(const RANGE & str, character_count start, character_count count) : NATURAL_POINTER(no_initialize_t{}) { construct2(str, start, count); }
192 //template<typed_range<const ::wd16_character *> RANGE>
193 //path(const RANGE & str, character_count start, character_count count) : NATURAL_POINTER(no_initialize_t{}) { construct2(str, start, count); }
194 //template<typed_range<::wd32_character *> RANGE>
195 //path(const RANGE & str, character_count start, character_count count) : NATURAL_POINTER(no_initialize_t{}) { construct2(str, start, count); }
196 //template<typed_range<const ::wd32_character *> RANGE>
197 //path(const RANGE & str, character_count start, character_count count) : NATURAL_POINTER(no_initialize_t{}) { construct2(str, start, count); }
198
199 // path(const ::const_ansi_range & ansirange) : NATURAL_POINTER(no_initialize_t{}){construct2(ansirange);}
200 // path(const ::const_wd16_range & wd16range) : NATURAL_POINTER(no_initialize_t{}){construct2(wd16range);}
201 // path(const ::const_wd32_range & wd32range) : NATURAL_POINTER(no_initialize_t{}){construct2(wd32range);}
202 //path(const const_ansi_range & ansirange) : NATURAL_POINTER(no_initialize_t{}) { construct2(ansirange, 0, -1); }
203 //path(const const_wd16_range & wd16range) : NATURAL_POINTER(no_initialize_t{}) { construct2(wd16range, 0, -1); }
204 //path(const const_wd32_range & wd32range) : NATURAL_POINTER(no_initialize_t{}) { construct2(wd32range, 0, -1); }
205 //path(const const_ansi_range & ansirange, character_count len) : NATURAL_POINTER(no_initialize_t{}) { construct2(ansirange, 0, len); }
206 //path(const const_wd16_range & wd16range, character_count len) : NATURAL_POINTER(no_initialize_t{}) { construct2(wd16range, 0, len); }
207 //path(const const_wd32_range & wd32range, character_count len) : NATURAL_POINTER(no_initialize_t{}) { construct2(wd32range, 0, len); }
208 //path(const const_ansi_range & ansirange, character_count start, character_count len) : NATURAL_POINTER(no_initialize_t{}) { construct2(ansirange, start, len); }
209 //path(const const_wd16_range & wd16range, character_count start, character_count len) : NATURAL_POINTER(no_initialize_t{}) { construct2(wd16range, start, len); }
210 //path(const const_wd32_range & wd32range, character_count start, character_count len) : NATURAL_POINTER(no_initialize_t{}) { construct2(wd32range, start, len); }
211 template < prototype_character CHARACTER2 >
212 path(const CHARACTER2 * start, const CHARACTER2 * end, enum_path epath = e_path_none, e_type etype = e_type_unknown, bool bNormalize = true, ::i64 iSize = -1) :
213 path(::string(start, end), epath, etype, bNormalize, iSize) {}
214 template < prototype_character CHARACTER2 >
215 path(const CHARACTER2 * start, enum_path epath = e_path_none, e_type etype = e_type_unknown, bool bNormalize = true, ::i64 iSize = -1) :
216 path(::string(start), epath, etype, bNormalize, iSize) {}
217 template < prototype_character CHARACTER2 >
218 path(const CHARACTER2 * start, character_count len, enum_path epath = e_path_none, e_type etype = e_type_unknown, bool bNormalize = true, ::i64 iSize = -1) :
219 path(::string(start, len), epath, etype, bNormalize, iSize) {}
220// template < prototype_character CHARACTER2 >
221// path(const CHARACTER2 * pszSource, character_count start, character_count len) :path(::string(scopedstrSource, start, len)){}
222 template < prototype_character CHARACTER2, character_count sizeMaximumLength >
223 path(const inline_string < CHARACTER2, sizeMaximumLength > & inlinestring) :
224 path(inlinestring.begin(), inlinestring.end())
225 { }
226 // path(const_char_pointer pansichar, character_count len);
227 //path(::str < iterator > str) : path((const_iterator)str.begin(), (const_iterator)str.end()) {}
228 //path(::str < const_iterator > str) : path(str.begin(), str.end()) {}
229 //path(::block block) : path((const_iterator)block.begin(), (const_iterator)block.end()) {}
230 //path(const path & str);
231 //path(const ::wd16_character * pwd16char);
232 // path(const ::wd16_character * pwd16char, character_count len);
233 //path(const ::wd32_character * pwd32char);
234 // path(const ::wd32_character * pwd32char, character_count len);
235 // path(const ::wd32_character * pwd32char, character_count len, character_count pos) : path(pwd32char + pos, len) { }
236 //template < prototype_character CHARACTER2 >
237 path(const_iterator begin, const_iterator end) : path(begin, end - begin) { }
238 //path(const path & str) : path(str, 0, str.size()) { }
239 //path(const path & str, character_count len) : path(str, 0, len) { }
240 //path(const path & str, character_count start, character_count len);
241 // template < prototype_character CHARACTER2 >
242 // path(const ::range < const CHARACTER2 * > & strSource) : path(strSource, 0, strSource.size()) {}
243 // template < prototype_character CHARACTER2 >
244 // path(const ::range < const CHARACTER2 * > & strSource, character_count len) : path(strSource, 0, minimum(strSource.size(), len)) {}
245 // template < prototype_character CHARACTER2 >
246 // path(const ::range < const CHARACTER2 * > & strSource, character_count start, character_count len);
247 //path(const simple_ansistring& simpleansistr);
248 //path(const simple_wd16string& simplewd16str);
249 //path(const simple_wd32string& simplewd32str);
250 template < prototype_character CHARACTER2 >
251 path(CHARACTER2 chSrc, character_count repeat);
252 path(::ansi_character ansich) : path(::string(ansich)) {}
253 path(::wd16_character wd16ch) : path(::string(wd16ch)) {}
254 path(::wd32_character wd32ch) : path(::string(wd32ch)) {}
255 //path(const character & character, character_count repeat = 1) :path(character.m_wd32char, repeat) {}
256 path(const ::atom & atom);
257 path(const ::payload & payload);
258 path(const ::property & property);
259 //path(const ::range < const_char_pointer >& range) : path(::string(range)) { }
260
261
262 ::url::url as_url() const;
263
264 ::string consume_item()
265 {
266
267 auto path = *this;
268
269 auto iFind = path.find_index('/');
270
271 if (iFind < 0)
272 {
273
274 empty();
275
276 return path;
277
278 }
279
280 ::string str = path.left(iFind);
281
282 while (path[iFind] == '/')
283 {
284
285 iFind++;
286
287 }
288
289 path = path.substr(iFind);
290
291 *this = path;
292
293 return str;
294
295 }
296 //template < has_as_string HAS_AS_STRING >
297 //path(const HAS_AS_STRING & has_as_string) : path(has_as_string.as_string()) {}
298 //inline ~path() {}
299
300// path() { m_epath = e_path_file; }
301// path(nullptr_t) {}
302// path(const ::ansi_string & str, enum_path epath = e_path_none, e_type etype = e_type_unknown, bool bNormalize = true, ::i64 iSize = -1);
307// path(const ::scoped_string & scopedstr, enum_path epath = e_path_none, e_type etype = e_type_unknown, bool bNormalize = true, ::i64 iSize = -1) :
308// path((const::ansi_string &)psz, epath, iDir, bNormalize, iSize) {}
313// //path(::ansi_character ch, enum_path epath = e_path_none, e_type etype = e_type_unknown, bool bNormalize = true, ::i64 iSize = -1) :
314// // path((const::ansi_string &)ch, epath, iDir, bNormalize, iSize) {}
315// path(enum_path epath) { m_epath = epath; }
316// path(const path& path);
317// path(const ::atom & atom) : path(::string(atom)){}
318// path(const ::payload & payload);
319// path(const ::property & property);
321 ~path() noexcept;
322
323
324 //void construct() { *this = ::file::path(); }
325
326
327 ::windows_path windows_path() const;
328
329
330 void set_type(enum_path epath);
331
332 path & set_file_path(const ::scoped_string & scopedstrFile);
333 path & set_folder_path(const ::scoped_string & scopedstrFolder);
334
335 path & set_file_path();
336 path & set_folder_path();
337
338 path& set_existent();
339
340 path& set_existent_file();
341 path& set_existent_folder();
342
343
344 constexpr e_type type() const { return m_etype; }
345 e_type & type() { return m_etype; }
346 bool is_unknown_type() const { return this->type() == ::file::e_type_unknown; }
347 void set_type(e_type etype) { m_etype = etype; }
348
349
350 constexpr ::i32_boolean does_exist() const { return (m_etype & e_type_exists) && !(m_etype & e_type_doesnt_exist); }
351 constexpr ::i32_boolean is_file() const { return (m_etype & e_type_file2); }
352 constexpr ::i32_boolean is_folder() const { return (m_etype & e_type_folder2); }
353 constexpr ::i32_boolean is_file_or_folder() const { return is_file() || is_folder(); }
354 constexpr ::i32_boolean not_file_or_folder() const { return !is_file_or_folder(); }
355 constexpr ::i32_boolean is_existent_file() const { return is_file() && does_exist(); }
356 constexpr ::i32_boolean is_existent_folder() const { return is_folder() && does_exist(); }
357 constexpr ::i32_boolean is_existent_file_or_folder() const { return is_file_or_folder() && does_exist(); }
358
359
360 //::file::path replace_extension(const ::scoped_string & scopedstrNewExtension, const ::scoped_string & scopedstrOldExtension);
361 void set_all_extensions(const ::scoped_string& scopestrExtension);
362 void set_final_extension(const ::scoped_string& scopestrExtension);
363 void set_extension_if_no_extension(const ::scoped_string & scopestrExtension);
364
377 void defer_set_extension(const ::string_array_base& straPreserveExtensions, const ::string_array_base& straRelatedExtensions);
378 void defer_set_extension(const ::string_array_base& straPreserveExtensions);
379 void defer_set_extension(const ::file::file_dialog * pdialog);
380
381 ::file::path with_all_extensions(const ::scoped_string& scopestrExtension) const;
382 ::file::path with_final_extension(const ::scoped_string& scopestrExtension) const;
383 ::file::path with_extension_if_no_extension(const ::scoped_string& scopestrExtension) const;
384
385 ::file::path with_deferred_extension(const ::string_array_base & straPreserveExtensions, const ::string_array_base& straRelatedExtensions) const;
386 ::file::path with_deferred_extension(const ::string_array_base & straPreserveExtensions) const;
387 ::file::path with_deferred_extension(const ::file::file_dialog* pdialog) const;
388
389 //inline ::i8 separator() const
390 //{
391
392 // return '/';
393
394 //}
395
396 //inline const_char_pointer separator_sz() const
397 //{
398
399 // return "/";
400
401 //}
402
403 //inline ::i8 other_separator() const
404 //{
405
406 // return file_path_other_separator(m_epath);
407
408 //}
409
410
411 path & operator = (const ::file::path & path);
412
413 //template < prototype_character CHARACTER2 >
414 //path & operator = (const ::character_range < const CHARACTER2 *> & range)
415 // requires()
416 //{
417
418 // auto path = ::file::path(range);
419
420 // path.::file::path_meta::operator=(*this);
421
422 // return operator=(path);
423
424 //}
425
426
427 //path & operator = (const ::ansi_string & str);
428
429// bool is_equal_full(const path & path) const
430// {
431//
432//#ifdef WINDOWS
433//
434// if (_stricmp(c_str(), path.c_str()) == 0) // undoubtely eaqual...
435// return true;
436//
437//#else
438//
439// if (strcmp(c_str(), path.c_str()) == 0) // undoubtely eaqual...
440// return true;
441//
442//#endif
443//
444// return __node_further_file_is_equal(*this, path);
445//
446// }
447
448
449 bool is_equal_fast(const path & path) const
450 {
451
452#ifdef WINDOWS
453
454 if (ansi_icmp(c_str(), path.c_str()) == 0) // undoubtely eaqual...
455 return true;
456
457#else
458
459 if (ansi_cmp(c_str(), path.c_str()) == 0) // undoubtely eaqual...
460 return true;
461
462#endif
463
464 return false;
465
466 }
467
468
469 bool operator == (const path & path) const
470 {
471
472 return is_equal_fast(path);
473
474 }
475
476 template < character_count n >
477 bool operator == (const ::i8 (&cha)[n]) const
478 {
479
480 return operator ==(::string(cha));
481
482 }
483
484 bool operator == (const ::scoped_string & scopedstr) const;
485 /*{
486
487 return is_equal_fast(path(block));
488
489 }*/
490
491
492
493 //bool operator == (const ::ansi_string & str) const;
494
495
496 bool operator == (const ::string & str) const;
497
498
499 bool operator != (const path & path) const;
500
501 bool operator != (const ::ansi_string & str) const;
502
503 bool operator != (const ::scoped_string & scopedstr) const;
504 // bool operator == (const path & path) const;
505
506 // bool operator == (const ::ansi_string & str) const;
507 // bool operator == (const ::scoped_string & scopedstr) const;
508 //bool operator == (const ::payload & payload) const;
509
510 // bool operator != (const path & path) const;
511
512 // bool operator != (const ::ansi_string & str) const;
513 // bool operator != (const ::scoped_string & scopedstr) const;
514 //bool operator != (const ::payload & payload) const;
515
516 //path operator + (const path & path) const;
517
518
519
520 //path & operator += (const path & path);
521 path & operator += (const ::scoped_string & scopedstr);
522 //path & operator += (const ::const_ansi_range & ansirange);
523 //using path_meta::operator +=;
524
525 //template < typename T > path slashed_path(const T & t) const {return ::transfer(_slashed_path(::file::path(t)));}
526 path slashed_path(const ::scoped_string & scopedstr) const;
527 //path operator / (const ::scoped_string & scopedstr) const;
528 //path operator / (const path & path) const;
529 //path operator / (const_char_pointer psz) const;
530 //path operator / (const ::scoped_string & scopedstr) const;
531
532 path slash_path(const ::scoped_string & scopedstr) const;
533 //path & operator /= (const path & path);
534 //path & operator /= (const ::ansi_string & str);
535 //path & operator /= (const ::inline_number_string &inlinenumberstring);
536 path & operator /= (const ::scoped_string & scopedstr);
537 //path & operator /= (const ::atom & atom);
538
539
540 bool is_empty() const;
541 bool has_character() const;
542
543
544// template <
545//
546
547 //::file::path & file_cat(const ::ansi_string & str) { return *this + str; }
548
549 //::file::path & operator | (const ::ansi_string & str) { return file_cat(str); } // what is good here is the operator precedence
550
551 ::file::path operator | (::file::e_flag eflag) const
552 {
553
554 auto path = *this;
555
556 path.flags() |= eflag;
557
558 return ::transfer(path);
559
560 }
561
562 //string arg(const ::ansi_string & str) const { return ((const string &)*this) + str; }
563
564 //string operator << (const ::ansi_string & str) const { return arg(str); }
565
566 //path & operator = (const ::scoped_string & scopedstr);
567 //path & operator += (const ::scoped_string & scopedstr);
568
569 //path & operator = (const ::payload & payload);
570 //path & operator += (const ::payload & payload);
571
572 //path & operator = (const property & property);
573 //path & operator += (const property & property);
574
575 //path & operator = (const wstring & wstr);
576 //path & operator += (const wstring & wstr);
577
578 //path & operator = (const ::wide_character * psz);
579 //path & operator += (const ::wide_character * psz);
580
581 //path operator * () const;
582
583 //path operator -- () const;
584 //path operator -- (::i32) const { return operator --(); }
585
586
587// void to_string(string & str) const;
588
589 //path sibling(const path & path) const;
590 //path sibling(const ::ansi_string & str) const;
591 path sibling(const ::scoped_string & scopedstr) const;
592
593 //path operator * (const path & path) const;
594
595 //path operator * (const ::ansi_string & str) const;
596 path operator * (const ::scoped_string & scopedstr) const;
597 //path operator * (const property & property) const;
598
599 //path & operator *= (const path & path);
600
601 //path & operator *= (const ::ansi_string & str);
602 path & operator *= (const ::scoped_string & scopedstr);
603 //path & operator *= (const property & property);
604
605 ::const_ansi_range title() const;
606
607 ::const_ansi_range name() const;
608
609 //string name(::collection::index i /* = -1 */) const;
610
612 const_iterator find_name() const;
613
616 ::const_ansi_range find_all_extensions() const;
617
620 ::const_ansi_range find_final_extension() const;
621
622 // bool is_equal(const ::file::path & path2) const;
623
624 ::const_ansi_range all_extensions() const;
625
626 //string ext() const;
627
628 ::const_ansi_range final_extension() const;
629
630 //void split(string_array_base & patha) const;
631 bool is_relative();
632
633 //string_array_base & ascendants_name(string_array_base & namea) const;
634 //string_array_base ascendants_name() const;
635
636 auto relative() const
637 {
638
639 return this->substr(maximum(0, m_iBasePathLength));
640
641 }
642
643
644 path folder() const;
645 path folder(::i32 i) const;
646 path parent() const;
647 path ascendant(::i32 i) const;
648 path & ascend();
649 path & ascend(::i32 i);
650 path operator - (::i32 i) const { return this->ascendant(i); }
651 path & operator -= (::i32 i);
652 //using path_meta::operator -=;
653
654 ::string_array_base parts() const;
655
656 //inline path operator | (enum_flag e) const { path path(*this); path |= e; return path; }
657
658
659 ::file::path & patch_base_path(const ::file::path & pathBase);
660
661
663 //::file::path& defer_extension(const ::scoped_string & scopedstrExtension);
664
666 //::file::path& force_extension(const ::scoped_string& scopedstrExtension);
667
668 using string::_get_count_parts_from_beginning;
669
670 //using string::get_count_parts_from_beginning;
671
672
673 const_ansi_range _get_count_parts_from_beginning(::collection::count iPathPartCountToConsume) const;
674
675 const_ansi_range get_count_parts_from_beginning(::collection::count iPathPartCountToConsume) const;
676
677 };
678
679
680 // e_path file_path_get_type(const ::ansi_string & str, e_path epathForce);
681
682
683 bool case_insensitive_begins_eat(string & str, const ::scoped_string & scopedstrPrefix);
684
685
686
687
688} // namespace file
689
690template<>
691struct std::formatter<::file::path> : std::formatter<std::string_view> {
692 template<typename FormatContext>
693 auto format(const ::file::path& p, FormatContext& ctx) const {
694 return std::formatter<std::string_view>::format(
695 std::string_view(p.begin(), p.end()), ctx);
696 }
697};
698
699
700
701
702
703
704inline const_char_pointer FormatArgument(const ::file::path & value) noexcept;
705
706
707template < >
708inline ::hash32 as_hash32 < const ::file::path & >(const ::file::path & key);
709
710
711// ::file::path node_full_file_path(file::path path);
712
713
714// ::file::path __xxxnode_full_file_path(file::path path);
715
716
717
718//inline ::file::path operator / (const_char_pointer psz, const ::file::path & pathConcat)
719//{
720//
721// string str(scopedstr);
722//
723// ::file::path path(str);
724//
725// return path / pathConcat;
726//
727//}
728
729
730
731
732
733
734//template < typename ITERATOR_TYPE2, character_count n, ::i32 t_size >
735//::file::path operator / (const ::non_pointer < non_const <ITERATOR_TYPE2>>(&sz)[n], const const_string_range_static_array <ITERATOR_TYPE2, t_size >& a)
736//{
737//
738// return ::transfer(::file::path(sz) / ::string(a));
739//
740//}
741//
742
743CLASS_DECL_ACME ::file::enum_type safe_get_file_system_item_type(const ::file::path & path);
744CLASS_DECL_ACME ::file::enum_type get_file_system_item_type(const ::file::path & path);
745CLASS_DECL_ACME ::file::path home_folder_path();
746CLASS_DECL_ACME bool safe_file_exists(const ::file::path & path);
747CLASS_DECL_ACME bool file_exists(const ::file::path & path);
748CLASS_DECL_ACME bool safe_is_directory(const ::file::path & path);
749CLASS_DECL_ACME bool is_directory(const ::file::path & path);
750CLASS_DECL_ACME ::file::e_type safe_file_type(const ::file::path& path);
751CLASS_DECL_ACME ::file::e_type file_type(const ::file::path& path);
752CLASS_DECL_ACME void create_directory(const ::file::path & path);
753CLASS_DECL_ACME void delete_file(const ::file::path & path);
754CLASS_DECL_ACME void erase_directory(const ::file::path & path);
755CLASS_DECL_ACME bool path_begins_eat(::string& strUri, const ::scoped_string& scopedstrPrefix);
756
757
758
759
760template < prototype_character CHARACTER >
761::file::path operator / (
762 const ::character_range < const CHARACTER* >& range1,
763 const ::character_range < const CHARACTER* >& range2)
764{
765
766 return ::file::path(range1).slashed_path(range2);
767
768}
769
770
771template < prototype_character CHARACTER, character_count n >
772::file::path operator / (
773 const ::character_range < const CHARACTER* >& range,
774 const CHARACTER(&s)[n])
775{
776
777 return ::file::path(range) / ::file::path(::as_string_literal< CHARACTER, n>(s));
778
779}
780
781
782template < prototype_character CHARACTER, character_count n >
783::file::path operator / (
784 const CHARACTER(&s)[n],
785 const ::character_range < const CHARACTER* >& range)
786{
787
788 return ::file::path(::as_string_literal< CHARACTER, n>(s)) / ::file::path(range);
789
790}
791
792
793template < prototype_character CHARACTER, typed_character_pointer < CHARACTER > TYPED_CHARACTER_POINTER >
794::file::path operator / (
795 const ::character_range < const CHARACTER* >& range,
796 TYPED_CHARACTER_POINTER p)
797{
798
799 return ::file::path(range) / ::file::path(p);
800
801}
802
803
804template < character_pointer CHARACTER_POINTER >
805::file::path operator / (
806 CHARACTER_POINTER p,
807 const ::character_range < const ::decay< CHARACTER_POINTER > * > & range
808 )
809{
810
811 return ::file::path(p) / ::file::path(range);
812
813}
814
815
816//template < prototype_character CHARACTER, ::i32 t_size >
817//::file::path operator / (
818// const ::character_range < const CHARACTER* >& range,
819// const const_string_range_static_array< const CHARACTER *, t_size > & a)
820//{
821//
822// return ::file::path(range) / ::file::path(::string(a));
823//
824//}
825
826
827template < prototype_character CHARACTER >
828::file::path operator / (
829 const ::character_range < const CHARACTER* >& range,
830 const ::atom & atom)
831{
832
833 return ::file::path(range) / ::file::path(atom.as_string());
834
835}
836
837
atom
Definition atom.h:237
CHARACTER
file::path
Definition path.h:52
file::path::find_name
const_iterator find_name() const
return index pointing to beginning of name
Definition _impl_path.h:1148
file::path::find_final_extension
::const_ansi_range find_final_extension() const
Definition _impl_path.h:1156
file::path::find_all_extensions
::const_ansi_range find_all_extensions() const
Definition _impl_path.h:1175
payload
Definition payload.h:54
property
Definition property.h:81
range
Definition range.h:223
url::url
Definition url.h:435
windows_path
Definition windows_path.h:7
file
Definition filesystem.h:16
no_initialize_t
Definition _structures.h:51