Boost-Commit mailing page: [Boost-commit] svn:boost r76853 - in trunk/libs/filesystem/v3/doc: . src

Date view	Thread view	Subject view	Author view

Subject: [Boost-commit] svn:boost r76853 - in trunk/libs/filesystem/v3/doc: . src
From: bdawes_at_[hidden]
Date: 2012-02-03 10:06:54

Author: bemandawes
Date: 2012-02-03 10:06:51 EST (Fri, 03 Feb 2012)
New Revision: 76853
URL: http://svn.boost.org/trac/boost/changeset/76853

Log:
Documentation updates
Text files modified:
   trunk/libs/filesystem/v3/doc/reference.html | 801 ++++++++++++++++++++-------------------
   trunk/libs/filesystem/v3/doc/src/source.html | 49 +
   trunk/libs/filesystem/v3/doc/src/tr2_snippets.html | 39 +
   3 files changed, 481 insertions(+), 408 deletions(-)

Modified: trunk/libs/filesystem/v3/doc/reference.html
==============================================================================
--- trunk/libs/filesystem/v3/doc/reference.html (original)
+++ trunk/libs/filesystem/v3/doc/reference.html 2012-02-03 10:06:51 EST (Fri, 03 Feb 2012)
@@ -5,22 +5,40 @@
<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">
+<title>
+
+ Filesystem V3 Reference
+ </title>
<style type="text/css">
- pre {background-color:#D7EEFF}
- body
- {
- font-family: sans-serif;
- max-width : 8.5in;
- margin: 1em;
- }
+/*
+
+ © Copyright Beman Dawes, 2007
+
+ Distributed under the Boost Software License, Version 1.0.
+ See www.boost.org/LICENSE_1_0.txt
+
+*/
+
+body {
+ font-family: sans-serif;
+ margin: 1em;
+ max-width : 8.5in;
+ }
+
+table { margin: 0.5em; }
+
+pre { background-color:#D7EEFF }
+
+ins { background-color:#A0FFA0 }
+del { background-color:#FFA0A0 }
+
+/*** end ***/
</style>
</head>

<body>

+
<table border="0" cellpadding="5" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111">
 <tr>
 <td width="277">
@@ -51,6 +69,8 @@

<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%">
@@ -81,6 +101,7 @@
    path decomposition 
    path query 
    path iterators 
+
    path deprecated functions 
    path non-member functions 
    path inserters and extractors 
@@ -135,7 +156,7 @@
   &nbsp is_regular_file 
   &nbsp is_symlink 
   &nbsp last_write_time 
-     permissions 
+     permissions 
     read_symlink 
   &nbsp remove 
   &nbsp remove_all 
@@ -158,15 +179,80 @@
 </tr>
</table>

+
<h2><a name="Introduction">Introduction</a></h2>

This reference documentation describes components that C++ programs may use
to perform operations involving file systems, including paths, regular files,
and directories.
+
+
+This reference documentation describes components that perform operations on file systems and
+their components, such as paths, regular files, and directories.
+Operating systems such as Linux, MAC OS, UNIX, and Windows are
+mentioned in this reference documentation for purposes of illustration or to give guidance to
+implementers. No slight to other operating systems is implied or intended.
+Footnote: Linux® is a
+registered trademark of Linus Torvalds.
+<a name="Footnote-3">Footnote</a>: MAC OS® is a registered trademark
+of Apple Inc.
+Footnote: UNIX® is a
+registered trademark of The Open Group. 
+<a name="Footnote-4">Footnote</a>: Windows® is a registered
+trademark of Microsoft Corporation.
+
+<h2><a name="Conformance">Conformance</a></h2>
+Behavior is sometimes specified by reference to ISO/IEC 9945:2003, 
+POSIX. How such behavior is actually implemented is unspecified.
+<blockquote>
+[Note: This constitutes an "as if" rule for implementation of
+operating system dependent behavior. Presumably implementations will usually call native
+operating system API's. --end note]
+</blockquote>
+Implementations are encouraged, but not required, to support such behavior
+
+as it is defined by POSIX. Implementations shall document any
+behavior that differs from the POSIX defined behavior. Implementations that do not support exact POSIX behavior are
+encouraged to provide behavior as close to POSIX 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.
+<blockquote>
+[Note: 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. --end note]
+</blockquote>
+Implementations are not required to provide behavior that is not supported by
+a particular file system.
+<blockquote>
+[Example: 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. -- end example]
+</blockquote>
+Specific operating systems such as OpenVMS,
+UNIX, and Windows 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 POSIX is
+sometimes used to refer to "POSIX-compliant operating systems".
+The behavior of functions described in this
+reference
+may differ from their specification in
+the presence of file system races. No diagnostic is required.
+If the possibility of a file system race would make it unreliable for a program to
+test for a precondition before calling a function described in this reference documentation, 
+Requires is not specified for the condition. Instead, the condition is
+specified as a Throws condition.
+<blockquote>
+[Note: As a design practice, preconditions are not specified when it
+is unreasonable for a program to detect them prior to calling the function. 
+-- end note]
+</blockquote>
<h2><a name="Definitions">Definitions</a></h2>
The following definitions shall apply throughout this reference documentation:
<a name="File">File</a>: 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
+has certain attributes, including type. File types include regular files
and directories. Other types of files, such as symbolic links, may be supported by the
implementation.
<a name="File-system">File system</a>: A collection of files and certain of their attributes.
@@ -189,7 +275,7 @@
A pathname is the concrete representation of a path. --end note]
<a name="Absolute-path">Absolute path</a>: A path that
unambiguously
-identifies the location of a file within a filesystem without reference to an
+identifies the location of a file within a file system without reference to an
additional starting location. The format is implementation defined. 
<blockquote>
 [Note: For POSIX-like implementations, including Unix
@@ -201,16 +287,15 @@
 specifier followed by a slash, or begin with two slashes, are absolute paths. --end
 note]
</blockquote>
-<a name="Relative-path">Relative path</a>: A path that only
+<a name="Relative-path">Relative path</a>: 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. [Note:
Paths "." and ".." are considered to be relative paths. --end note]
-<a name="Canonical-path">Canonical path</a>: An absolute path that has
+<a name="Canonical-path">Canonical path</a>: An absolute path that has
no elements which are symbolic links, and no dot or dot dot elements.
<a name="Pathname">Pathname</a>: A character string that represents a
-path. Pathnames are formatted according to the generic pathname format or the
-implementation defined
+path. Pathnames are formatted according to the generic pathname format or an implementation defined
native pathname format.
<a name="generic-pathname-format">Generic pathname format:</a>
<blockquote>
@@ -222,7 +307,7 @@
implementation-defined
<blockquote>
 <blockquote>
-[Note: Most POSIX and Windows based operating system define a name
+[Note: Most POSIX and Windows based operating systems 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. --end note]
@@ -276,255 +361,207 @@
If the file pointed to does not exist, the symbolic link is said to be a
"dangling" symbolic link. -- end note] 
</blockquote>
-<a name="Race-condition">Race condition</a>: The condition that occurs
+<a name="Race-condition">File system race</a>: The condition that occurs
when multiple threads, processes, or computers interleave access and
modification of
the same object within a file system.
<a name="Dot">Dot</a>, Dot Dot: 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.
-<h2><a name="Conformance">Conformance</a></h2>
-Behavior is sometimes specified by reference to ISO/IEC 9945:2003, 
-POSIX. How such behavior is actually implemented is unspecified.
-<blockquote>
-[Note: This constitutes an "as if" rule for implementation of
-operating system dependent behavior. Presumably implementations will usually call native
-operating system API's. --end note]
-</blockquote>
-Implementations are encouraged, but not required, to support such behavior
-
-as it is defined by POSIX. Implementations shall document any
-behavior that differs from the POSIX defined behavior. Implementations that do not support exact POSIX behavior are
-encouraged to provide behavior as close to POSIX 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.
-<blockquote>
-[Note: 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. --end note]
-</blockquote>
-Implementations are not required to provide behavior that is not supported by
-a particular file system.
-<blockquote>
-[Example: 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. -- end example]
-</blockquote>
-Specific operating systems such as OpenMVS,
-UNIX, and Windows 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 POSIX is
-sometimes used to refer to "POSIX-compliant operating systems".
-The behavior of functions described in this
-reference
-may not be achieved in
-the presence of race conditions. No diagnostic is required.
-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, 
-Requires is not specified for the condition. Instead, the condition is
-specified as a Throws condition.
-<blockquote>
-[Note: As a design practice, preconditions are not specified when it
-is unreasonable for a program to detect them prior to calling the function. 
--- end note]
-</blockquote>
<h2><a name="Header-filesystem-synopsis">Header <code><boost/filesystem.hpp></code> synopsis</a></h2>
-<pre> namespace boost
+<pre>namespace boost
+{
+ namespace filesystem
 {
- namespace filesystem
- {
- class path;
+ class path;

- void swap(path& lhs, path& rhs);
- bool lexicographical_compare(path::iterator first1, path::iterator last1,
- path::iterator first2, path::iterator last2);
- std::size_t hash_value(const path& p);
+ void swap(path& lhs, path& rhs);
+ bool lexicographical_compare(path::iterator first1, path::iterator last1,
+ path::iterator first2, path::iterator last2);
+ std::size_t hash_value(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);
+ 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);
+ 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 )
+ 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 filesystem_error;
- class directory_entry;
+ class filesystem_error;
+ class directory_entry;

- class directory_iterator;
+ class directory_iterator;

- class recursive_directory_iterator;
+ class recursive_directory_iterator;

- 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 perms
- {
- 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
- };
+ 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
+ };

- class file_status;
+ enum perms
+ {
+ 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
+ };

- struct <a name="space_info">space_info</a> // returned by space function
- {
- uintmax_t capacity;
- uintmax_t free;
- uintmax_t available; // free space available to a non-privileged process
- };
+ class file_status;

- BOOST_SCOPED_ENUM_START(<a name="copy_option">copy_option</a>)
- {
- none
- fail_if_exists = none,
- overwrite_if_exists
- };
- BOOST_SCOPED_ENUM_END
+ struct <a name="space_info">space_info</a> // returned by space function
+ {
+ uintmax_t capacity;
+ uintmax_t free;
+ uintmax_t available; // free space available to a non-privileged process
+ };

- BOOST_SCOPED_ENUM_START(<a name="symlink_option">symlink_option</a>)
- {
- none
- no_recurse = none,
- recurse
- };
- BOOST_SCOPED_ENUM_END
+ enum class <a name="copy_option">copy_option</a>
+ {
+ none
+ fail_if_exists = none,
+ overwrite_if_exists
+ };

- // operational functions
+ enum class <a name="symlink_option">symlink_option</a>
+ {
+ none
+ no_recurse = none,
+ recurse
+ };
+
+ // operational functions

- path absolute(const path& p, const path& base=current_path());
+ path absolute(const path& p, const path& base=current_path());

- path canonical(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);
+ path canonical(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);

- void copy(const path& from, const path& to);
- void copy(const path& from, const path& to, system::error_code& ec);
+ void copy(const path& from, const path& to);
+ void copy(const path& from, const path& to, system::error_code& ec);

- void copy_directory(const path& from, const path& to);
- void copy_directory(const path& from, const path& to, system::error_code& ec);
+ void copy_directory(const path& from, const path& to);
+ void copy_directory(const path& from, const path& to, system::error_code& ec);

- void copy_file(const path& from, const path& to);
- void copy_file(const path& from, const path& to, system::error_code& ec);
- void copy_file(const path& from, const path& to, BOOST_SCOPED_ENUM(copy_option) option);
- void copy_file(const path& from, const path& to, BOOST_SCOPED_ENUM(copy_option) option,
- system::error_code& ec);
+ void copy_file(const path& from, const path& to);
+ void copy_file(const path& from, const path& to, system::error_code& ec);
+ void copy_file(const path& from, const path& to, copy_option option);
+ void copy_file(const path& from, const path& to, copy_option option,
+ system::error_code& ec);

- void copy_symlink(const path& existing_symlink, const path& new_symlink);
- void copy_symlink(const path& existing_symlink, const path& new_symlink, system::error_code& ec);
+ void copy_symlink(const path& existing_symlink, const path& new_symlink);
+ void copy_symlink(const path& existing_symlink, const path& new_symlink, system::error_code& ec);

- bool create_directories(const path& p);
- bool create_directories(const path& p, system::error_code& ec);
+ bool create_directories(const path& p);
+ bool create_directories(const path& p, system::error_code& ec);

- bool create_directory(const path& p);
- bool create_directory(const path& p, system::error_code& ec);
+ bool create_directory(const path& p);
+ bool create_directory(const path& p, system::error_code& ec);

- void create_directory_symlink(const path& to, const path& new_symlink);
- void create_directory_symlink(const path& to, const path& new_symlink, system::error_code& ec);
+ void create_directory_symlink(const path& to, const path& new_symlink);
+ void create_directory_symlink(const path& to, const path& new_symlink, system::error_code& ec);

- void create_hard_link(const path& to, const path& new_hard_link);
- void create_hard_link(const path& to, const path& new_hard_link, system::error_code& ec);
+ void create_hard_link(const path& to, const path& new_hard_link);
+ void create_hard_link(const path& to, const path& new_hard_link, system::error_code& ec);

- void create_symlink(const path& to, const path& new_symlink);
- void create_symlink(const path& to, const path& new_symlink, system::error_code& ec);
+ void create_symlink(const path& to, const path& new_symlink);
+ void create_symlink(const path& to, const path& new_symlink, system::error_code& ec);

- path current_path();
- path current_path(system::error_code& ec);
- void current_path(const path& p);
- void current_path(const path& p, system::error_code& ec);
+ path current_path();
+ path current_path(system::error_code& ec);
+ void current_path(const path& p);
+ void current_path(const path& p, system::error_code& ec);

- bool exists(file_status s);
- bool exists(const path& p);
- bool exists(const path& p, system::error_code& ec);
+ bool exists(file_status s) noexcept;
+ bool exists(const path& p);
+ bool exists(const path& p, system::error_code& ec) noexcept;

- bool equivalent(const path& p1, const path& p2);
- bool equivalent(const path& p1, const path& p2, system::error_code& ec);
+ bool equivalent(const path& p1, const path& p2);
+ bool equivalent(const path& p1, const path& p2, system::error_code& ec);

- uintmax_t file_size(const path& p);
- uintmax_t file_size(const path& p, system::error_code& ec);
- uintmax_t hard_link_count(const path& p);
- uintmax_t hard_link_count(const path& p, system::error_code& ec);
+ uintmax_t file_size(const path& p);
+ uintmax_t file_size(const path& p, system::error_code& ec);

- const path& initial_path();
- const path& initial_path(<code>system::error_code& ec</code>);
+ uintmax_t hard_link_count(const path& p);
+ uintmax_t hard_link_count(const path& p, system::error_code& ec);

- bool is_directory(file_status s);
- bool is_directory(const path& p);
- bool is_directory(const path& p, system::error_code& ec);
+ const path& initial_path();
+ const path& initial_path(<code>system::error_code& ec</code>);

- bool is_empty(const path& p);
- bool is_empty(const path& p, system::error_code& ec);
+ bool is_directory(file_status s) noexcept;
+ bool is_directory(const path& p);
+ bool is_directory(const path& p, system::error_code& ec) noexcept;

- bool is_other(file_status s);
- bool is_other(const path& p,);
- bool is_other(const path& p, system::error_code& ec);
+ bool is_empty(const path& p);
+ bool is_empty(const path& p, system::error_code& ec);

- bool is_regular_file(file_status s);
- bool is_regular_file(const path& p);
- bool is_regular_file(const path& p, system::error_code& ec);
+ bool is_other(file_status s) noexcept;
+ bool is_other(const path& p,);
+ bool is_other(const path& p, system::error_code& ec) noexcept;

- bool is_symlink(file_status s);
- bool is_symlink(const path& p);
- bool is_symlink(const path& p, system::error_code& ec);
+ bool is_regular_file(file_status s) noexcept;
+ bool is_regular_file(const path& p);
+ bool is_regular_file(const path& p, system::error_code& ec) noexcept;

- std::time_t last_write_time(const path& p);
- std::time_t last_write_time(const path& p, system::error_code& ec);
- void last_write_time(const path& p, const std::time_t new_time);
- void last_write_time(const path& p, const std::time_t new_time, system::error_code& ec);
+ bool is_symlink(file_status s noexcept);
+ bool is_symlink(const path& p);
+ bool is_symlink(const path& p, system::error_code& ec) noexcept;

- path read_symlink(const path& p);
- path read_symlink(const path& p, system::error_code& ec);
+ std::time_t last_write_time(const path& p);
+ std::time_t last_write_time(const path& p, system::error_code& ec);
+ void last_write_time(const path& p, const std::time_t new_time);
+ void last_write_time(const path& p, const std::time_t new_time, system::error_code& ec);

- bool remove(const path& p);
- bool remove(const path& p, system::error_code& ec);
+ path read_symlink(const path& p);
+ path read_symlink(const path& p, system::error_code& ec);

- uintmax_t remove_all(const path& p);
- uintmax_t remove_all(const path& p, system::error_code& ec);
+ bool remove(const path& p);
+ bool remove(const path& p, system::error_code& ec);

- void rename(const path& from, const path& to);
- void rename(const path& from, const path& to, system::error_code& ec);
+ uintmax_t remove_all(const path& p);
+ uintmax_t remove_all(const path& p, system::error_code& ec);

- void resize_file(const path& p, uintmax_t size);
- void resize_file(const path& p, uintmax_t size, system::error_code& ec);
+ void rename(const path& from, const path& to);
+ void rename(const path& from, const path& to, system::error_code& ec);

- space_info space(const path& p);
- space_info space(const path& p, system::error_code& ec);
- file_status status(const path& p);
- file_status status(const path& p, system::error_code& ec);
+ void resize_file(const path& p, uintmax_t size);
+ void resize_file(const path& p, uintmax_t size, system::error_code& ec);

- bool status_known(file_status s);
+ space_info space(const path& p);
+ space_info space(const path& p, system::error_code& ec);

- file_status symlink_status(const path& p);
- file_status symlink_status(const path& p, system::error_code& ec);
+ file_status status(const path& p);
+ file_status status(const path& p, system::error_code& ec) noexcept;

- path system_complete(const path& p);
- path system_complete(const path& p, system::error_code& ec);
+ bool status_known(file_status s) noexcept;

- path temp_directory_path();
- path temp_directory_path(system::error_code& ec);
+ file_status symlink_status(const path& p);
+ file_status symlink_status(const path& p, system::error_code& ec) noexcept;

- path unique_path(const path& model="%%%%-%%%%-%%%%-%%%%");
- path unique_path(const path& model, system::error_code& ec);
+ path system_complete(const path& p);
+ path system_complete(const path& p, system::error_code& ec);

- } // namespace filesystem
- } // namespace boost</pre>
+ path temp_directory_path();
+ path temp_directory_path(system::error_code& ec);
+
+ path unique_path(const path& model="%%%%-%%%%-%%%%-%%%%");
+ path unique_path(const path& model, system::error_code& ec);
+
+ } // namespace filesystem
+} // namespace boost</pre>
<h2><a name="Error-reporting">Error reporting</a></h2>
Filesystem library functions often provide two overloads, one that
throws an exception to report file system errors, and another that sets an
@@ -585,10 +622,10 @@
is an example of an innocuous appearing path that is not actually valid. --
end example]
</blockquote>
-<pre> namespace boost
+<pre>namespace boost
+{
+ namespace filesystem
 {
- namespace filesystem
- {
 class path
 {
 public:
@@ -599,6 +636,7 @@
 // constructors and destructor
 path();
 path(const path& p);
+ path(path&& p) noexcept;

 template <class Source>
 path(Source const& source, const codecvt_type& cvt=codecvt());
@@ -610,6 +648,7 @@

 // assignments
 path& operator=(const path& p);
+ path& operator=(path&& p) noexcept;

 template <class Source>
 path& operator=(Source const& source);
@@ -641,8 +680,8 @@
 void swap(path& rhs);

 // native format observers
- const string_type& native() const; // native format, encoding
- const value_type* c_str() const; // native().c_str()
+ const string_type& native() const noexcept; // native format, encoding
+ const value_type* c_str() const noexcept; // native().c_str()

 template <class String>
 String string(const codecvt_type& cvt=codecvt()) const; // native format
@@ -699,8 +738,8 @@
 string_type pathname; // exposition only
 };

- } // namespace filesystem
- } // namespace boost</pre>
+ } // namespace filesystem
+} // namespace boost</pre>
<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.
@@ -735,31 +774,36 @@
rationale]
</blockquote>

