cpp reconcile pr13

mdsebolt · mdsebolt · commit 99bfcd753463 · 2019-05-13T17:32:26.000Z
diff --git a/docs/standard-library/ciso646.md b/docs/standard-library/ciso646.md
@@ -9,6 +9,9 @@ ms.assetid: 9d570924-d299-4225-9a58-8c4c820f5903
 
 Includes the Standard C library header \<iso646.h> and adds the associated names to the `std` namespace.
 
+> [!NOTE]
+> Use of this header is unnecessary in C++.
+
 ## Syntax
 
 ```cpp
diff --git a/docs/standard-library/condition-variable.md b/docs/standard-library/condition-variable.md
@@ -50,6 +50,14 @@ Each class also has two methods that are used to notify a condition variable tha
 
 - `notify_all` wakes up all of the threads that are waiting for the condition variable.
 
+## Functions and Enums
+
+```cpp
+void notify_all_at_thread_exit(condition_variable& cond, unique_lock<mutex> lk);
+
+enum class cv_status { no_timeout, timeout };
+```
+
 ## See also
 
 [Header Files Reference](../standard-library/cpp-standard-library-header-files.md)<br/>
diff --git a/docs/standard-library/cstdbool.md b/docs/standard-library/cstdbool.md
@@ -7,6 +7,9 @@ ms.assetid: 44ccb8b2-d808-4715-8097-58ba09ab33ed
 
 Includes the Standard C library header \<stdbool.h> and adds the associated names to the `std` namespace.
 
+> [!NOTE]
+> This header has been deprecated in C++ 17.
+
 ## Syntax
 
 ```cpp
diff --git a/docs/standard-library/ctgmath.md b/docs/standard-library/ctgmath.md
@@ -5,7 +5,7 @@ ms.assetid: ff521893-f445-4dc8-a2f6-699185bb7024
 ---
 # &lt;ctgmath&gt;
 
-In effect, includes the C++ Standard Library headers \<ccomplex> and \<cmath>, which provide type-generic math macros equivalent to \<tgmath.h>.
+In effect, includes the C++ Standard Library headers \<complex> and \<cmath>, which provide type-generic math macros equivalent to \<tgmath.h>.
 
 ## Syntax
 
@@ -15,7 +15,7 @@ In effect, includes the C++ Standard Library headers \<ccomplex> and \<cmath>, w
 
 ## Remarks
 
-The functionality of the Standard C library header \<tgmath.h> is provided by overloads in \<ccomplex> and \<cmath>.
+The functionality of the Standard C library header \<tgmath.h> is provided by overloads in \<complex> and \<cmath>.
 
 Including this header ensures that the names declared using external linkage in the Standard C library header are declared in the `std` namespace.
 
