diff options
Diffstat (limited to 'src/third_party/boost/libs/filesystem/v3/doc/reference.html')
| -rw-r--r-- | src/third_party/boost/libs/filesystem/v3/doc/reference.html | 3672 |
1 files changed, 3672 insertions, 0 deletions
diff --git a/src/third_party/boost/libs/filesystem/v3/doc/reference.html b/src/third_party/boost/libs/filesystem/v3/doc/reference.html new file mode 100644 index 00000000000..f7002750157 --- /dev/null +++ b/src/third_party/boost/libs/filesystem/v3/doc/reference.html @@ -0,0 +1,3672 @@ +<html> + +<head> +<meta http-equiv="Content-Language" content="en-us"> +<meta name="GENERATOR" content="Microsoft FrontPage 5.0"> +<meta name="ProgId" content="FrontPage.Editor.Document"> +<meta http-equiv="Content-Type" content="text/html; charset=windows-1252"> +<title>Filesystem V3 Reference +</title> +<link rel="stylesheet" type="text/css" href="../../../../doc/src/minimal.css"> +<style type="text/css"> + pre {background-color:#D7EEFF} + body + { + font-family: sans-serif; + max-width : 8.5in; + margin: 1em; + } +</style> +</head> + +<body> + +<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111"> + <tr> + <td width="277"> +<a href="../../../../index.htm"> +<img src="../../../../boost.png" alt="boost.png (6897 bytes)" align="middle" width="300" height="86" border="0"></a></td> + <td align="middle"> + <font size="7">Filesystem Library<br> + </font> + <font size="6">Version 3</font></td> + </tr> +</table> + +<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" bgcolor="#D7EEFF" width="100%"> + <tr> + <td><a href="index.htm">Filesystem Home</a> + <a href="release_history.html">Releases</a> + <a href="reference.html">Reference</a> + <a href="tutorial.html">Tutorial</a> + <a href="faq.htm">FAQ</a> + <a href="portability_guide.htm">Portability</a> + <a href="v3.html">V3 Intro</a> + <a href="v3_design.html">V3 Design</a> + <a href="deprecated.html">Deprecated</a> + </td> + </td> + </tr> +</table> + +<h1>Reference Documentation</h1> + +<h2><a name="TOC">Table of Contents</a></h2> + +<table border="0" cellpadding="0" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" width="100%"> + <tr> + <td width="33%" valign="top"><a href="#Introduction">Introduction</a><br> + <a href="#Definitions">Definitions</a><br> + <a href="#Conformance">Conformance</a><br> + <a href="#Header-filesystem-synopsis"> + Header <code><boost/filesystem.hpp></code> synopsis</a><br> + <a href="#Error-reporting">Error reporting</a><br> + <a href="#class-path">Class <code>path</code></a><br> + <a href="#path-Conversions"><code>path</code> conversions</a><br> + <a href="#path-Conversions-to-native-format"><code>path</code> + conversions to native format</a><br> + <a href="#path-Conversions-to-generic-format"><code>path</code> + conversions to generic format</a><br> + <a href="#path-Encoding-conversions"><code>path</code> + encoding conversions</a><br> + <a href="#path-Requirements"><code>path</code> requirements</a><br> + <a href="#path-constructors"><code>path</code> constructors</a><br> + <a href="#path-assignments"><code>path</code> assignments</a><br> + <a href="#path-appends"><code>path</code> appends</a><br> + <a href="#path-modifiers"><code>path</code> modifiers</a><br> + <a href="#path-native-format-observers"><code>path</code> native + format observers</a><br> + <a href="#path-generic-format-observers"><code>path</code> generic + format observers</a><br> + <a href="#path-decomposition"><code>path</code> decomposition</a><br> + <a href="#path-query"><code>path</code> query</a><br> + <a href="#path-iterators"><code>path</code> iterators</a><br> + <a href="#path-deprecated-functions"><code>path</code> deprecated functions</a><br> + <a href="#path-non-member-functions"><code>path</code> non-member functions</a><br> + <a href="#path-inserter-extractor"><code>path</code> inserters and extractors</a><br> + <a href="#Class-filesystem_error">Class <code>filesystem_error</code></a><br> + <a href="#filesystem_error-members"><code>filesystem_error</code> + constructors</a><br> + <code>f</code><a href="#filesystem_error-path1"><code>ilesystem_error</code> path1</a><br> + <a href="#filesystem_error-path2"><code>filesystem_error</code> path2</a><br> + <a href="#filesystem_error-what"><code>filesystem_error</code><code> + </code>what</a></td> + <td width="33%" valign="top"> + <a href="#Enum-file_type">Enum <code>file_type</code></a><br> + <a href="#Enum-perms">Enum <code>perms</code></a><br> + <a href="#file_status">Class + <code>file_status</code></a><br> + + <a href="#file_status"> + <code>file_status</code></a><a href="#file_status-constructors"> constructors</a><br> + <code><a href="#file_status-modifiers">file_status-modifiers</a></code><a href="#directory_entry-observers"> observers</a><br> + <code><a href="#file_status-observers">file_status-observers</a></code><a href="#directory_entry-modifiers"> modifiers</a><br> +<a href="#Class-directory_entry">Class <code>directory_entry</code></a><br> + +<a href="#directory_entry-constructors"><code>directory_entry</code> constructors</a><br> + <a href="#directory_entry-observers"><code>directory_entry</code> observers</a><br> + <a href="#directory_entry-modifiers"><code>directory_entry</code> modifiers</a><br> +<a href="#Class-directory_iterator">Class <code>directory_iterator</code></a><br> + <a href="#directory_iterator-members"><code>directory_iterator</code> + members</a><br> +<a href="#Class-recursive_directory_iterator">Class <code>recursive_directory_iterator</code></a><br> + <a href="#Operational-functions"> + Operational functions</a><br> + <code>   <a href="#absolute">absolute</a><br> + <a href="#canonical">canonical</a><br> + <a href="#copy">copy</a><br> + <a href="#copy_directory">copy_directory</a><br> + <a href="#copy_file">copy_file</a><br> + <a href="#copy_symlink">copy_symlink</a><br> +   <a href="#create_directories">create_directories</a><br> +   <a href="#create_directory">create_directory</a><br> +   <a href="#create_hard_link">create_hard_link</a><br> +   <a href="#create_symlink">create_symlink</a><br> +   <a href="#current_path">current_path</a><br> +   <a href="#exists">exists</a><br> +   <a href="#equivalent">equivalent</a><br> +   <a href="#file_size">file_size</a><br> + <a href="#hard_link_count">hard_link_count</a><br> + <a href="#initial_path">initial_path</a><br> +   i<a href="#is_directory">s_directory</a><br> +   <a href="#is_empty">is_empty</a></code></td> + <td width="34%" valign="top"> + <code>   <a href="#is_other">is_other</a><br> +   <a href="#is_regular_file">is_regular_file</a><br> +   <a href="#is_symlink">is_symlink</a><br> +   <a href="#last_write_time">last_write_time</a><br> + permissions<br> + <a href="#read_symlink">read_symlink</a><br> +   <a href="#remove">remove</a><br> +   <a href="#remove_all">remove_all</a><br> +   <a href="#rename">rename</a><br> + <a href="#resize_file">resize_file</a><br> +   <a href="#space">space</a><br> +   <a href="#status">status</a><br> +   <a href="#status_known">status_known</a><br> +   <a href="#symlink_status">symlink_status</a><br> +   <a href="#system_complete">system_complete</a><br> +   <a href="#temp_directory_path">temp_directory_path</a><br> + </code> <code> <a href="#unique_path">unique_path</a></code><br> + <a href="#File-streams">File streams</a><br> +<a href="#Path-decomposition-table">Path decomposition table</a><br> + <a href="#long-path-warning">Warning: Long paths on Windows and the + extended-length <b>\\?\ </b>prefix</a><br> +<a href="#Acknowledgements">Acknowledgements</a><br> +<a href="#References">References</a><br> + </td> + </tr> +</table> + +<h2><a name="Introduction">Introduction</a></h2> + +<p>This reference documentation describes components that C++ programs may use +to perform operations involving file systems, including paths, regular files, +and directories.</p> +<h2><a name="Definitions">Definitions</a></h2> +<p>The following definitions shall apply throughout this reference documentation:</p> +<p><i><b><a name="File">File</a>:</b> </i>An object that can be written to, or read from, or both. A file +has certain attributes, including type. Common types of files include regular files +and directories. Other types of files, such as symbolic links, may be supported by the +implementation.</p> +<p><b><i><a name="File-system">File system</a>:</i></b> A collection of files and certain of their attributes.</p> +<p><b><i><a name="Filename">Filename</a>:</i></b> The name of a file. Slash and +0x00 +characters are not permitted. Implementations may define additional +characters or specific names that are not permitted. Filenames <code>.</code> +and <code>..</code> have special meaning. Implementations may define +additional filenames that have special meaning.</p> +<blockquote> + <p><i>[Note:</i> Most operating systems prohibit the ASCII control characters + (0x00-0x1F) in filenames.</p> + <p>Windows prohibits the characters 0x00-0x1F, <code>"</code>,<code> + *</code>,<code> :</code>,<code> <</code>,<code> ></code>,<code> ?</code>,<code> + \</code>,<code> /</code>, and<code> |</code> <i>--end note]</i></p> +</blockquote> +<p><b><i><a name="Path">Path</a>:</i></b> A sequence of elements that identify +the location of a file within a filesystem. The elements are the <i>root-name<sub>opt</sub></i>, <i> +root-directory<sub>opt</sub></i>, and an optional sequence of filenames. [<i>Note:</i> +A <a href="#Pathname">pathname</a> is the concrete representation of a path. <i>--end note</i>]</p> +<p><b><i><a name="Absolute-path">Absolute path</a>:</i></b> A path that +unambiguously +identifies the location of a file within a filesystem without reference to an +additional starting location. The format is implementation defined. </p> +<blockquote> + <p><i>[Note:</i> For POSIX-like implementations, including<b> </b>Unix + variants, Linux, and Mac OS X, only paths + that begin with a slash are absolute paths.</p> + <p>For Windows-like implementations, including <a href="http://www.cygwin.com/"> + Cygwin</a> and + <a href="http://www.mingw.org/">MinGW</a>, only paths that begin with a drive + specifier followed by a slash, or begin with two slashes, are absolute paths. <i>--end + note]</i></p> +</blockquote> +<p><b><a name="Relative-path">Relative path</a>:</b> A path that only +unambiguously +identifies the location of a file within a filesystem when resolved relative to +a starting location. The format is implementation defined. [<i>Note:</i> +Paths "." and ".." are considered to be relative paths. <i>--end note</i>]</p> +<p><b><a name="Canonical-path">Canonical path</a>:</b> An absolute path that has +no elements which are symbolic links, and no dot or dot dot elements.</p> +<p><i><b><a name="Pathname">Pathname</a>:</b> </i>A character string that represents a +path. Pathnames are formatted according to the generic pathname format or the +implementation defined +native pathname format.</p> +<p><b><i><a name="generic-pathname-format">Generic pathname format:</a></i></b></p> +<blockquote> +<p><i>pathname:<br> + root-name<sub>opt</sub> +root-directory<sub>opt</sub> relative-path<sub>opt</sub></i></p> +<p><i>root-name:<br> + +implementation-defined</i></p> +<blockquote> + <blockquote> +<p>[<i>Note:</i> Most POSIX and Windows based operating system define a name +beginning with two slashes (or backslashes, for Windows) as a root-name +identifying network locations. Windows defines a single letter followed by a +<code>":"</code> as a root-name identifying a disc drive. <i>--end note</i>]</p> + </blockquote> +</blockquote> +<p><i>root-directory:<br> + +directory-separator</i></p> +<p><i>relative-path:<br> + +filename<br> + relative-path +directory-separator<br> + relative-path +directory-separator filename</i></p> +<p><i>filename:<br> + name<br> + </i><code>"."</code><i><br> + </i><code> +".."</code></p> +<p><i>directory-separator:<br> + <code>"/"<br> + "/"</code> directory-separator</i></p> +<p>Multiple successive <i>directory-separator</i> characters are considered to +be the same as one <i>directory-separator</i> character. The <i>filename</i> +<code>"."</code> is considered to be a reference to the current directory. The +<i>filename</i> <code>".."</code> is considered to be a reference to the current +directory. Specific <i>filenames</i> may have special meaning for a particular +operating system.</p> +</blockquote> +<p><b><i><a name="native-pathname-format">Native pathname format:</a></i></b> +An implementation defined format. [<i>Note:</i> For POSIX-like operating +systems, the native format is the same as the generic format. For Windows, the +native format is similar to the generic format, but the directory-separator +characters can be either slashes or backslashes. <i>--end note</i>]</p> +<p><i><b><a name="Link">Link</a>:</b> </i>A directory entry object that associates a +filename with a file. On some file systems, several directory entries can +associate names with the same file.</p> +<p><b><i><a name="Hard-link">Hard link</a>:</i></b> A link to an existing file. Some +file systems support multiple hard links to a file. If the last hard link to a +file is removed, the file itself is removed.</p> +<blockquote> +<p>[<i>Note:</i> A hard link can be thought of as a shared-ownership smart +pointer to a file.<i> -- end note</i>]<i> </i></p> +</blockquote> +<p><i><a name="Symbolic-link">S<b>ymbolic link</b></a><b>:</b> </i>A type of file with the +property that when the file is encountered during pathname resolution, a string +stored by the file is used to modify the pathname resolution.</p> +<blockquote> +<p>[<i>Note:</i> A symbolic link can be thought of as a raw pointer to a file. +If the file pointed to does not exist, the symbolic link is said to be a +"dangling" symbolic link.<i> -- end note</i>]<i> </i></p> +</blockquote> +<p><b><i><a name="Race-condition">Race condition</a>:</i></b> The condition that occurs +when multiple threads, processes, or computers interleave access and +modification of +the same object within a file system.</p> +<p><b><i><a name="Dot">Dot</a>, Dot Dot:</i></b> Synonyms for the filenames <code>"."</code> +and <code>".."</code>, respectively. The dot filename names the current +directory. The dot dot filename names the parent directory.</p> +<h2><a name="Conformance">Conformance</a></h2> +<p>Behavior is sometimes specified by reference to ISO/IEC 9945:2003, <i> +<a href="http://www.unix.org/single_unix_specification/">POSIX</a></i>. How such behavior is actually implemented is unspecified.</p> +<blockquote> +<p>[<i>Note:</i> This constitutes an "as if" rule for implementation of +operating system dependent behavior. Presumably implementations will usually call native +operating system API's. <i>--end note</i>]</p> +</blockquote> +<p>Implementations are encouraged, but not required, to support such behavior + +as it is defined by <i>POSIX</i>. Implementations shall document any +behavior that differs from the <i>POSIX</i> defined behavior. Implementations that do not support exact <i>POSIX</i> behavior are +encouraged to provide behavior as close to <i>POSIX</i> behavior as is reasonable given the +limitations of actual operating systems and file systems. If an implementation cannot provide any +reasonable behavior, the implementation shall report an error in an +implementation-defined manner.</p> +<blockquote> +<p>[<i>Note:</i> Such errors might be reported by an #error directive, a <code> +static_assert</code>, a <code>filesystem_error</code> exception, a special +return value, or some other manner. <i>--end note</i>]</p> +</blockquote> +<p>Implementations are not required to provide behavior that is not supported by +a particular file system.</p> +<blockquote> +<p>[<i>Example:</i> The <a href="http://en.wikipedia.org/wiki/FAT_filesystem"> +FAT file system</a> used by some memory cards, camera memory, and floppy discs +does not support hard links, symlinks, and many other features of more capable +file systems. Implementations are only required to support the FAT features +supported by the host operating system. <i>-- end example</i>]</p> +</blockquote> +<p>Specific operating systems such as <i>OpenMVS</i>, +<i>UNIX</i>, and <i>Windows</i> are mentioned only for purposes of illustration or to +give guidance to users and implementers. No slight to other operating systems is implied +or intended. When unlikely to cause confusion, the term <i>POSIX</i> is +sometimes used to refer to "POSIX-compliant operating systems".</p> +<p>The behavior of functions described in this +reference +may not be achieved in +the presence of <a href="#Race-condition">race conditions</a>. No diagnostic is required.</p> +<p>If the possibility of race conditions would make it unreliable for a program to +test for a precondition before calling a function described in this clause, <i> +Requires</i> is not specified for the condition. Instead, the condition is +specified as a <i>Throws</i> condition.</p> +<blockquote> +<p>[<i>Note:</i> As a design practice, preconditions are not specified when it +is unreasonable for a program to detect them prior to calling the function. <i> +-- end note</i>]</p> +</blockquote> +<h2><a name="Header-filesystem-synopsis">Header <code><boost/filesystem.hpp></code> synopsis</a></h2> +<pre> namespace boost + { + namespace filesystem + { + class <a href="#class-path">path</a>; + + void swap(path& lhs, path& rhs); + bool lexicographical_compare(path::iterator first1, path::iterator last1, + path::iterator first2, path::iterator last2); + std::size_t <a href="#hash_value">hash_value</a>(const path& p); + + bool operator==(const path& lhs, const path& rhs); + bool operator!=(const path& lhs, const path& rhs); + bool operator< (const path& lhs, const path& rhs); + bool operator<=(const path& lhs, const path& rhs); + bool operator> (const path& lhs, const path& rhs); + bool operator>=(const path& lhs, const path& rhs); + + path operator/ (const path& lhs, const path& rhs); + + std::ostream& operator<<( std::ostream& os, const path& p ); + std::wostream& operator<<( std::wostream& os, const path& p ); + std::istream& operator>>( std::istream& is, path& p ); + std::wistream& operator>>( std::wistream& is, path& p ) + + class <a href="#Class-filesystem_error">filesystem_error</a>; + class <a href="#Class-directory_entry">directory_entry</a>; + + class <a href="#Class-directory_iterator">directory_iterator</a>; + + class <a href="#Class-recursive_directory_iterator">recursive_directory_iterator</a>; + + enum <a name="file_type" href="#Enum-file_type">file_type</a> + { + status_error, file_not_found, regular_file, directory_file, + symlink_file, block_file, character_file, fifo_file, socket_file, + type_unknown + }; + + enum <a href="#Enum-perms">perms</a> + { + no_perms, + owner_read, owner_write, owner_exe, owner_all, + group_read, group_write, group_exe, group_all, + others_read, others_write, others_exe, others_all, all_all, + set_uid_on_exe, set_gid_on_exe, sticky_bit, + perms_mask, perms_not_known, + add_perms, remove_perms, symlink_perms + }; + + class <a href="#file_status">file_status</a>; + + struct <a name="space_info">space_info</a> // returned by <a href="#space" style="text-decoration: none">space</a> function + { + uintmax_t capacity; + uintmax_t free; + uintmax_t available; // free space available to a non-privileged process + }; + + BOOST_SCOPED_ENUM_START(<a name="copy_option">copy_option</a>) + { + none + fail_if_exists = none, + overwrite_if_exists + }; + BOOST_SCOPED_ENUM_END + + BOOST_SCOPED_ENUM_START(<a name="symlink_option">symlink_option</a>) + { + none + no_recurse = none, + recurse + }; + BOOST_SCOPED_ENUM_END + + // <a href="#Operational-functions">operational functions</a> + + path <a href="#absolute">absolute</a>(const path& p, const path& base=current_path()); + + path <a href="#canonical">canonical</a>(const path& p, const path& base = current_path()); + path <a href="#canonical">canonical</a>(const path& p, system::error_code& ec); + path <a href="#canonical">canonical</a>(const path& p, const path& base, system::error_code& ec); + + void <a href="#copy">copy</a>(const path& from, const path& to); + void <a href="#copy">copy</a>(const path& from, const path& to, system::error_code& ec); + + void <a href="#create_directory">copy_directory</a>(const path& from, const path& to); + void <a href="#create_directory">copy_directory</a>(const path& from, const path& to, system::error_code& ec); + + void <a href="#copy_file">copy_file</a>(const path& from, const path& to); + void <a href="#copy_file">copy_file</a>(const path& from, const path& to, system::error_code& ec); + void <a href="#copy_file">copy_file</a>(const path& from, const path& to, BOOST_SCOPED_ENUM(<a href="#copy_option">copy_option</a>) option); + void <a href="#copy_file">copy_file</a>(const path& from, const path& to, BOOST_SCOPED_ENUM(<a href="#copy_option">copy_option</a>) option, + system::error_code& ec); + + void <a href="#copy_symlink">copy_symlink</a>(const path& existing_symlink, const path& new_symlink); + void <a href="#copy_symlink">copy_symlink</a>(const path& existing_symlink, const path& new_symlink, system::error_code& ec); + + bool <a href="#create_directories">create_directories</a>(const path& p); + bool <a href="#create_directories">create_directories</a>(const path& p, system::error_code& ec); + + bool <a href="#create_directory">create_directory</a>(const path& p); + bool <a href="#create_directory">create_directory</a>(const path& p, system::error_code& ec); + + void <a href="#create_directory_symlink">create_directory_symlink</a>(const path& to, const path& new_symlink); + void <a href="#create_directory_symlink">create_directory_symlink</a>(const path& to, const path& new_symlink, system::error_code& ec); + + void <a href="#create_hard_link">create_hard_link</a>(const path& to, const path& new_hard_link); + void <a href="#create_hard_link">create_hard_link</a>(const path& to, const path& new_hard_link, system::error_code& ec); + + void <a href="#create_symlink">create_symlink</a>(const path& to, const path& new_symlink); + void <a href="#create_symlink">create_symlink</a>(const path& to, const path& new_symlink, system::error_code& ec); + + path <a href="#current_path">current_path</a>(); + path <a href="#current_path">current_path</a>(system::error_code& ec); + void <a href="#current_path">current_path</a>(const path& p); + void <a href="#current_path">current_path</a>(const path& p, system::error_code& ec); + + bool <a href="#exists">exists</a>(file_status s); + bool <a href="#exists">exists</a>(const path& p); + bool <a href="#exists">exists</a>(const path& p, system::error_code& ec); + + bool <a href="#equivalent">equivalent</a>(const path& p1, const path& p2); + bool <a href="#equivalent">equivalent</a>(const path& p1, const path& p2, system::error_code& ec); + + uintmax_t <a href="#file_size">file_size</a>(const path& p); + uintmax_t <a href="#file_size">file_size</a>(const path& p, system::error_code& ec); + uintmax_t <a href="#hard_link_count">hard_link_count</a>(const path& p); + uintmax_t <a href="#hard_link_count">hard_link_count</a>(const path& p, system::error_code& ec); + + const path& <a href="#initial_path">initial_path</a>(); + const path& <a href="#initial_path">initial_path</a>(<code>system::error_code& ec</code>); + + bool <a href="#is_directory">is_directory</a>(file_status s); + bool <a href="#is_directory2">is_directory</a>(const path& p); + bool <a href="#is_directory2">is_directory</a>(const path& p, system::error_code& ec); + + bool <a href="#is_empty">is_empty</a>(const path& p); + bool <a href="#is_empty">is_empty</a>(const path& p, system::error_code& ec); + + bool <a href="#is_other">is_other</a>(file_status s); + bool <a href="#is_other2">is_other</a>(const path& p,); + bool <a href="#is_other2">is_other</a>(const path& p, system::error_code& ec); + + bool <a href="#is_regular_file">is_regular_file</a>(file_status s); + bool i<a href="#is_regular_file2">s_regular_file</a>(const path& p); + bool i<a href="#is_regular_file2">s_regular_file</a>(const path& p, system::error_code& ec); + + bool <a href="#is_symlink">is_symlink</a>(file_status s); + bool <a href="#is_symlink2">is_symlink</a>(const path& p); + bool <a href="#is_symlink2">is_symlink</a>(const path& p, system::error_code& ec); + + std::time_t <a href="#last_write_time">last_write_time</a>(const path& p); + std::time_t <a href="#last_write_time">last_write_time</a>(const path& p, system::error_code& ec); + void <a href="#last_write_time2">last_write_time</a>(const path& p, const std::time_t new_time); + void <a href="#last_write_time2">last_write_time</a>(const path& p, const std::time_t new_time, system::error_code& ec); + + path <a href="#read_symlink">read_symlink</a>(const path& p); + path <a href="#read_symlink">read_symlink</a>(const path& p, system::error_code& ec); + + bool <a href="#remove">remove</a>(const path& p); + bool <a href="#remove">remove</a>(const path& p, system::error_code& ec); + + uintmax_t <a href="#remove_all">remove_all</a>(const path& p); + uintmax_t <a href="#remove_all">remove_all</a>(const path& p, system::error_code& ec); + + void <a href="#rename">rename</a>(const path& from, const path& to); + void <a href="#rename">rename</a>(const path& from, const path& to, system::error_code& ec); + + void <a href="#resize_file">resize_file</a>(const path& p, uintmax_t size); + void <a href="#resize_file2">resize_file</a>(const path& p, uintmax_t size, system::error_code& ec); + + <a href="#space_info">space_info</a> <a href="#space">space</a>(const path& p); + <a href="#space_info">space_info</a> <a href="#space">space</a>(const path& p, system::error_code& ec); + <a href="#file_status">file_status</a> <a href="#status">status</a>(const path& p); + <a href="#file_status">file_status</a> <a href="#status">status</a>(const path& p, system::error_code& ec); + + bool <a href="#status_known">status_known</a>(file_status s); + + <a href="#file_status">file_status</a> <a href="#symlink_status">symlink_status</a>(const path& p); + <a href="#file_status">file_status</a> <a href="#symlink_status">symlink_status</a>(const path& p, system::error_code& ec); + + path <a href="#system_complete">system_complete</a>(const path& p); + path <a href="#system_complete">system_complete</a>(const path& p, system::error_code& ec); + + path <a href="#temp_directory_path">temp_directory_path</a>(); + path <a href="#temp_directory_path">temp_directory_path</a>(system::error_code& ec); + + path <a href="#unique_path">unique_path</a>(const path& model="%%%%-%%%%-%%%%-%%%%"); + path <a href="#unique_path">unique_path</a>(const path& model, system::error_code& ec); + + } // namespace filesystem + } // namespace boost</pre> +<h2><a name="Error-reporting">Error reporting</a></h2> +<p>Filesystem library functions often provide two overloads, one that +throws an exception to report file system errors, and another that sets an +<code>error_code</code>.</p> +<blockquote> +<p>[<i>Note:</i> This supports two common use cases:</p> +<ul> + <li>Uses where file system +errors are truly exceptional and indicate a serious failure. Throwing an + exception is the most appropriate response. This is the preferred default for + most everyday programming.<br> + </li> + <li>Uses where file system system errors are routine and do not necessarily represent + failure. Returning an error code is the most appropriate response. This allows + application specific error handling, including simply ignoring the error.</li> +</ul> + <p><i>--end note</i>]</p> +</blockquote> +<p>Functions <b>not</b> having an argument of type +<code>system::error_code&</code> +report errors as follows, unless otherwise specified:</p> + <ul> + <li>When a call by the + implementation to an operating system or other underlying API results in an + error that prevents the function from meeting its specifications, an exception + of type +<code>filesystem_error</code> is thrown.<br> + </li> + <li>Failure to allocate storage is reported by throwing an exception as described in the C++ standard, + 17.6.4.10 [res.on.exception.handling].<br> + </li> + <li>Destructors throw nothing.</li> + </ul> + <p>Functions having an argument of type +<code>system::error_code&</code> report errors as follows, unless otherwise + specified:</p> +<ul> + <li>If a call by the + implementation to an operating system or other underlying API results in an + error that prevents the function from meeting its specifications, the +<code>system::error_code&</code> argument is set as + appropriate appropriate for the specific error. Otherwise, <code>clear()</code> + is called on the +<code>system::error_code&</code> argument.<br> + </li> + <li>Failure to allocate storage is reported by + throwing an exception as described in the C++ standard, + 17.6.4.10 [res.on.exception.handling].</li> +</ul> +<h2><a name="class-path">Class <code>path</code></a></h2> +<p>An object of class <code>path</code> represents a <a href="#Path">path</a>, +and contains a <a href="#Pathname">pathname</a> Such an object is concerned only with the lexical and syntactic aspects +of a path. The path does not necessarily exist in external storage, and the +pathname is not necessarily valid for the current operating +system or for a particular file system.</p> +<blockquote> +<p>[<i>Example:</i> A <a href="#long-path-warning">long path name on Windows</a> +is an example of an innocuous appearing path that is not actually valid. <i>-- +end example</i>]</p> +</blockquote> +<pre> namespace boost + { + namespace filesystem + { + class path + { + public: + typedef <b><i><a href="#value_type">see below</a></i></b> value_type; // char for POSIX, wchar_t for Windows + typedef std::basic_string<value_type> string_type; + typedef std::codecvt<wchar_t, char, std::mbstate_t> codecvt_type; + + // <a href="#path-constructors">constructors</a> and destructor + path(); + path(const path& p); + + template <class <a href="#Source">Source</a>> + path(Source const& source, const codecvt_type& cvt=codecvt()); + + template <class <a href="#InputIterator">InputIterator</a>> + path(InputIterator begin, InputIterator end, const codecvt_type& cvt=codecvt()); + + ~path(); + + // <a href="#path-assignments">assignments</a> + path& operator=(const path& p); + + template <class <a href="#Source">Source</a>> + path& operator=(Source const& source); + + template <class <a href="#Source">Source</a>> + path& assign(Source const& source, const codecvt_type& cvt) + + template <class <a href="#InputIterator">InputIterator</a>> + path& assign(InputIterator begin, InputIterator end, const codecvt_type& cvt=codecvt()); + + // <a href="#path-appends">appends</a> + path& operator/=(const path& p); + + template <class <a href="#Source">Source</a>> + path& operator/=(Source const& source); + + template <class <a href="#Source">Source</a>> + path& append(Source const& source, const codecvt_type& cvt); + + template <class <a href="#InputIterator">InputIterator</a>> + path& append(InputIterator begin, InputIterator end, const codecvt_type& cvt=codecvt()); + + // <a href="#path-modifiers">modifiers</a> + void <a href="#path-clear">clear</a>(); + path& <a href="#absolute">make_absolute</a>(const path& base); + path& <a href="#path-make_preferred">make_preferred</a>(); // POSIX: no effect. Windows: convert slashes to backslashes + path& <a href="#path-remove_filename">remove_filename</a>(); + path& <a href="#path-replace_extension">replace_extension</a>(const path& new_extension = path()); + void <a href="#path-swap">swap</a>(path& rhs); + + // <a href="#path-native-format-observers">native format observers</a> + const string_type& <a href="#native">native</a>() const; // native format, encoding + const value_type* <a href="#c_str">c_str</a>() const; // native().c_str() + + template <class String> + String <a href="#string-template">string</a>(const codecvt_type& cvt=codecvt()) const; // native format + + const string <a href="#string">string</a>(const codecvt_type& cvt=codecvt()) const; // native format + const wstring <a href="#wstring">wstring</a>(const codecvt_type& cvt=codecvt()) const; // ditto + const u16string <a href="#u16string">u16string</a>() const; // ditto + const u32string <a href="#u32wstring">u32string</a>() const; // ditto + + // <a href="#path-generic-format-observers">generic format observers</a> + template <class String> + String <a href="#generic_string-template">generic_string</a>() const; + + const string <a href="#generic_string">generic_string</a>(const codecvt_type& cvt=codecvt()) const; // generic format + const wstring <a href="#generic_wstring">generic_wstring</a>(const codecvt_type& cvt=codecvt()) const; // ditto + const u16string <a href="#generic_u16string">generic_u16string</a>() const; // ditto + const u32string <a href="#generic_u32wstring">generic_u32string</a>() const; // ditto + + // <a href="#path-decomposition">decomposition</a> + path <a href="#path-root_name">root_name</a>() const; + path <a href="#path-root_directory">root_directory</a>() const; + path <a href="#path-root_path">root_path</a>() const; + path <a href="#path-relative_path">relative_path</a>() const; + path <a href="#path-parent_path">parent_path</a>() const; + path <a href="#path-filename">filename</a>() const; + path <a href="#path-stem">stem</a>() const; + path <a href="#path-extension">extension</a>() const; + + // <a href="#path-query">query</a> + bool <a href="#path-query">empty</a>() const; + bool <a href="#path-has_root_name">has_root_name</a>() const; + bool <a href="#path-has_root_directory">has_root_directory</a>() const; + bool <a href="#path-has_root_path">has_root_path</a>() const; + bool <a href="#path-has_relative_path">has_relative_path</a>() const; + bool <a href="#path-has_parent_path">has_parent_path</a>() const; + bool <a href="#path-has_filename">has_filename</a>() const; + bool <a href="#path-has_stem">has_stem</a>() const; + bool <a href="#path-has_extension">has_extension</a>() const; + bool <a href="#path-is_absolute">is_absolute</a>() const; + bool <a href="#path-is_relative">is_relative</a>() const; + + // <a href="#path-iterators">iterators</a> + class iterator; + typedef iterator const_iterator; + + iterator begin() const; + iterator end() const; + + // <a href="#path_encoding">encoding conversion</a> + static std::locale <a href="#path-imbue">imbue</a>( const std::locale& loc ); + static const codecvt_type & <a href="#path-codecvt">codecvt</a>(); + + private: + string_type pathname; // <b><i>exposition only</i></b> + }; + + } // namespace filesystem + } // namespace boost</pre> +<p><code><a name="value_type">value_type</a></code> is an implementation-defined +<code>typedef</code> for the +character type used by the operating system to represent pathnames.</p> +<p>Member functions described as returning <code>const string</code>, <code> +const wstring</code>, <code>const u16string</code>, or <code>const u32string</code> are permitted to return <code>const string&</code>, <code>const +wstring&</code>, <code>const u16string&</code>, or <code>const u32string&</code>, +respectively.</p> +<blockquote> +<p>[<i>Note:</i> This allows implementations to avoid unnecessary copies when no +conversion is required. +Return-by-value is specified as +<code>const</code> to ensure programs won't break if moved to a return-by-reference +implementation. <i>-- +end note</i>]</p> +</blockquote> +<h3><a name="path-Conversions"><code>path</code> Conversions</a></h3> +<h4><a name="path-Conversions-to-native-format"><code>path</code> Conversions to +native format</a></h4> +<p>Member function arguments that take character sequences representing paths +may use the <a href="#generic-pathname-format">generic pathname format</a> or +the <a href="#native-pathname-format">native pathname format</a>. If such an +argument uses the generic format, an implementation defined conversion to native format is performed +during the processing of the argument. </p> +<blockquote> +<p>[<i>Note:</i> No conversion occurs on POSIX and Windows since they have +native formats that conform to the generic format. <i>--end note</i>]</p> +<p>[<i>Rationale:</i> There is no unambiguous way for an implementation to +always be able distinguish between native format and generic format arguments. +This is by design as it simplifies use. Should an implementation encounter an +operating system where disambiguation is required, an implementation defined +native format prefix can be introduced to identify the native format. <i>-- end +rationale</i>]</p> +</blockquote> + +<table align="center" border="1" cellpadding="3" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" bgcolor="#D7EEFF" width="90%"> + <tr> + <td style="font-size: 10pt"> + Class <code>path</code> does not currently map invalid characters in + filenames to valid characters. In the future we might add something like + this:<blockquote> +<p>When converting filenames to the native operating system format, +implementations are encouraged, but not required, to convert otherwise invalid +characters or character sequences to valid characters or character sequences. +Such conversions are implementation-defined.</p> +<blockquote> +<p>[<i>Note:</i> Filename conversion allows much wider portability of both +programs and filenames that would otherwise be possible.</p> +<p>Implementations are encouraged to base conversion on existing standards or +practice. Examples include the Uniform Resource Locator escape syntax of a percent sign (<code>'%'</code>) +followed by two hex digits representing the character value. On +<i>OpenVMS</i>, which does not allow percent signs in filenames, a dollar sign (<code>'$'</code>) +followed by two hex digits is the existing practice, as is converting lowercase +letters to uppercase.<i> -- end note.</i>]</p> +</blockquote> + </blockquote> + </td> + </tr> +</table> + +<p>If the native format requires +paths for regular files to be formatted differently from paths for directories, the +path shall be treated as a directory path if last element is a separator, +otherwise it shall be treated as a regular file path.</p> + +<blockquote> + +<p>[<i>Note</i>: The above paragraph does not apply to POSIX and Windows since +they use the same format +for both regular file and directory pathnames. <i>--end note</i>]</p> + +<p>[<i>Example:</i> +On <a href="http://en.wikipedia.org/wiki/OpenVMS">OpenVMS</a>, a path +constructed from <code>"/cats/jane"</code> would considered a regular file +path, and have a native format of <code>"[CATS]JANE"</code>, while a +path constructed from <code>"/cats/jane/"</code> would be considered a +directory path, and have a native format of <code>"[CATS.JANE]"</code>. +<i>--end example</i>]</p> + +</blockquote> +<h4><a name="path-Conversions-to-generic-format"><code>path</code> Conversions +to generic format</a></h4> +<p><a href="#path-generic-format-observers">Generic format observer</a> +functions return strings formatted according to the +<a href="#generic-pathname-format">generic pathname format</a>. The conversion +from generic to native formats is implementation defined.</p> +<blockquote> +<p>[<i>Note:</i> For POSIX, no conversion is performed. For Windows, backslashes are converted to +forward slashes. <i>-- end note</i>]</p> +</blockquote> +<h4><a name="path-Encoding-conversions"><code>path</code> Encoding conversions</a></h4> +<p>If the value type of member function arguments that are character sequences +representing paths is not <code>value_type</code>, +and no <code>cvt</code> argument is supplied, conversion to <code>value_type</code> +occurs using an imbued locale. This imbued locale is initialized with a <code> +codecvt</code> facet appropriate for the operating system.</p> +<blockquote> +<p>For Apple OS X implementations, <code>path::value_type</code> +is <code>char</code>. The default imbued locale provides a UTF-8 <code>codecvt</code> +facet. [<i>Rationale:</i> "All BSD system functions expect their string +parameters to be in UTF-8 encoding and nothing else." See +<a href="http://developer.apple.com/mac/library/documentation/MacOSX/Conceptual/BPInternational/Articles/FileEncodings.html"> +Apple docs</a>. <i>-- end rationale</i>]</p> +<p>For Windows-like implementations, including +<a href="http://www.mingw.org/">MinGW</a>, <code>path::value_type</code> is <code> +wchar_t</code>. The default imbued locale provides a <code>codecvt</code> facet +that invokes Windows <code>MultiByteToWideChar</code> or <code> +WideCharToMultiByte</code> API with a codepage of <code>CP_THREAD_ACP</code> +if Windows <code>AreFileApisANSI()</code>is true, otherwise codepage <code> +CP_OEMCP</code>. [<i>Rationale:</i> this is the current behavior of C and C++ +programs that perform file operations using narrow character string to identify +paths. Changing this in the Filesystem library would be too surprising, +particularly where user input is involved. <i>-- end rationale</i>]</p> +<p>For all other implementations, including<b> </b>Linux, <code>path::value_type</code> +is <code>char</code>. The default imbued locale is <code>std::locale("")</code>. +[<i>Rationale:</i> ISO C specifies this as "the locale-specific native +environment", while POSIX says it "Specifies an implementation-defined native +environment." <i>-- end rationale</i>]</p> +</blockquote> +<h3><a name="path-Requirements"><code>path</code> Requirements</a></h3> +<p>Template parameters named <code><a name="InputIterator">InputIterator</a></code> +are required meet the +requirements for a C++ standard library <code>RandomIterator</code> +compliant iterator. The iterator's value type is required to be <code>char</code>, <code> + wchar_t</code>, <code>char16_t</code>, or <code>char32_t</code>.</p> +<p>Template parameters named <code><a name="Source">Source</a></code> are required to be one of:</p> +<ul> + <li>A container with a value type of <code>char</code>, <code> + wchar_t</code>, <code>char16_t</code>, or <code>char32_t</code>.</li> + <li>An iterator for a null terminated byte-string. The value type is required + to be <code>char</code>, <code>wchar_t</code>, <code>char16_t</code>, or <code> + char32_t</code>.</li> + <li>A C-array. The value type is required to be <code>char</code>, <code> + wchar_t</code>, <code>char16_t</code>, or <code>char32_t</code>.</li> + <li>A <code>boost::filesystem::directory_entry</code>.</li> +</ul> + +<h3> <a name="path-constructors"> <code> +<font size="4">path</font></code> constructors</a></h3> +<pre><span style="background-color: #D7EEFF">path();</span></pre> +<blockquote> + <p><i>Postcondition:</i> <code>empty()</code>.</p> + </blockquote> +<pre>template <class <a href="#Source">Source</a>> + path(Source const& source, const codecvt_type& cvt=codecvt());</pre> +<pre>template <class <a href="#InputIterator">InputIterator</a>> + path(InputIterator begin, InputIterator end, const codecvt_type& cvt=codecvt());</pre> +<blockquote> + <p><i>Effects:</i> Stores the contents [<code>begin</code>,<code>end</code>) + or <code>source</code> in <code>pathname</code>. If the contents are in the + generic format and the generic format is unacceptable to the operating + system's API, they are converted to the native format. [<i>Note:</i> For + POSIX and Windows implementations, the generic format is already + acceptable as a native format, so no generic to native conversion is + performed. <i>--end note</i>]</p> + <p> + <i>Remarks:</i> If the value type of [<code>begin</code>,<code>end</code>) + or <code>source</code> is not <code>value_type</code>, conversion is performed + by <code>cvt</code>.</p> +</blockquote> +<h3> <a name="path-assignments"> <code> +<font size="4">path</font></code> assignments</a></h3> +<pre>template <class <a href="#Source">Source</a>> + path& operator=(Source const& source);</pre> +<pre>template <class <a href="#Source">Source</a>> + path& assign(Source const& source, const codecvt_type& cvt);</pre> +<pre>template <class <a href="#InputIterator">InputIterator</a>> + path& assign(InputIterator begin, InputIterator end, const codecvt_type& cvt=codecvt());</pre> +<blockquote> + <p><i>Effects:</i> Stores the contents [<code>begin</code>,<code>end</code>) + or <code>source</code> in <code>pathname</code>. If the contents are in the + generic format, they are converted to the native format. [<i>Note:</i> For + POSIX and Windows based implementations, the generic format is already + acceptable as a native format, so no generic to native conversion is + performed. <i>--end note</i>]</p> + <p> + <i>Returns: </i><code>*this</code></p> + <p> + <i>Remarks:</i> If the value type of [<code>begin</code>,<code>end</code>) + or <code>source</code> is not <code>value_type</code>, conversion is performed + by <code>cvt</code>.</p> + </blockquote> +<h3> <a name="path-appends"><code><font size="4"> path</font></code> appends</a></h3> + <p>The append operations use <code>operator/=</code> to denote their semantic + effect of appending the platform's preferred directory separator when needed. The + preferred + directory separator is implementation-defined.</p> +<blockquote> + <p align="left">[<i>Note: </i>For POSIX-like implementations, including<b> </b> + Unix variants, Linux, and Mac OS X, the preferred directory separator is a + single forward slash.</p> + <p align="left">For Windows-like implementations, including + <a href="http://www.cygwin.com/">Cygwin</a> and + <a href="http://www.mingw.org/">MinGW</a>, the preferred directory + separator is a single backslash.<i>--end note</i>]</p> + </blockquote> +<pre>path& operator/=(const path& p);</pre> +<blockquote> + <p><i>Effects:</i></p> + <blockquote> + Appends the preferred directory separator to the contained pathname, unless:<ul> + <li>an added separator + would be redundant, or</li> + <li>would change an relative path to an absolute path, or</li> + <li><code>p.empty()</code>, or</li> + <li><code>*p.native().cbegin()</code> is a directory separator.</li> + </ul> + <p>Appends <code>p.native()</code> to <code>pathname</code>.</p> + </blockquote> + <p><i>Returns: </i><code>*this</code></p> +</blockquote> +<pre>template <class <a href="#Source">Source</a>> + path& operator/=(Source const & source);</pre> +<pre>template <class <a href="#Source">Source</a>> + path& append(Source const & source, const codecvt_type& cvt);</pre> +<pre>template <class <a href="#InputIterator">InputIterator</a>> + path& append(InputIterator begin, InputIterator end, const codecvt_type& cvt=codecvt());</pre> +<blockquote> + <p><i>Effects:</i></p> + <blockquote> + <p>Appends a native directory separator to the contained pathname, unless:</p> + <ul> + <li>an added separator + would be redundant, or</li> + <li>would change an relative path to an absoute path, or</li> + <li><code>p.empty()</code>, or</li> + <li><code>*p.native().cbegin()</code> is a separator.</li> + </ul> + <p>Appends the contents [<code>begin</code>,<code>end</code>) + or <code>source</code> to <code>pathname</code>. If the contents are in the + generic format, they are converted to the native format. [<i>Note:</i> For + POSIX and Windows based implementations, the generic format is already + acceptable as a native format, so no generic to native conversion is + performed. <i>--end note</i>]</p> + </blockquote> + <p><i>Remarks:</i> If the value type of [<code>begin</code>,<code>end</code>) + or <code>source</code> is not <code>value_type</code>, conversion is performed + by <code>cvt</code>.</p> + <p><i>Returns: </i><code>*this</code></p> + </blockquote> + +<h3> <a name="path-modifiers"> <code> +<font size="4">path</font></code> modifiers</a></h3> +<pre>void <a name="path-clear">clear</a>();</pre> +<blockquote> +<p><i>Postcondition:</i> <code>this->empty()</code> is true.</p> +</blockquote> +<pre>path& <a name="path-make_preferred">make_preferred</a>();</pre> +<blockquote> + <p><i>Effects:</i> The contained pathname is converted to the preferred native + format. [<i>Note:</i> On Windows, the effect is to replace slashes with + backslashes. On POSIX, there is no effect. <i>-- end note</i>]</p> + <p><i>Returns:</i> <code>*this</code></p> +</blockquote> + +<pre>path& <a name="path-remove_filename">remove_filename</a>();</pre> +<blockquote> + <p><i>Returns: </i>As if, <code>*this = parent_path();</code></p> + <p>[<i>Note:</i> This function is needed to efficiently implement <code> + directory_iterator</code>. It is exposed to allow additional uses. The actual + implementation may be much more efficient than <code>*this = parent_path()</code> <i>-- end + note</i>]</p> +</blockquote> +<pre>path& <a name="path-replace_extension">replace_extension</a>(const path& new_extension = path());</pre> +<blockquote> + <p><i>Postcondition: </i> <code>extension() == <i>replacement</i></code>, + where <code><i>replacement</i></code> is <code>new_extension</code> if <code> + new_extension.empty() || new_extension[0] ==</code> the dot character, + otherwise <code><i>replacement</i></code> is the dot character followed by + <code>new_extension</code>.</p> + <p><i>Returns:</i> <code>*this</code></p> +</blockquote> +<pre><code>void <a name="path-swap">swap</a>(path& rhs);</code></pre> +<blockquote> + <p><i>Effects:</i> + Swaps the contents of the two paths.</p> + <p><i>Throws: </i> + nothing.</p> + <p><i>Complexity: </i> + constant time.</p> +</blockquote> + +<h3> <a name="path-native-format-observers"><code><font size="4">path</font></code> +native format observers</a></h3> +<p>The string returned by all native format observers is in the +<a href="#native-pathname-format">native pathname format</a>.</p> +<pre>const string_type& <a name="native">native</a>() const;</pre> +<blockquote> +<p><i>Returns:</i> <code>pathname</code>.</p> +<p><i>Throws:</i> nothing.</p> +</blockquote> +<pre>const value_type* <a name="c_str">c_str</a>() const;</pre> +<blockquote> +<p><i>Returns:</i> <code>pathname.c_str()</code>.</p> +<p><i>Throws:</i> nothing.</p> +</blockquote> +<pre>template <class String> +String <a name="string-template">string</a>(const codecvt_type& cvt=codecvt()) const;</pre> +<blockquote> + <p><i>Returns:</i> <code>pathname</code>.</p> +<p><i>Remarks:</i> If <code>string_type</code> is a different type than <code> +String</code>, conversion is performed by <code>cvt</code>.</p> +</blockquote> +<pre>const string <a name="string">string</a>(const codecvt_type& cvt=codecvt()) const; +const wstring <a name="wstring">wstring</a>(const codecvt_type& cvt=codecvt()) const; +const u16string <a name="u16string">u16string</a>() const; +const u32wstring <a name="u32wstring">u32wstring</a>() const; </pre> +<blockquote> +<p><i>Returns:</i> <code>pathname</code>.</p> +<p><i>Remarks:</i> If <code>string_type</code> is a different type than +function's return type, conversion is performed by <code>cvt</code>.</p> +<p>If <code>string_type</code> is the same type as the +function's return type, the function is permitted to return by <code>const&</code> +rather than <code>const</code> value. [<i>Note:</i> For POSIX, this occurs for +<code>string()</code>, for Windows, <code>wstring()</code>. <i>--end note</i>]</p> +</blockquote> + +<h3> <a name="path-generic-format-observers"><code><font size="4">path</font></code> +generic format observers</a></h3> +<p>The string returned by all generic format observers is in the +<a href="#generic-pathname-format">generic pathname format</a>.</p> +<p>[<i>Note:</i> For POSIX, no conversion occurs, since the native format and +generic format are the same. For Windows, backslashes are converted to slashes +<i>--end note</i>]</p> +<pre>template <class String> +String <a name="generic_string-template">generic_string</a>(const codecvt_type& cvt=codecvt()) const;</pre> +<blockquote> + <p><i>Returns:</i> <code>pathname</code>.</p> +<p><i>Remarks:</i> If <code>string_type</code> is a different type than <code> +String</code>, conversion is performed by +<code>cvt</code>.</p> +</blockquote> +<pre>const string <a name="generic_string">generic_string</a>(const codecvt_type& cvt=codecvt()) const; +const wstring <a name="generic_wstring">generic_wstring</a>(const codecvt_type& cvt=codecvt()) const; +const u16string <a name="generic_u16string">generic_u16string</a>() const; +const u32wstring <a name="generic_u32wstring">generic_u32wstring</a>() const; </pre> +<blockquote> +<p><i>Returns:</i> <code>pathname</code>.</p> +<p><i>Remarks:</i> If <code>string_type</code> is a different type than +function's return type, conversion is performed by <code>cvt</code>.</p> +<p>If <code>string_type</code> is of the same type as the +function's return type, and the generic format is the same as the native format, +the function is permitted to return by <code>const&</code> rather than <code> +const</code> value. [<i>Note:</i> For POSIX, this occurs for <code>string()</code>. +It never occurs for Windows, because backslashes must be converted to slashes. +<i>--end note</i>]</p> +</blockquote> + +<h3> <a name="path-decomposition"> <code><font size="4">path</font></code> +decomposition</a></h3> +<p><span style="background-color: #E0E0E0"><i>See the +<a href="#Path-decomposition-table">Path decomposition table</a> for examples +for values returned by decomposition functions. The +<a href="tutorial.html#Using-path-decomposition">Tutorial</a> may also be +helpful.</i></span></p> +<pre>path <a name="path-root_name">root_name</a>() const;</pre> +<blockquote> +<p><i>Returns:</i> <i>root-name,</i> if <code>pathname</code> includes <i> +root-name</i>, otherwise <code>path()</code>. </p> +</blockquote> +<pre>path <a name="path-root_directory">root_directory</a>() const;</pre> +<blockquote> +<p><i>Returns:</i> <i>root-directory</i>, if <code>pathname</code> includes <i> +root-directory</i>, otherwise <code>path()</code>.</p> +<p>If <i>root-directory</i> is composed of <i>slash name</i>, <i>slash</i> is +excluded from the returned string.</p> +</blockquote> +<pre>path <a name="path-root_path">root_path</a>() const;</pre> +<blockquote> + <p><i>Returns:</i> <code>root_name() / root_directory()</code></p> +</blockquote> +<pre>path <a name="path-relative_path">relative_path</a>() const;</pre> +<blockquote> +<p><i>Returns:</i> A <code>path</code> composed from <code>pathname</code>, if <code> +!empty()</code>, beginning +with the first <i>filename</i> after <i>root-path</i>. Otherwise, <code>path()</code>.</p> +</blockquote> +<pre>path <a name="path-parent_path">parent_path</a>() const;</pre> +<blockquote> + <p><i>Returns:</i> <code>(empty() || begin() == --end()) ? path() : <i>pp</i></code>, where + <code><i>pp</i></code> is constructed as if by + starting with an empty <code>path</code> and successively applying <code> + operator/=</code> for each element in the range <code>begin()</code>, <code> + --end()</code>.</p> +</blockquote> +<pre>path <a name="path-filename">filename</a>() const;</pre> +<blockquote> + <p><i>Returns:</i> <code>empty() ? path() : *--end()</code></p> + <p>[<i>Example:</i></p> + <blockquote> + <pre><code>std::cout << path("/foo/bar.txt").filename();</code> // outputs "<code>bar.txt</code>"</pre> + </blockquote> + <p> <i>--end example</i>]</p> +</blockquote> +<pre>path <a name="path-stem">stem</a>(const path& p) const;</pre> +<blockquote> + <p><i>Returns:</i> if <code>p.filename()</code>contains a dot but does not + consist solely of one or to two dots, returns + the substring of <code>p.filename()</code> starting at its beginning and + ending at the last dot (the dot is not included). Otherwise, + returns <code> + p.filename()</code>.</p> + <p>[<i>Example:</i></p> + <blockquote> + <pre><code>std::cout << path("/foo/bar.txt").stem();</code> // outputs "<code>bar</code>" +path p = "foo.bar.baz.tar"; +for (; !p.extension().empty(); p = p.stem()) + std::cout << p.extension() << '\n'; + // outputs: .tar + // .baz + // .bar</pre> + </blockquote> + <p> <i>--end example</i>]</p> +</blockquote> +<pre>path <a name="path-extension">extension</a>(const path& p) const;</pre> +<blockquote> + <p><i>Returns:</i> if <code>p.filename()</code> contains a dot but does not + consist solely of one or to two dots, returns + the substring of <code>p.filename()</code> starting at the rightmost dot + and ending at the path's end. Otherwise, returns an empty <code>path</code> + object. </p> + <p><i>Remarks:</i> Implementations are permitted but not required to define additional + behavior for file systems which append additional elements to extensions, such + as alternate data streams or partitioned dataset names.</p> + <p>[<i>Example:</i></p> + <blockquote> + <pre><code>std::cout << path("/foo/bar.txt").extension(); //</code> outputs "<code>.txt</code>"</pre> + </blockquote> + <p> <i>--end example</i>]</p> + <p>[<i>Note:<b> </b></i>The dot is included in the return value so that + it is possible to distinguish between no extension and an empty extension. See + <a href="http://permalink.gmane.org/gmane.comp.lib.boost.devel/199744"> + http://permalink.gmane.org/gmane.comp.lib.boost.devel/199744</a> for more + extensive rationale. <i>-- end note</i>]</p> +</blockquote> +<h3> <a name="path-query"> <code><font size="4">path</font></code> query</a></h3> +<pre>bool <a name="path-empty">empty</a>() const;</pre> +<blockquote> + <p><i>Returns:</i> <code>m_pathname.empty()</code>.</p> +</blockquote> +<pre>bool <a name="path-has_root_path">has_root_path</a>() const;</pre> +<blockquote> + <p><i>Returns:</i> <code>!<a href="#path-root_path">root_path</a>().empty()</code></p> +</blockquote> +<pre>bool <a name="path-has_root_name">has_root_name</a>() const;</pre> +<blockquote> + <p><i>Returns:</i> <code>!<a href="#path-root_name">root_name</a>().empty()</code></p> +</blockquote> +<pre>bool <a name="path-has_root_directory">has_root_directory</a>() const;</pre> +<blockquote> + <p><i>Returns:</i> <code>!<a href="#path-root_directory">root_directory</a>().empty()</code></p> +</blockquote> +<pre>bool <a name="path-has_relative_path">has_relative_path</a>() const;</pre> +<blockquote> + <p><i>Returns:</i> <code>!<a href="#path-has_relative_path">relative_path</a>().empty()</code></p> +</blockquote> +<pre>bool <a name="path-has_parent_path">has_parent_path</a>() const;</pre> +<blockquote> + <p><i>Returns:</i> <code>!<a href="#path-parent_path">parent_path</a>().empty()</code></p> +</blockquote> +<pre>bool <a name="path-has_filename">has_filename</a>() const;</pre> +<blockquote> + <p><i>Returns:</i> <code>!<a href="#path-filename">filename</a>().empty()</code></p> +</blockquote> +<pre>bool <a name="path-has_stem">has_stem</a>() const;</pre> +<blockquote> + <p><i>Returns:</i> <code>!<a href="#path-stem">stem</a>().empty()</code></p> +</blockquote> +<pre>bool <a name="path-has_extension">has_extension</a>() const;</pre> +<blockquote> + <p><i>Returns:</i> <code>!<a href="#path-has_extension">extension</a>().empty()</code></p> +</blockquote> +<pre>bool <a name="path-is_absolute">is_absolute</a>() const;</pre> +<blockquote> + <p><i>Returns:</i> <code>true</code> + if the elements of <code>root_path()</code> uniquely identify a directory, else <code>false</code>.</p> + <p>[<i>Note:</i> On POSIX,<code> + path("/foo").is_absolute()</code> returns <code>true</code>. On Windows, <code> + path("/foo").is_absolute()</code> returns <code>false</code>. <i>--end note</i>]</p> +</blockquote> +<pre>bool <a name="path-is_relative">is_relative</a>() const;</pre> +<blockquote> + <p><i>Returns:</i> <code>!is_absolute()</code>.</p> +</blockquote> +<h3> <a name="path-iterators"> <code> +<font size="4">path</font></code> iterators</a></h3> +<p> A <code>path::iterator</code> is a constant iterator satisfying all +the requirements of a bidirectional iterator (C++ Std, 24.1.4 Bidirectional +iterators [lib.bidirectional.iterators]). Its <code>value_type</code> is <code> +path</code>.</p> + <p>Calling any non-const member function of a <code>path</code> object + invalidates all iterators referring to elements of that object.</p> +<p> The forward traversal order is as follows:</p> +<ul> + <li>The <i>root-name</i> element, if present.</li> + <li>The <i>root-directory</i> element, if present.</li> + <li>Each successive <i>filename</i> element, if present.</li> + <li><i>Dot</i>, if one or more trailing non-root <i>slash</i> + characters are present.</li> +</ul> + <p>The backward traversal order is the reverse of forward traversal.</p> + <pre>iterator begin() const;</pre> +<blockquote> + <p><i>Returns:</i> An iterator for the first present element in the traversal + list above. If no elements are present, the end iterator.</p> +</blockquote> +<pre>iterator end() const;</pre> +<blockquote> + <p><i>Returns:</i> The end iterator.</p> +</blockquote> + <h3><a name="path_encoding"><code><font size="4"> path</font></code> encoding</a> conversion</h3> + <pre>static std::locale <a name="path-imbue">imbue</a>(const std::locale& loc);</pre> +<blockquote> + <p><i>Effects:</i> Stores <code>loc</code> as the default locale for all + objects of type <code>path</code>.</p> + <p><i>Returns:</i> The previous default locale for all objects of type <code> + path</code>.</p> +</blockquote> +<pre>static const codecvt_type& <a name="path-codecvt">codecvt</a>();</pre> +<blockquote> + <p><i>Returns:</i> The <code>codecvt</code> facet for the default locale for + all objects of type <code>path</code>.</p> +</blockquote> +<h3> <a name="path-deprecated-functions"><code><font size="4"> path</font></code> deprecated functions</a></h3> +<p> Several member functions from previous versions of <code>class path</code> +have been deprecated, either because they have been renamed or because the +functionality is no longer desirable or has become obsolete.</p> +<p> Deprecated functions available by default; will be suppressed if <code> +BOOST_FILESYSTEM_NO_DEPRECATED</code> is defined:</p> +<blockquote> + <pre>path& remove_leaf() { return remove_filename(); } +path leaf() const { return filename(); } +path branch_path() const { return parent_path(); } +bool has_leaf() const { return !m_path.empty(); } +bool has_branch_path() const { return !parent_path().empty(); }</pre> +</blockquote> +<p> Deprecated functions not available by default; will be supplied if <code> +BOOST_FILESYSTEM_DEPRECATED</code> is defined:</p> +<blockquote> + <pre>const std::string file_string() const { return native_string(); } +const std::string directory_string() const { return native_string(); } +const std::string native_file_string() const { return native_string(); } +const std::string native_directory_string() const { return native_string(); } +const string_type external_file_string() const { return native(); } +const string_type external_directory_string() const { return native(); }</pre> +</blockquote> +<h3> <a name="path-non-member-functions"> <code><font size="4">path</font></code> +non-member functions</a></h3> +<pre>void swap( path& lhs, path& rhs )</pre> +<blockquote> + <p><i>Effects: </i><code> + lhs.swap(rhs)</code>.</p> +</blockquote> + <pre>bool lexicographical_compare(path::iterator first1, path::iterator last1, + path::iterator first2, path::iterator last2)</pre> +<blockquote> + <p><i>Returns:</i> <code>true</code> if the sequence of <code>native()</code> + strings for the elements defined by the range <code>[first1,last1)</code> is + lexicographically less than the sequence of <code>native()</code> strings for + the elements defined by the range <code>[first2,last2)</code>. Returns <code> + false</code> otherwise.</p> + <p><i>Remarks:</i> If two sequences have the same number of elements and their + corresponding elements are equivalent, then neither sequence is + lexicographically less than the other. If one sequence is a prefix of the + other, then the shorter sequence is lexicographically less than the longer + sequence. Otherwise, the lexicographical comparison of the sequences yields + the same result as the comparison of the first corresponding pair of elements + that are not equivalent.</p> + <pre> for ( ; first1 != last1 && first2 != last2 ; ++first1, ++first2) { + if (first1->native() < first2->native()) return true; + if (first2->native() < first1->native()) return false; + } + return first1 == last1 && first2 != last2;</pre> + <p>[<i>Note:</i> A <code>path</code> aware<code> lexicographical_compare</code> + is provided to avoid infinite recursion in <code>std::lexicographical_compare</code> + due to the <code>path</code> iterator's value type itself being <code>path</code>. + <i>--end note</i>]</p> +</blockquote> +<pre>std::size_t <a name="hash_value">hash_value</a> (const path& p);</pre> +<blockquote> + <p><i>Returns:</i> A hash value for the path <code>p</code>. If + for two paths, <code>p1 == p2</code> then + <code>hash_value(p1) == hash_value(p2)</code>.</p> + <p>This allows paths to be used with + <a href="../../../functional/hash/index.html">Boost.Hash</a>.</p> +</blockquote> +<pre>bool operator< (const path& lhs, const path& rhs);</pre> +<blockquote> + <p><i>Returns:</i> <code>return lexicographical_compare(lhs.begin(), lhs.end(), + rhs.begin(), rhs.end())</code>.</p> +</blockquote> +<pre>bool operator<=(const path& lhs, const path& rhs);</pre> +<blockquote> + <p><i>Returns:</i> <code>!(rhs < lhs)</code>.</p> +</blockquote> +<pre>bool operator> (const path& lhs, const path& rhs);</pre> +<blockquote> + <p><i>Returns:</i> <code>rhs < lhs</code>.</p> +</blockquote> +<pre>bool operator>=(const path& lhs, const path& rhs);</pre> +<blockquote> + <p><i>Returns:</i> <code>!(lhs < rhs)</code>.</p> +</blockquote> +<pre>bool operator==(const path& lhs, const path& rhs);</pre> +<blockquote> + <p><i>Returns:</i> <code>!(lhs < rhs) && !(rhs < lhs)</code>.</p> + <p>[<i>Note:</i> Actual implementations may use an equivalent, but more + efficient, algorithm. <i>--end note</i>]</p> + <p>[<i>Note:</i> <a name="Path-equality">Path equality</a> and path + equivalence have different semantics.</p> + <p>Equality is determined by the <code>path</code> + non-member <code>operator==</code>, which considers the two path's lexical + representations only. Thus <code>path("foo") == "bar"</code> is never + <code>true</code>.</p> + <p>Equivalence is determined by the <a href="#equivalent"><code>equivalent()</code></a> + non-member function, which determines if two paths <a href="#Path">resolve</a> to the same file system entity. + Thus <code>equivalent("foo", "bar")</code> will be <code>true</code> + when both paths resolve to the same file.</p> + <p>Programmers wishing to determine if two paths are "the same" must decide if + "the same" means "the same representation" or "resolve to the same actual + file", and choose the appropriate function accordingly. <i> + -- end note</i>]</p> +</blockquote> +<pre>bool operator!=(const path& lhs, const path& rhs);</pre> +<blockquote> + <p><i>Returns:</i> <code>!(lhs == rhs)</code>.</p> +</blockquote> +<pre>path operator/ (const path& lhs, const path& rhs);</pre> +<blockquote> + <p><i>Returns:</i> <code>path(lhs) /= rhs</code>.</p> +</blockquote> +<h3> <a name="path-non-member-operators"><code><font size="4">path</font></code></a><a name="path-inserter-extractor"> inserter + and extractor</a></h3> +<p> The inserter and extractor delimit the string with double-quotes (<code>"</code>) +to ensure that paths with embedded spaces will round trip correctly. Ampersand (<code>&</code>) +is used as an escape character, so the path can itself contain double quotes.</p> +<pre>template <class Char, class Traits> +std::basic_ostream<Char, Traits>& operator<<(std::basic_ostream<Char, Traits>& os, + const path& p) +</pre> +<blockquote> + <p><i>Effects:</i> + <code>os << <a href="../../../io/doc/quoted_manip.html"> + boost::io::quoted</a>(p.string<std::basic_string<Char>>(), static_cast<Char>('&'));</code></p> + <p><i>Returns:</i> + <code>os</code></p> +</blockquote> +<pre>template <class Char, class Traits> +inline std::basic_istream<Char, Traits>& operator>>(std::basic_istream<Char, Traits>& is, + path& p) +</pre> +<blockquote> + <p><i>Effects: </i> + <code> std::basic_string<Char> str;<br> + is >> + <a href="../../../io/doc/quoted_manip.html">boost::io::quoted</a>(str, + static_cast<Char>('&'));<br> + p = str;</code></p> + <p><i>Returns:</i> + <code>is</code></p> + </blockquote> +<h3><a name="Class-filesystem_error">Class <code>filesystem_error</code></a></h3> +<pre> namespace boost + { + namespace filesystem + { + class basic_filesystem_error : public system_error + { + public: + filesystem_error(); + filesystem_error(const filesystem_error&); + <a href="#filesystem_error-2-arg">filesystem_error</a>(const std::string& what_arg, + system::error_code ec); + <a href="#filesystem_error-3-arg">filesystem_error</a>(const std::string& what_arg, + const path& p1, system::error_code ec); + <a href="#filesystem_error-4-arg">filesystem_error</a>(const std::string& what_arg, + const path& p1, const path& p2, system::error_code ec); + + filesystem_error& filesystem_error(const filesystem_error&); + ~filesystem_error(); + + filesystem_error& operator=(const filesystem_error&); + + const path& <a href="#filesystem_error-path1">path1</a>() const; + const path& <a href="#filesystem_error-path2">path2</a>() const; + + const char * <a href="#filesystem_error-what">what</a>() const; + }; + } // namespace filesystem + } // namespace boost</pre> +<p>The class template <code>basic_filesystem_error</code> defines the type of +objects thrown as exceptions to report file system errors from functions described in this +clause.</p> +<h4> <a name="filesystem_error-members"> <code>filesystem_error</code> members</a></h4> +<pre><a name="filesystem_error-2-arg">filesystem_error</a>(const std::string& what_arg, error_code ec);</pre> +<blockquote> + <p><i>Postcondition:</i></p> + <table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" width="46%"> + <tr> + <td width="18%"><b>Expression</b></td> + <td width="82%"><b>Value</b></td> + </tr> + <tr> + <td width="18%" bgcolor="#FFFFFF"><code> + runtime_error::what()</code></td> + <td width="82%" bgcolor="#FFFFFF"> + <code><i>what_arg</i>.c_str()</code></td> + </tr> + <tr> + <td width="18%"><code>code()</code></td> + <td width="82%"><code>ec</code></td> + </tr> + <tr> + <td width="18%"><code>path1().empty()</code></td> + <td width="82%"><code>true</code></td> + </tr> + <tr> + <td width="18%"><code>path2().empty()</code></td> + <td width="82%"><code>true</code></td> + </tr> + </table> +</blockquote> +<pre><a name="filesystem_error-3-arg">filesystem_error</a>(const std::string& what_arg, const path_type& p1, error_code ec);</pre> +<blockquote> + <p><i>Postcondition:</i></p> + <table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" width="46%"> + <tr> + <td width="18%"><b>Expression</b></td> + <td width="82%"><b>Value</b></td> + </tr> + <tr> + <td width="18%" valign="top"><code> + runtime_error::what()</code></td> + <td width="82%"> + <code><i>what_arg</i>.c_str()</code></td> + </tr> + <tr> + <td width="18%" valign="top"><code>code()</code></td> + <td width="82%"><code>ec</code></td> + </tr> + <tr> + <td width="18%" valign="top"><code>path1()</code></td> + <td width="82%">Reference to stored copy of + <code>p1</code></td> + </tr> + <tr> + <td width="18%" valign="top"><code>path2().empty()</code></td> + <td width="82%"><code>true</code></td> + </tr> + </table> +</blockquote> +<pre><a name="filesystem_error-4-arg">filesystem_error</a>(const std::string& what_arg, const path_type& p1, const path_type& p2, error_code ec);</pre> +<blockquote> + <p><i>Postcondition:</i></p> + <table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" width="46%"> + <tr> + <td width="18%"><b>Expression</b></td> + <td width="82%"><b>Value</b></td> + </tr> + <tr> + <td width="18%"><code> + runtime_error::what()</code></td> + <td width="82%"> + <u> + <code><i>w</i></code></u><code><i>hat_arg</i>.c_str()</code></td> + </tr> + <tr> + <td width="18%"><code>code()</code></td> + <td width="82%"><code>ec</code></td> + </tr> + <tr> + <td width="18%"><code>path1()</code></td> + <td width="82%">Reference to stored copy of + <code>p1</code></td> + </tr> + <tr> + <td width="18%"><code>path2()</code></td> + <td width="82%">Reference to stored copy of + <code>p2</code></td> + </tr> + </table> +</blockquote> +<pre>const path& <a name="filesystem_error-path1">path1</a>() const;</pre> +<blockquote> + <p><i>Returns:</i> Reference to copy of <code>p1</code> stored by the + constructor, or, if none, an empty path.</p> +</blockquote> +<pre>const path& <a name="filesystem_error-path2">path2</a>() const;</pre> +<blockquote> + <p><i>Returns:</i> Reference to copy of <code>p2</code> stored by the + constructor, or, if none, an empty path.</p> +</blockquote> +<pre>const char* <a name="filesystem_error-what">what</a>() const;</pre> +<blockquote> + <p><i>Returns: </i>A string containing <code>runtime_error::what()</code>. The exact format is unspecified. + Implementations are encouraged but not required to include <code> + path1.native_string()</code>if not empty, <code>path2.native_string()</code>if + not empty, and <code>system_error::what()</code> strings in the returned + string.</p> +</blockquote> +<h3><a name="Enum-file_type">Enum file_type</a></h3> +<p>This enum specifies constants uses to identify file types.</p> +<table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111"> + <tr> + <td><b>Constant Name</b></td> + <td><b>Meaning</b></td> + </tr> + <tr> + <td><code>status_error</code></td> + <td>An error occurred while trying to obtain the status of the file. The + file simply not being found is <b><u>not</u></b> considered a status error. + </td> + </tr> + <tr> + <td><code>file_not_found</code></td> + <td>The file could not be found</td> + </tr> + <tr> + <td><code>regular_file</code></td> + <td>Regular file</td> + </tr> + <tr> + <td><code>directory_file</code></td> + <td>Directory file</td> + </tr> + <tr> + <td><code>symlink_file</code></td> + <td>Symbolic link file</td> + </tr> + <tr> + <td><code>block_file</code></td> + <td>Block special file</td> + </tr> + <tr> + <td><code>character_file</code></td> + <td>Character special file</td> + </tr> + <tr> + <td><code>fifo_file</code></td> + <td>FIFO or pipe file</td> + </tr> + <tr> + <td><code>socket_file</code></td> + <td>Socket file</td> + </tr> + <tr> + <td><code>type_unknown</code></td> + <td>The file exists, but it is of a system specific type not covered by any + of the above cases.</td> + </tr> +</table> +<h3><a name="Enum-perms">Enum perms</a></h3> +<p>This enum specifies bitmask constants uses to identify file +permissions. The POSIX standard specifies actual values, and those values have +been adopted here because they are very familiar and ingrained for many POSIX +users.</p> +<blockquote> +<p>Caution: Operating systems do not always support permissions as described in +the table.</p> +<p>There is much variation in the meaning of <code><a href="#sticky_bit"> +sticky_bit</a></code>; do not use it unless you understand what it means for +your operating system.</p> +<p>There is much variation in how operating systems treat symlinks. See <code> +<a href="#symlink_perms">symlink_perms</a></code>.</p> +<p>Windows: All permissions except write are currently ignored. There is only a +single write permission; setting write permission for owner, group, or others +sets write permission for all, and removing write permission for owner, group, +or others removes write permission for all. </p> +</blockquote> +<table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111"> + <tr> + <td><b>Name</b></td> + <td align="center"><b>Value<br> + (octal)</b></td> + <td align="center"><b>POSIX<br> + macro</b></td> + <td><b>Definition or notes</b></td> + </tr> + +<tr><td> + <p dir="ltr"><code>no_perms</code></td><td><code>0</code></td><td></td> + <td>There are no permissions set for the file. Note: <code>file_not_found</code> is + <code>no_perms</code> rather than <code>perms_not_known</code></td> +</tr> +<tr><td><code>owner_read</code></td><td><code>0400</code></td><td> <code>S_IRUSR</code></td> + <td> Read permission, owner</td> +</tr> +<tr><td><code>owner_write</code></td><td><code>0200</code></td><td> <code>S_IWUSR</code></td> + <td> Write permission, owner</td> +</tr> +<tr><td><code>owner_exe</code></td><td><code>0100</code></td><td> <code>S_IXUSR</code></td> + <td> Execute/search permission, owner</td> +</tr> +<tr><td><code>owner_all</code></td><td><code>0700</code></td><td> <code>S_IRWXU</code></td> + <td> Read, write, execute/search by owner; <code>owner_read | owner_write | owner_exe</code></td> +</tr> +<tr><td><code>group_read</code></td><td><code>040</code></td><td> <code>S_IRGRP</code></td> + <td> Read permission, group</td> +</tr> +<tr><td><code>group_write</code></td><td><code>020</code></td><td> <code>S_IWGRP</code></td> + <td> Write permission, group</td> +</tr> +<tr><td><code>group_exe</code></td><td><code>010</code></td><td> <code>S_IXGRP</code></td> + <td> Execute/search permission, group</td> +</tr> +<tr><td><code>group_all</code></td><td><code>070</code></td><td> <code>S_IRWXG</code></td> + <td> Read, write, execute/search by group; <code>group_read | group_write | + group_exe</code></td> +</tr> +<tr><td><code>others_read</code></td><td><code>04</code></td><td> <code>S_IROTH</code></td> + <td> Read permission, others</td> +</tr> +<tr><td><code>others_write</code></td><td><code>02</code></td><td> <code>S_IWOTH</code></td> + <td> Write permission, others</td> +</tr> +<tr><td><code>others_exe</code></td><td><code>01</code></td><td> <code>S_IXOTH</code></td> + <td> Execute/search permission, others</td> +</tr> +<tr><td><code>others_all</code></td><td><code>07</code></td><td> <code>S_IRWXO</code></td> + <td>Read, write, execute/search by others; <code>others_read | others_write | others_exe</code></td> +</tr> +<tr><td><code>all_all</code></td><td><code>0777</code></td><td> </td><td><code>owner_all | group_all | others_all</code></td> +</tr> +<tr><td><code>set_uid_on_exe</code></td><td><code>04000</code></td><td> <code>S_ISUID</code></td> + <td> Set-user-ID on execution</td> +</tr> +<tr><td><code>set_gid_on_exe</code></td><td><code>02000</code></td><td> <code>S_ISGID</code></td> + <td> Set-group-ID on execution</td> +</tr> +<tr><td><code><a name="sticky_bit">sticky_bit</a> </code> </td><td><code>01000</code></td><td> <code>S_ISVTX</code></td> + <td> Meaning varies; see <a href="http://en.wikipedia.org/wiki/Sticky_bit">http:en.wikipedia.org/wiki/Sticky_bit</a></td> +</tr> +<tr><td><code>perms_mask</code></td><td><code>07777</code></td><td> </td> + <td><code>all_all | set_uid_on_exe | set_gid_on_exe | sticky_bit</code></td> +</tr> +<tr><td><code>perms_not_known</code></td><td><code>0xFFFF</code></td><td></td><td> + The permissions are not known, such as when a <code>file_status</code> object + is created without specifying the permissions</td> +</tr> +<tr><td> + <p dir="ltr"><code>add_perms</code></td><td><code>0x1000</code></td><td></td><td> + <p dir="ltr"><code>permissions()</code> adds the argument permission bits to the + file's current bits</td> +</tr> +<tr><td><code>remove_perms</code></td><td><code>0x2000</code></td><td></td><td> + <code>permissions()</code> removes the argument permission bits from the + file's current bits</td> +</tr> +<tr><td><code><a name="symlink_perms">symlink_perms</a></code></td><td><code>0x4000</code></td><td></td><td> + On POSIX <code>permissions()</code> resolves symlinks unless <code>symlink_perms</code> + is specified. + Meaningless on Windows as <code>permissions()</code> never resolves symlinks. + Meaningless on Mac OS X and some other BSD systems as <code>permissions()</code> + always resolves symlinks. Get over it.</td> +</tr> + +</table> +<h3><a name="file_status">Class file_status</a></h3> +<pre> namespace boost + { + namespace filesystem + { + class file_status + { + public: + + // <a href="#file_status-constructors">constructors</a> + file_status() noexcept; + explicit file_status(<a href="#file_type">file_type</a> ft, <a href="#Enum-perms">perms</a> prms = perms_not_known) noexcept; + + // compiler generated + file_status(const file_status&) noexcept; + file_status& operator=(const file_status&) noexcept; + ~file_status() noexcept; + + // <a href="#file_status-observers">observers</a> + <a href="#file_type">file_type</a> type() const noexcept; + <a href="#Enum-perms">perms</a> permissions() const noexcept; + + // <a href="#file_status-modifiers">modifiers</a> + void type(<a href="#file_type">file_type</a> ft) noexcept; + void permissions(<a href="#Enum-perms">perms</a> prms) noexcept; + }; + } // namespace filesystem + } // namespace boost</pre> +<p>An object of type <code>file_status</code> stores information about the type +and permissions of a file.</p> +<h4 dir="ltr"><a name="file_status-constructors"><code>file_status</code> +constructors</a></h4> +<pre>explicit file_status() noexcept;</pre> +<blockquote> + <p><i>Postconditions:</i> <code>type() == status_error</code>, <code> + permissions() == perms_not_known</code>.</p> +</blockquote> +<pre>explicit file_status(<a href="#file_type">file_type</a> ft, <a href="#Enum-perms">perms</a> prms = perms_not_known) noexcept;</pre> +<blockquote> + <p><i>Postconditions:</i> <code>type() == ft</code>, <code>permissions() == + prms</code>.</p> +</blockquote> + <h4 dir="ltr"><a name="file_status-observers"><code>file_status</code> + observers</a></h4> +<pre><a href="#file_type">file_type</a> type() const noexcept;</pre> +<blockquote> + <p><i>Returns: </i>The value of <code>type()</code> specified by the <i> + postconditions</i> of the most recent call to a constructor, operator=, or + <code>type(file_type)</code> function.</p> +</blockquote> +<pre><a href="#Enum-perms">perms</a> permissions() const noexcept;</pre> +<blockquote> + <p><i>Returns: </i>The value of <code>permissions()</code> specified by the <i> + postconditions</i> of the most recent call to a constructor, operator=, or + <code>permissions(perms)</code> function.</p> +</blockquote> +<h4 dir="ltr"><a name="file_status-modifiers"><code>file_status</code> modifiers</a></h4> +<pre>void type(<a href="#file_type">file_type</a> ft) noexcept;</pre> +<blockquote> + <p dir="ltr"><i>Postconditions:</i> <code>type() == ft</code>.</p> +</blockquote> +<pre>void permissions(<a href="#Enum-perms">perms</a> prms) noexcept;</pre> +<blockquote> + <p dir="ltr"><i>Postconditions:</i> <code>permissions() == prms</code>.</p> +</blockquote> +<h3><a name="Class-directory_entry">Class <code>directory_entry</code></a></h3> +<div dir="ltr"> +<pre> namespace boost + { + namespace filesystem + { + class directory_entry + { + public: + + // <a href="#directory_entry-constructors">constructors</a> and destructor + directory_entry(); + directory_entry(const directory_entry&); + explicit directory_entry(const path_type& p, file_status st=file_status(), + file_status symlink_st=file_status()); + ~directory_entry(); + + // <a href="#directory_entry-modifiers">modifiers</a> + directory_entry& operator=(const directory_entry&); + void assign(const path_type& p, file_status st=file_status(), + file_status symlink_st=file_status()); + void replace_filename(const path& p, file_status st=file_status(), + file_status symlink_st=file_status()); + + // <a href="#directory_entry-observers">observers</a> + const path& path() const; + file_status status() const; + file_status status(system::error_code& ec) const; + file_status symlink_status() const; + file_status symlink_status(system::error_code& ec) const; + + bool operator< (const directory_entry& rhs); + bool operator==(const directory_entry& rhs); + bool operator!=(const directory_entry& rhs); + bool operator< (const directory_entry& rhs); + bool operator<=(const directory_entry& rhs); + bool operator> (const directory_entry& rhs); + bool operator>=(const directory_entry& rhs); + private: + path_type m_path; // for exposition only + mutable file_status m_status; // for exposition only; stat()-like + mutable file_status m_symlink_status; // for exposition only; lstat()-like + }; + + } // namespace filesystem + } // namespace boost</pre> +</div> +<p>A <code>directory_entry</code> object stores a <code>path object</code>, +a <code>file_status</code> object for non-symbolic link status, and a <code> +file_status</code> object for symbolic link status. The <code>file_status</code> +objects act as value caches.</p> +<blockquote> +<p>[<i>Note:</i> Because <code>status()</code>on a pathname may be a very expensive operation, +some operating systems provide status information as a byproduct of directory +iteration. Caching such status information can result is significant time savings. Cached and +non-cached results may differ in the presence of race conditions. <i>-- end note</i>]</p> +<p><span style="background-color: #E0E0E0"><i>Actual cold-boot timing of iteration over +a directory with 15,047 entries was six seconds for non-cached status queries +versus one second for cached status queries. Windows XP, 3.0 GHz processor, with +a moderately fast hard-drive. Similar speedups are expected on Linux and BSD-derived +systems that provide status as a by-product of directory iteration.</i></span></p> +</blockquote> +<h4> <a name="directory_entry-constructors"> <code>directory_entry </code>constructors</a></h4> +<pre>directory_entry();</pre> +<blockquote> + <p><i>Postcondition:</i></p> + <table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" width="36%"> + <tr> + <td width="18%"><b>Expression</b></td> + <td width="82%"><b>Value</b></td> + </tr> + <tr> + <td width="18%"><code>path().empty()</code></td> + <td width="82%"><code>true</code></td> + </tr> + <tr> + <td width="18%"><code>status()</code></td> + <td width="82%"><code>file_status()</code></td> + </tr> + <tr> + <td width="18%"><code>symlink_status()</code></td> + <td width="82%"><code>file_status()</code></td> + </tr> + </table> +</blockquote> +<pre>explicit directory_entry(const path_type& p, file_status st=file_status(), file_status symlink_st=file_status());</pre> +<blockquote> + <p><i>Postcondition:</i></p> + <table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" width="36%"> + <tr> + <td width="18%"><b>Expression</b></td> + <td width="82%"><b>Value</b></td> + </tr> + <tr> + <td width="18%"><code>path()</code></td> + <td width="82%"><code>p</code></td> + </tr> + <tr> + <td width="18%"><code>status()</code></td> + <td width="82%"><code>st</code></td> + </tr> + <tr> + <td width="18%"><code>symlink_status()</code></td> + <td width="82%"><code>symlink_st</code></td> + </tr> + </table> +</blockquote> +<h4> <a name="directory_entry-modifiers"> <code>directory_entry </code>modifiers</a></h4> +<pre>void assign(const path_type& p, file_status st=file_status(), file_status symlink_st=file_status());</pre> +<blockquote> + <p><i>Postcondition:</i></p> + <table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" width="36%"> + <tr> + <td width="18%"><b>Expression</b></td> + <td width="82%"><b>Value</b></td> + </tr> + <tr> + <td width="18%"><code>path()</code></td> + <td width="82%"><code>p</code></td> + </tr> + <tr> + <td width="18%"><code>status()</code></td> + <td width="82%"><code>st</code></td> + </tr> + <tr> + <td width="18%"><code>symlink_status()</code></td> + <td width="82%"><code>symlink_st</code></td> + </tr> + </table> +</blockquote> +<pre>void replace_filename(const path& p, file_status st=file_status(), file_status symlink_st=file_status());</pre> +<blockquote> + <p><i>Postcondition:</i></p> + <table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" width="43%"> + <tr> + <td width="18%"><b>Expression</b></td> + <td width="82%"><b>Value</b></td> + </tr> + <tr> + <td width="18%"><code>path()</code></td> + <td width="82%"><code>path().branch() / s</code></td> + </tr> + <tr> + <td width="18%"><code>status()</code></td> + <td width="82%"><code>st</code></td> + </tr> + <tr> + <td width="18%"><code>symlink_status()</code></td> + <td width="82%"><code>symlink_st</code></td> + </tr> + </table> +</blockquote> +<h4> <a name="directory_entry-observers"> <code>directory_entry</code> observers</a></h4> +<pre>const path& path() const;</pre> +<blockquote> + <p><i>Returns:</i> <code>m_path</code></p> +</blockquote> +<pre>file_status status() const; +file_status status(system::error_code& ec) const;</pre> +<blockquote> +<p><i>Effects:</i> +As if,</p> + <blockquote> + <pre>if ( !status_known( m_status ) ) +{ + if ( status_known(m_symlink_status) && !is_symlink(m_symlink_status) ) + { m_status = m_symlink_status; } + else { m_status = status(m_path<i>[, ec]</i>); } +}</pre> + </blockquote> + <p><i>Returns:</i> <code>m_status</code></p> + + <p><i>Throws:</i> As specified in + <a href="#Error-reporting"> + Error reporting</a>.</p> + +</blockquote> +<pre>file_status symlink_status() const; +file_status symlink_status(system::error_code& ec) const;</pre> +<blockquote> +<p> + <i>Effects:</i> +As if,</p> + <blockquote> + <pre>if ( !status_known( m_symlink_status ) ) +{ + m_symlink_status = symlink_status(m_path<i>[, ec]</i>); +}</pre> + </blockquote> + <p><i>Returns:</i> <code> + m_symlink_status</code></p> + + <p><i>Throws:</i> As specified in + <a href="#Error-reporting"> + Error reporting</a>.</p> + +</blockquote> +<pre>bool operator==(const directory_entry& rhs);</pre> +<blockquote> + <p><i>Returns:</i> <code>m_path == + rhs.m_path</code>.</p> +</blockquote> +<pre>bool operator!=(const directory_entry& rhs);</pre> +<blockquote> + <p><i>Returns:</i> <code>m_path != + rhs.m_path</code>.</p> +</blockquote> +<pre>bool operator< (const directory_entry& rhs);</pre> +<blockquote> + <p><i>Returns:</i> <code>m_path < + rhs.m_path</code>.</p> +</blockquote> +<pre>bool operator<=(const directory_entry& rhs);</pre> +<blockquote> + <p><i>Returns:</i> <code>m_path <= + rhs.m_path</code>.</p> +</blockquote> +<pre>bool operator> (const directory_entry& rhs);</pre> +<blockquote> + <p><i>Returns:</i> <code>m_path > + rhs.m_path</code>.</p> +</blockquote> +<pre>bool operator>=(const directory_entry& rhs);</pre> +<blockquote> + <p><i>Returns:</i> <code>m_path >= + rhs.m_path</code>.</p> +</blockquote> +<h3><a name="Class-directory_iterator">Class <code>directory_iterator</code></a></h3> +<p>Objects of type <code>directory_iterator</code> provide standard library +compliant iteration over the contents of a directory. Also see class <code> +<a href="#Class-recursive_directory_iterator">recursive_directory_iterator</a></code>.</p> +<pre> namespace boost + { + namespace filesystem + { + class directory_iterator + : public boost::iterator_facade< directory_iterator, + <a href="#Class-directory_entry">directory_entry</a>, + boost::single_pass_traversal_tag > + { + public: + // <a href="#directory_iterator-members">member functions</a> + + directory_iterator(); // creates the "end" iterator + directory_iterator(const directory_iterator&); + explicit directory_iterator(const path& p); + directory_iterator(const path& p, system::error_code& ec); + ~directory_iterator(); + + directory_iterator& operator=(const directory_iterator&); + + directory_iterator& operator++(); + directory_iterator& increment(system::error_code& ec); + + // other members as required by + // C++ Std, 24.1.1 Input iterators [input.iterators] + }; + + } // namespace filesystem + } // namespace boost</pre> +<p> <code>directory_iterator</code> satisfies the requirements of an +input iterator (C++ Std, 24.2.1, Input iterators [input.iterators]).</p> +<p>A <code>directory_iterator</code> reads successive elements from the directory for +which it was constructed, as if by calling <i>POSIX</i> +<code> +<a href="http://www.opengroup.org/onlinepubs/000095399/functions/readdir_r.html">readdir_r()</a></code>. After a <code>directory_iterator</code> is constructed, and every time +<code>operator++</code> is called, +it reads a directory element and stores information about it in a object of type <code> +<a href="#Class-directory_entry">directory_entry</a></code>. +<code>operator++</code> is not equality preserving; that is, <code>i == j</code> does not imply that +<code>++i == ++j</code>. </p> +<blockquote> +<p>[<i>Note:</i> The practical consequence of not preserving equality is that directory iterators +can only be used for single-pass algorithms. <i>--end note</i>]</p> +</blockquote> +<p>If the end of the directory elements is reached, the iterator becomes equal to +the end iterator value. The constructor <code>directory_iterator()</code> +with no arguments always constructs an end iterator object, which is the only +legitimate iterator to be used for the end condition. The result of <code> +operator*</code> on an end iterator is not defined. For any other iterator value +a <code>const directory_entry&</code> is returned. The result of +<code>operator-></code> on an end iterator is not defined. For any other iterator value a <code>const directory_entry*</code> is +returned. </p> +<p>Two end iterators are always equal. An end iterator is not equal to a non-end +iterator.</p> +<blockquote> +<p><i><span style="background-color: #E0E0E0">The above wording is based on the +Standard Library's istream_iterator wording.</span></i></p> +</blockquote> +<p>The result of calling the <code>path()</code> member of the <code> +directory_entry</code> object obtained by dereferencing a <code> +directory_iterator</code> is a reference to a <code>path</code> +object composed of the directory argument from which the iterator was +constructed with filename of the directory entry appended as if by <code> +operator/=</code>. </p> +<p>Directory iteration shall not yield directory entries for the current (<i>dot</i>) +and parent (<i>dot dot</i>) directories.</p> +<p>The order of directory entries obtained by dereferencing successive +increments of a <code>directory_iterator</code> is unspecified.</p> +<blockquote> +<p>[<i>Note:</i> Programs performing directory iteration may wish to test if the +path obtained by dereferencing a directory iterator actually exists. It could be +a +symbolic link to a non-existent file. Programs recursively +walking directory trees for purposes of removing and renaming entries may wish +to avoid following symbolic links.</p> +<p>If a file is removed from or added to a directory after the +construction of a <code>directory_iterator</code> for the directory, it is +unspecified whether or not subsequent incrementing of the iterator will ever +result in an iterator whose value is the removed or added directory entry. See +<i>POSIX</i> +<code> +<a href="http://www.opengroup.org/onlinepubs/000095399/functions/readdir_r.html">readdir_r()</a></code>. <i> +--end note</i>]</p> +</blockquote> +<h4><a name="directory_iterator-members"><code>directory_iterator</code> members</a></h4> + +<p><code><a name="directory_iterator-default-ctor">directory_iterator</a>();</code></p> + +<blockquote> + +<p><i>Effects:</i> Constructs the end iterator.</p> + +<p><i>Throws:</i> Nothing.</p> + +</blockquote> + +<pre><code>explicit <a name="directory_iterator-ctor-path">directory_iterator</a>(</code>const path& p<code>); +directory_iterator(</code>const path& p, system::error_code& ec<code>);</code></pre> +<blockquote> + +<p><i>Effects:</i> Constructs a iterator representing the first +entry in the directory <code>p</code> resolves to, if any; otherwise, the end iterator.</p> + +<p><i>Throws:</i> As specified in + <a href="#Error-reporting"> + Error reporting</a>.</p> + +<p>[<i>Note:</i> To iterate over the current directory, use <code> +directory_iterator(".")</code> rather than <code>directory_iterator("")</code>. +<i>-- end note</i>]</p> +</blockquote> +<pre>directory_iterator& <a name="directory_iterator-increment">operator++</a>(); +directory_iterator& increment(system::error_code& ec);</pre> +<blockquote> + +<p><i>Effects:</i> As specified by the C++ Standard, 24.1.1 Input iterators [input.iterators]</p> + +<p><i>Returns:</i> <code>*this</code>.</p> + +<p><i>Throws:</i> As specified in + <a href="#Error-reporting"> + Error reporting</a>.</p> + +</blockquote> +<h3><a name="Class-recursive_directory_iterator">Class <code>recursive_directory_iterator</code></a></h3> +<p>Objects of type <code>recursive_directory_iterator</code> provide standard library +compliant iteration over the contents of a directory, including recursion into +its sub-directories.</p> +<pre> namespace boost + { + namespace filesystem + { + class recursive_directory_iterator : + public iterator<input_iterator_tag, directory_entry> + { + public: + + // constructors and destructor + recursive_directory_iterator(); + recursive_directory_iterator(const recursive_directory_iterator&); + explicit recursive_directory_iterator(const path& p, + BOOST_SCOPED_ENUM(<a href="#symlink_option">symlink_option</a>) opt = symlink_option::none); + recursive_directory_iterator(const path& p, + BOOST_SCOPED_ENUM(<a href="#symlink_option">symlink_option</a>) opt, system::error_code& ec); + recursive_directory_iterator(const path& p, system::error_code& ec); + ~recursive_directory_iterator(); + + // observers + int level() const; + bool no_push<code>_pending</code>() const; + + // modifiers + recursive_directory_iterator& operator=(const recursive_directory_iterator&); + + recursive_directory_iterator& operator++(); + recursive_directory_iterator& increment(system::error_code& ec); + + void pop(); + void no_push(bool value=true); + + // other members as required by + // C++ Std, 24.1.2 Input iterators [input.iterators] + + private: +<i><b> // actual data members will probably be stored in a shared pimpl object, + // or some similar mechanism, to achieve the required input iterator copy semantics +</b></i> int m_level; <b><i> // for exposition only</i></b> + bool m_no_<code>push</code>; <i><b> // for exposition only + </b></i>BOOST_SCOPED_ENUM(<a href="#symlink_option">symlink_option</a>) m_options; <i><b>// for exposition only</b></i> + }; + + } // namespace filesystem + } // namespace boost</pre> + +<p>The behavior of a <code>recursive_directory_iterator</code> is the same +as a <code>directory_iterator</code> unless otherwise specified.</p> +<ul> + <li>Incrementing a <code>recursive_directory_iterator</code> pointing to a + directory causes that directory itself to be iterated ovee, as specified by + the <code>operator++</code> and <code>increment</code> functions.<br> + </li> + <li>When a <code>recursive_directory_iterator</code> reaches the end of the directory currently being iterated + over, or when <code>pop()</code> is called, <code>m_level</code> is + decremented, and iteration of the parent directory continues.</li> +</ul> +<pre>recursive_directory_iterator();</pre> +<blockquote> + +<p><i>Effects:</i> Constructs the end iterator.</p> + +<p><i>Throws:</i> Nothing.</p> + +</blockquote> + +<pre>explicit recursive_directory_iterator(const path& p, BOOST_SCOPED_ENUM(<a href="#symlink_option">symlink_option</a>) opt = symlink_option::none); +recursive_directory_iterator(const path& p, BOOST_SCOPED_ENUM(<a href="#symlink_option">symlink_option</a>) opt, system::error_code& ec); +recursive_<code>directory_iterator(</code>const path& p, system::error_code& ec<code>);</code></pre> +<blockquote> + +<p><i>Effects:</i> Constructs a iterator representing the first +entry in the directory <code>p</code> resolves to, if any; otherwise, the end iterator.</p> + +<p dir="ltr"><i>Postcondition: </i>Unless the end iterator was constructed,<i> </i> +<code>level() == 0 && no_push_pending() == false && m_options == opt</code>. +For the signature without a <code>symlink_option</code> argument, <code>opt</code> +is assumed to be <code>symlink_option::none</code>.</p> + +<p><i>Throws:</i> As specified in + <a href="#Error-reporting"> + Error reporting</a>.</p> + +<p>[<i>Note:</i> To iterate over the current directory, use <code>recursive_directory_iterator(".")</code> rather than +<code>recursive_directory_iterator("")</code>. +<i>-- end note</i>]</p> + +<p>[<i>Note:</i> By default, <code>recursive_directory_iterator</code> does not +follow directory symlinks. To follow directory symlinks, specify <code>opt</code> +as <code>symlink_option::recurse</code> +<i>-- end note</i>]</p> +</blockquote> +<pre>int level() const;</pre> +<blockquote> + <p><i>Requires:</i> <code>*this != recursive_directory_iterator()</code>.</p> + <p><i>Returns:</i> <code>m_level</code>.</p> + <p><i>Throws:</i> Nothing.</p> +</blockquote> +<pre>bool <code>no_push_pending</code>() const;</pre> +<blockquote> + <p><i>Requires:</i> <code>*this != recursive_directory_iterator()</code>.</p> + <p><i>Returns:</i> <code>m_no_push</code>.</p> + <p><i>Throws:</i> Nothing.</p> +</blockquote> +<pre><code>recursive_directory_iterator</code>& <a name="recursive_directory_iterator-increment">operator++</a>(); +recursive_directory_iterator& increment(system::error_code& ec);</pre> +<blockquote> + +<p><i>Effects:</i> As specified by the C++ Standard, 24.1.1 Input iterators [input.iterators], +except:</p> + +<ul> + <li dir="ltr"> + +<p dir="ltr">if <code>!no_push_pending() && is_directory(this->status()) +&& (!is_symlink(this->symlink_status()) || (m_options +& symlink_option::recurse) != 0)</code> then <code>m_level</code> +is incremented and directory <code>(*this)->path()</code> is recursively iterated into.<br> + </p> + + </li> + <li>if there are no more directory entries at this level then <code>m_level</code> +is decremented and iteration of the parent directory resumes.</li> +</ul> + +<p><i>Postcondition:</i> <code>no_push_pending() == false</code>.</p> + +<p><i>Returns:</i> <code>*this</code>.</p> + +<p><i>Throws:</i> As specified in + <a href="#Error-reporting"> + Error reporting</a>.</p> + +</blockquote> +<pre>void pop();</pre> +<blockquote> + <p><i>Requires:</i> <code>*this != recursive_directory_iterator()</code>.</p> + <p><i>Effects:</i> If <code>level() == 0</code>, set <code>*this</code> to <code>recursive_directory_iterator()</code>. + Otherwise, <code>--m_level</code>, cease iteration of the directory currently being + iterated over, and continue iteration over the parent directory.</p> + <p><i>Throws:</i> Nothing.</p> +</blockquote> +<pre>void no_push(bool value=true);</pre> +<blockquote> + <p><i>Requires:</i> <code>*this != recursive_directory_iterator()</code>.</p> +<p><i>Postcondition:</i> <code>no_push_pending() == value</code>.</p> + <p><i>Throws:</i> Nothing.</p> + <p>[<i>Note:</i> <code>no_push()</code> is used to prevent + unwanted recursion into a directory. <i>--end note</i>]</p> +</blockquote> +<h3><a name="Operational-functions">Operational functions</a></h3> +<p>Operational functions query or modify files, including directories, in external +storage.</p> +<p style="font-size: 10pt">Operational functions access a file by resolving an +object of class <code>path</code> to a particular file in a file hierarchy. The +path is resolved as if by the <i>POSIX</i> +<a href="http://www.opengroup.org/onlinepubs/000095399/basedefs/xbd_chap04.html#tag_04_11"> +Pathname Resolution</a> mechanism.</p> +<p>[<i>Note: </i>Because hardware failures, network failures, +<a href="#Race-condition">race conditions</a>, and many +other kinds of errors occur frequently in file system operations, users should be aware +that any filesystem operational function, no matter how apparently innocuous, may encounter +an error. See <a href="#Error-reporting">Error reporting</a>. <i>-- end note</i>]</p> +<h4><a name="Function-specifications">Operational function specifications</a></h4> +<pre>path <a name="absolute">absolute</a>(const path& p, const path& base=current_path());</pre> + <blockquote> + <p><i>Returns:</i> A <a href="#Absolute-path">absolute path</a> composed according to the + following table</p> + <table border="1" cellpadding="5" cellspacing="0" bordercolor="#111111" style="border-collapse: collapse"> + <tr> + <td align="center"> </td> + <td align="center"><b><code>p.has_root_directory()</code></b></td> + <td align="center"><b><code>!p.has_root_directory()</code></b></td> + </tr> + <tr> + <td align="center"><b><code>p.has_root_name()</code></b></td> + <td align="center"><code>return p</code></td> + <td align="center"><code>return p.root_name() / + absolute(base).root_directory()<br> + / absolute(base).relative_path() / p.relative_path()</code></td> + </tr> + <tr> + <td align="center"><b><code>!p.has_root_name()</code></b></td> + <td align="center"><code>return absolute(base).root_name()<br> + / p</code></td> + <td align="center"><code>return absolute(base) / p</code></td> + </tr> + </table> + <p dir="ltr">[<i>Note:</i> For the returned path, <code>rp,</code> <code> + rp.is_absolute()</code> is true. <i>-- end note</i>]</p> + <p><i>Throws:</i> If <code>base.is_absolute()</code> is true, throws only if + memory allocation fails.</p> +</blockquote> +<pre>path <a name="canonical">canonical</a>(const path& p, const path& base = current_path()); +path canonical(const path& p, system::error_code& ec); +path canonical(const path& p, const path& base, system::error_code& ec);</pre> +<blockquote> +<p><i>Overview:</i> Converts <code>p</code>, which must exist, to an absolute +path that has no symbolic link, <a href="#Dot">dot</a>, +or <a href="#Dot">dot-dot</a> elements. </p> +<p><i>Returns:</i> A <a href="#Canonical-path">canonical path</a> that refers to +the same file system object as <code>absolute(p,base)</code>. For the overload +without a <code>base</code> argument, <code>base</code> is <code>current_path()</code>.</p> + <p><i>Throws:</i> As specified in + <a href="#Error-reporting"> + Error reporting</a>.</p> + + <p><i>Remarks:</i> <code>!exists(p)</code> is an error.</p> + + <p>[<i>Note:</i> Canonical pathnames allow security checking of a path (eg. + does this path live in /home/goodguy or /home/badguy?) -- end note]</p> + +</blockquote> +<pre>void <a name="copy">copy</a>(const path& from, const path& to); +void copy(const path& from, const path& to, system::error_code& ec);</pre> +<blockquote> + <p><i>Effects:</i> As if</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_option::fail_if_exists<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& from, const path& to); +void copy_directory(const path& from, const path& to, system::error_code& ec);</pre> +<blockquote> + <p><i>Effects: </i></p> + + <p><i>Throws:</i> As specified in + <a href="#Error-reporting"> + Error reporting</a>.</p> + +</blockquote> +<pre>void copy_file(const path& from, const path& to); +void copy_file(const path& from, const path& to, system::error_code& ec);</pre> +<blockquote> + <p><i>Effects: </i><code>copy_file(from, to, + copy_option::fail_if_exists</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_file">copy_file</a>(const path& from, const path& to, BOOST_SCOPED_ENUM(<a href="#copy_option">copy_option</a>) option); +void <a name="copy_file2">copy_file</a>(const path& from, const path& to, BOOST_SCOPED_ENUM(<a href="#copy_option">copy_option</a>) option, system::error_code& ec);</pre> +<blockquote> + <p><i>Effects:</i> If <code>option == copy_option::</code><code>fail_if_exists + && exists(to)</code>, an error is reported. 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>Throws:</i> As specified in + <a href="#Error-reporting"> + Error reporting</a>.</p> +</blockquote> +<pre>void <a name="copy_symlink">copy_symlink</a>(const path& existing_symlink, const path& new_symlink); +void copy_symlink(const path& existing_symlink, const path& new_symlink, system::error_code& ec);</pre> +<blockquote> + <p><i>Effects: </i><code>create_symlink(read_symlink(existing_symlink</code><i>[</i><code>, ec</code><i>]</i><code>), + new_symlink</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>bool <a name="create_directories">create_directories</a>(const path& p); +bool <a name="create_directories2">create_directories</a>(const path& p, system::error_code& ec);</pre> +<blockquote> + <p><i>Requires:</i> <code>p.empty() || <br> + forall px: px == p || is_parent(px, p): is_directory(px) || !exists( px )</code> + </p> + <p><i>Postcondition:</i> <code>is_directory(p)</code></p> + <p><i>Returns:</i> The value of <code>!exists(p)</code> prior to the + establishment of the postcondition.</p> + <p><i>Throws:</i> As specified in + <a href="#Error-reporting"> + Error reporting</a>.</p> +</blockquote> +<pre>bool <a name="create_directory">create_directory</a>(const path& p); +bool <a name="create_directory2">create_directory</a>(const path& p, system::error_code& ec);</pre> +<blockquote> + <p><i>Effects:</i> Attempts to create the directory <code>p</code> resolves to, + as if by<i> POSIX </i><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. </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> +</blockquote> +<pre>void <a name="create_directory_symlink">create_directory_symlink</a>(const path& to, const path& new_symlink); +void create_directory_symlink(const path& to, const path& new_symlink, system::error_code& ec);</pre> +<blockquote style="font-size: 10pt"> + <p style="font-size: 10pt"><i>Effects:</i> + Establishes the postcondition, as if by <i> + POSIX</i> + <code> + <a href="http://www.opengroup.org/onlinepubs/000095399/functions/symlink.html"> + symlink()</a></code>.</p> + <p style="font-size: 10pt"><i> + Postcondition:</i> <code>new_symlink</code> resolves to a symbolic link file that + contains an unspecified representation of <code>to</code>.</p> + <p style="font-size: 10pt"><i>Throws:</i> As specified in + <a href="#Error-reporting"> + Error reporting</a>.</p> + <p style="font-size: 10pt">[<i>Note:</i> + Some <b>operating systems</b>, such as Windows, require symlink creation to + identify that the link is to a directory. Portable code should use <code> + create_directory_symlink()</code> to create directory symlinks rather than + <code>create_symlink()</code> <i>-- end note</i>]</p> + <p>[<i>Note:</i> + Some <b>operating systems</b> do not support symbolic links at all or support + them only for regular files. Windows prior to Vista, for example, did not + support symbolic links. + Some <b>file systems</b> do not + support + symbolic links regardless of the operating system - the FAT system used on floppy discs, memory cards and flash + drives, + for example. Thus symbolic links should only be used if these situations are + not concerns, or if workarounds are provided. <i>-- end note</i>]</p> + </blockquote> +<pre>void <a name="create_hard_link">create_hard_link</a>(const path& to, const path& new_hard_link); +void <a name="create_hard_link2">create_hard_link</a>(const path& to, const path& new_hard_link, system::error_code& ec);</pre> +<blockquote> + <p><i>Effects:</i> Establishes the postcondition, as if by + <i>POSIX</i> + <code> + <a href="http://www.opengroup.org/onlinepubs/000095399/functions/link.html"> + link()</a></code>.</p> + <p><i>Postcondition:</i></p> + <ul> + <li> <code>exists(to) && + exists(</code><code>new_hard_link</code><code>) && equivalent(to, + + </code><code>new_hard_link</code><code>)</code></li> + <li>The contents of the file or directory + <code>to</code> resolves to are unchanged.</li> + </ul> + <p><i>Throws:</i> As specified in + <a href="#Error-reporting"> + Error reporting</a>.</p> + <p>[<i>Note:</i> + Some <b>operating systems</b> do not support hard links at all or support + them only for regular files. Some <b>file systems</b> do not support hard + links regardless of the operating system - the FAT system used on floppy + discs, memory cards and flash drives, for example. Some file systems limit the + number of links per file. Thus hard links should only be used if these + situations are not concerns, or if workarounds are provided. <i>-- end note</i>]</p> + </blockquote> +<pre>void <a name="create_symlink">create_symlink</a>(const path& to, const path& new_symlink); +void <a name="create_symlink2">create_symlink</a>(const path& to, const path& new_symlink, system::error_code& ec);</pre> +<blockquote style="font-size: 10pt"> + <p style="font-size: 10pt"><i>Effects:</i> + Establishes the postcondition, as if by <i> + POSIX</i> + <code> + <a href="http://www.opengroup.org/onlinepubs/000095399/functions/symlink.html"> + symlink()</a></code>.</p> + <p style="font-size: 10pt"><i> + Postcondition:</i> <code>new_symlink</code> resolves to a symbolic link file that + contains an unspecified representation of <code>to</code>.</p> + <p style="font-size: 10pt"><i>Throws:</i> As specified in + <a href="#Error-reporting"> + Error reporting</a>.</p> + <p>[<i>Note:</i> + Some <b>operating systems</b> do not support symbolic links at all or support + them only for regular files. Windows prior to Vista, for example, did not + support symbolic links. + Some <b>file systems</b> do not + support + symbolic links regardless of the operating system - the FAT system used on floppy discs, memory cards and flash + drives, + for example. Thus symbolic links should only be used if these situations are + not concerns, or if workarounds are provided. <i>-- end note</i>]</p> + </blockquote> +<pre>path <a name="current_path">current_path</a>(); +path <a name="current_path2">current_path</a>(system::error_code& ec);</pre> +<blockquote> + <p><i>Returns:</i> The current working directory path, as if by <i>POSIX</i> + <code> + <a href="http://www.opengroup.org/onlinepubs/000095399/functions/getcwd.html"> + getcwd()</a></code>. <code>is_absolute()</code> is true for the returned path.</p> + <p><i>Throws:</i> As specified in + <a href="#Error-reporting"> + Error reporting</a>.</p> + <p>[<i>Note: </i>The <code> + current_path()</code> name was chosen to emphasize that the return is a + path, not just a single directory name.</p> + <p>The current path as returned by many operating systems is a dangerous + global variable. It may be changed unexpectedly by a third-party or system + library functions, or by another thread. <i>-- end note</i>]</p> +</blockquote> +<pre>void current_path(const path& p); +void current_path(const path& p, system::error_code& ec);</pre> +<blockquote> + <p style="font-size: 10pt"><i>Effects:</i> + Establishes the postcondition, as if by <i> + POSIX</i> + <code> + <a href="http://www.opengroup.org/onlinepubs/000095399/functions/chdir.html"> + chdir()</a></code>.</p> +<p><i>Postcondition:</i> <code>equivalent(p, current_path())</code>.</p> +<p><i>Throws:</i> As specified in +<a href="#Error-reporting"> +Error reporting</a>.</p> + <p>[<i>Note: </i>The current path for many operating systems is a dangerous + global state. It may be changed unexpectedly by a third-party or system + library functions, or by another thread. <i>-- end note</i>]</p> +</blockquote> +<pre>bool <a name="exists">exists</a>(file_status s);</pre> +<blockquote> + <p><i>Returns:</i> + <code>status_known(s) && s.type() != file_not_found</code></p> + <p><i>Throws:</i> Nothing.</p> +</blockquote> +<pre>bool <a name="exists2">exists</a>(const path& p); +bool <a name="exists3">exists</a>(const path& p, system::error_code& ec);</pre> +<blockquote> + <p><i>Returns:</i> <code>exists(status(p))</code> or <code>exists(status(p, ec))</code>, + respectively.</p> +<p><i>Throws:</i> <code>filesystem_error</code>; overload with <code>error_code&</code> throws +nothing.</p> +</blockquote> +<pre><code>bool <a name="equivalent">equivalent</a>(const path& p1, const path& p2); +bool <a name="equivalent2">equivalent</a>(const path& p1, const path& p2, system::error_code& ec);</code></pre> +<blockquote style="font-size: 10pt"> + <p style="font-size: 10pt"><i>Effects:</i> Determines <code>file_status s1</code> + and <code>s2</code>, as if by <code>status(p1)</code> and <code>status(p2)</code>, + respectively.</p> + <p style="font-size: 10pt"><i>Returns:</i> <code>true</code>, if <code>sf1 == + sf2</code> and <code>p1</code> and <code>p2</code> resolve to the same file + system entity, else <code>false</code>.</p> + <blockquote> + <p style="font-size: 10pt">Two paths are considered to resolve to the same + file system entity if two candidate entities reside on the same device at the + same location. This is determined as if by the values of the <i>POSIX</i> + <code> + <a href="http://www.opengroup.org/onlinepubs/000095399/basedefs/sys/stat.h.html"> + stat</a></code> structure<code>,</code> obtained as if by <code> + <a href="http://www.opengroup.org/onlinepubs/000095399/functions/stat.html"> + stat()</a></code> for the two paths, having equal <code>st_dev</code> values + and equal <code>st_ino</code> values.</p> + <p style="font-size: 10pt">[<i>Note:</i> <i>POSIX</i> requires that <i>"st_dev</i> + must be unique within a Local Area Network". Conservative <i>POSIX</i> + implementations may also wish to check for equal <code>st_size</code> and + <code>st_mtime</code> values. <i>Windows</i> implementations may use <code> + GetFileInformationByHandle()</code> as a surrogate for <code>stat()</code>, + and consider "same" to be equal values for <code>dwVolumeSerialNumber</code>, + <code>nFileIndexHigh</code>, <code>nFileIndexLow</code>, <code>nFileSizeHigh</code>, + <code>nFileSizeLow</code>, <code>ftLastWriteTime.dwLowDateTime</code>, and + <code>ftLastWriteTime.dwHighDateTime</code>. <i>-- end note</i>]</p> + </blockquote> + <p style="font-size: 10pt"><i>Throws:</i> <code>filesystem_error</code> + if <code>(!exists(s1) && !exists(s2)) || (is_other(s1) && is_other(s2))</code>, + otherwise as specified in + <a href="#Error-reporting"> + Error reporting</a>.</p> +</blockquote> +<div dir="ltr"> +<pre>uintmax_t <a name="file_size">file_size</a>(const path& p); +uintmax_t <a name="file_size2">file_size</a>(const path& p, system::error_code& ec);</pre> +</div> +<blockquote> + <p> + <span style="background-color: #FFFF00">Remarks: </span> + </p> + <p><i>Returns:</i> If <code>exists(p) && is_regular_file(p)</code>, the size + in bytes + of the file <code>p</code> resolves to, determined as if by the value of + the <i>POSIX</i> <code> + <a href="http://www.opengroup.org/onlinepubs/000095399/basedefs/sys/stat.h.html">stat</a></code> structure member <code>st_size</code> + obtained as if by <i>POSIX</i> <code> + <a href="http://www.opengroup.org/onlinepubs/000095399/functions/stat.html">stat()</a></code>. + Otherwise, <code>static_cast<uintmax_t>(-1)</code>.</p> + <p style="font-size: 10pt"><i>Throws:</i> As specified in + <a href="#Error-reporting"> + Error reporting</a>.</p> +</blockquote> +<pre>uintmax_t <a name="hard_link_count">hard_link_count</a>(const path& p); +uintmax_t hard_link_count(const path& p, system::error_code& ec);</pre> +<blockquote> + + <p><i>Returns:</i> The number of hard links for <code>p</code>.</p> + <p style="font-size: 10pt"><i>Throws:</i> As specified in + <a href="#Error-reporting"> + Error reporting</a>.</p> + +</blockquote> + +<pre>const path& <a name="initial_path">initial_path</a>(); +const path& <a name="initial_path">initial_path</a>(<code>system::error_code& ec</code>);</pre> +<blockquote> + <p><i>Returns:</i> + <code>current_path()</code> as of the first call to <code>initial_path()</code>.</p> + <p>[<i>Note:</i> <code> + initial_path()</code> is not thread safe, and may return an undesirable result + if called subsequent to a change to the current directory. These problems can + be avoided by calling <code>initial_path()</code> immediately on entry to + main(). <i>--end note</i>]</p> + <p><i>Throws:</i> For the first call, as specified in + <a href="#Error-reporting"> + Error reporting</a>. Subsequent calls throw nothing.</p> +</blockquote> +<pre>bool <code><a name="is_directory">is_directory</a></code>(file_status s);</pre> +<blockquote> + <p><i>Returns:</i> + <code>s.type() == directory_file</code></p> + <p><i>Throws:</i> Nothing.</p> +</blockquote> +<pre><code>bool <a name="is_directory2">is_directory</a>(const path& p); +bool <a name="is_directory3">is_directory</a>(const path& p, system::error_code& ec);</code></pre> +<blockquote> + <p dir="ltr"><i>Returns:</i> <code>is_directory(status(p))</code> or <code>is_directory(status(p, ec))</code>, + respectively.</p> +<p><i>Throws:</i> <code>filesystem_error</code>; overload with <code>error_code&</code> throws +nothing.</p> +</blockquote> +<pre><code>bool <a name="is_empty">is_empty</a>(const path& p); +bool <a name="is_empty2">is_empty</a></a>(const path& p, system::error_code& ec);</code></pre> +<blockquote> + <p><i>Effects:</i> Determines <code>file_status s</code>, as if by <code> + status(p, ec)</code>.</p> + <p><i>Returns:</i> <code>is_directory(s)<br> + ? + directory_iterator(p) == directory_iterator()<br> + : file_size(p) == 0;</code></p> +</blockquote> +<pre>bool <code><a name="is_regular_file">is_regular_file</a></code>(file_status s);</pre> +<blockquote> + <p><i>Returns:</i> + <code>s.type() == regular_file</code></p> + <p><i>Throws:</i> Nothing.</p> +</blockquote> +<pre><code>bool <a name="is_regular_file2">is_regular_file</a>(const path& p);</code></pre> +<blockquote> + <p><i>Returns:</i> <code>is_regular_file(status(p))</code>.</p> + <p><i>Throws:</i> <code>filesystem_error</code> + if <code>status(p)</code> would throw <code>filesystem_error.</code></p> + </blockquote> +<pre><code>bool <a name="is_regular_file3">is_regular_file</a>(const path& p, system::error_code& ec);</code></pre> +<blockquote> + <p><i>Effects:</i> Sets <code>ec</code> as if by <code>status(p, ec)</code>. [<i>Note:</i> + <code>status_error</code>, + <code>file_not_found</code> + and + <code>type_unknown</code> + cases set <code>ec</code> + to error values. To distinguish between cases, call the <code> + status</code> + function directly. <i>-- end + note</i>] </p> + <p><i>Returns:</i> <code>is_regular_file(status(p, ec))</code>.</p> + <p><i>Throws:</i> Nothing.</p> +</blockquote> +<pre>bool <a name="is_other">is_other</a>(file_status s);</pre> +<blockquote> + <p><i>Returns:</i> + <code>return exists(s) && !is_regular_file(s) && !is_directory(s) && !is_symlink(s)</code></p> + <p><i>Throws:</i> Nothing.</p> +</blockquote> +<pre><code>bool <a name="is_other2">is_other</a>(const path& p); +bool <a name="is_other3">is_other</a>(const path& p, system::error_code& ec);</code></pre> +<blockquote> + <p><i>Returns:</i> <code>is_other(status(p))</code> or <code>is_other(status(p, ec))</code>, + respectively.</p> + <p><i>Throws:</i> <code>filesystem_error</code>; overload with <code>error_code&</code> throws + nothing.</p> +</blockquote> +<pre>bool <a name="is_symlink">is_symlink</a>(file_status s);</pre> +<blockquote> + <p><i>Returns:</i> + <code>s.type() == symlink_file</code></p> + <p><i>Throws:</i> Nothing.</p> +</blockquote> +<pre><code>bool <a name="is_symlink2">is_symlink</a>(const path& p); +bool <a name="is_symlink3">is_symlink</a>(const path& p, system::error_code& ec);</code></pre> +<blockquote> + <p><i>Returns:</i> <code>is_symlink(symlink_status(p))</code> or <code>is_symlink(symlink_status(p, ec))</code>, + respectively.</p> + <p><i>Throws:</i> <code>filesystem_error</code>; overload with <code>error_code&</code> throws + nothing.</p> +</blockquote> +<pre>std::time_t <a name="last_write_time">last_write_time</a>(const path& p); +std::time_t <a name="last_write_time2">last_write_time</a>(const path& p<code>, system::error_code& ec</code>);</pre> +<blockquote> + <p><i>Returns:</i> The time of last data modification of <code>p</code>, determined as if by the + value of the <i>POSIX</i> <code> + <a href="http://www.opengroup.org/onlinepubs/000095399/basedefs/sys/stat.h.html">stat</a></code> structure member <code>st_mtime</code> obtained + as if by <i>POSIX</i> <code> + <a href="http://www.opengroup.org/onlinepubs/000095399/functions/stat.html">stat()</a></code>.</p> +</blockquote> +<pre>void <a name="last_write_time3">last_write_time</a>(const path& p, const std::time_t new_time); +void <a name="last_write_time4">last_write_time</a>(const path& p, const std::time_t new_time<code>, system::error_code& ec</code>);</pre> +<blockquote> + <p><i>Effects:</i> Sets the time of last data modification of the file + resolved to by <code>p</code> + to <code>new_time</code>, as if by <i>POSIX</i> <code> + <a href="http://www.opengroup.org/onlinepubs/000095399/functions/stat.html">stat()</a></code> + followed by <i>POSIX</i> + <a href="http://www.opengroup.org/onlinepubs/000095399/functions/utime.html"> + <code>utime()</code></a>.</p> + <p><i>Throws:</i> As specified in + <a href="#Error-reporting"> + Error reporting</a>.</p> + <p>[<i>Note:</i> A postcondition of <code>last_write_time(p) == + new_time</code> is not specified since it might not hold for file systems + with coarse time granularity. <i>-- end note</i>]</p> +</blockquote> +<pre>void permissions(const path& p, <a href="#symlink_perms">perms</a> prms); +void permissions(const path& p, <a href="#symlink_perms">perms</a> prms, system::error_code& ec);</pre> +<blockquote> + <p dir="ltr">Applies an operating system set of permissions to a file. See + <a href="#symlink_perms">perms</a> for specifics.<br> + <i><br> + Requires:</i> <code>!((prms & add_perms) && (prms & remove_perms))</code>.</p> + <p dir="ltr"><i>Effects:</i> Applies the effective permissions bits from <code> + prms</code> to the file <code>p</code> resolves to, as if by <i>POSIX</i> + <code> + <a href="http://pubs.opengroup.org/onlinepubs/9699919799/functions/fchmodat.html"> + fchmodat()</a></code>. The effective permission bits are determined as + specified by the following table. </p> + <table border="1" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111"> + <tr> + <td><b>bits present in <code>prms</code></b></td> + <td><b>Effective bits applied</b></td> + </tr> + <tr> + <td>Neither <code>add_perms</code> nor <code>remove_perms</code></td> + <td><code>prms & perms_mask</code></td> + </tr> + <tr> + <td><code>add_perms</code></td> + <td> + <p dir="ltr">current_status.permissions() | (<code>prms & perms_mask</code>) + </td> + </tr> + <tr> + <td><code>remove_perms</code></td> + <td>current_status.permissions() & ~(<code>prms & perms_mask</code>) </td> + </tr> + </table> + <p>[<i>Note:</i> Conceptually permissions are viewed as bits, but the actual + implementation by a file system may use some other mechanism. -- <i>end note</i>]</p> +</blockquote> +<pre>path <a name="read_symlink">read_symlink</a>(const path& p); +path read_symlink(const path& p, system::error_code& ec);</pre> +<blockquote> + <p dir="ltr"><i>Returns:</i> If <code>p</code> resolves to a symbolic + link, a <code>path</code> object containing the contents of that symbolic + link. Otherwise an empty <code>path</code> object.</p> + <p><i>Throws:</i> As specified in + <a href="#Error-reporting"> + Error reporting</a>. [<i>Note:</i> It is an error if <code>p</code> does not + resolve to a symbolic link. <i>-- end note</i>]</p> +</blockquote> +<pre>bool <a name="remove">remove</a>(const path& p); +bool <a name="remove2">remove</a>(const path& p, system::error_code& ec);</pre> +<blockquote> + <p><i>Effects:</i> If <code>exists(symlink_status(p,ec))</code>, it is + removed + as if by<i> POSIX </i><code> + <a href="http://www.opengroup.org/onlinepubs/000095399/functions/remove.html">remove()</a></code>.</p> + <blockquote> + <p>[<i>Note:</i> A symbolic link is itself removed, rather than the file it + resolves to being removed. <i>-- end note</i>]</p> + </blockquote> + <p><i>Postcondition:</i> <code>!exists(symlink_status(p))</code>.</p> + <p><i>Returns:</i> <code>false</code> if p did not exist in the first + place, otherwise <code>true</code>.</p> + <p><i>Throws:</i> As specified in + <a href="#Error-reporting"> + Error reporting</a>.</p> +</blockquote> +<pre>uintmax_t <a name="remove_all">remove_all</a>(const path& p); +uintmax_t <a name="remove_all2">remove_all</a>(const path& p, system::error_code& ec);</pre> +<blockquote> + <p><i>Effects:</i> Recursively deletes the contents of p if it exists, + then deletes file <code>p</code> itself, + as if by<i> POSIX </i><code> + <a href="http://www.opengroup.org/onlinepubs/000095399/functions/remove.html">remove()</a></code>.</p> + <blockquote> + <p>[<i>Note:</i> A symbolic link is itself removed, rather than the file it + resolves to being removed. <i>-- end note</i>]</p> + </blockquote> + <p><i>Postcondition:</i> <code>!exists(p)</code></p> + <p><i>Returns:</i> The number of files removed.</p> + <p><i>Throws:</i> As specified in + <a href="#Error-reporting"> + Error reporting</a>.</p> +</blockquote> +<pre>void <a name="rename">rename</a>(const path& old_p, const path& new_p); +void <a name="rename2">rename</a>(const path& old_p, const path& new_p, system::error_code& ec);</pre> +<blockquote> + <p><i>Effects:</i> Renames <code>old_p</code> to <code>new_p</code>, as if by + <i>POSIX</i> <code> + <a href="http://www.opengroup.org/onlinepubs/000095399/functions/rename.html"> + rename()</a></code>.</p> + <blockquote> + <p>[<i>Note:</i> If <code>old_p</code> and <code>new_p</code> resolve to the + same existing file, no action is taken. Otherwise, if <code>new_p</code> resolves to an + existing non-directory file, it is removed, while if <code>new_p</code> resolves to an + existing directory, it is removed if empty on POSIX but is an error on Windows. A symbolic link is itself renamed, rather than + the file it resolves to being renamed. <i>-- end note</i>]</p> + </blockquote> + <p><i>Throws:</i> As specified in + <a href="#Error-reporting"> + Error reporting</a>.</p> +</blockquote> +<pre>void <a name="resize_file">resize_file</a>(const path& p, uintmax_t new_size); +void <a name="resize_file2">resize_file</a>(const path& p, uintmax_t new_size, system::error_code& ec);</pre> +<blockquote> +<p><i>Postcondition:</i> <code>file_size() == new_size</code>.</p> +<p><i>Throws:</i> As specified in +<a href="#Error-reporting"> +Error reporting</a>.</p> + <p style="font-size: 10pt"><i>Remarks:</i> Achieves its postconditions as if by + POSIX <code> + <a href="http://www.opengroup.org/onlinepubs/000095399/functions/truncate.html"> + truncate()</a></code>.</p> +</blockquote> +<pre>space_info <a name="space">space</a>(const path& p); +space_info <a name="space2">space</a>(const path& p, system::error_code& ec);</pre> +<blockquote> + <p><i>Returns:</i> An object of type <code> + <a href="#space_info">space_info</a></code>. The value of the <code>space_info</code> object is determined as if by + using <i>POSIX</i> <code> + <a href="http://www.opengroup.org/onlinepubs/000095399/functions/statvfs.html" style="text-decoration: none"> + statvfs()</a></code> to obtain a <i>POSIX</i> struct <code> + <a href="http://www.opengroup.org/onlinepubs/000095399/basedefs/sys/statvfs.h.html" style="text-decoration: none"> + statvfs</a></code>, and then multiplying its <code>f_blocks</code>, <code> + f_bfree</code>, and <code>f_bavail</code> members by its <code>f_frsize</code> + member, and assigning the results to the <code>capacity</code>, <code>free</code>, + and <code>available</code> members respectively. Any members for which the + value cannot be determined shall be set to -1.</p> + <p><i>Throws:</i> As specified in + <a href="#Error-reporting"> + Error reporting</a>.</p> +</blockquote> +<pre><a href="#file_status">file_status</a> <a name="status">status</a>(const path& p);</pre> +<blockquote> + <p><i>Effects: </i>As if:</p> + <blockquote> + <pre>system::error_code ec; +file_status result = status(p, ec); +if (result == status_error) + throw filesystem_error(<i>implementation-supplied-message</i>, p, ec); +return result;</pre> + </blockquote> + <p><i>Returns:</i> See above.</p> + <p><i>Throws:</i> <code>filesystem_error</code>. +[<i>Note:</i> <code>result</code> values of <code> + file_status(file_not_found)</code>and <code> + file_status(type_unknown)</code> are not considered failures and do not + cause an exception to be +thrown.<i> -- end note</i>] </p> + </blockquote> +<pre><a href="#file_status">file_status</a> <a name="status2">status</a>(const path& p, system::error_code& ec);</pre> +<blockquote> + <p><i>Effects: </i></p> + <blockquote> + <p>If possible, determines the attributes + of the file + <code>p</code> resolves to, as if by<i> POSIX </i> <code> + <a href="http://www.opengroup.org/onlinepubs/000095399/functions/stat.html">stat()</a></code>.</p> + If, during attribute determination, the underlying file system API reports + an error, sets <code>ec</code> to indicate the specific error reported. + Otherwise, <code>ec.clear()</code>.<blockquote> + <p>[<i>Note:</i> This allows users to inspect the specifics of underlying + API errors even when the value returned by <code>status()</code> is not <code> + file_status(status_error)</code>. <i>--end note</i>]</p> + </blockquote> + </blockquote> + <p><i>Returns:</i></p> + <blockquote> + <p>If <code>ec != error_code()</code>:</p> + <ul> + <li>If the specific error indicates that <code>p</code> cannot be resolved + because some element of the path does not exist, return <code> + file_status(file_not_found)</code>. [<i>Note:</i> POSIX errors that + indicate this are ENOENT or ENOTDIR. Windows equivalents + include ERROR_FILE_NOT_FOUND, ERROR_PATH_NOT_FOUND, ERROR_INVALID_NAME, + ERROR_INVALID_PARAMETER, ERROR_BAD_PATHNAME, and ERROR_BAD_NETPATH. <i>-- + end note</i>]<br> + </li> + <li>Otherwise, if the specific error indicates that <code>p</code> can be resolved + but the attributes cannot be determined, return <code> + file_status(type_unknown)</code>. [<i>Note: </i>For example, Windows + ERROR_SHARING_VIOLATION errors. For POSIX, the case never arises. <i>-- end + note</i>]<br> + </li> + <li>Otherwise, return <code> + file_status(status_error)</code>.</li> + </ul> + <blockquote> + <p>[<i>Note:</i> These semantics distinguish between + <code>p</code> being known not to exist, + <code>p</code> existing but not being able to determine its attributes, + and there being an error that prevents even knowing if + <code>p</code> exists. These + distinctions are important to some use cases. <i>--end note</i>]</p> + </blockquote> + <p>Otherwise,</p> + <ul> + <li>If the attributes indicate a regular file, as if by <i>POSIX</i> <a href="http://www.opengroup.org/onlinepubs/000095399/basedefs/sys/stat.h.html">S_ISREG()</a>, + return <code> + file_status(regular_file)</code>. [<i>Note:</i> <code> +regular_file</code> implies appropriate <code><fstream></code> operations + would succeed, assuming no hardware, permission, access, or race condition + errors. Lack of +<code>regular_file</code> does not necessarily imply <code><fstream></code> operations would +fail on a directory. +<i>-- end note</i>]<br> + </li> + <li>Otherwise, if the attributes indicate a directory, as if by <i>POSIX</i> + <a href="http://www.opengroup.org/onlinepubs/000095399/basedefs/sys/stat.h.html">S_ISDIR()</a>, + return <code> + file_status(directory_file)</code>. [<i>Note:</i> <code>directory_file</code> implies <code> +directory_iterator(p)</code>would succeed. +<i>-- end note</i>]<br> + </li> + <li>Otherwise, if the attributes indicate a block special file, as if by <i>POSIX</i> + <a href="http://www.opengroup.org/onlinepubs/000095399/basedefs/sys/stat.h.html">S_ISBLK()</a>, + return <code> + file_status(block_file)</code>.<br> + </li> + <li>Otherwise, if the attributes indicate a character special file, as if by <i>POSIX</i> + <a href="http://www.opengroup.org/onlinepubs/000095399/basedefs/sys/stat.h.html">S_ISCHR()</a>, + return <code> + file_status(character_file)</code>.<br> + </li> + <li>Otherwise, if the attributes indicate a fifo or pipe file, as if by <i>POSIX</i> + <a href="http://www.opengroup.org/onlinepubs/000095399/basedefs/sys/stat.h.html">S_ISFIFO()</a>, + return <code> + file_status(fifo_file)</code>.<br> + </li> + <li>Otherwise, if the attributes indicate a socket, as if by <i>POSIX</i> + <a href="http://www.opengroup.org/onlinepubs/000095399/basedefs/sys/stat.h.html">S_ISSOCK()</a>, + return <code> + file_status(socket_file)</code>.<br> + </li> + <li>Otherwise, return <code> + file_status(type_unknown)</code>.</li> + </ul> + </blockquote> +<p><i>Throws:</i> Nothing.</p> + <p><i>Remarks:</i> If a symbolic link is encountered during pathname + resolution, + pathname resolution continues using the contents of the symbolic link.</p> +</blockquote> +<pre>bool <a name="status_known">status_known</a>(file_status s);</pre> +<blockquote> + <p><i>Returns:</i> + <code>s.type() != status_error</code></p> + <p><i>Throws:</i> Nothing.</p> +</blockquote> +<pre>file_status <a name="symlink_status">symlink_status</a>(const path& p); +file_status <a name="symlink_status2">symlink_status</a>(const path& p, system::error_code& ec);</pre> +<blockquote> + <p><i>Effects:</i> Same as <a href="#status">status()</a>, above, + except that the attributes + of + <code>p</code> are determined as if by<i> POSIX </i> <code> + <a href="http://www.opengroup.org/onlinepubs/000095399/functions/lstat.html"> + lstat()</a></code>.</p> +</blockquote> +<blockquote> + <p><i>Returns:</i> Same as <a href="#status">status()</a>, above, except + that if the attributes indicate a symbolic link, as if by <i>POSIX</i> + <a class="external" href="http://www.opengroup.org/onlinepubs/000095399/basedefs/sys/stat.h.html"> + S_ISLNK()</a>, return <code>file_status(symlink_file)</code>.</p> +<p><i>Throws:</i> Nothing.</p> + <p><i>Remarks:</i> Pathname resolution terminates if <code>p</code> names a symbolic link.</p> +</blockquote> +<pre>path <a name="system_complete">system_complete</a>(const path& p); +path <a name="system_complete2">system_complete</a>(const path& p, system::error_code& ec);</pre> +<blockquote> + <p><i>Effects:</i> Composes an absolute path from <code>p</code>, using the + same rules used by the operating system to resolve a path passed as the + filename argument to standard library open functions.</p> + <p><i>Returns:</i> The composed path.</p> + <p><i>Postcondition:</i> For the returned path, <code>rp,</code> <code> + rp.is_absolute()</code> is true.</p> + <p>[<i>Note:</i> For <i>POSIX</i>, <code>system_complete(p)</code> has the same semantics as + <code>complete(p, current_path())</code>.</p> + <p><a name="windows_effects">For <i>Windows</i></a>, <code>system_complete(p)</code> has the + same semantics as <code>complete(ph, current_path())</code> if + <code>p.is_absolute() || !p.has_root_name()</code> or <code>p</code> and <code>base</code> have the same + <code>root_name()</code>. + Otherwise it acts like <code>complete(p, kinky)</code>, where <code>kinky</code> + is the current directory for the <code>p.root_name()</code> drive. This will + be the current directory of that drive the last time it was set, and thus may + be <b>residue left over from a prior program</b> run by the command + processor! Although these semantics are often useful, they are also very + error-prone.</p> + <p>See <a href="#complete_note"> + <i>complete()</i> note</a> for usage suggestions. <i>-- end note</i>]</p> +</blockquote> +<pre>path <a name="temp_directory_path">temp_directory_path</a>(); +path temp_directory_path(system::error_code& ec);</pre> +<blockquote> + <p><i>Returns:</i> A directory path suitable for temporary files under the + conventions of the operating system. The specifics of how this path is + determined are implementation defined. An error shall be reported if<code> !exists(p) + || !is_directory(p)</code>, where <code>p</code> is the path to be returned.</p> + <p><i>POSIX:</i> The path supplied by the first environment variable found in the + list TMPDIR, TMP, TEMP, TEMPDIR. If none of these are found, <code>"/tmp"</code>.</p> + <p><i>Windows:</i> The path reported by the <i>Windows</i> <code>GetTempPath</code> API function.</p> + <p><i>Throws:</i> As specified in <a href="#Error-reporting"> + Error reporting</a>.</p> + <p>[<i>Note: </i>The <code>temp_directory_path()</code> name was chosen to emphasize that the return is a + path, not just a single directory name. <i>-- end note</i>]</p> +</blockquote> +<pre>path <a name="unique_path">unique_path</a>(const path& model="%%%%-%%%%-%%%%-%%%%"); +path unique_path(const path& model, system::error_code& ec);</pre> +<blockquote> + <p>The <code>unique_path</code> function generates a path name suitable for + creating temporary files, including directories. The name is based + on a model that uses the percent sign character to specify replacement by a + random hexadecimal digit. [<i>Note:</i> The more bits of randomness in the + generated path name, the less likelihood of prior existence or being guessed. + Each replacement hexadecimal digit in the model adds four bits of randomness. + The default model thus provides 64 bits of randomness. This is sufficient for + most applications. <i>--end note</i>]</p> + <p><i>Returns:</i> A path identical to <code>model</code>, except that each + occurrence of a percent sign character is replaced by a random hexadecimal + digit character in the range 0-9, a-f.</p> + <p><i>Throws:</i> As specified in + <a href="#Error-reporting"> + Error reporting</a>.</p> + <p><i>Remarks:</i> Implementations are encouraged to obtain the required + randomness via a + <a href="http://en.wikipedia.org/wiki/Cryptographically_secure_pseudorandom_number_generator"> + cryptographically secure pseudo-random number generator</a>, such as one + provided by the operating system. [<i>Note</i>: Such generators may block + until sufficient entropy develops. <i>--end note</i>]</p> +</blockquote> +<h3><a name="File-streams">File streams</a> - +<a href="../../../../boost/filesystem/fstream.hpp"><boost/filesystem/fstream.hpp></a></h3> +<p>Replacements are provided for the file stream classes from the C++ standard +library's <code><fstream></code> header. These replacement classes +publicly inherit from the standard library classes. In the Boost.Filesystem +version, constructors and open functions take <code>const path&</code> arguments +instead of <code> +const char*</code> arguments. There are no other differences in syntax or +semantics.</p> +<pre>namespace boost +{ + namespace filesystem + { + template < class charT, class traits = std::char_traits<charT> > + class basic_filebuf : public std::basic_filebuf<charT,traits> + { + public: + basic_filebuf<charT,traits>* + open(const path& p, std::ios_base::openmode mode); + }; + + template < class charT, class traits = std::char_traits<charT> > + class basic_ifstream : public std::basic_ifstream<charT,traits> + { + public: + explicit basic_ifstream(const path& p, std::ios_base::openmode mode=std::ios_base::in) + void open(const path& p, std::ios_base::openmode mode=std::ios_base::in); + }; + + template < class charT, class traits = std::char_traits<charT> > + class basic_ofstream : public std::basic_ofstream<charT,traits> + { + public: + explicit basic_ofstream(const path& p, std::ios_base::openmode mode=std::ios_base::out); + void open(const path& p, std::ios_base::openmode mode=std::ios_base::out); + }; + + template < class charT, class traits = std::char_traits<charT> > + class basic_fstream : public std::basic_fstream<charT,traits> + { + public: + explicit basic_fstream(const path& p, + std::ios_base::openmode mode=std::ios_base::in | std::ios_base::out); + void open(const path& p, + std::ios_base::openmode mode=std::ios_base::in | std::ios_base::out); + }; + + typedef basic_filebuf<char> filebuf; + typedef basic_ifstream<char> ifstream; + typedef basic_ofstream<char> ofstream; + typedef basic_fstream<char> fstream; + + typedef basic_filebuf<wchar_t> wfilebuf; + typedef basic_ifstream<wchar_t> wifstream; + typedef basic_fstream<wchar_t> wfstream; + typedef basic_ofstream<wchar_t> wofstream; + + } // namespace filesystem +} // namespace boost</pre> +<h2><a name="Path-decomposition-table">Path decomposition table</a></h2> +<p>The table is generated by a program compiled with the Boost implementation.</p> +<p>Shaded entries indicate cases where <i>POSIX</i> and <i>Windows</i> +implementations yield different results. The top value is the +<i>POSIX</i> result and the bottom value is the <i>Windows</i> result. <br> +<table border="1" cellspacing="0" cellpadding="5"> +<p> +<tr><td><b>Constructor<br>argument</b></td> +<td><b>Iteration<br>over<br>Elements</b></td> +<td><b><code>string()</code></b></td> +<td><b><code>generic_<br>string()</code></b></td> +<td><b><code>root_<br>path()</code></b></td> +<td><b><code>root_<br>name()</code></b></td> +<td><b><code>root_<br>directory()</code></b></td> +<td><b><code>relative_<br>path()</code></b></td> +<td><b><code>parent_<br>path()</code></b></td> +<td><b><code>filename()</code></b></td> +</tr> +<tr> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +</tr> +<tr> +<td><code>.</code></td> +<td><code>.</code></td> +<td><code>.</code></td> +<td><code>.</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>.</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>.</code></td> +</tr> +<tr> +<td><code>..</code></td> +<td><code>..</code></td> +<td><code>..</code></td> +<td><code>..</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>..</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>..</code></td> +</tr> +<tr> +<td><code>foo</code></td> +<td><code>foo</code></td> +<td><code>foo</code></td> +<td><code>foo</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>foo</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>foo</code></td> +</tr> +<tr> +<td><code>/</code></td> +<td><code>/</code></td> +<td><code>/</code></td> +<td><code>/</code></td> +<td><code>/</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>/</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>/</code></td> +</tr> +<tr> +<td><code>/foo</code></td> +<td><code>/,foo</code></td> +<td><code>/foo</code></td> +<td><code>/foo</code></td> +<td><code>/</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>/</code></td> +<td><code>foo</code></td> +<td><code>/</code></td> +<td><code>foo</code></td> +</tr> +<tr> +<td><code>foo/</code></td> +<td><code>foo,.</code></td> +<td><code>foo/</code></td> +<td><code>foo/</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>foo/</code></td> +<td><code>foo</code></td> +<td><code>.</code></td> +</tr> +<tr> +<td><code>/foo/</code></td> +<td><code>/,foo,.</code></td> +<td><code>/foo/</code></td> +<td><code>/foo/</code></td> +<td><code>/</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>/</code></td> +<td><code>foo/</code></td> +<td><code>/foo</code></td> +<td><code>.</code></td> +</tr> +<tr> +<td><code>foo/bar</code></td> +<td><code>foo,bar</code></td> +<td><code>foo/bar</code></td> +<td><code>foo/bar</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>foo/bar</code></td> +<td><code>foo</code></td> +<td><code>bar</code></td> +</tr> +<tr> +<td><code>/foo/bar</code></td> +<td><code>/,foo,bar</code></td> +<td><code>/foo/bar</code></td> +<td><code>/foo/bar</code></td> +<td><code>/</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>/</code></td> +<td><code>foo/bar</code></td> +<td><code>/foo</code></td> +<td><code>bar</code></td> +</tr> +<tr> +<td><code>//net</code></td> +<td><code>//net</code></td> +<td><code>//net</code></td> +<td><code>//net</code></td> +<td><code>//net</code></td> +<td><code>//net</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>//net</code></td> +</tr> +<tr> +<td><code>//net/foo</code></td> +<td><code>//net,/,foo</code></td> +<td><code>//net/foo</code></td> +<td><code>//net/foo</code></td> +<td><code>//net/</code></td> +<td><code>//net</code></td> +<td><code>/</code></td> +<td><code>foo</code></td> +<td><code>//net/</code></td> +<td><code>foo</code></td> +</tr> +<tr> +<td><code>///foo///</code></td> +<td><code>/,foo,.</code></td> +<td><code>///foo///</code></td> +<td><code>///foo///</code></td> +<td><code>/</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>/</code></td> +<td><code>foo///</code></td> +<td><code>///foo</code></td> +<td><code>.</code></td> +</tr> +<tr> +<td><code>///foo///bar</code></td> +<td><code>/,foo,bar</code></td> +<td><code>///foo///bar</code></td> +<td><code>///foo///bar</code></td> +<td><code>/</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>/</code></td> +<td><code>foo///bar</code></td> +<td><code>///foo</code></td> +<td><code>bar</code></td> +</tr> +<tr> +<td><code>/.</code></td> +<td><code>/,.</code></td> +<td><code>/.</code></td> +<td><code>/.</code></td> +<td><code>/</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>/</code></td> +<td><code>.</code></td> +<td><code>/</code></td> +<td><code>.</code></td> +</tr> +<tr> +<td><code>./</code></td> +<td><code>.,.</code></td> +<td><code>./</code></td> +<td><code>./</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>./</code></td> +<td><code>.</code></td> +<td><code>.</code></td> +</tr> +<tr> +<td><code>/..</code></td> +<td><code>/,..</code></td> +<td><code>/..</code></td> +<td><code>/..</code></td> +<td><code>/</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>/</code></td> +<td><code>..</code></td> +<td><code>/</code></td> +<td><code>..</code></td> +</tr> +<tr> +<td><code>../</code></td> +<td><code>..,.</code></td> +<td><code>../</code></td> +<td><code>../</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>../</code></td> +<td><code>..</code></td> +<td><code>.</code></td> +</tr> +<tr> +<td><code>foo/.</code></td> +<td><code>foo,.</code></td> +<td><code>foo/.</code></td> +<td><code>foo/.</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>foo/.</code></td> +<td><code>foo</code></td> +<td><code>.</code></td> +</tr> +<tr> +<td><code>foo/..</code></td> +<td><code>foo,..</code></td> +<td><code>foo/..</code></td> +<td><code>foo/..</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>foo/..</code></td> +<td><code>foo</code></td> +<td><code>..</code></td> +</tr> +<tr> +<td><code>foo/./</code></td> +<td><code>foo,.,.</code></td> +<td><code>foo/./</code></td> +<td><code>foo/./</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>foo/./</code></td> +<td><code>foo/.</code></td> +<td><code>.</code></td> +</tr> +<tr> +<td><code>foo/./bar</code></td> +<td><code>foo,.,bar</code></td> +<td><code>foo/./bar</code></td> +<td><code>foo/./bar</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>foo/./bar</code></td> +<td><code>foo/.</code></td> +<td><code>bar</code></td> +</tr> +<tr> +<td><code>foo/..</code></td> +<td><code>foo,..</code></td> +<td><code>foo/..</code></td> +<td><code>foo/..</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>foo/..</code></td> +<td><code>foo</code></td> +<td><code>..</code></td> +</tr> +<tr> +<td><code>foo/../</code></td> +<td><code>foo,..,.</code></td> +<td><code>foo/../</code></td> +<td><code>foo/../</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>foo/../</code></td> +<td><code>foo/..</code></td> +<td><code>.</code></td> +</tr> +<tr> +<td><code>foo/../bar</code></td> +<td><code>foo,..,bar</code></td> +<td><code>foo/../bar</code></td> +<td><code>foo/../bar</code></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>foo/../bar</code></td> +<td><code>foo/..</code></td> +<td><code>bar</code></td> +</tr> +<tr> +<td><code>c:</code></td> +<td><code>c:</code></td> +<td><code>c:</code></td> +<td><code>c:</code></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:</code></span></td> +<td><font size="-1"><i>empty</i></font></td> +<td><span style="background-color: #CCFFCC"><code>c:</code><br><font size="-1"><i>empty</i></font></span></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>c:</code></td> +</tr> +<tr> +<td><code>c:/</code></td> +<td><span style="background-color: #CCFFCC"><code>c:,.</code><br><code>c:,/</code></span></td> +<td><code>c:/</code></td> +<td><code>c:/</code></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:/</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>/</code></span></td> +<td><span style="background-color: #CCFFCC"><code>c:/</code><br><font size="-1"><i>empty</i></font></span></td> +<td><code>c:</code></td> +<td><span style="background-color: #CCFFCC"><code>.</code><br><code>/</code></span></td> +</tr> +<tr> +<td><code>c:foo</code></td> +<td><span style="background-color: #CCFFCC"><code>c:foo</code><br><code>c:,foo</code></span></td> +<td><code>c:foo</code></td> +<td><code>c:foo</code></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:</code></span></td> +<td><font size="-1"><i>empty</i></font></td> +<td><span style="background-color: #CCFFCC"><code>c:foo</code><br><code>foo</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:</code></span></td> +<td><span style="background-color: #CCFFCC"><code>c:foo</code><br><code>foo</code></span></td> +</tr> +<tr> +<td><code>c:/foo</code></td> +<td><span style="background-color: #CCFFCC"><code>c:,foo</code><br><code>c:,/,foo</code></span></td> +<td><code>c:/foo</code></td> +<td><code>c:/foo</code></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:/</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>/</code></span></td> +<td><span style="background-color: #CCFFCC"><code>c:/foo</code><br><code>foo</code></span></td> +<td><span style="background-color: #CCFFCC"><code>c:</code><br><code>c:/</code></span></td> +<td><code>foo</code></td> +</tr> +<tr> +<td><code>c:foo/</code></td> +<td><span style="background-color: #CCFFCC"><code>c:foo,.</code><br><code>c:,foo,.</code></span></td> +<td><code>c:foo/</code></td> +<td><code>c:foo/</code></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:</code></span></td> +<td><font size="-1"><i>empty</i></font></td> +<td><span style="background-color: #CCFFCC"><code>c:foo/</code><br><code>foo/</code></span></td> +<td><code>c:foo</code></td> +<td><code>.</code></td> +</tr> +<tr> +<td><code>c:/foo/</code></td> +<td><span style="background-color: #CCFFCC"><code>c:,foo,.</code><br><code>c:,/,foo,.</code></span></td> +<td><code>c:/foo/</code></td> +<td><code>c:/foo/</code></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:/</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>/</code></span></td> +<td><span style="background-color: #CCFFCC"><code>c:/foo/</code><br><code>foo/</code></span></td> +<td><code>c:/foo</code></td> +<td><code>.</code></td> +</tr> +<tr> +<td><code>c:/foo/bar</code></td> +<td><span style="background-color: #CCFFCC"><code>c:,foo,bar</code><br><code>c:,/,foo,bar</code></span></td> +<td><code>c:/foo/bar</code></td> +<td><code>c:/foo/bar</code></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:/</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>/</code></span></td> +<td><span style="background-color: #CCFFCC"><code>c:/foo/bar</code><br><code>foo/bar</code></span></td> +<td><code>c:/foo</code></td> +<td><code>bar</code></td> +</tr> +<tr> +<td><code>prn:</code></td> +<td><code>prn:</code></td> +<td><code>prn:</code></td> +<td><code>prn:</code></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>prn:</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>prn:</code></span></td> +<td><font size="-1"><i>empty</i></font></td> +<td><span style="background-color: #CCFFCC"><code>prn:</code><br><font size="-1"><i>empty</i></font></span></td> +<td><font size="-1"><i>empty</i></font></td> +<td><code>prn:</code></td> +</tr> +<tr> +<td><code>c:\</code></td> +<td><span style="background-color: #CCFFCC"><code>c:\</code><br><code>c:,/</code></span></td> +<td><code>c:\</code></td> +<td><span style="background-color: #CCFFCC"><code>c:\</code><br><code>c:/</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:\</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>\</code></span></td> +<td><span style="background-color: #CCFFCC"><code>c:\</code><br><font size="-1"><i>empty</i></font></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:</code></span></td> +<td><span style="background-color: #CCFFCC"><code>c:\</code><br><code>\</code></span></td> +</tr> +<tr> +<td><code>c:foo</code></td> +<td><span style="background-color: #CCFFCC"><code>c:foo</code><br><code>c:,foo</code></span></td> +<td><code>c:foo</code></td> +<td><code>c:foo</code></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:</code></span></td> +<td><font size="-1"><i>empty</i></font></td> +<td><span style="background-color: #CCFFCC"><code>c:foo</code><br><code>foo</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:</code></span></td> +<td><span style="background-color: #CCFFCC"><code>c:foo</code><br><code>foo</code></span></td> +</tr> +<tr> +<td><code>c:\foo</code></td> +<td><span style="background-color: #CCFFCC"><code>c:\foo</code><br><code>c:,/,foo</code></span></td> +<td><code>c:\foo</code></td> +<td><span style="background-color: #CCFFCC"><code>c:\foo</code><br><code>c:/foo</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:\</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>\</code></span></td> +<td><span style="background-color: #CCFFCC"><code>c:\foo</code><br><code>foo</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:\</code></span></td> +<td><span style="background-color: #CCFFCC"><code>c:\foo</code><br><code>foo</code></span></td> +</tr> +<tr> +<td><code>c:foo\</code></td> +<td><span style="background-color: #CCFFCC"><code>c:foo\</code><br><code>c:,foo,.</code></span></td> +<td><code>c:foo\</code></td> +<td><span style="background-color: #CCFFCC"><code>c:foo\</code><br><code>c:foo/</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:</code></span></td> +<td><font size="-1"><i>empty</i></font></td> +<td><span style="background-color: #CCFFCC"><code>c:foo\</code><br><code>foo\</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:foo</code></span></td> +<td><span style="background-color: #CCFFCC"><code>c:foo\</code><br><code>.</code></span></td> +</tr> +<tr> +<td><code>c:\foo\</code></td> +<td><span style="background-color: #CCFFCC"><code>c:\foo\</code><br><code>c:,/,foo,.</code></span></td> +<td><code>c:\foo\</code></td> +<td><span style="background-color: #CCFFCC"><code>c:\foo\</code><br><code>c:/foo/</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:\</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>\</code></span></td> +<td><span style="background-color: #CCFFCC"><code>c:\foo\</code><br><code>foo\</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:\foo</code></span></td> +<td><span style="background-color: #CCFFCC"><code>c:\foo\</code><br><code>.</code></span></td> +</tr> +<tr> +<td><code>c:\foo/</code></td> +<td><span style="background-color: #CCFFCC"><code>c:\foo,.</code><br><code>c:,/,foo,.</code></span></td> +<td><code>c:\foo/</code></td> +<td><span style="background-color: #CCFFCC"><code>c:\foo/</code><br><code>c:/foo/</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:\</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>\</code></span></td> +<td><span style="background-color: #CCFFCC"><code>c:\foo/</code><br><code>foo/</code></span></td> +<td><code>c:\foo</code></td> +<td><code>.</code></td> +</tr> +<tr> +<td><code>c:/foo\bar</code></td> +<td><span style="background-color: #CCFFCC"><code>c:,foo\bar</code><br><code>c:,/,foo,bar</code></span></td> +<td><code>c:/foo\bar</code></td> +<td><span style="background-color: #CCFFCC"><code>c:/foo\bar</code><br><code>c:/foo/bar</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:/</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>c:</code></span></td> +<td><span style="background-color: #CCFFCC"><font size="-1"><i>empty</i></font><br><code>/</code></span></td> +<td><span style="background-color: #CCFFCC"><code>c:/foo\bar</code><br><code>foo\bar</code></span></td> +<td><span style="background-color: #CCFFCC"><code>c:</code><br><code>c:/foo</code></span></td> +<td><span style="background-color: #CCFFCC"><code>foo\bar</code><br><code>bar</code></span></td> +</tr> +</table> +<h2><a name="long-path-warning"></a>Warning: Long paths on Windows and the +extended-length <b>\\?\ </b>prefix</h2> +<p>The Microsoft Windows "Maximum Path Length Limitation" specifies:</p> +<blockquote> +<p>In the Windows API (with some exceptions ...), the maximum length for a path +is MAX_PATH, which is defined as 260 characters.</p> +<p>The Windows API has many functions that also have Unicode versions to permit +an extended-length path for a maximum total path length of 32,767 characters. +... To specify an extended-length path, use the <b>"\\?\" prefix</b>. For +example, "\\?\D:\<em>very long path</em>". +<i>[C++ string literals require backslashes be doubled, of course.]</i></p> +</blockquote> +<p>Because most Boost.Filesystem operational functions just pass the contents of +a class path object to the Windows API, they do work with the extended-length +prefixes. But some won't work, because to the limitations imposed by Windows. +Read the following cautions carefully!</p> +<h3>Cautions for paths with extended-length prefixes</h3> +<ul> + <li>Individual components of a path are still are limited to whatever is + supported for the particular filesystem, commonly 255 characters.</li> + <li>Only backslashes only are acceptable as directory separators. Slashes are + not treated as separators.</li> + <li>All paths must be absolute - relative paths are not allowed.</li> + <li>Once an absolute path grows beyond 260 characters, it is essentially + poisoned and all operations must use extended-length prefixes. So even a + simple operation like <code>create_directory("a")</code> will fail if the + absolute path of the resulting directory would exceed 260 characters.</li> + <li>Certain Boost.Filesystem functions that decompose their argument path and + then work on individual relative directories or files will not work properly + with extended-length prefix paths.</li> +</ul> +<h2><a name="Acknowledgements">Acknowledgements</a></h2> +<p>This Filesystem Library is dedicated to my wife, Sonda, who provided the +support necessary to see both a trial implementation and the proposal itself +through to completion. She gave me the strength to continue after a difficult +year of cancer treatment in the middle of it all.</p> +<p>Many people contributed technical comments, ideas, and suggestions to the +Boost Filesystem Library. See +<a href="http://www.boost.org/libs/filesystem/doc/index.htm#Acknowledgements"> +http://www.boost.org/libs/filesystem/doc/index.htm#Acknowledgements</a>.</p> +<p>Dietmar Kuehl contributed the original Boost Filesystem Library directory_iterator design. Peter Dimov, Walter Landry, Rob Stewart, and Thomas +Witt were particularly helpful in refining the library.</p> +<p>The create_directories, extension, basename, and replace_extension functions +were developed by Vladimir Prus. The temp_directory_path function was +contributed by Jeff Flinn. David Svoboda suggested the canonical function and +provided psuedo-code.</p> +<p>Howard Hinnant and John Maddock reviewed a draft of the version 2 proposal, and +identified a number of mistakes or weaknesses, resulting in a more polished +final document.</p> +<p>Peter Dimov suggested a single class path, with member templates to adapt to +multiple string types. His idea became the basis for the version 3 path design.</p> +<p> </p> +<h2><a name="References">References</a></h2> +<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" width="100%"> + <tr> + <td width="16%" valign="top">[<a name="ISO_POSIX">ISO-POSIX</a>]</td> + <td width="84%">ISO/IEC 9945:2003, IEEE Std 1003.1-2001, and The Open Group + Base Specifications, Issue 6. Also known as The Single Unix<font face="Times New Roman">® + Specification, Version 3. Available from each of the organizations involved + in its creation. For example, read online or download from + <a href="http://www.unix.org/single_unix_specification/"> + www.unix.org/single_unix_specification/</a>.</font> The ISO JTC1/SC22/WG15 - + POSIX homepage is <a href="http://www.open-std.org/jtc1/sc22/WG15/"> + www.open-std.org/jtc1/sc22/WG15/</a></td> + </tr> + <tr> + <td width="16%" valign="top">[Abrahams]</td> + <td width="84%">Dave Abrahams, Error and Exception Handling, + <a href="http://www.boost.org/more/error_handling.html"> + www.boost.org/more/error_handling.html</a></td> + </tr> +</table> +<hr> +<p><font size="2">© Copyright Beman Dawes, 2002, 2006, 2007, 2009, 2010, 2011</font></p> +<p><font size="2">Distributed under the Boost Software License, Version 1.0. See +</font> +<a href="http://www.boost.org/LICENSE_1_0.txt"><font size="2">www.boost.org/LICENSE_1_0.txt</font></a></p> +<p><font size="2">Revised +<!--webbot bot="Timestamp" S-Type="EDITED" S-Format="%d %B %Y" startspan -->31 October 2011<!--webbot bot="Timestamp" endspan i-checksum="32182" --></font></p> + +</body> + +</html>
\ No newline at end of file |