-<table align="center" border="1" cellpadding="3" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" bgcolor="#D7EEFF" width="90%">
+<div align="center">
+ <center>
+
+<table border="1" cellpadding="3" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" bgcolor="#E0E0E0" width="90%">
 <tr>
- <td style="font-size: 10pt">
- Class <code>path</code> does not currently map invalid characters in
+ <td>
+ 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>
-When converting filenames to the native operating system format,
+ this:<blockquote>
+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.
+Such conversions are implementation-defined.
<blockquote>
-[Note: Filename conversion allows much wider portability of both
-programs and filenames that would otherwise be possible.
-Implementations are encouraged to base conversion on existing standards or
+[Note: Filename conversion allows much wider portability of both
+programs and filenames that would otherwise be possible.
+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
-OpenVMS, which does not allow percent signs in filenames, a dollar sign (<code>'$'</code>)
+followed by two hex digits representing the character value. On OpenVMS, 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. -- end note.]
+letters to uppercase. -- end note.]
</blockquote>
 </blockquote>
 </td>
 </tr>
</table>

+ </center>
+</div>
+
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,
@@ -972,12 +1016,10 @@
 <code>new_extension</code>.
 Returns: <code>*this</code>
</blockquote>
-<pre><code>void <a name="path-swap">swap</a>(path& rhs);</code></pre>
+<pre><code>void <a name="path-swap">swap</a>(path& rhs) noexcept;</code></pre>
<blockquote>
 Effects:
 Swaps the contents of the two paths.