diff --git a/docs/standard-library/filesystem-enumerations.md b/docs/standard-library/filesystem-enumerations.md
@@ -106,6 +106,14 @@ enum class file_type {
 |`socket`|7|Represents a socket on UNIX based systems. (Not supported.)|
 |`unknown`|8|Represents a file whose status cannot be determined.|
 
+## <a name="perm_options"></a>  perm_options
+
+Includes values `replace`, `add`, `remove`, and `nofollow`.
+
+```cpp
+enum class perm_options;
+```
+
 ## <a name="perms"></a>  perms
 
 Flags for file permissions. The supported values are essentially “readonly” and all. For a readonly file, none of the *_write bits are set. Otherwise the `all` bit (0x0777) is set.
diff --git a/docs/standard-library/filesystem-functions.md b/docs/standard-library/filesystem-functions.md
@@ -20,11 +20,12 @@ These free functions in the [\<filesystem>](../standard-library/filesystem.md) h
 |[is_block_file](#is_block_file)|[is_character_file](#is_character_file)|[is_directory](#is_directory)|
 |[is_empty](#is_empty)|[is_fifo](#is_fifo)|[is_other](#is_other)|
 |[is_regular_file](#is_regular_file)|[is_socket](#is_socket)|[is_symlink](#is_symlink)|
-|[last_write_time](#last_write_time)|[permissions](#permissions)|[read_symlink](#read_symlink)|
-|[remove](#remove)|[remove_all](#remove_all)|[rename](#rename)|
-|[resize_file](#resize_file)|[space](#space)|[status](#status)|
-|[status_known](#status_known)|[swap](#swap)|[symlink_status](#symlink_status)|
-|[system_complete](#system_complete)|[temp_directory_path](#temp_directory_path)|[u8path](#u8path)|
+|[last_write_time](#last_write_time)|[permissions](#permissions)|[proximate](#proximate)|
+|[read_symlink](#read_symlink)|[relative](#relative)|[remove](#remove)|
+|[remove_all](#remove_all)|[rename](#rename)|[resize_file](#resize_file)|
+|[space](#space)|[status](#status)|[status_known](#status_known)|
+|[swap](#swap)|[symlink_status](#symlink_status)|[system_complete](#system_complete)|
+|[temp_directory_path](#temp_directory_path)|[u8path](#u8path)|[weakly_canonical](#weakly_canonical)|
 
 ## <a name="absolute"></a> absolute
 
@@ -385,6 +386,14 @@ The functions set the permissions for the pathname designated by *pval* to `mask
 
 If `mask & perms::add_perms` the functions set the permissions to `status(pval).permissions() | mask & perms::mask`. Otherwise, if `mask & perms::remove_perms` the functions set the permissions to `status(pval).permissions() & ~(mask & perms::mask)`. Otherwise, the functions set the permissions to `mask & perms::mask`.
 
+## <a name="proximate"></a> proximate
+
+```cpp
+path proximate(const path& p, error_code& ec);
+path proximate(const path& p, const path& base = current_path());
+path proximate(const path& p, const path& base, error_code& ec);
+```
+
 ## <a name="read_symlink"></a>  read_symlink
 
 ```cpp
@@ -394,6 +403,14 @@ path read_symlink(const path& pval, error_code& ec);
 
 The functions report an error and return `path()` if `!is_symlink(pval)`. Otherwise, the functions return an object of type `path` containing the symbolic link.
 
+## <a name="relative"></a> relative
+
+```cpp
+path relative(const path& p, error_code& ec);
+path relative(const path& p, const path& base = current_path());
+path relative(const path& p, const path& base, error_code& ec);
+```
+
 ## <a name="remove"></a>  remove
 
 ```cpp
@@ -502,3 +519,10 @@ path u8path(InIt first, InIt last);
 ```
 
 The first function behaves the same as `path(source)` and the second function behaves the same as `path(first, last)` except that the designated source in each case is taken as a sequence of char elements encoded as UTF-8, regardless of the filesystem.
+
+## <a name="weakly_canonical"></a> weakly_canonical
+
+```cpp
+path weakly_canonical(const path& p);
+path weakly_canonical(const path& p, error_code& ec);
+```
diff --git a/docs/standard-library/filesystem.md b/docs/standard-library/filesystem.md
@@ -110,6 +110,7 @@ For more information and code examples, see [File System Navigation (C++)](../st
 |[copy_options](../standard-library/filesystem-enumerations.md#copy_options)|An enumeration that is used with [copy_file](../standard-library/filesystem-functions.md#copy_file) and determines behavior if a destination file already exists.|
 |[directory_options](../standard-library/filesystem-enumerations.md#directory_options)|An enumeration that specifies options for directory iterators.|
 |[file_type](../standard-library/filesystem-enumerations.md#file_type)|An enumeration for file types.|
+|[perm_options](../standard-library/filesystem-enumerations.md#perm_options)||
 |[perms](../standard-library/filesystem-enumerations.md#perms)|A bitmask type used to convey permissions and options to permissions|
 
 ## See also
diff --git a/docs/standard-library/mutex-functions.md b/docs/standard-library/mutex-functions.md
@@ -10,7 +10,8 @@ helpviewer_keywords: ["std::adopt_lock [C++]", "std::call_once [C++]", "std::def
 ||||
 |-|-|-|
 |[adopt_lock](#adopt_lock)|[call_once](#call_once)|[defer_lock](#defer_lock)|
-|[lock](#lock)|[try_to_lock](#try_to_lock)|
+|[lock](#lock)|[swap](#swap)|[try_lock](#try_lock)|
+|[try_to_lock](#try_to_lock)|||
 
 ## <a name="adopt_lock"></a>  adopt_lock Variable
 
@@ -68,6 +69,19 @@ The arguments to the template function must be *mutex types*, except that calls
 
 The function locks all of its arguments without deadlock by calls to `lock`, `try_lock`, and `unlock`. If a call to `lock` or `try_lock` throws an exception, the function calls `unlock` on any of the mutex objects that were successfully locked before rethrowing the exception.
 
+## <a name="swap"></a>  swap
+
+```cpp
+template <class Mutex>
+void swap(unique_lock<Mutex>& x, unique_lock<Mutex>& y) noexcept;
+```
+
+## <a name="try_lock"></a>  try_lock
+
+```cpp
+template <class L1, class L2, class... L3> int try_lock(L1&, L2&, L3&...);
+```
+
 ## <a name="try_to_lock"></a>  try_to_lock Variable
 
 Represents an object that can be passed to the constructor for [unique_lock](../standard-library/unique-lock-class.md) to indicate that the constructor should try to unlock the `mutex` that is also being passed to it without blocking.
diff --git a/docs/standard-library/mutex.md b/docs/standard-library/mutex.md
@@ -48,6 +48,7 @@ A mutex type is also known as a *lockable type*. If it does not provide the memb
 |[mutex Class (C++ Standard Library)](../standard-library/mutex-class-stl.md)|Represents a mutex type. Use objects of this type to enforce mutual exclusion within a program.|
 |[recursive_mutex Class](../standard-library/recursive-mutex-class.md)|Represents a mutex type. In constrast to the `mutex` class, the behavior of calling locking methods for objects that are already locked is well-defined.|
 |[recursive_timed_mutex Class](../standard-library/recursive-timed-mutex-class.md)|Represents a timed mutex type. Use objects of this type to enforce mutual exclusion that has time-limited blocking within a program. Unlike objects of type `timed_mutex`, the effect of calling locking methods for `recursive_timed_mutex` objects is well-defined.|
+|[scoped_lock Class](../standard-library/scoped-lock-class.md)||
 |[timed_mutex Class](../standard-library/timed-mutex-class.md)|Represents a timed mutex type. Use objects of this type to enforce mutual exclusion that has time-limited blocking within a program.|
 |[unique_lock Class](../standard-library/unique-lock-class.md)|Represents a template that can be instantiated to create objects that manage the locking and unlocking of a `mutex`.|
 
@@ -57,6 +58,8 @@ A mutex type is also known as a *lockable type*. If it does not provide the memb
 |----------|-----------------|
 |[call_once](../standard-library/mutex-functions.md#call_once)|Provides a mechanism for calling a specified callable object exactly once during execution.|
 |[lock](../standard-library/mutex-functions.md#lock)|Attempts to lock all arguments without deadlock.|
+|[swap](../standard-library/mutex-functions.md#swap)||
+|[try_lock](../standard-library/mutex-functions.md#try_lock)||
 
 ### Structs
 
diff --git a/docs/standard-library/scoped-lock-class.md b/docs/standard-library/scoped-lock-class.md
@@ -0,0 +1,31 @@
+---
+title: "scoped_lock Class"
+ms.date: "11/04/2016"
+f1_keywords: ["mutex/std::scoped_lock"]
+---
+# scoped_lock Class
+
+## Syntax
+
+```cpp
+template <class... MutexTypes>
+class scoped_lock {
+    using mutex_type = Mutex; // If MutexTypes... consists of the single type Mutex
+    explicit scoped_lock(MutexTypes&... m);
+    explicit scoped_lock(MutexTypes&... m, adopt_lock_t);
+    ~scoped_lock();
+    scoped_lock(const scoped_lock&) = delete;
+    scoped_lock& operator=(const scoped_lock&) = delete;
+}
+```
+
+## Requirements
+
+**Header:** \<mutex>
+
+**Namespace:** std
+
+## See also
+
+[Header Files Reference](../standard-library/cpp-standard-library-header-files.md)<br/>
+[\<mutex>](../standard-library/mutex.md)<br/>
diff --git a/docs/standard-library/strstream.md b/docs/standard-library/strstream.md
@@ -31,6 +31,14 @@ Objects of type `strstream` work with `char` *, which are C strings. Use [\<sstr
 |[ostrstream Class](../standard-library/ostrstream-class.md)|The class describes an object that controls insertion of elements and encoded objects into a stream buffer of class [strstreambuf](../standard-library/strstreambuf-class.md).|
 |[strstream Class](../standard-library/strstream-class.md)|The class describes an object that controls insertion and extraction of elements and encoded objects using a stream buffer of class [strstreambuf](../standard-library/strstreambuf-class.md).|
 
+### Functions
+
+```cpp
+void freeze(bool freezefl = true);
+char* str();
+int pcount();
+```
+
 ## See also
 
 [\<strstream>](../standard-library/strstream.md)<br/>
