townforge/filesystem
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Reworked copy operation. Added create_directory with two paths.

Browse Source 
The updated copy implementation follows C++20 [fs.op.copy] definition
and implements additional copy options.

The new create_directory overloads accepting two paths are functionally
similar to copy_directory, but are compliant with C++20
[fs.op.create.directory]. The copy_directory operation has been deprecated
in favor of create_directory.
This commit is contained in:
Andrey Semashev 2020-05-10 03:02:32 +03:00
parent 4e6317e4b0
commit 80709a9411
6 changed files with 353 additions and 124 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
doc/deprecated.html
View File

@ -293,6 +293,16 @@ BOOST_FILESYSTEM_NO_DEPRECATED</code> is defined.</p>
<td style="font-size: 10pt" valign="top">
<i>Function removed</i></td>
</tr>
<tr>
<td style="font-size: 10pt" valign="top">
<code>operations.hpp</code></td>
<td style="font-size: 10pt" valign="top">
<code>copy_directory(const path&amp; from, const path&amp; to)</code></td>
<td style="font-size: 10pt" valign="top">
&nbsp;</td>
<td style="font-size: 10pt" valign="top">
<i>Function removed, use <code>create_directory(const path&amp; to, const path&amp; from)</code> instead (note the reversed order of arguments)</i></td>
</tr>
<tr>
<td style="font-size: 10pt" valign="top">
<code>class directory_entry</code></td>

146
doc/reference.html
View File