- Throws: 
- nothing.
 Complexity: 
 constant time.
</blockquote>
@@ -986,15 +1028,13 @@
native format observers</a></h3>
The string returned by all native format observers is in the
<a href="#native-pathname-format">native pathname format</a>.
-<pre>const string_type& <a name="native">native</a>() const;</pre>
+<pre>const string_type& <a name="native">native</a>() const noexcept;</pre>
<blockquote>
Returns: <code>pathname</code>.
-Throws: nothing.
</blockquote>
-<pre>const value_type* <a name="c_str">c_str</a>() const;</pre>
+<pre>const value_type* <a name="c_str">c_str</a>() const noexcept;</pre>
<blockquote>
Returns: <code>pathname.c_str()</code>.
-Throws: nothing.
</blockquote>
<pre>template <class String>
String <a name="string-template">string</a>(const codecvt_type& cvt=codecvt()) const;</pre>
@@ -1195,7 +1235,9 @@
 The forward traversal order is as follows:
<ul>
 <li>The root-name element, if present.</li>
- <li>The root-directory element, if present.</li>
+ <li>The root-directory element, if present, in the generic format. 
+ [note: the generic format is required to ensure lexicographical
+ comparison works correctly. -- end note]</li>
 <li>Each successive filename element, if present.</li>
 <li>Dot, if one or more trailing non-root slash
 characters are present.</li>
