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
|
// file : libbuild2/filesystem.hxx -*- C++ -*-
// license : MIT; see accompanying LICENSE file
#ifndef LIBBUILD2_FILESYSTEM_HXX
#define LIBBUILD2_FILESYSTEM_HXX
#include <libbutl/filesystem.mxx>
#include <libbuild2/types.hxx>
#include <libbuild2/utility.hxx>
#include <libbuild2/context.hxx>
#include <libbuild2/export.hxx>
// Higher-level filesystem utilities built on top of <libbutl/filesystem.mxx>.
//
// Compared to the libbutl's versions, these handle errors and issue
// diagnostics. Some of them also print the corresponding command line
// equivalent at the specified verbosity level. Note that most of such
// functions also respect the dry_run flag.
//
namespace build2
{
using butl::auto_rmfile;
using butl::auto_rmdir;
// The dual interface wrapper for the {mk,rm}{file,dir}() functions
// below that allows you to use it as a true/false return or a more
// detailed enum from <libbutl/filesystem.mxx>
//
template <typename T>
struct fs_status
{
T v;
fs_status (T v): v (v) {};
operator T () const {return v;}
explicit operator bool () const {return v == T::success;}
};
// Set the file access and modification times (unless dry-run) to the
// current time printing the standard diagnostics starting from the
// specified verbosity level. If the file does not exist and create is true,
// create it and fail otherwise.
//
LIBBUILD2_SYMEXPORT void
touch (context&, const path&, bool create, uint16_t verbosity = 1);
// Return the modification time for an existing regular file and
// timestamp_nonexistent otherwise. Print the diagnostics and fail on system
// error.
//
LIBBUILD2_SYMEXPORT timestamp
mtime (const char*);
inline timestamp
mtime (const path& p)
{
return mtime (p.string ().c_str ());
}
// Create the directory and print the standard diagnostics starting from the
// specified verbosity level.
//
// Note that these functions ignore the dry_run flag (we might need to save
// something in such a directory, such as depdb, ignoring dry_run). Overall,
// it feels like we should establish the structure even for dry-run.
//
// Note that the implementation may not be suitable if the performance is
// important and it is expected that the directory will exist in most cases.
// See the fsdir{} rule for details.
//
using mkdir_status = butl::mkdir_status;
LIBBUILD2_SYMEXPORT fs_status<mkdir_status>
mkdir (const dir_path&, uint16_t verbosity = 1);
LIBBUILD2_SYMEXPORT fs_status<mkdir_status>
mkdir_p (const dir_path&, uint16_t verbosity = 1);
// Rename a file (or file symlink) overwriting the destination if exists.
//
LIBBUILD2_SYMEXPORT void
mvfile (const path& from, const path& to, uint16_t verbosity = 1);
// Remove the file (unless dry-run) and print the standard diagnostics
// starting from the specified verbosity level. The second argument is only
// used in diagnostics, to print the target name. Passing the path for
// target will result in the relative path being printed.
//
using rmfile_status = butl::rmfile_status;
template <typename T>
fs_status<rmfile_status>
rmfile (const path&, const T& target, uint16_t verbosity = 1);
fs_status<rmfile_status>
rmfile (context&, const path&, uint16_t verbosity = 1);
fs_status<rmfile_status>
rmfile (const path&, int = 1) = delete;
fs_status<rmfile_status>
rmfile (const path&, uint16_t) = delete;
// Similar to rmfile() but for symlinks.
//
LIBBUILD2_SYMEXPORT fs_status<rmfile_status>
rmsymlink (context&, const path&, bool dir, uint16_t verbosity);
// Similar to rmfile() but for directories (note: not -r).
//
using rmdir_status = butl::rmdir_status;
template <typename T>
fs_status<rmdir_status>
rmdir (const dir_path&, const T& target, uint16_t verbosity = 1);
fs_status<rmdir_status>
rmdir (context&, const dir_path&, uint16_t verbosity = 1);
fs_status<rmdir_status>
rmdir (const dir_path&, int = 1) = delete;
fs_status<rmdir_status>
rmdir (const dir_path&, uint16_t) = delete;
// Remove the directory recursively (unless dry-run) and print the standard
// diagnostics starting from the specified verbosity level. Note that this
// function returns not_empty if we try to remove a working directory. If
// the dir argument is false, then the directory itself is not removed.
//
LIBBUILD2_SYMEXPORT fs_status<rmdir_status>
rmdir_r (context& ctx,
const dir_path&, bool dir = true, uint16_t verbosity = 1);
fs_status<rmdir_status>
rmdir_r (const dir_path&, bool = true, uint16_t = 1) = delete;
// Check for a file, directory or filesystem entry existence. Print the
// diagnostics and fail on system error, unless ignore_error is true.
//
LIBBUILD2_SYMEXPORT bool
exists (const path&, bool follow_symlinks = true, bool ignore_error = false);
LIBBUILD2_SYMEXPORT bool
exists (const dir_path&, bool ignore_error = false);
LIBBUILD2_SYMEXPORT bool
entry_exists (const path&,
bool follow_symlinks = false,
bool ignore_error = false);
// Check for a directory emptiness. Print the diagnostics and fail on system
// error.
//
LIBBUILD2_SYMEXPORT bool
empty (const dir_path&);
// Directories containing .buildignore (or .build2ignore in the alternative
// naming scheme) file are automatically ignored by recursive name patterns.
// For now the file is just a marker and its contents don't matter. Note
// that these functions ignore dry-run.
// Create a directory containing an empty .buildignore file.
//
LIBBUILD2_SYMEXPORT fs_status<mkdir_status>
mkdir_buildignore (context&,
const dir_path&, const path&, uint16_t verbosity = 1);
// Return true if the directory is empty or only contains the .buildignore
// file. Fail if the directory doesn't exist.
//
LIBBUILD2_SYMEXPORT bool
empty_buildignore (const dir_path&, const path&);
// Remove a directory if it is empty or only contains the .buildignore file.
//
LIBBUILD2_SYMEXPORT fs_status<rmdir_status>
rmdir_buildignore (context&,
const dir_path&, const path&, uint16_t verbosity = 1);
// Get/set a path permissions.
//
using permissions = butl::permissions;
LIBBUILD2_SYMEXPORT permissions
path_perms (const path&);
LIBBUILD2_SYMEXPORT void
path_perms (const path&, permissions);
}
#include <libbuild2/filesystem.ixx>
#include <libbuild2/filesystem.txx>
#endif // LIBBUILD2_FILESYSTEM_HXX
|