@ -774,9 +774,17 @@ nothing else.&quot;</p>
enum class <a name="copy_options">copy_options</a>
{
none = 0u,
// <a href="#copy_file">copy_file</a> options
skip_existing,
overwrite_existing,
update_existing
update_existing,
// <a href="#copy">copy</a> options
recursive,
copy_symlinks,
skip_symlinks,
directories_only,
create_symlinks,
create_hard_links
};
// Deprecated, use <a href="#copy_options">copy_options</a> instead
@ -815,9 +823,14 @@ nothing else.&quot;</p>
void <a href="#copy">copy</a>(const path&amp; from, const path&amp; to);
void <a href="#copy">copy</a>(const path&amp; from, const path&amp; to,
system::error_code&amp; ec);
void <a href="#copy">copy</a>(const path&amp; from, const path&amp; to,
<a href="#copy_options">copy_options</a> options);
void <a href="#copy">copy</a>(const path&amp; from, const path&amp; to,
<a href="#copy_options">copy_options</a> options, system::error_code&amp; ec);
void <a href="#create_directory">copy_directory</a>(const path&amp; from, const path&amp; to);
void <a href="#create_directory">copy_directory</a>(const path&amp; from, const path&amp; to,
// Deprecated, use <a href="#create_directory">create_directory</a> instead
void <a href="#copy_directory">copy_directory</a>(const path&amp; from, const path&amp; to);
void <a href="#copy_directory">copy_directory</a>(const path&amp; from, const path&amp; to,
system::error_code&amp; ec);
bool <a href="#copy_file">copy_file</a>(const path&amp; from, const path&amp; to);
@ -844,6 +857,8 @@ nothing else.&quot;</p>
bool <a href="#create_directory">create_directory</a>(const path&amp; p);
bool <a href="#create_directory">create_directory</a>(const path&amp; p, system::error_code&amp; ec);
bool <a href="#create_directory">create_directory</a>(const path&amp; p, const path&amp; existing);
bool <a href="#create_directory">create_directory</a>(const path&amp; p, const path&amp; existing, system::error_code&amp; ec);
void <a href="#create_directory_symlink">create_directory_symlink</a>(const path&amp; to,
const path&amp; new_symlink);
@ -3080,58 +3095,87 @@ without a <code>base</code> argument, <code>base</code> is <code>current_path()<
does this path live in /home/goodguy or /home/badguy?)&nbsp; —end note]</p>
</blockquote>
<pre>void <a name="copy">copy</a>(const path&amp; from, const path&amp; to);
<pre>void copy(const path&amp; from, const path&amp; to);
void copy(const path&amp; from, const path&amp; to, system::error_code&amp; ec);</pre>
<blockquote>
<p><i>Effects:</i> As if</p>
<p><i>Effects: </i><code>copy(from, to, copy_options::none</code><i>[</i><code>, ec</code><i>]</i><code>)</code>.</p>
<p><i>Throws:</i> As specified in <a href="#Error-reporting">Error reporting</a>.</p>
</blockquote>
<pre>void <a name="copy">copy</a>(const path&amp; from, const path&amp; to, <a href="#copy_options">copy_options</a> options);
void copy(const path&amp; from, const path&amp; to, <a href="#copy_options">copy_options</a> options, system::error_code&amp; ec);</pre>
<blockquote>
<p><i>Precondition:</i> <code>options</code> must contain at most one option from each of the following groups:
<ul>
<li><code>copy_options::skip_existing</code>, <code>copy_options::overwrite_existing</code> or <code>copy_options::update_existing</code>;</li>
<li><code>copy_options::recursive</code>;</li>
<li><code>copy_options::copy_symlinks</code> or <code>copy_options::skip_symlinks</code>;</li>
<li><code>copy_options::directories_only</code>, <code>copy_options::create_symlinks</code> or <code>copy_options::create_hard_links</code>.</li>
</ul></p>
<p><i>Effects:</i> Let <code>f</code> and <code>t</code> be <code>file_status</code> objects obtained the following way:
<ul>
<li>If <code>(options &amp; (copy_options::create_symlinks | copy_options::skip_symlinks)) != copy_options::none</code> then <code>f = <a href="#symlink_status">symlink_status</a>(from)</code> and <code>t = <a href="#symlink_status">symlink_status</a>(to)</code>;</li>
<li>Otherwise, if <code>(options &amp; copy_options::copy_symlinks) != copy_options::none</code> then <code>f = <a href="#symlink_status">symlink_status</a>(from)</code> and <code>t = <a href="#status">status</a>(to)</code>;</li>
<li>Otherwise, <code>f = <a href="#status">status</a>(from)</code> and <code>t = <a href="#status">status</a>(to)</code>.</li>
</ul>
Then, report an error if:
<ul>
<li><code>!exists(f)</code>, or</li>
<li><code>equivalent(from, to)</code>, or</li>
<li><code>is_other(f) || is_other(t)</code>, or</li>
<li><code>is_directory(f) &amp;&amp; is_regular_file(t)</code>.</li>
</ul>
Otherwise, if <code>is_symlink(f)</code>, then:
<ul>
<li>If <code>(options &amp; copy_options::skip_symlinks) != copy_options::none</code> then return;</li>
<li>Otherwise if <code>!exists(t) &amp;&amp; (options &amp; copy_options::copy_symlinks) != copy_options::none</code> then <code><a href="#copy_symlink">copy_symlink</a>(from, to)</code>;</li>
<li>Otherwise report error.</li>
</ul>
Otherwise, if <code>is_regular_file(f)</code>, then:
<ul>
<li>If <code>(options &amp; copy_options::directories_only) != copy_options::none</code> then return;</li>
<li>Otherwise if <code>(options &amp; copy_options::create_symlinks) != copy_options::none</code> then <code>create_symlink(from, to)</code>;</li>
<li>otherwise if <code>(options &amp; copy_options::create_hard_links) != copy_options::none</code> then <code>create_hard_link(from, to)</code>;</li>
<li>Otherwise if <code>is_directory(t)</code> then <code><a href="#copy_file">copy_file</a>(from, to / from.filename(), options)</code>;</li>
<li>Otherwise <code><a href="#copy_file">copy_file</a>(from, to, options)</code>.</li>
</ul>
Otherwise, if <code>is_directory(f)</code>, then:
<ul>
<li>If <code>(options &amp; copy_options::create_symlinks) != copy_options::none</code> then report error with error code equal to <code>make_error_code(system::errc::is_a_directory)</code>;</li>
<li>Otherwise if
<ul>
<li><code>(options &amp; copy_options::recursive) != copy_options::none</code>, or</li>
<li><code>options == copy_options::none</code> and this call to <code>copy</code> is not a recursive call from <code>copy</code></li>
</ul>
then:
<ul>
<li>If <code>!exists(t)</code>, then <code><a href="#create_directory">create_directory</a>(to, from)</code>.</li>
<li>Then, iterate over files in <code>from</code> and for each <code>directory_entry x</code> obtained during iteration invoke <code>copy(x.path(), to / x.path().filename(), options)</code>.</li>
</ul>
</li>
<li>Otherwise, return.</li>
</ul>
Otherwise, for all unsupported file types of <code>f</code> report error.</p>
<blockquote>
<pre>file_status s(symlink_status(from<i>[</i><code>, ec</code><i>]</i>));
if(is_symlink(s))
copy_symlink(from, to<i>[</i><code>, ec</code><i>]</i>);
else if(is_directory(s))
copy_directory(from, to<i>[</i><code>, ec</code><i>]</i>);
else if(is_regular_file(s))
copy_file(from, to, copy_options::none<i>[</i><code>, ec</code><i>]</i>);
else
<i> Report error as specified in <a href="#Error-reporting">Error reporting</a>.</i></pre>
</blockquote>
<p><i>Throws:</i> As specified in <a href="#Error-reporting">Error reporting</a>.</p>
</blockquote>
<pre>void <a name="copy_directory">copy_directory</a>(const path&amp; from, const path&amp; to);
void copy_directory(const path&amp; from, const path&amp; to, system::error_code&amp; ec);</pre>
<blockquote>
<table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse"
bordercolor="#111111" width="90%" bgcolor="#E0E0E0">
<tr>
<td width="100%">
<p><i>This function is poorly named; it should probably be an overload of
<code>create_directory</code> with an additional argument.</i></td>
</tr>
</table>
<p><i>Effects: </i>Creates directory <code>to</code>, with
attributes copied from directory <code>from</code>. The set of attributes
copied is operating system dependent.</p>
<blockquote>
<table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse"
bordercolor="#111111" width="90%" bgcolor="#E8FFE8">
<tr>
<td width="100%">
<p>[<i>Note:</i> For ISO 9945/POSIX based operating systems the
attributes are those copied by native API <code>stat(from.c_str(), &amp;from_stat)</code>
followed by <code>mkdir(to.c_str(),from_stat.st_mode)</code>.&nbsp; For
Windows based operating systems the attributes are those copied by native
API <code>CreateDirectoryExW(from.c_str(), to.c_str(), 0)</code>.&nbsp; <i>
—end note</i>]</td>
</tr>
</table>
</blockquote>
<p>[<i>Note:</i> For ISO 9945/POSIX based operating systems the
attributes are those copied by native API <code>stat(from.c_str(), &amp;from_stat)</code>
followed by <code>mkdir(to.c_str(),from_stat.st_mode)</code>.&nbsp; For
Windows based operating systems the attributes are those copied by native
API <code>CreateDirectoryExW(from.c_str(), to.c_str(), 0)</code>.&nbsp; <i>
—end note</i>]</td>
<p><i>Throws:</i> As specified in <a href="#Error-reporting">Error reporting</a>.</p>
<p>[<i>Note:</i> This operation is deprecated, use <a href="#create_directory">create_directory</a> instead. —end note]</p>
</blockquote>
<pre>bool copy_file(const path&amp; from, const path&amp; to);
@ -3143,9 +3187,9 @@ bool copy_file(const path&amp; from, const path&amp; to, system::error_code&amp;
</blockquote>
<pre>bool <a name="copy_file">copy_file</a>(const path&amp; from, const path&amp; to, <a href="#copy_options">copy_options</a> options);
bool <a name="copy_file2">copy_file</a>(const path&amp; from, const path&amp; to, <a href="#copy_options">copy_options</a> options, system::error_code&amp; ec);
bool <a name="copy_file3">copy_file</a>(const path&amp; from, const path&amp; to, <a href="#copy_option">copy_option</a> options);
bool <a name="copy_file4">copy_file</a>(const path&amp; from, const path&amp; to, <a href="#copy_option">copy_option</a> options, system::error_code&amp; ec);</pre>
bool copy_file(const path&amp; from, const path&amp; to, <a href="#copy_options">copy_options</a> options, system::error_code&amp; ec);
bool copy_file(const path&amp; from, const path&amp; to, <a href="#copy_option">copy_option</a> options);
bool copy_file(const path&amp; from, const path&amp; to, <a href="#copy_option">copy_option</a> options, system::error_code&amp; ec);</pre>
<blockquote>
<p><i>Precondition:</i> At most one of <code>copy_options::skip_existing</code>, <code>copy_options::overwrite_existing</code> or <code>copy_options::update_existing</code> must be specified in <code>options</code>.</p>
<p><i>Effects:</i> Report an error if:
@ -3153,12 +3197,12 @@ bool <a name="copy_file4">copy_file</a>(const path&amp; from, const path&amp; to
<li><code>!is_regular_file(from)</code>, or</li>
<li><code>exists(to) &amp;&amp; !is_regular_file(to)</code>, or</li>
<li><code>exists(to) &amp;&amp; equivalent(from, to)</code>, or</li>
<li><code>exists(to) &amp;&amp; (options & (copy_options::skip_existing | copy_options::overwrite_existing)) == copy_options::none</code>.</li>
<li><code>exists(to) &amp;&amp; (options &amp; (copy_options::skip_existing | copy_options::overwrite_existing)) == copy_options::none</code>.</li>
</ul>
Otherwise, return successfully with no effect if:
<ul>
<li><code>exists(to) &amp;&amp; (options & copy_options::skip_existing) != copy_options::none</code>, or</li>
<li><code>exists(to) &amp;&amp; (options & copy_options::update_existing) != copy_options::none</code> and last write time of <code>from</code> is more recent than that of <code>to</code>.</li>
<li><code>exists(to) &amp;&amp; (options &amp; copy_options::skip_existing) != copy_options::none</code>, or</li>
<li><code>exists(to) &amp;&amp; (options &amp; copy_options::update_existing) != copy_options::none</code> and last write time of <code>from</code> is more recent than that of <code>to</code>.</li>
</ul>
Otherwise, the contents and attributes of the file <code>from</code> resolves to are copied to the file <code>to</code> resolves to.</p>
<p><i>Returns:</i> <code>true</code> if the file was copied without error, otherwise <code>false</code>.</p>
@ -3188,13 +3232,17 @@ bool <a name="create_directories2">create_directories</a>(const path&amp; p, sys
of <code>p</code> that do not exist.</p>
</blockquote>
<pre>bool <a name="create_directory">create_directory</a>(const path&amp; p);
bool <a name="create_directory2">create_directory</a>(const path&amp; p, system::error_code&amp; ec);</pre>
bool create_directory(const path&amp; p, system::error_code&amp; ec);
bool create_directory(const path&amp; p, const path&amp; existing);
bool create_directory(const path&amp; p, const path&amp; existing, system::error_code&amp; ec);</pre>
<blockquote>
<p><i>Effects:</i> Establishes the postcondition by attempting to create the
directory <code>p</code> resolves to, as if by ISO/IEC 9945 <code><a href="http://www.opengroup.org/onlinepubs/000095399/functions/mkdir.html">
mkdir()</a></code> with a second argument of S_IRWXU|S_IRWXG|S_IRWXO. Creation
failure because <code>p</code> resolves to an existing directory shall not be
treated as an error. </p>
mkdir()</a></code>. For overloads without <code>existing</code> argument, the new directory is created with <code>S_IRWXU|S_IRWXG|S_IRWXO</code> mode.
Overloads with <code>existing</code> argument obtain mode from <code>existing</code>, which must be a path to an existing directory. On Windows,
<code>CreateDirectoryW(p.c_str(), NULL)</code> is used when <code>existing</code> is not specified and <code>CreateDirectoryExW(existing.c_str(), p.c_str(), NULL)</code> otherwise.
Creation failure because <code>p</code> resolves to an existing directory shall not be
treated as an error.</p>
<p><i>Postcondition:</i> <code>is_directory(p)</code></p>
<p><i>Returns:</i> <code>true</code> if a new directory was created, otherwise <code>false</code>.</p>
<p><i>Throws:</i> As specified in <a href="#Error-reporting">Error reporting</a>.</p>

5
doc/release_history.html
View File

@ -34,7 +34,7 @@
<a href="v3.html">V3 Intro</a> &nbsp;&nbsp;
<a href="v3_design.html">V3 Design</a> &nbsp;&nbsp;
<a href="deprecated.html">Deprecated</a> &nbsp;&nbsp;
<a href="issue_reporting.html">Bug Reports </a>&nbsp;&nbsp;
<a href="issue_reporting.html">Bug Reports</a>&nbsp;&nbsp;
</td>
</table>
@ -50,6 +50,9 @@
<li><b>New:</b> Added <code>copy_options::skip_existing</code> option, which allows <code>copy_file</code> operation to succeed without overwriting the target file, if it exists.</li>
<li><b>New:</b> Added <code>copy_options::update_existing</code> option, which allows <code>copy_file</code> operation to conditionally overwrite the target file, if it exists, if its last write time is older than that of the replacement file.</li>
<li><b>New:</b> <code>copy_file</code> now returns <code>bool</code>, which indicates whether the file was copied.</li>
<li><b>New, breaking change:</b> <code>copy</code> operation has been extended and reworked to implement behavior specified in C++20 [fs.op.copy]. This includes support for <code>copy_options::recursive</code>, <code>copy_options::copy_symlinks</code>, <code>copy_options::skip_symlinks</code>, <code>copy_options::directories_only</code>, <code>copy_options::create_symlinks</code> and <code>copy_options::create_hard_links</code> options. The operation performs additional checks based on the specified options. Applying <code>copy</code> to a directory with default <code>copy_options</code> will now also copy files residing in that directory (but not nested directories or files in those directories).</li>
<li><b>New:</b> Added <code>create_directory</code> overload taking two paths. The second path is a path to an existing directory, which is used as a source of permission attributes to use in the directory to create.</li>
<li><b>Deprecated:</b> <code>copy_directory</code> operation has been deprecated in favor of the new <code>create_directory</code> overload. Note that the two operations have reversed order of the path arguments.</li>
<li><code>equivalent</code> on POSIX systems now returns the actual error code from the OS if one of the paths does not resolve to a file. Previously the function would return an error code of 1. (<a href="https://github.com/boostorg/filesystem/issues/141">#141</a>)</li>
<li><code>equivalent</code> no longer considers file size and last modification time in order to test whether the two paths refer to the same file. These checks could result in a false negative if the file was modified during the <code>equivalent</code> call.</li>
<li><code>space</code> now initializes the <code>space_info</code> structure members to -1 values on error, as required by C++20 ([fs.op.space]/1).</li>

54
include/boost/filesystem/operations.hpp
View File

@ -55,10 +55,21 @@ struct space_info
BOOST_SCOPED_ENUM_UT_DECLARE_BEGIN(copy_options, unsigned int)
{
none = 0u, // Default, error if the target file exists
none = 0u, // Default. For copy_file: error if the target file exists. For copy: do not recurse, follow symlinks, copy file contents.
// copy_file options:
skip_existing = 1u, // Don't overwrite the existing target file, don't report an error
overwrite_existing = 1u << 1, // Overwrite existing file
update_existing = 1u << 2 // Overwrite existing file if its last write time is older than the replacement file
update_existing = 1u << 2, // Overwrite existing file if its last write time is older than the replacement file
// copy options:
recursive = 1u << 8, // Recurse into sub-directories
copy_symlinks = 1u << 9, // Copy symlinks as symlinks instead of copying the referenced file
skip_symlinks = 1u << 10, // Don't copy symlinks
directories_only = 1u << 11, // Only copy directory structure, do not copy non-directory files
create_symlinks = 1u << 12, // Create symlinks instead of copying files
create_hard_links = 1u << 13, // Create hard links instead of copying files
_detail_recursing = 1u << 14 // Internal use only, do not use
}
BOOST_SCOPED_ENUM_DECLARE_END(copy_options)
@ -91,9 +102,11 @@ path initial_path(system::error_code* ec=0);
BOOST_FILESYSTEM_DECL
path canonical(const path& p, const path& base, system::error_code* ec=0);
BOOST_FILESYSTEM_DECL
void copy(const path& from, const path& to, system::error_code* ec=0);
void copy(const path& from, const path& to, unsigned int options, system::error_code* ec=0);
#if !defined(BOOST_FILESYSTEM_NO_DEPRECATED)
BOOST_FILESYSTEM_DECL
void copy_directory(const path& from, const path& to, system::error_code* ec=0);
#endif
BOOST_FILESYSTEM_DECL
bool copy_file(const path& from, const path& to, // See ticket #2925
unsigned int options, system::error_code* ec=0); // see copy_options for options
@ -102,7 +115,7 @@ void copy_symlink(const path& existing_symlink, const path& new_symlink, system:
BOOST_FILESYSTEM_DECL
bool create_directories(const path& p, system::error_code* ec=0);
BOOST_FILESYSTEM_DECL
bool create_directory(const path& p, system::error_code* ec=0);
bool create_directory(const path& p, const path* existing, system::error_code* ec=0);
BOOST_FILESYSTEM_DECL
void create_directory_symlink(const path& to, const path& from,
system::error_code* ec=0);
@ -247,17 +260,34 @@ path complete(const path& p, const path& base)
#endif
inline
void copy(const path& from, const path& to) {detail::copy(from, to);}
void copy(const path& from, const path& to)
{
detail::copy(from, to, static_cast< unsigned int >(copy_options::none));
}
inline
void copy(const path& from, const path& to, system::error_code& ec) BOOST_NOEXCEPT
{detail::copy(from, to, &ec);}
{
detail::copy(from, to, static_cast< unsigned int >(copy_options::none), &ec);
}
inline
void copy(const path& from, const path& to, BOOST_SCOPED_ENUM_NATIVE(copy_options) options)
{
detail::copy(from, to, static_cast< unsigned int >(options));
}
inline
void copy(const path& from, const path& to, BOOST_SCOPED_ENUM_NATIVE(copy_options) options, system::error_code& ec) BOOST_NOEXCEPT
{
detail::copy(from, to, static_cast< unsigned int >(options), &ec);
}
#if !defined(BOOST_FILESYSTEM_NO_DEPRECATED)
inline
void copy_directory(const path& from, const path& to)
{detail::copy_directory(from, to);}
inline
void copy_directory(const path& from, const path& to, system::error_code& ec) BOOST_NOEXCEPT
{detail::copy_directory(from, to, &ec);}
#endif
inline
bool copy_file(const path& from, const path& to)
{
@ -309,11 +339,17 @@ inline
bool create_directories(const path& p, system::error_code& ec) BOOST_NOEXCEPT
{return detail::create_directories(p, &ec);}
inline
bool create_directory(const path& p) {return detail::create_directory(p);}
bool create_directory(const path& p) {return detail::create_directory(p, 0);}
inline
bool create_directory(const path& p, system::error_code& ec) BOOST_NOEXCEPT
{return detail::create_directory(p, &ec);}
{return detail::create_directory(p, 0, &ec);}
inline
bool create_directory(const path& p, const path& existing)
{return detail::create_directory(p, &existing);}
inline
bool create_directory(const path& p, const path& existing, system::error_code& ec) BOOST_NOEXCEPT
{return detail::create_directory(p, &existing, &ec);}
inline
void create_directory_symlink(const path& to, const path& from)
{detail::create_directory_symlink(to, from);}

4
src/error_handling.hpp
View File

@ -34,8 +34,9 @@ typedef int err_t;
// POSIX uses a 0 return to indicate success
#define BOOST_ERRNO errno
#define BOOST_ERROR_NOT_SUPPORTED ENOSYS
#define BOOST_ERROR_FILE_NOT_FOUND ENOENT
#define BOOST_ERROR_ALREADY_EXISTS EEXIST
#define BOOST_ERROR_NOT_SUPPORTED ENOSYS
#else
@ -44,6 +45,7 @@ typedef boost::winapi::DWORD_ err_t;
// Windows uses a non-0 return to indicate success
#define BOOST_ERRNO boost::winapi::GetLastError()
#define BOOST_ERROR_FILE_NOT_FOUND boost::winapi::ERROR_FILE_NOT_FOUND_
#define BOOST_ERROR_ALREADY_EXISTS boost::winapi::ERROR_ALREADY_EXISTS_
#define BOOST_ERROR_NOT_SUPPORTED boost::winapi::ERROR_NOT_SUPPORTED_

258
src/operations.cpp
View File

@ -256,7 +256,6 @@ union reparse_data_buffer
# if defined(BOOST_POSIX_API)
# define BOOST_SET_CURRENT_DIRECTORY(P)(::chdir(P)== 0)
# define BOOST_CREATE_DIRECTORY(P)(::mkdir(P, S_IRWXU|S_IRWXG|S_IRWXO)== 0)
# define BOOST_CREATE_HARD_LINK(F,T)(::link(T, F)== 0)
# define BOOST_CREATE_SYMBOLIC_LINK(F,T,Flag)(::symlink(T, F)== 0)
# define BOOST_REMOVE_DIRECTORY(P)(::rmdir(P)== 0)
@ -269,7 +268,6 @@ union reparse_data_buffer
# else // BOOST_WINDOWS_API
# define BOOST_SET_CURRENT_DIRECTORY(P)(::SetCurrentDirectoryW(P)!= 0)
# define BOOST_CREATE_DIRECTORY(P)(::CreateDirectoryW(P, 0)!= 0)
# define BOOST_CREATE_HARD_LINK(F,T)(create_hard_link_api(F, T, 0)!= 0)
# define BOOST_CREATE_SYMBOLIC_LINK(F,T,Flag)(create_symbolic_link_api(F, T, Flag)!= 0)
# define BOOST_REMOVE_DIRECTORY(P)(::RemoveDirectoryW(P)!= 0)
@ -304,8 +302,9 @@ fs::file_type query_file_type(const path& p, error_code* ec);
bool is_empty_directory(const path& p, error_code* ec)
{
return (ec != 0 ? fs::directory_iterator(p, *ec) : fs::directory_iterator(p))
== fs::directory_iterator();
fs::directory_iterator itr;
detail::directory_iterator_construct(itr, p, static_cast< unsigned int >(directory_options::none), ec);
return itr == fs::directory_iterator();
}
bool not_found_error(int errval) BOOST_NOEXCEPT; // forward declaration
@ -356,19 +355,14 @@ bool remove_file_or_directory(const path& p, fs::file_type type, error_code* ec)
boost::uintmax_t remove_all_aux(const path& p, fs::file_type type,
error_code* ec)
{
boost::uintmax_t count = 0;
boost::uintmax_t count = 0u;
if (type == fs::directory_file) // but not a directory symlink
{
fs::directory_iterator itr;
if (ec != 0)
{
itr = fs::directory_iterator(p, *ec);
if (*ec)
return count;
}
else
itr = fs::directory_iterator(p);
fs::detail::directory_iterator_construct(itr, p, static_cast< unsigned int >(directory_options::none), ec);
if (ec && *ec)
return count;
const fs::directory_iterator end_dit;
while(itr != end_dit)
@ -970,40 +964,145 @@ path canonical(const path& p, const path& base, system::error_code* ec)
}
BOOST_FILESYSTEM_DECL
void copy(const path& from, const path& to, system::error_code* ec)
void copy(const path& from, const path& to, unsigned int options, system::error_code* ec)
{
file_status s(detail::symlink_status(from, ec));
if (ec != 0 && *ec) return;
BOOST_ASSERT((((options & static_cast< unsigned int >(copy_options::overwrite_existing)) != 0u) +
((options & static_cast< unsigned int >(copy_options::skip_existing)) != 0u) +
((options & static_cast< unsigned int >(copy_options::update_existing)) != 0u)) <= 1u);
if (is_symlink(s))
BOOST_ASSERT((((options & static_cast< unsigned int >(copy_options::copy_symlinks)) != 0u) +
((options & static_cast< unsigned int >(copy_options::skip_symlinks)) != 0u)) <= 1u);
BOOST_ASSERT((((options & static_cast< unsigned int >(copy_options::directories_only)) != 0u) +
((options & static_cast< unsigned int >(copy_options::create_symlinks)) != 0u) +
((options & static_cast< unsigned int >(copy_options::create_hard_links)) != 0u)) <= 1u);
file_status from_stat;
if ((options & (static_cast< unsigned int >(copy_options::copy_symlinks) |
static_cast< unsigned int >(copy_options::skip_symlinks) |
static_cast< unsigned int >(copy_options::create_symlinks))) != 0u)
{
detail::copy_symlink(from, to, ec);
}
else if (is_directory(s))
{
detail::copy_directory(from, to, ec);
}
else if (is_regular_file(s))
{
detail::copy_file(from, to, static_cast< unsigned int >(copy_options::none), ec);
from_stat = detail::symlink_status(from, ec);
}
else
{
if (ec == 0)
BOOST_FILESYSTEM_THROW(filesystem_error("boost::filesystem::copy",
from, to, error_code(BOOST_ERROR_NOT_SUPPORTED, system_category())));
ec->assign(BOOST_ERROR_NOT_SUPPORTED, system_category());
from_stat = detail::status(from, ec);
}
}
BOOST_FILESYSTEM_DECL
void copy_directory(const path& from, const path& to, system::error_code* ec)
{
# ifdef BOOST_POSIX_API
struct stat from_stat;
# endif
error(!BOOST_COPY_DIRECTORY(from.c_str(), to.c_str()) ? BOOST_ERRNO : 0,
from, to, ec, "boost::filesystem::copy_directory");
if (ec && *ec)
return;
if (!exists(from_stat))
{
emit_error(BOOST_ERROR_FILE_NOT_FOUND, from, to, ec, "boost::filesystem::copy");
return;
}
if (is_symlink(from_stat))
{
if ((options & static_cast< unsigned int >(copy_options::skip_symlinks)) != 0u)
return;
if ((options & static_cast< unsigned int >(copy_options::copy_symlinks)) == 0u)
goto fail;
detail::copy_symlink(from, to, ec);
}
else if (is_regular_file(from_stat))
{
if ((options & static_cast< unsigned int >(copy_options::directories_only)) != 0u)
return;
if ((options & static_cast< unsigned int >(copy_options::create_symlinks)) != 0u)
{
detail::create_symlink(from, to, ec);
return;
}
if ((options & static_cast< unsigned int >(copy_options::create_hard_links)) != 0u)
{
detail::create_hard_link(from, to, ec);
return;
}
file_status to_stat;
if ((options & (static_cast< unsigned int >(copy_options::skip_symlinks) |
static_cast< unsigned int >(copy_options::create_symlinks))) != 0u)
{
to_stat = detail::symlink_status(to, ec);
}
else
{
to_stat = detail::status(to, ec);
}
if (ec && *ec)
return;
if (is_directory(to_stat))
detail::copy_file(from, to / from.filename(), options, ec);
else
detail::copy_file(from, to, options, ec);
}
else if (is_directory(from_stat))
{
if ((options & static_cast< unsigned int >(copy_options::create_symlinks)) != 0u)
{
error_code err_code = make_error_code(system::errc::is_a_directory);
if (!ec)
BOOST_FILESYSTEM_THROW(filesystem_error("boost::filesystem::copy", from, to, err_code));
*ec = err_code;
return;
}
file_status to_stat;
if ((options & (static_cast< unsigned int >(copy_options::skip_symlinks) |
static_cast< unsigned int >(copy_options::create_symlinks))) != 0u)
{
to_stat = detail::symlink_status(to, ec);
}
else
{
to_stat = detail::status(to, ec);
}
if (ec && *ec)
return;
if (!exists(to_stat))
{
detail::create_directory(to, &from, ec);
if (ec && *ec)
return;
}
if ((options & static_cast< unsigned int >(copy_options::recursive)) != 0u || options == 0u)
{
fs::directory_iterator itr;
detail::directory_iterator_construct(itr, from, static_cast< unsigned int >(directory_options::none), ec);
if (ec && *ec)
return;
const fs::directory_iterator end_dit;
while (itr != end_dit)
{
path const& p = itr->path();
// Set _detail_recursing flag so that we don't recurse more than for one level deeper into the directory if options are copy_options::none
detail::copy(p, to / p.filename(), options | static_cast< unsigned int >(copy_options::_detail_recursing), ec);
if (ec && *ec)
return;
detail::directory_iterator_increment(itr, ec);
if (ec && *ec)
return;
}
}
}
else
{
fail:
emit_error(BOOST_ERROR_NOT_SUPPORTED, from, to, ec, "boost::filesystem::copy");
}
}
BOOST_FILESYSTEM_DECL
@ -1033,7 +1132,7 @@ bool copy_file(const path& from, const path& to, unsigned int options, error_cod
continue;
fail:
error(err, from, to, ec, "boost::filesystem::copy_file");
emit_error(err, from, to, ec, "boost::filesystem::copy_file");
return false;
}
@ -1190,7 +1289,7 @@ bool copy_file(const path& from, const path& to, unsigned int options, error_cod
{
fail_last_error:
DWORD err = ::GetLastError();
error(err, from, to, ec, "boost::filesystem::copy_file");
emit_error(err, from, to, ec, "boost::filesystem::copy_file");
return false;
}
@ -1222,7 +1321,7 @@ bool copy_file(const path& from, const path& to, unsigned int options, error_cod
DWORD err = ::GetLastError();
if ((err == ERROR_FILE_EXISTS || err == ERROR_ALREADY_EXISTS) && (options & static_cast< unsigned int >(copy_options::skip_existing)) != 0u)
return false;
error(err, from, to, ec, "boost::filesystem::copy_file");
emit_error(err, from, to, ec, "boost::filesystem::copy_file");
return false;
}
@ -1291,40 +1390,75 @@ bool create_directories(const path& p, system::error_code* ec)
}
// create the directory
return create_directory(p, ec);
return create_directory(p, NULL, ec);
}
BOOST_FILESYSTEM_DECL
bool create_directory(const path& p, error_code* ec)
bool create_directory(const path& p, const path* existing, error_code* ec)
{
if (BOOST_CREATE_DIRECTORY(p.c_str()))
if (ec)
ec->clear();
#if defined(BOOST_POSIX_API)
mode_t mode = S_IRWXU | S_IRWXG | S_IRWXO;
if (existing)
{
if (ec != 0)
ec->clear();
return true;
struct ::stat existing_stat = {};
if (::stat(existing->c_str(), &existing_stat) < 0)
{
emit_error(errno, p, *existing, ec, "boost::filesystem::create_directory");
return false;
}
if (!S_ISDIR(existing_stat.st_mode))
{
emit_error(ENOTDIR, p, *existing, ec, "boost::filesystem::create_directory");
return false;
}
mode = existing_stat.st_mode;
}
if (::mkdir(p.c_str(), mode) == 0)
return true;
#else // defined(BOOST_POSIX_API)
BOOL res;
if (existing)
res = ::CreateDirectoryExW(existing->c_str(), p.c_str(), NULL);
else
res = ::CreateDirectoryW(p.c_str(), NULL);
if (res)
return true;
#endif // defined(BOOST_POSIX_API)
// attempt to create directory failed
int errval(BOOST_ERRNO); // save reason for failure
err_t errval = BOOST_ERRNO; // save reason for failure
error_code dummy;
if (is_directory(p, dummy))
{
if (ec != 0)
ec->clear();
return false;
}
// attempt to create directory failed && it doesn't already exist
if (ec == 0)
BOOST_FILESYSTEM_THROW(filesystem_error("boost::filesystem::create_directory",
p, error_code(errval, system_category())));
else
ec->assign(errval, system_category());
emit_error(errval, p, ec, "boost::filesystem::create_directory");
return false;
}
// Deprecated, to be removed in a future release
BOOST_FILESYSTEM_DECL
void copy_directory(const path& from, const path& to, system::error_code* ec)
{
# ifdef BOOST_POSIX_API
struct stat from_stat;
# endif
error(!BOOST_COPY_DIRECTORY(from.c_str(), to.c_str()) ? BOOST_ERRNO : 0,
from, to, ec, "boost::filesystem::copy_directory");
}
BOOST_FILESYSTEM_DECL
void create_directory_symlink(const path& to, const path& from,
system::error_code* ec)
@ -1401,11 +1535,7 @@ path current_path(error_code* ec)
{
if (BOOST_UNLIKELY(path_max > absolute_path_max))
{
if (ec == 0)
BOOST_FILESYSTEM_THROW(filesystem_error("boost::filesystem::current_path",
error_code(ENAMETOOLONG, system_category())));
else
ec->assign(ENAMETOOLONG, system_category());
emit_error(ENAMETOOLONG, ec, "boost::filesystem::current_path");
break;
}