@@ -1223,6 +1265,8 @@
 Returns: The <code>codecvt</code> facet for the default locale for
 all objects of type <code>path</code>.
</blockquote>
+
+
<h3> <a name="path-deprecated-functions"><code> path</code> deprecated functions</a></h3>
 Several member functions from previous versions of <code>class path</code>
have been deprecated, either because they have been renamed or because the
@@ -1246,6 +1290,7 @@
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>path</code>
non-member functions</a></h3>
<pre>void swap( path& lhs, path& rhs )</pre>
@@ -1362,11 +1407,11 @@
 <code>is</code>
 </blockquote>
<h3><a name="Class-filesystem_error">Class <code>filesystem_error</code></a></h3>
-<pre> namespace boost
+<pre>namespace boost
+{
+ namespace filesystem
 {
- namespace filesystem
- {
- class basic_filesystem_error : public system_error
+ class filesystem_error : public system_error
 {
 public:
 filesystem_error();
@@ -1388,11 +1433,11 @@

 const char * what() const;
 };
- } // namespace filesystem
- } // namespace boost</pre>
-The class template <code>basic_filesystem_error</code> defines the type of
+ } // namespace filesystem
+} // namespace boost</pre>
+The class template <code>filesystem_error</code> defines the type of
objects thrown as exceptions to report file system errors from functions described in this
-clause.
+reference documentation.
<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>
@@ -1632,7 +1677,7 @@
<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 http:en.wikipedia.org/wiki/Sticky_bit</td>
</tr>
-<tr><td><code>perms_mask</code></td><td><code>07777</code></td><td>  </td>
+<tr><td><code><a name="perms_mask">perms_mask</a></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>
@@ -1658,10 +1703,10 @@

</table>
<h3><a name="file_status">Class file_status</a></h3>
-<pre> namespace boost
+<pre>namespace boost
+{
+ namespace filesystem
 {
- namespace filesystem
- {
 class file_status
 {
 public:
@@ -1683,8 +1728,8 @@
 void type(file_type ft) noexcept;
 void permissions(perms prms) noexcept;
 };
- } // namespace filesystem
- } // namespace boost</pre>
+ } // namespace filesystem
+} // namespace boost</pre>
An object of type <code>file_status</code> stores information about the type
and permissions of a file.
<h4 dir="ltr"><a name="file_status-constructors"><code>file_status</code>
@@ -1724,10 +1769,10 @@
</blockquote>
<h3><a name="Class-directory_entry">Class <code>directory_entry</code></a></h3>
<div dir="ltr">
-<pre> namespace boost
+<pre>namespace boost
+{
+ namespace filesystem
 {
- namespace filesystem
- {
 class directory_entry
 {
 public:
@@ -1766,8 +1811,8 @@
 mutable file_status m_symlink_status; // for exposition only; lstat()-like
 };

- } // namespace filesystem
- } // namespace boost</pre>
+ } // namespace filesystem
+} // namespace boost</pre>
</div>
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>
@@ -1777,7 +1822,7 @@
[Note: 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. -- end note]
+non-cached results may differ in the presence of file system races. -- end note]
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
@@ -1953,19 +1998,16 @@
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>.
-<pre> namespace boost
+<pre>namespace boost
+{
+ namespace filesystem
 {
- namespace filesystem
- {
 class directory_iterator
- : public boost::iterator_facade< directory_iterator,
- directory_entry,
- boost::single_pass_traversal_tag >
 {
 public:
 // member functions

- directory_iterator(); // creates the "end" iterator
+ directory_iterator() noexcept; // creates the "end" iterator
 directory_iterator(const directory_iterator&);
 explicit directory_iterator(const path& p);
 directory_iterator(const path& p, system::error_code& ec);
@@ -1980,8 +2022,8 @@
 // C++ Std, 24.1.1 Input iterators [input.iterators]
 };

- } // namespace filesystem
- } // namespace boost</pre>
+ } // namespace filesystem
+} // namespace boost</pre>
 <code>directory_iterator</code> satisfies the requirements of an
input iterator (C++ Std, 24.2.1, Input iterators [input.iterators]).
A <code>directory_iterator</code> reads successive elements from the directory for
@@ -2039,14 +2081,13 @@
</blockquote>
<h4><a name="directory_iterator-members"><code>directory_iterator</code> members</a></h4>

