From 902ca6fdf3cf93af0d01c4066d7297f7ddb0c22f Mon Sep 17 00:00:00 2001
From: Glen Fernandes <glen.fernandes@gmail.com>
Date: Wed, 14 Jun 2017 20:39:49 -0400
Subject: [PATCH] Remove 'see below' in documentation

---
 doc/smart_ptr/make_shared.adoc | 23 ++++++++++-------------
 doc/smart_ptr/make_unique.adoc |  6 ++----
 2 files changed, 12 insertions(+), 17 deletions(-)

diff --git a/doc/smart_ptr/make_shared.adoc b/doc/smart_ptr/make_shared.adoc
index af59deb..80afd39 100644
--- a/doc/smart_ptr/make_shared.adoc
+++ b/doc/smart_ptr/make_shared.adoc
@@ -75,15 +75,16 @@ namespace boost {
 
   `// only if T is an array type of the form U[]`
   template<class T>
-    shared_ptr<T> make_shared(std::size_t n, _see below_ v);
+    shared_ptr<T> make_shared(std::size_t n, const remove_extent_t<T>& v);
   template<class T, class A>
-    shared_ptr<T> allocate_shared(const A& a, std::size_t n, _see below_ v);
+    shared_ptr<T>
+      allocate_shared(const A& a, std::size_t n, const remove_extent_t<T>& v);
 
   `// only if T is an array type of the form U[N]`
   template<class T>
-    shared_ptr<T> make_shared(_see below_ v);
+    shared_ptr<T> make_shared(const remove_extent_t<T>& v);
   template<class T, class A>
-    shared_ptr<T> allocate_shared(const A& a, _see below_ v);
+    shared_ptr<T> allocate_shared(const A& a, const remove_extent_t<T>& v);
 
   `// only if T is not an array type of the form U[]`
   template<class T>
@@ -126,7 +127,6 @@ initialization of the object.
 Remarks::
 * Performs no more than one memory allocation. This provides efficiency
 equivalent to an intrusive smart pointer.
-* The type of `v` is equivalent to `const std::remove_extent_t<T>&`.
 * When an object of an array type is specified to be initialized to a value of
 the same type `v`, this shall be interpreted to mean that each array element
 of the object is initialized to the corresponding element from `v`.
@@ -225,16 +225,15 @@ Examples:::
 * `auto p = make_shared<double[1024]>();`
 * `auto p = make_shared<double[6][2][2]>();`
 
-[subs=+quotes]
 ```
 template<class T>
-  shared_ptr<T> make_shared(std::size_t n, _see above_ v);
+  shared_ptr<T> make_shared(std::size_t n, const remove_extent_t<T>& v);
 ```
 ::
-[subs=+quotes]
 ```
 template<class T, class A>
-  shared_ptr<T> allocate_shared(const A& a, std::size_t n, _see above_ v);
+  shared_ptr<T>
+    allocate_shared(const A& a, std::size_t n, const remove_extent_t<T>& v);
 ```
 ::
 Remarks::: These overloads shall only participate in overload resolution when
@@ -246,16 +245,14 @@ Examples:::
 * `auto p = make_shared<double[][2]>(6, {1.0, 0.0});`
 * `auto p = make_shared<std::vector<int>[]>(4, {1, 2});`
 
-[subs=+quotes]
 ```
 template<class T>
-  shared_ptr<T> make_shared(_see above_ v);
+  shared_ptr<T> make_shared(const remove_extent_t<T>& v);
 ```
 ::
-[subs=+quotes]
 ```
 template<class T, class A>
-  shared_ptr<T> allocate_shared(const A& a, _see above_ v);
+  shared_ptr<T> allocate_shared(const A& a, const remove_extent_t<T>& v);
 ```
 ::
 Remarks::: These overloads shall only participate in overload resolution when
diff --git a/doc/smart_ptr/make_unique.adoc b/doc/smart_ptr/make_unique.adoc
index 30b7137..b01da5a 100644
--- a/doc/smart_ptr/make_unique.adoc
+++ b/doc/smart_ptr/make_unique.adoc
@@ -46,7 +46,7 @@ namespace boost {
 
   `// only if T is not an array type`
   template<class T>
-    std::unique_ptr<T> make_unique(_see below_ v);
+    std::unique_ptr<T> make_unique(remove_reference_t<T>&& v);
 
   `// only if T is an array type of the form U[]`
   template<class T>
@@ -74,16 +74,14 @@ Remarks::: These overloads shall only participate in overload resolution when
 Returns::: `std::unique_ptr<T>(new T(std::forward<Args>(args)$$...$$)`.
 Example::: `auto p = make_unique<int>();`
 
-[subs=+quotes]
 ```
 template<class T>
-  std::unique_ptr<T> make_unique(_see below_ v);
+  std::unique_ptr<T> make_unique(remove_reference_t<T>&& v);
 ```
 ::
 Remarks:::
 * These overloads shall only participate in overload resolution when `T` is
 not an array type.
-* The type of `v` is equivalent to `std::remove_reference_t<T>&&`.
 Returns::: `std::unique_ptr<T>(new T(std::move(v))`.
 Example::: `auto p = make_unique<std::vector<int> >({1, 2});`