-<code><a name="directory_iterator-default-ctor">directory_iterator</a>();</code>
+<code><a name="directory_iterator-default-ctor">directory_iterator</a>()
+noexcept;</code>

<blockquote>

Effects: Constructs the end iterator.

-Throws: Nothing.
-
</blockquote>

<pre><code>explicit <a name="directory_iterator-ctor-path">directory_iterator</a>(</code>const path& p<code>);
@@ -2081,28 +2122,28 @@
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.
-<pre> namespace boost
+<pre>namespace boost
+{
+ namespace filesystem
 {
- namespace filesystem
- {
 class recursive_directory_iterator :
 public iterator<input_iterator_tag, directory_entry>
 {
 public:

 // constructors and destructor
- recursive_directory_iterator();
+ recursive_directory_iterator() noexcept;
 recursive_directory_iterator(const recursive_directory_iterator&);
 explicit recursive_directory_iterator(const path& p,
- BOOST_SCOPED_ENUM(symlink_option) opt = symlink_option::none);
+ symlink_option opt = symlink_option::none);
 recursive_directory_iterator(const path& p,
- BOOST_SCOPED_ENUM(symlink_option) opt, system::error_code& ec);
+ symlink_option 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;
+ int level() const noexcept;
+ bool no_push<code>_pending</code>() const noexcept;

 // modifiers
 recursive_directory_iterator& operator=(const recursive_directory_iterator&);
@@ -2114,18 +2155,19 @@
 void no_push(bool value=true);

 // other members as required by
- // C++ Std, 24.1.2 Input iterators [input.iterators]
+ // C++ Std, Input iterators [input.iterators]

 private:
- // actual data members will probably be stored in a shared pimpl object,
- // or some similar mechanism, to achieve the required input iterator copy semantics
- int m_level; // for exposition only
- bool m_no_<code>push</code>; // for exposition only
- BOOST_SCOPED_ENUM(symlink_option) m_options; // for exposition only
+ // actual data members will probably be stored in a shared object,
+ // or some similar mechanism, to achieve the required input iterator
+ // copy semantics
+ int m_level; // for exposition only
+ bool m_no_<code>push</code>; // for exposition only
+ symlink_option m_options; // for exposition only
 };

- } // namespace filesystem
- } // namespace boost</pre>
+ } // namespace filesystem
+} // namespace boost</pre>

The behavior of a <code>recursive_directory_iterator</code> is the same
as a <code>directory_iterator</code> unless otherwise specified.
@@ -2138,17 +2180,15 @@
 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>
+<pre>recursive_directory_iterator() noexcept;</pre>
<blockquote>

Effects: Constructs the end iterator.

-Throws: Nothing.
-
</blockquote>

-<pre>explicit recursive_directory_iterator(const path& p, BOOST_SCOPED_ENUM(symlink_option) opt = symlink_option::none);
-recursive_directory_iterator(const path& p, BOOST_SCOPED_ENUM(symlink_option) opt, system::error_code& ec);
+<pre>explicit recursive_directory_iterator(const path& p, symlink_option opt = symlink_option::none);
+recursive_directory_iterator(const path& p, symlink_option opt, system::error_code& ec);
recursive_<code>directory_iterator(</code>const path& p, system::error_code& ec<code>);</code></pre>
<blockquote>

@@ -2173,17 +2213,15 @@
as <code>symlink_option::recurse</code>
-- end note]
</blockquote>
-<pre>int level() const;</pre>
+<pre>int level() const noexcept;</pre>
<blockquote>
 Requires: <code>*this != recursive_directory_iterator()</code>.
 Returns: <code>m_level</code>.
- Throws: Nothing.
</blockquote>
-<pre>bool <code>no_push_pending</code>() const;</pre>
+<pre>bool <code>no_push_pending</code>() const noexcept;</pre>
<blockquote>
 Requires: <code>*this != recursive_directory_iterator()</code>.
 Returns: <code>m_no_push</code>.
- Throws: Nothing.
</blockquote>
<pre><code>recursive_directory_iterator</code>& <a name="recursive_directory_iterator-increment">operator++</a>();
recursive_directory_iterator& increment(system::error_code& ec);</pre>
@@ -2221,26 +2259,24 @@
 Effects: 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.
- Throws: Nothing.
</blockquote>
<pre>void no_push(bool value=true);</pre>
<blockquote>
 Requires: <code>*this != recursive_directory_iterator()</code>.
Postcondition: <code>no_push_pending() == value</code>.
- Throws: Nothing.
 [Note: <code>no_push()</code> is used to prevent
 unwanted recursion into a directory. --end note]
</blockquote>
<h3><a name="Operational-functions">Operational functions</a></h3>
Operational functions query or modify files, including directories, in external
storage.
-Operational functions access a file by resolving an
+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 POSIX
<a href="http://www.opengroup.org/onlinepubs/000095399/basedefs/xbd_chap04.html#tag_04_11">
Pathname Resolution</a> mechanism.
[Note: Because hardware failures, network failures,
-race conditions, and many
+file system races, 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 Error reporting. -- end note]
@@ -2336,8 +2372,8 @@
 Error reporting</a>.

</blockquote>
-<pre>void <a name="copy_file">copy_file</a>(const path& from, const path& to, BOOST_SCOPED_ENUM(copy_option) option);
-void <a name="copy_file2">copy_file</a>(const path& from, const path& to, BOOST_SCOPED_ENUM(copy_option) option, system::error_code& ec);</pre>
+<pre>void <a name="copy_file">copy_file</a>(const path& from, const path& to, copy_option option);
+void <a name="copy_file2">copy_file</a>(const path& from, const path& to, copy_option option, system::error_code& ec);</pre>
<blockquote>
 Effects: 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>
@@ -2385,34 +2421,31 @@
</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">
- Effects:
+<blockquote>
+ Effects:
 Establishes the postcondition, as if by 
 POSIX
 <code>
 <a href="http://www.opengroup.org/onlinepubs/000095399/functions/symlink.html">
 symlink()</a></code>.
- 
+ 
 Postcondition: <code>new_symlink</code> resolves to a symbolic link file that
 contains an unspecified representation of <code>to</code>.
- Throws: As specified in
+ Throws: As specified in
 <a href="#Error-reporting">
 Error reporting</a>.
- [Note:
- Some operating systems, such as Windows, require symlink creation to
+ [Note:
+ Some operating systems, 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> -- end note]
 [Note:
- Some operating systems 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 file systems do not
+ Some operating systems do not support symbolic links at all or support
+ them only for regular files.
+ Some file systems 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. -- end note]
+ symbolic links regardless of the operating system - the FAT file system used on
+ memory cards and flash drives, for example. -- end note]
 </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>
@@ -2435,38 +2468,34 @@
 <a href="#Error-reporting">
 Error reporting</a>.
 [Note:
- Some operating systems do not support hard links at all or support
- them only for regular files. Some file systems 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. -- end note]
+ Some operating systems do not support hard links at all or support
+ them only for regular files. Some file systems do not support hard
+ links regardless of the operating system - the FAT file system used on memory
+ cards and flash drives, for example. Some file systems limit the number of
+ links per file. -- end note]
 </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">
- Effects:
+<blockquote>
+ Effects:
 Establishes the postcondition, as if by 
 POSIX
 <code>
 <a href="http://www.opengroup.org/onlinepubs/000095399/functions/symlink.html">
 symlink()</a></code>.
- 
+ 
 Postcondition: <code>new_symlink</code> resolves to a symbolic link file that
 contains an unspecified representation of <code>to</code>.
- Throws: As specified in
+ Throws: As specified in
 <a href="#Error-reporting">
 Error reporting</a>.
 [Note:
- Some operating systems 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 file systems do not
+ Some operating systems do not support symbolic links at all or support
+ them only for regular files.
+ Some file systems 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. -- end note]
+ symbolic links regardless of the operating system - the FAT system used on
+ memory cards and flash drives, for example. -- end note]
 </blockquote>
<pre>path <a name="current_path">current_path</a>();
path <a name="current_path2">current_path</a>(system::error_code& ec);</pre>
@@ -2488,7 +2517,7 @@
<pre>void current_path(const path& p);
void current_path(const path& p, system::error_code& ec);</pre>
<blockquote>
- Effects:
+ Effects:
 Establishes the postcondition, as if by 
 POSIX
 <code>
@@ -2502,14 +2531,13 @@
 global state. It may be changed unexpectedly by a third-party or system
 library functions, or by another thread.  -- end note]
</blockquote>
-<pre>bool <a name="exists">exists</a>(file_status s);</pre>
+<pre>bool <a name="exists">exists</a>(file_status s) noexcept;</pre>
<blockquote>
 Returns:
 <code>status_known(s) && s.type() != file_not_found</code>
- Throws: Nothing.
</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>
+bool <a name="exists3">exists</a>(const path& p, system::error_code& ec) noexcept;</pre>
<blockquote>
 Returns: <code>exists(status(p))</code> or <code>exists(status(p, ec))</code>,
 respectively.
@@ -2518,15 +2546,15 @@
</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">
- Effects: Determines <code>file_status s1</code>
+<blockquote>
+ Effects: Determines <code>file_status s1</code>
 and <code>s2</code>, as if by <code>status(p1)</code> and  <code>status(p2)</code>,
 respectively.
- Returns: <code>true</code>, if <code>sf1 ==
+ Returns: <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>.
 <blockquote>
- Two paths are considered to resolve to the same
+ 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 POSIX
 <code>
@@ -2535,7 +2563,7 @@
 <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.
- [Note: POSIX requires that "st_dev
+ [Note: POSIX requires that "st_dev
 must be unique within a Local Area Network". Conservative POSIX
 implementations may also wish to check for equal <code>st_size</code> and
 <code>st_mtime</code> values. Windows implementations may use <code>
@@ -2545,7 +2573,7 @@
 <code>nFileSizeLow</code>, <code>ftLastWriteTime.dwLowDateTime</code>, and
 <code>ftLastWriteTime.dwHighDateTime</code>. -- end note]
 </blockquote>
- Throws: <code>filesystem_error</code>
+ Throws: <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">
@@ -2556,9 +2584,6 @@
uintmax_t <a name="file_size2">file_size</a>(const path& p, system::error_code& ec);</pre>
</div>
<blockquote>
- 
- Remarks: 
- 
 Returns: 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
@@ -2567,7 +2592,7 @@
 obtained as if by POSIX <code>
 <a href="http://www.opengroup.org/onlinepubs/000095399/functions/stat.html">stat()</a></code>.
 Otherwise, <code>static_cast<uintmax_t>(-1)</code>.
- Throws: As specified in
+ Throws: As specified in
 <a href="#Error-reporting">
 Error reporting</a>.
</blockquote>
@@ -2576,7 +2601,7 @@
<blockquote>

 Returns: The number of hard links for <code>p</code>.
- Throws: As specified in
+ Throws: As specified in
 <a href="#Error-reporting">
 Error reporting</a>.

@@ -2596,14 +2621,13 @@
 <a href="#Error-reporting">
 Error reporting</a>. Subsequent calls throw nothing.
</blockquote>
-<pre>bool <code><a name="is_directory">is_directory</a></code>(file_status s);</pre>
+<pre>bool <code><a name="is_directory">is_directory</a></code>(file_status s) noexcept;</pre>
<blockquote>
 Returns:
 <code>s.type() == directory_file</code>
- Throws: Nothing.
</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>
+bool <a name="is_directory3">is_directory</a>(const path& p, system::error_code& ec) noexcept;</code></pre>
<blockquote>
 Returns: <code>is_directory(status(p))</code> or <code>is_directory(status(p, ec))</code>,
 respectively.
@@ -2620,11 +2644,10 @@
 directory_iterator(p) == directory_iterator() 
         : file_size(p) == 0;</code>
</blockquote>
-<pre>bool <code><a name="is_regular_file">is_regular_file</a></code>(file_status s);</pre>
+<pre>bool <code><a name="is_regular_file">is_regular_file</a></code>(file_status s) noexcept;</pre>
<blockquote>
 Returns:
 <code>s.type() == regular_file</code>
- Throws: Nothing.
</blockquote>
<pre><code>bool <a name="is_regular_file2">is_regular_file</a>(const path& p);</code></pre>
<blockquote>
@@ -2632,7 +2655,7 @@
 Throws: <code>filesystem_error</code>
 if <code>status(p)</code> would throw <code>filesystem_error.</code>
 </blockquote>
-<pre><code>bool <a name="is_regular_file3">is_regular_file</a>(const path& p, system::error_code& ec);</code></pre>
+<pre><code>bool <a name="is_regular_file3">is_regular_file</a>(const path& p, system::error_code& ec) noexcept;</code></pre>
<blockquote>
 Effects: Sets <code>ec</code> as if by <code>status(p, ec)</code>. [Note:
 <code>status_error</code>,
@@ -2645,30 +2668,27 @@
 function directly. -- end
 note] 
 Returns: <code>is_regular_file(status(p, ec))</code>.
- Throws: Nothing.
</blockquote>
-<pre>bool <a name="is_other">is_other</a>(file_status s);</pre>
+<pre>bool <a name="is_other">is_other</a>(file_status s) noexcept;</pre>
<blockquote>
 Returns:
 <code>return exists(s) && !is_regular_file(s) && !is_directory(s) && !is_symlink(s)</code>
- Throws: Nothing.
</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>
+bool <a name="is_other3">is_other</a>(const path& p, system::error_code& ec) noexcept;</code></pre>
<blockquote>
 Returns: <code>is_other(status(p))</code> or <code>is_other(status(p, ec))</code>,
 respectively.
 Throws: <code>filesystem_error</code>; overload with <code>error_code&</code> throws
 nothing.
</blockquote>
-<pre>bool <a name="is_symlink">is_symlink</a>(file_status s);</pre>
+<pre>bool <a name="is_symlink">is_symlink</a>(file_status s) noexcept;</pre>
<blockquote>
 Returns:
 <code>s.type() == symlink_file</code>
- Throws: Nothing.
</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>
+bool <a name="is_symlink3">is_symlink</a>(const path& p, system::error_code& ec) noexcept;</code></pre>
<blockquote>
 Returns: <code>is_symlink(symlink_status(p))</code> or <code>is_symlink(symlink_status(p, ec))</code>,
 respectively.
@@ -2683,6 +2703,9 @@
 <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 POSIX <code>
 <a href="http://www.opengroup.org/onlinepubs/000095399/functions/stat.html">stat()</a></code>.
+ Throws: As specified in
+ <a href="#Error-reporting">
+ Error reporting</a>.
</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>
@@ -2701,13 +2724,11 @@
 new_time</code> is not specified since it might not hold for file systems
 with coarse time granularity. -- end note]
</blockquote>
-<pre>void permissions(const path& p, perms prms);
+<pre>void <a name="permissions">permissions</a>(const path& p, perms prms);
void permissions(const path& p, perms prms, system::error_code& ec);</pre>
<blockquote>
- Applies an operating system set of permissions to a file. See
- perms for specifics. 
- 
- Requires: <code>!((prms & add_perms) && (prms & remove_perms))</code>.
+ 
+ Requires: <code>!((prms & add_perms) && (prms & remove_perms))</code>.
 Effects: Applies the effective permissions bits from <code>
 prms</code> to the file <code>p</code> resolves to, as if by POSIX
 <code>
@@ -2726,16 +2747,22 @@
 <tr>
 <td><code>add_perms</code></td>
 <td>
- current_status.permissions() | (<code>prms & perms_mask</code>)
+ <code>status(p).permissions() | (prms &
+ perms_mask)</code>
 </td>
 </tr>
 <tr>
 <td><code>remove_perms</code></td>
- <td>current_status.permissions() & ~(<code>prms & perms_mask</code>) </td>
+ <td><code>status(p)</code><code>.permissions() & ~(prms &
+ perms_mask)
+ </code> </td>
 </tr>
 </table>
 [Note: Conceptually permissions are viewed as bits, but the actual
- implementation by a file system may use some other mechanism. -- end note]
+ implementation may use some other mechanism. -- end note]
+ Throws: As specified in
+ <a href="#Error-reporting">
+ Error reporting</a>.
</blockquote>
<pre>path <a name="read_symlink">read_symlink</a>(const path& p);
path read_symlink(const path& p, system::error_code& ec);</pre>
@@ -2808,7 +2835,7 @@
Throws: As specified in
<a href="#Error-reporting">
Error reporting</a>.
- Remarks: Achieves its postconditions as if by
+ Remarks: Achieves its postconditions as if by
 POSIX <code>
 <a href="http://www.opengroup.org/onlinepubs/000095399/functions/truncate.html">
 truncate()</a></code>.
@@ -2849,7 +2876,7 @@
 cause an exception to be
thrown. -- end note] 
 </blockquote>
-<pre>file_status <a name="status2">status</a>(const path& p, system::error_code& ec);</pre>
+<pre>file_status <a name="status2">status</a>(const path& p, system::error_code& ec) noexcept;</pre>
<blockquote>
 Effects: 
 <blockquote>
@@ -2900,7 +2927,8 @@
 return <code>
 file_status(regular_file)</code>. [Note: <code>
regular_file</code> implies appropriate <code><fstream></code> operations
- would succeed, assuming no hardware, permission, access, or race condition
+ would succeed, assuming no hardware, permission, access, or file system
+ race
 errors. Lack of
<code>regular_file</code> does not necessarily imply <code><fstream></code> operations would
fail on a directory.
@@ -2937,19 +2965,17 @@
 file_status(type_unknown)</code>.</li>
 </ul>
 </blockquote>
-Throws: Nothing.
 Remarks: If a symbolic link is encountered during pathname
 resolution,
 pathname resolution continues using the contents of the symbolic link.
</blockquote>
-<pre>bool <a name="status_known">status_known</a>(file_status s);</pre>
+<pre>bool <a name="status_known">status_known</a>(file_status s) noexcept;</pre>
<blockquote>
 Returns:
 <code>s.type() != status_error</code>
- Throws: Nothing.
</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>
+file_status <a name="symlink_status2">symlink_status</a>(const path& p, system::error_code& ec) noexcept;</pre>
<blockquote>
 Effects:  Same as status(), above,
 except that the attributes
@@ -2963,8 +2989,9 @@
 that if the attributes indicate a symbolic link, as if by POSIX
 <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>.
-Throws: Nothing.
 Remarks: Pathname resolution terminates if <code>p</code> names a symbolic link.
+ Throws: <code>filesystem_error</code>; overload with <code>error_code&</code> throws
+ nothing.
</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>
@@ -2975,6 +3002,9 @@
 Returns: The composed path.
 Postcondition: For the returned path, <code>rp,</code> <code>
 rp.is_absolute()</code> is true.
+ Throws: As specified in
+ <a href="#Error-reporting">
+ Error reporting</a>.
 [Note: For POSIX, <code>system_complete(p)</code> has the same semantics as
 <code>complete(p, current_path())</code>.
 <a name="windows_effects">For Windows</a>, <code>system_complete(p)</code> has the
@@ -3029,6 +3059,7 @@
 provided by the operating system. [Note: Such generators may block
 until sufficient entropy develops. --end note]
</blockquote>
+
<h3><a name="File-streams">File streams</a> -
<a href="../../../../boost/filesystem/fstream.hpp"><boost/filesystem/fstream.hpp></a></h3>
Replacements are provided for the file stream classes from the C++ standard
@@ -3086,8 +3117,11 @@
 typedef basic_fstream<wchar_t> wfstream;
 typedef basic_ofstream<wchar_t> wofstream;

- } // namespace filesystem
-} // namespace boost</pre>
+ } // namespace filesystem
+} // namespace boost</pre>
+
+
+
<h2><a name="Path-decomposition-table">Path decomposition table</a></h2>
The table is generated by a program compiled with the Boost implementation.
Shaded entries indicate cases where POSIX and Windows
@@ -3638,13 +3672,12 @@
final document.
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.
- 
<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Ã‚Â®
+ Base Specifications, Issue 6. Also known as The Single Unix®
 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/">
@@ -3660,12 +3693,14 @@
 </tr>
</table>
<hr>
+>
© Copyright Beman Dawes, 2002, 2006, 2007, 2009, 2010, 2011
Distributed under the Boost Software License, Version 1.0. See

<a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>
Revised
-31 October 2011
+13 January 2012
+

</body>

Modified: trunk/libs/filesystem/v3/doc/src/source.html
==============================================================================
--- trunk/libs/filesystem/v3/doc/src/source.html (original)
+++ trunk/libs/filesystem/v3/doc/src/source.html 2012-02-03 10:06:51 EST (Fri, 03 Feb 2012)
@@ -69,7 +69,9 @@
    path decomposition 
    path query 
    path iterators 
+$if $TARGET; == BOOST
    path deprecated functions 
+$endif
    path non-member functions 
    path inserters and extractors 
  Class filesystem_error 
@@ -150,12 +152,16 @@

This $WHAT; describes components that perform operations on file systems and
their components, such as paths, regular files, and directories.
-Operating systems such as MAC OS, UNIX, and Windows are
+Operating systems such as Linux, MAC OS, UNIX, and Windows are
mentioned in this $WHAT; for purposes of illustration or to give guidance to
implementers. No slight to other operating systems is implied or intended.
-<a name="Footnote-3">Footnote 3</a>: MAC OS® is a registered trademark
+Footnote: Linux® is a
+registered trademark of Linus Torvalds.
+<a name="Footnote-3">Footnote</a>: MAC OS® is a registered trademark
of Apple Inc.
-<a name="Footnote-4">Footnote 4</a>: Windows® is a registered
+Footnote: UNIX® is a
+registered trademark of The Open Group. 
+<a name="Footnote-4">Footnote</a>: Windows® is a registered
trademark of Microsoft Corporation.

<h2><a name="Conformance">Conformance</a></h2>
@@ -723,31 +729,36 @@
rationale]
</blockquote>

-<table align="center" border="1" cellpadding="3" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" bgcolor="#D7EEFF" width="90%">
+<div align="center">
+ <center>
+
+<table border="1" cellpadding="3" cellspacing="0" style="border-collapse: collapse" bordercolor="#111111" bgcolor="#E0E0E0" width="90%">
 <tr>
 <td>
- Class <code>path</code> does not currently map invalid characters in
+ 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>
-When converting filenames to the native operating system format,
+ this:<blockquote>
+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.
+Such conversions are implementation-defined.
<blockquote>
-[Note: Filename conversion allows much wider portability of both
-programs and filenames that would otherwise be possible.
-Implementations are encouraged to base conversion on existing standards or
+[Note: Filename conversion allows much wider portability of both
+programs and filenames that would otherwise be possible.
+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
-OpenVMS, which does not allow percent signs in filenames, a dollar sign (<code>'$'</code>)
+followed by two hex digits representing the character value. On OpenVMS, 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. -- end note.]
+letters to uppercase. -- end note.]
</blockquote>
 </blockquote>
 </td>
 </tr>
</table>

+ </center>
+</div>
+
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,
@@ -822,7 +833,7 @@
 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>
+ <li>A <code>$NAMESPACE;::$SUBNAMESPACE;::directory_entry</code>.</li>
</ul>

<h3> <a name="path-constructors"> <code>
@@ -1179,7 +1190,9 @@
 The forward traversal order is as follows:
<ul>
 <li>The root-name element, if present.</li>
- <li>The root-directory element, if present.</li>
+ <li>The root-directory element, if present, in the generic format. 
+ [note: the generic format is required to ensure lexicographical
+ comparison works correctly. -- end note]</li>
 <li>Each successive filename element, if present.</li>
 <li>Dot, if one or more trailing non-root slash
 characters are present.</li>
@@ -1352,7 +1365,7 @@
 </blockquote>
<h3><a name="Class-filesystem_error">Class <code>filesystem_error</code></a></h3>
<pre>$NAMESPACE_BEGIN;
- class basic_filesystem_error : public system_error
+ class filesystem_error : public system_error
 {
 public:
 filesystem_error();
@@ -1375,7 +1388,7 @@
 const char * what() const;
 };
$NAMESPACE_END;</pre>
-The class template <code>basic_filesystem_error</code> defines the type of
+The class template <code>filesystem_error</code> defines the type of
objects thrown as exceptions to report file system errors from functions described in this
$WHAT;.
<h4> <a name="filesystem_error-members"> <code>filesystem_error</code> members</a></h4>

Modified: trunk/libs/filesystem/v3/doc/src/tr2_snippets.html
==============================================================================
--- trunk/libs/filesystem/v3/doc/src/tr2_snippets.html (original)
+++ trunk/libs/filesystem/v3/doc/src/tr2_snippets.html 2012-02-03 10:06:51 EST (Fri, 03 Feb 2012)
@@ -18,7 +18,7 @@
 <tr>
 <td width="153" align="left" valign="top">Date:</td>
 <td width="426">
- 2012-01-30</td>
+ 2012-02-02</td>
 </tr>
 <tr>
 <td width="153" align="left" valign="top">Project:</td>
@@ -41,7 +41,19 @@
<a href="#TODO">TODO</a> list identifies remaining work to be done.

-<h2>Revision history</h2>
+<h2>Revision history </h2>
+
+
+N????=12-????, Filesystem Library for C++11/TR2 (Revision
+2). Changes
+include:
+
+
+<ul>
+ <li>Removed references to Boost within the proposed wording.</li>
+ <li>Corrected namespaces and made other minor fixes to the proposed wording.</li>
+ <li>Added Issue 7: How should class path inserter and extractor be specified?</li>
+</ul>

<a href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2012/n3335.html">
@@ -57,7 +69,7 @@
 raised by the LWG review of N3239 at the Bloomington meeting, and private
 communications from LWG members.</li>
 <li>Namespace changed to <code>files</code> as an experiment. Made this
- issue number 1 so the LWG can pass judgement.</li>
+ issue number 1 so the LWG can pass judgment.</li>
 <li>New functions were added, suggested by David Svoboda, to generate
 canonical paths and manage permissions.</li>
 <li>More C++11 functionality was applied. This process is still incomplete,
@@ -300,12 +312,25 @@
is not a template?
<h4>Proposed resolution</h4>
<hr>
-<h3>Issue 7: Should ?</h3>
+<h3>Issue 7: How should class path inserter and extractor be specified?</h3>
<h4>Discussion</h4>
-Question raised by a committee member in private email.
-Comment from Beman: How would allocator support work, given that class path
-is not a template?
+Class <code>path</code> currently is specified to used the Boost detail <code>
+quoted</code> stream manipulator. A path object is inserted delimited by quotes,
+and extracted accordingly, ensuring that paths containing spaces are
+round-tripped correctly.  Quotes in the path itself are escaped, and io
+state is saved and restored.
+See
+<a href="http://www.boost.org/doc/libs/1_48_0/libs/io/doc/quoted_manip.html">
+http://www.boost.org/doc/libs/1_48_0/libs/io/doc/quoted_manip.html>
+Since the standard can't specify behavior in terms of something in Boost, we
+have to change the specification. Since the <code>quoted</code> stream
+manipulator is a handy little component, the issue is raised as to whether it
+should go in TR2.
<h4>Proposed resolution</h4>
+Option 1: Add Boost's <code>quoted</code> stream manipulator to TR2,
+and change the Filesystem docs to reference it.
+Option 2: Specify the path inserter and extractor to have the desired
+behavior with reference to how it is achieved. 
<hr>
$endid

Next message: barend.gehrels_at_[hidden]: "[Boost-commit] svn:boost r76854 - trunk/boost/geometry/algorithms"
Previous message: dnljms_at_[hidden]: "[Boost-commit] svn:boost r76852 - in branches/release: . tools tools/quickbook tools/quickbook/doc tools/quickbook/src"

Date view	Thread view	Subject view	Author view