Boost logo

Boost-Commit :

Subject: [Boost-commit] svn:boost r72300 - in sandbox/conversion/libs/conversion_ext/doc/html: . boost
From: vicente.botet_at_[hidden]
Date: 2011-05-31 06:05:44


Author: viboes
Date: 2011-05-31 06:05:43 EDT (Tue, 31 May 2011)
New Revision: 72300
URL: http://svn.boost.org/trac/boost/changeset/72300

Log:
Conversion: doc cleanup
Removed:
   sandbox/conversion/libs/conversion_ext/doc/html/boost/
Text files modified:
   sandbox/conversion/libs/conversion_ext/doc/html/index.html | 232 ++++++++++++++++++---------------------
   sandbox/conversion/libs/conversion_ext/doc/html/standalone_HTML.manifest | 83 ++++++-------
   2 files changed, 149 insertions(+), 166 deletions(-)

Modified: sandbox/conversion/libs/conversion_ext/doc/html/index.html
==============================================================================
--- sandbox/conversion/libs/conversion_ext/doc/html/index.html (original)
+++ sandbox/conversion/libs/conversion_ext/doc/html/index.html 2011-05-31 06:05:43 EDT (Tue, 31 May 2011)
@@ -917,7 +917,7 @@
     <span class="keyword">namespace</span> <span class="identifier">chrono</span> <span class="special">{</span>
         <span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">&gt;</span>
         <span class="keyword">inline</span> <span class="identifier">posix_time</span><span class="special">::</span><span class="identifier">ptime</span> <span class="identifier">convert_to</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">from</span>
- <span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span><span class="identifier">posix_time</span><span class="special">::</span><span class="identifier">ptime</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span>
+ <span class="special">,</span> <span class="identifier">conversion</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span><span class="identifier">posix_time</span><span class="special">::</span><span class="identifier">ptime</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span>
         <span class="special">{</span>
                 <span class="keyword">typedef</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;</span> <span class="identifier">time_point_t</span><span class="special">;</span>
                 <span class="keyword">typedef</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">nanoseconds</span> <span class="identifier">duration_t</span><span class="special">;</span>
@@ -937,7 +937,6 @@
 
         <span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">&gt;</span>
         <span class="keyword">inline</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">assign_to</span><span class="special">(</span><span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">to</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">posix_time</span><span class="special">::</span><span class="identifier">ptime</span><span class="special">&amp;</span> <span class="identifier">from</span>
- <span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span><span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span>
         <span class="special">)</span>
         <span class="special">{</span>
             <span class="identifier">to</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">conversion</span><span class="special">::</span><span class="identifier">convert_to</span><span class="special">&lt;</span><span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;</span> <span class="special">&gt;(</span><span class="identifier">from</span><span class="special">);</span>
@@ -949,7 +948,7 @@
     <span class="keyword">namespace</span> <span class="identifier">posix_time</span> <span class="special">{</span>
         <span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">TP</span><span class="special">&gt;</span>
         <span class="keyword">inline</span> <span class="identifier">TP</span> <span class="identifier">convert_to</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ptime</span><span class="special">&amp;</span> <span class="identifier">from</span>
- <span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span><span class="identifier">TP</span> <span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span>
+ <span class="special">,</span> <span class="identifier">conversion</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span><span class="identifier">TP</span> <span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span>
         <span class="special">{</span>
             <span class="identifier">time_duration</span> <span class="keyword">const</span> <span class="identifier">time_since_epoch</span><span class="special">=</span><span class="identifier">from</span><span class="special">-</span><span class="identifier">from_time_t</span><span class="special">(</span><span class="number">0</span><span class="special">);</span>
             <span class="identifier">TP</span> <span class="identifier">t</span><span class="special">=</span><span class="identifier">chrono</span><span class="special">::</span><span class="identifier">system_clock</span><span class="special">::</span><span class="identifier">from_time_t</span><span class="special">(</span><span class="identifier">time_since_epoch</span><span class="special">.</span><span class="identifier">total_seconds</span><span class="special">());</span>
@@ -960,7 +959,6 @@
 
         <span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Duration</span><span class="special">&gt;</span>
         <span class="keyword">inline</span> <span class="identifier">ptime</span><span class="special">&amp;</span> <span class="identifier">assign_to</span><span class="special">(</span><span class="identifier">ptime</span><span class="special">&amp;</span> <span class="identifier">to</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span><span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span><span class="special">&gt;&amp;</span> <span class="identifier">from</span>
- <span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span><span class="identifier">posix_time</span><span class="special">::</span><span class="identifier">ptime</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span>
         <span class="special">)</span>
         <span class="special">{</span>
             <span class="identifier">to</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">conversion</span><span class="special">::</span><span class="identifier">convert_to</span><span class="special">&lt;</span><span class="identifier">ptime</span><span class="special">&gt;(</span><span class="identifier">from</span><span class="special">);</span>
@@ -991,10 +989,12 @@
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">conversion</span><span class="special">/</span><span class="identifier">convert_to</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">conversion</span><span class="special">/</span><span class="identifier">assign_to</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 <span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">config</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">mpl</span><span class="special">/</span><span class="keyword">bool</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
+<span class="preprocessor">#include</span> <span class="special">&lt;</span><span class="identifier">boost</span><span class="special">/</span><span class="identifier">utility</span><span class="special">/</span><span class="identifier">enable_if</span><span class="special">.</span><span class="identifier">hpp</span><span class="special">&gt;</span>
 
 <span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
 
- <span class="preprocessor">#ifdef</span> <span class="identifier">BOOST_NO_FUNCTION_TEMPLATE_ORDERING</span> <span class="special">&amp;&amp;</span> <span class="special">!</span> <span class="identifier">defined</span><span class="special">(</span><span class="identifier">BOOST_CONVERSION_DOXYGEN_INVOKED</span><span class="special">)</span>
+<span class="preprocessor">#ifdef</span> <span class="identifier">BOOST_NO_FUNCTION_TEMPLATE_ORDERING</span> <span class="special">&amp;&amp;</span> <span class="special">!</span> <span class="identifier">defined</span><span class="special">(</span><span class="identifier">BOOST_CONVERSION_DOXYGEN_INVOKED</span><span class="special">)</span>
   <span class="keyword">namespace</span> <span class="identifier">conversion</span> <span class="special">{</span>
     <span class="keyword">namespace</span> <span class="identifier">overload_workaround</span> <span class="special">{</span>
       <span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">Target</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Source</span><span class="special">&gt;</span>
@@ -1035,45 +1035,63 @@
     <span class="special">}</span>
   <span class="special">}</span>
 <span class="preprocessor">#else</span>
+ <span class="preprocessor">#if</span> <span class="special">!</span><span class="identifier">defined</span><span class="special">(</span><span class="identifier">BOOST_CONVERSION_DOXYGEN_INVOKED</span><span class="special">)</span>
+ <span class="keyword">namespace</span> <span class="identifier">conversion</span> <span class="special">{</span>
+ <span class="keyword">namespace</span> <span class="identifier">detail</span> <span class="special">{</span>
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
+ <span class="keyword">struct</span> <span class="identifier">is_optional</span> <span class="special">:</span> <span class="identifier">mpl</span><span class="special">::</span><span class="identifier">false_</span> <span class="special">{};</span>
+ <span class="keyword">template</span> <span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">T</span><span class="special">&gt;</span>
+ <span class="keyword">struct</span> <span class="identifier">is_optional</span><span class="special">&lt;</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">T</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="special">:</span> <span class="identifier">mpl</span><span class="special">::</span><span class="identifier">true_</span> <span class="special">{};</span>
 
+ <span class="special">}</span>
+ <span class="special">}</span>
+ <span class="preprocessor">#endif</span>
   <span class="comment">//! @brief @c convert_to overloading for source and target been @c boost::optional.
 </span> <span class="comment">//!
 </span> <span class="comment">//! @Returns If the optional source is initialized @c boost::optional&lt;Target&gt; initialized to the conversion of the optional value.
 </span> <span class="comment">//! Uninitialized @c boost::optional&lt;Target otherwise.
 </span> <span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">Target</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Source</span><span class="special">&gt;</span>
- <span class="keyword">inline</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">Target</span><span class="special">&gt;</span> <span class="identifier">convert_to</span><span class="special">(</span><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">Source</span><span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="identifier">from</span>
- <span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">Target</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span>
+ <span class="keyword">inline</span>
+ <span class="keyword">typename</span> <span class="identifier">enable_if</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">conversion</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">is_optional</span><span class="special">&lt;</span><span class="identifier">Target</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">,</span><span class="identifier">Target</span><span class="special">&gt;::</span><span class="identifier">type</span>
+ <span class="identifier">convert_to</span><span class="special">(</span>
+ <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">Source</span><span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="identifier">from</span>
+ <span class="special">,</span> <span class="identifier">conversion</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span><span class="identifier">Target</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="identifier">p</span><span class="special">=</span><span class="identifier">conversion</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span><span class="identifier">Target</span><span class="special">&gt;()</span>
+ <span class="special">)</span>
   <span class="special">{</span>
- <span class="keyword">return</span> <span class="special">(</span><span class="identifier">from</span><span class="special">?</span><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">Target</span><span class="special">&gt;(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">conversion</span><span class="special">::</span><span class="identifier">convert_to</span><span class="special">&lt;</span><span class="identifier">Target</span><span class="special">&gt;(</span><span class="identifier">from</span><span class="special">.</span><span class="identifier">get</span><span class="special">())):</span><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">Target</span><span class="special">&gt;());</span>
+ <span class="special">(</span><span class="keyword">void</span><span class="special">)</span><span class="identifier">p</span><span class="special">;</span> <span class="comment">// warning removal
+</span> <span class="keyword">return</span> <span class="special">(</span><span class="identifier">from</span><span class="special">?</span><span class="identifier">Target</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">conversion</span><span class="special">::</span><span class="identifier">convert_to</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Target</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">&gt;(</span><span class="identifier">from</span><span class="special">.</span><span class="identifier">get</span><span class="special">())):</span><span class="identifier">Target</span><span class="special">());</span>
   <span class="special">}</span>
-
+
+<span class="preprocessor">#if</span> <span class="number">0</span>
   <span class="comment">//! @brief @c convert_to overloading to try to convert the source to the target.
 </span> <span class="comment">//!
-</span> <span class="comment">//! We can see this specialization as a try_convert_to function.
-</span> <span class="comment">//! @Returns If the source is convertible to the target @c boost::optional&lt;Target&gt; initialized to the result of the conversion.
+</span> <span class="comment">//! We can see this overloading as a try_convert_to function.
+</span> <span class="comment">//! @Returns If the source is convertible to the target @c value_type @c boost::optional&lt;Target&gt; initialized to the result of the conversion.
 </span> <span class="comment">//! Uninitialized @c boost::optional&lt;Target otherwise.
 </span> <span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">Target</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Source</span><span class="special">&gt;</span>
- <span class="keyword">inline</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">Target</span><span class="special">&gt;</span> <span class="identifier">convert_to</span><span class="special">(</span><span class="identifier">Source</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="identifier">from</span>
- <span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">Target</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;)</span>
+ <span class="keyword">inline</span>
+ <span class="keyword">typename</span> <span class="identifier">enable_if</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">conversion</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">is_optional</span><span class="special">&lt;</span><span class="identifier">Target</span><span class="special">&gt;::</span><span class="identifier">type</span><span class="special">,</span><span class="identifier">Target</span><span class="special">&gt;::</span><span class="identifier">type</span>
+ <span class="identifier">convert_to</span><span class="special">(</span><span class="identifier">Source</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="identifier">from</span>
+ <span class="special">,</span> <span class="identifier">conversion</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span><span class="identifier">Target</span><span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span><span class="identifier">p</span><span class="special">=</span><span class="identifier">conversion</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span><span class="identifier">Target</span><span class="special">&gt;()</span>
+ <span class="special">)</span>
   <span class="special">{</span>
     <span class="keyword">try</span>
     <span class="special">{</span>
- <span class="keyword">return</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">Target</span><span class="special">&gt;(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">conversion</span><span class="special">::</span><span class="identifier">convert_to</span><span class="special">&lt;</span><span class="identifier">Target</span><span class="special">&gt;(</span><span class="identifier">from</span><span class="special">));</span>
+ <span class="keyword">return</span> <span class="identifier">Target</span><span class="special">(</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">conversion</span><span class="special">::</span><span class="identifier">convert_to</span><span class="special">&lt;</span><span class="keyword">typename</span> <span class="identifier">Target</span><span class="special">::</span><span class="identifier">value_type</span><span class="special">&gt;(</span><span class="identifier">from</span><span class="special">));</span>
     <span class="special">}</span>
     <span class="keyword">catch</span> <span class="special">(...)</span>
     <span class="special">{</span>
- <span class="keyword">return</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">Target</span><span class="special">&gt;();</span>
+ <span class="keyword">return</span> <span class="identifier">Target</span><span class="special">();</span>
     <span class="special">}</span>
   <span class="special">}</span>
-
+<span class="preprocessor">#endif</span>
   <span class="comment">//! @brief @c assign_to overloading for source and target been @c boost::optional.
 </span> <span class="comment">//!
 </span> <span class="comment">//! @Effects As if &lt;c&gt;to = boost::conversion::convert_to&lt;optional&lt;Target&gt; &gt;(from)&lt;/c&gt;.
 </span> <span class="comment">//! @Returns The @c to parameter reference.
 </span> <span class="keyword">template</span> <span class="special">&lt;</span> <span class="keyword">class</span> <span class="identifier">Target</span><span class="special">,</span> <span class="keyword">class</span> <span class="identifier">Source</span><span class="special">&gt;</span>
   <span class="keyword">inline</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">Target</span><span class="special">&gt;&amp;</span> <span class="identifier">assign_to</span><span class="special">(</span><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">Target</span><span class="special">&gt;&amp;</span> <span class="identifier">to</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">Source</span><span class="special">&gt;&amp;</span> <span class="identifier">from</span>
- <span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">Target</span><span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">const</span><span class="special">&amp;</span>
- <span class="special">)</span>
+ <span class="special">)</span>
   <span class="special">{</span>
     <span class="identifier">to</span> <span class="special">=</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">conversion</span><span class="special">::</span><span class="identifier">convert_to</span><span class="special">&lt;</span><span class="identifier">optional</span><span class="special">&lt;</span><span class="identifier">Target</span><span class="special">&gt;</span> <span class="special">&gt;(</span><span class="identifier">from</span><span class="special">);</span>
     <span class="comment">//to = from?optional&lt;Target&gt;(boost::conversion::convert_to&lt;Target&gt;(from.get())):optional&lt;Target&gt;();
@@ -1241,22 +1259,17 @@
 <div class="titlepage"><div><div><h4 class="title">
 <a name="header.boost.conversion.assign_to_hpp"></a>Header &lt;boost/conversion/assign_to.hpp&gt;</h4></div></div></div>
 <p>Defines the free function <code class="computeroutput">assign_to</code>. </p>
-<p>The function <code class="computeroutput">assign_to</code> assigns the <code class="computeroutput">from</code> parameter to the <code class="computeroutput">to</code> parameter. The default implementation applies the the assignment operator of the <code class="computeroutput">To</code> class. A user adapting another type could need to specialize the <code class="computeroutput">assign_to</code> free function if the default behavior is not satisfactory.</p>
-<p>The user can add the <code class="computeroutput">assign_to</code> overloading on the namespace of the Source or Target classes. But sometimes as it is the case for the standard classes, we can not add new functions on the std namespace, so we need a different technique.</p>
-<p>The technique consists in partially specialize on the function <code class="computeroutput">assign_to</code> on the <code class="computeroutput">boost::conversion</code> namespace. For compilers for which we can not partially specialize a function a trick is used: instead of calling directly to the <code class="computeroutput">assign_to</code> member function, <code class="computeroutput">assign_to</code> calls to the static operation apply on a class with the same name in the namespace <code class="computeroutput">overload_workaround</code>. Thus the user can specialize partially this class. </p>
+<p>The function <code class="computeroutput">assign_to</code> assigns the <code class="computeroutput">from</code> parameter to the <code class="computeroutput">to</code> parameter. The default implementation uses the <code class="computeroutput">convert_to</code> to convert the source to the target and use the copy assignment of the <code class="computeroutput">Target</code> class.</p>
+<p>A user adapting another type could need to specialize the <code class="computeroutput">assign_to</code> free function if the default behavior is not satisfactory. The user can add the <code class="computeroutput">assign_to</code> overloading on the namespace of the Source or Target classes. But sometimes as it is the case for the standard classes, we can not add new functions on the std namespace, so we need a different technique. The technique consists in partially specialize on the function <code class="computeroutput">assign_to</code> on the <code class="computeroutput">boost::conversion::overload_workaround</code> namespace. </p>
 <pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
   <span class="keyword">namespace</span> <span class="identifier">conversion</span> <span class="special">{</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Target<span class="special">,</span> <span class="keyword">typename</span> Source<span class="special">&gt;</span>
- <span class="identifier">Target</span> <span class="special">&amp;</span> <a class="link" href="boost/conversion/assign_to_id35974124.html" title="Function template assign_to"><span class="identifier">assign_to</span></a><span class="special">(</span><span class="identifier">Target</span> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Source</span> <span class="special">&amp;</span><span class="special">,</span>
- <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">boost::dummy::base_tag</a><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="special">=</span> <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">boost::dummy::base_tag</a><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
+ <span class="identifier">Target</span> <span class="special">&amp;</span> <a class="link" href="boost/conversion/assign_to_id35974515.html" title="Function template assign_to"><span class="identifier">assign_to</span></a><span class="special">(</span><span class="identifier">Target</span> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Source</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
     <span class="keyword">namespace</span> <span class="identifier">overload_workaround</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> To<span class="special">,</span> <span class="keyword">typename</span> From<span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="boost/conversion/overload_workaround/assign_to.html" title="Struct template assign_to">assign_to</a><span class="special">;</span>
+ <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> To<span class="special">,</span> <span class="keyword">typename</span> From<span class="special">,</span> <span class="keyword">typename</span> Enable <span class="special">=</span> <span class="keyword">void</span><span class="special">&gt;</span>
+ <span class="keyword">struct</span> <a class="link" href="boost/conversion/overload_workaround/assign_to.html" title="Struct template assign_to">assign_to</a><span class="special">;</span>
     <span class="special">}</span>
   <span class="special">}</span>
- <span class="keyword">namespace</span> <span class="identifier">conversion_2</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> To<span class="special">,</span> <span class="keyword">typename</span> From<span class="special">&gt;</span>
- <span class="identifier">To</span> <span class="special">&amp;</span> <a class="link" href="boost/conversion_2/assign_to_id35974194.html" title="Function template assign_to"><span class="identifier">assign_to</span></a><span class="special">(</span><span class="identifier">To</span> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">From</span> <span class="special">&amp;</span><span class="special">,</span> <a class="link" href="boost/dummy/type_tag.html" title="Struct template type_tag">dummy::type_tag</a><span class="special">&lt;</span> <span class="identifier">To</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
 <span class="special">}</span></pre>
 </div>
 <div class="section">
@@ -1274,24 +1287,24 @@
 <div class="titlepage"><div><div><h4 class="title">
 <a name="header.boost.conversion.convert_to_hpp"></a>Header &lt;boost/conversion/convert_to.hpp&gt;</h4></div></div></div>
 <p>Defines the free function <code class="computeroutput">convert_to</code>. </p>
-<p>The <code class="computeroutput">convert_to</code> function converts the <code class="computeroutput">from</code> parameter to a <code class="computeroutput">To</code> type. The default implementation applies the conversion <code class="computeroutput">To</code> operator of the <code class="computeroutput">From</code> class or the copy constructor of the <code class="computeroutput">To</code> class. Of course if both exist the conversion is ambiguous. A user adapting another type could need to overload the <code class="computeroutput">convert_to</code> free function if the default behavior is not satisfactory.</p>
-<p>The user can add the <code class="computeroutput">convert_to</code> overloading on any namespace found by ADL from the <code class="computeroutput">Source</code> or the <code class="computeroutput">Target</code>. A trick is used to overload on the return type by adding a dummy parameter having the Target.</p>
-<p>But sometimes, as it is the case for the standard classes, we can not add new functions on the <code class="computeroutput">std</code> namespace, so we need a different technique.</p>
-<p>Instead of calling directly to the conversion operator, <code class="computeroutput">convert_to</code> calls to the static operation apply on a class with the same name in the namespace <code class="computeroutput">boost::conversion::overload_workaround</code>. Thus the user can specialize partially this class. </p>
+<p>The <code class="computeroutput">convert_to</code> function converts the <code class="computeroutput">from</code> parameter to a <code class="computeroutput">To</code> type. The default implementation applies the conversion <code class="computeroutput">To</code> operator of the <code class="computeroutput">From</code> class or the copy constructor of the <code class="computeroutput">To</code> class. Of course if both exist the conversion is ambiguous.</p>
+<p>A user adapting another type could need to overload the <code class="computeroutput">convert_to</code> free function if the default behavior is not satisfactory. The user can add the <code class="computeroutput">convert_to</code> overloading on any namespace found by ADL from the <code class="computeroutput">Source</code> or the <code class="computeroutput">Target</code>. A trick is used to overload on the return type by adding a dummy parameter having the Target.</p>
+<p>But sometimes, as it is the case for the standard classes, we can not add new functions on the <code class="computeroutput">std</code> namespace, so we need a different technique. In this case the user can partially specialize the <code class="computeroutput"><a class="link" href="boost/conversion/overload_workaround/convert_to.html" title="Struct template convert_to">boost::conversion::overload_workaround::convert_to</a></code> struct. </p>
 <pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
   <span class="keyword">namespace</span> <span class="identifier">conversion</span> <span class="special">{</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> Enabled <span class="special">=</span> <span class="keyword">void</span><span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="boost/conversion/enable_functor.html" title="Struct template enable_functor">enable_functor</a><span class="special">;</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Target<span class="special">,</span> <span class="keyword">typename</span> Source<span class="special">&gt;</span>
- <span class="identifier">Target</span> <a class="link" href="boost/conversion/convert_to_id35974710.html" title="Function template convert_to"><span class="identifier">convert_to</span></a><span class="special">(</span><span class="identifier">Source</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
- <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">boost::dummy::base_tag</a><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="special">=</span> <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">boost::dummy::base_tag</a><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
+ <span class="identifier">Target</span> <a class="link" href="boost/conversion/convert_to_id35975289.html" title="Function template convert_to"><span class="identifier">convert_to</span></a><span class="special">(</span><span class="identifier">Source</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
+ <a class="link" href="boost/conversion/dummy/base_tag.html" title="Struct template base_tag">dummy::base_tag</a><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="special">=</span> <a class="link" href="boost/conversion/dummy/base_tag.html" title="Struct template base_tag">dummy::base_tag</a><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
+ <span class="keyword">namespace</span> <span class="identifier">dummy</span> <span class="special">{</span>
+ <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="boost/conversion/dummy/base_tag.html" title="Struct template base_tag">base_tag</a><span class="special">;</span>
+ <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="boost/conversion/dummy/type_tag.html" title="Struct template type_tag">type_tag</a><span class="special">;</span>
+ <span class="special">}</span>
     <span class="keyword">namespace</span> <span class="identifier">overload_workaround</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> To<span class="special">,</span> <span class="keyword">typename</span> From<span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="boost/conversion/overload_workaround/convert_to.html" title="Struct template convert_to">convert_to</a><span class="special">;</span>
+ <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> To<span class="special">,</span> <span class="keyword">typename</span> From<span class="special">,</span> <span class="keyword">typename</span> Enable <span class="special">=</span> <span class="keyword">void</span><span class="special">&gt;</span>
+ <span class="keyword">struct</span> <a class="link" href="boost/conversion/overload_workaround/convert_to.html" title="Struct template convert_to">convert_to</a><span class="special">;</span>
     <span class="special">}</span>
   <span class="special">}</span>
- <span class="keyword">namespace</span> <span class="identifier">dummy</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">base_tag</a><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="boost/dummy/type_tag.html" title="Struct template type_tag">type_tag</a><span class="special">;</span>
- <span class="special">}</span>
 <span class="special">}</span></pre>
 </div>
 <div class="section">
@@ -1300,8 +1313,11 @@
 <pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
   <span class="keyword">namespace</span> <span class="identifier">conversion</span> <span class="special">{</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">&gt;</span>
- <span class="keyword">struct</span> <a class="link" href="boost/conversion/enable_functor_T__typen_id35974986.html" title="Struct template enable_functor&lt;T, typename enable_if&lt; phoenix::is_actor&lt; T &gt; &gt;::type&gt;">enable_functor</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">enable_if</span><span class="special">&lt;</span> <span class="identifier">phoenix</span><span class="special">::</span><span class="identifier">is_actor</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span><span class="special">&gt;</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> U<span class="special">&gt;</span> <span class="emphasis"><em><span class="identifier">unspecified</span></em></span> <a class="link" href="boost/conversion/convert_to_id35975024.html" title="Function template convert_to"><span class="identifier">convert_to</span></a><span class="special">(</span><span class="identifier">U</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
+ <span class="keyword">struct</span> <a class="link" href="boost/conversion/enable_functor_T__typen_id35975418.html" title="Struct template enable_functor&lt;T, typename enable_if&lt; phoenix::is_actor&lt; T &gt; &gt;::type&gt;">enable_functor</a><span class="special">&lt;</span><span class="identifier">T</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">enable_if</span><span class="special">&lt;</span> <span class="identifier">phoenix</span><span class="special">::</span><span class="identifier">is_actor</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span><span class="special">&gt;</span><span class="special">;</span>
+ <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> U<span class="special">&gt;</span>
+ <span class="identifier">unspecified_converter_type</span> <a class="link" href="boost/conversion/make_converter_to.html" title="Function template make_converter_to"><span class="identifier">make_converter_to</span></a><span class="special">(</span><span class="identifier">U</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
+ <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> U<span class="special">&gt;</span>
+ <span class="identifier">unspecified_converter_type</span> <a class="link" href="boost/conversion/convert_to_id35975523.html" title="Function template convert_to"><span class="identifier">convert_to</span></a><span class="special">(</span><span class="identifier">U</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
   <span class="special">}</span>
 <span class="special">}</span></pre>
 </div>
@@ -1310,18 +1326,15 @@
 <a name="header.boost.conversion.convert_to_or_fallback_hpp"></a>Header &lt;boost/conversion/convert_to_or_fallback.hpp&gt;</h4></div></div></div>
 <p>Defines the free function <code class="computeroutput">convert_to_or_fallback</code>. </p>
 <p>The <code class="computeroutput">convert_to_or_fallback</code> function converts the <code class="computeroutput">from</code> parameter to a <code class="computeroutput">To</code> type. If the conversion fails the fallback value is used to construct a To <code class="computeroutput">instance</code>.</p>
-<p>The default implementation applies the conversion <code class="computeroutput">To</code> operator of the <code class="computeroutput">From</code> class or the copy constructor of the <code class="computeroutput">To</code> class. When an exception is thrown the falback is returned. Of course if both exist the conversion is ambiguous. A user adapting another type could need to specialize the <code class="computeroutput">convert_to_or_fallback</code> free function if the default behavior is not satisfactory.</p>
+<p>The default implementation applies the conversion <code class="computeroutput">To</code> operator of the <code class="computeroutput">From</code> class or the copy constructor of the <code class="computeroutput">To</code> class. When an exception is thrown the fallback is returned. Of course if both exist the conversion is ambiguous. A user adapting another type could need to specialize the <code class="computeroutput">convert_to_or_fallback</code> free function if the default behavior is not satisfactory.</p>
 <p>The user can add the <code class="computeroutput">convert_to_or_fallback</code> overloading on any namespace found by ADL from the <code class="computeroutput">Source</code> or the <code class="computeroutput">Target</code>. A trick is used to overload on the return type by adding a dummy parameter having the Target.</p>
 <p>But sometimes, as it is the case for the standard classes, we can not add new functions on the std namespace, so we need a different technique.</p>
 <p>The technique consists in partially specialize on the function <code class="computeroutput">convert_to_or_fallback</code> on the <code class="computeroutput">boost::conversion</code> namespace. For compilers for which we can not partially specialize a function a trick is used: instead of calling directly to the <code class="computeroutput">convert_to_or_fallback</code> member function, <code class="computeroutput">convert_to_or_fallback</code> calls to the static operation apply on a class with the same name in the namespace <code class="computeroutput">overload_workaround</code>. Thus the user can specialize partially this class. </p>
 <pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Target<span class="special">,</span> <span class="keyword">typename</span> Source<span class="special">,</span> <span class="keyword">typename</span> Fallback<span class="special">&gt;</span>
- <span class="identifier">Target</span> <a class="link" href="boost/convert_to_or_fallback_id35975332.html" title="Function template convert_to_or_fallback"><span class="identifier">convert_to_or_fallback</span></a><span class="special">(</span><span class="identifier">Source</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">Fallback</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
- <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">boost::dummy::base_tag</a><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="special">=</span> <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">boost::dummy::base_tag</a><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
   <span class="keyword">namespace</span> <span class="identifier">conversion</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> To<span class="special">,</span> <span class="keyword">typename</span> From<span class="special">,</span> <span class="keyword">typename</span> Fallback<span class="special">&gt;</span>
- <span class="identifier">To</span> <a class="link" href="boost/conversion/convert_to_or_fallback_id35975263.html" title="Function template convert_to_or_fallback"><span class="identifier">convert_to_or_fallback</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">From</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">Fallback</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
- <a class="link" href="boost/dummy/type_tag.html" title="Struct template type_tag">dummy::type_tag</a><span class="special">&lt;</span> <span class="identifier">To</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
+ <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Target<span class="special">,</span> <span class="keyword">typename</span> Source<span class="special">,</span> <span class="keyword">typename</span> Fallback<span class="special">&gt;</span>
+ <span class="identifier">Target</span> <a class="link" href="boost/conversion/convert_to_or_fallback_id35975775.html" title="Function template convert_to_or_fallback"><span class="identifier">convert_to_or_fallback</span></a><span class="special">(</span><span class="identifier">Source</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">Fallback</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
+ <a class="link" href="boost/conversion/dummy/base_tag.html" title="Struct template base_tag">dummy::base_tag</a><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="special">=</span> <a class="link" href="boost/conversion/dummy/base_tag.html" title="Struct template base_tag">dummy::base_tag</a><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
     <span class="keyword">namespace</span> <span class="identifier">overload_workaround</span> <span class="special">{</span>
       <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> To<span class="special">,</span> <span class="keyword">typename</span> From<span class="special">,</span> <span class="keyword">typename</span> Fallback<span class="special">&gt;</span>
         <span class="keyword">struct</span> <a class="link" href="boost/conversion/overload_workaround/convert_to_or_fallback.html" title="Struct template convert_to_or_fallback">convert_to_or_fallback</a><span class="special">;</span>
@@ -1353,22 +1366,22 @@
   <span class="keyword">namespace</span> <span class="identifier">conversion</span> <span class="special">{</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T1<span class="special">,</span> <span class="keyword">typename</span> T2<span class="special">&gt;</span>
       <a class="link" href="boost/conversion/result_of/pack2.html" title="Struct template pack2">boost::conversion::result_of::pack2</a><span class="special">&lt;</span> <span class="identifier">T1</span> <span class="keyword">const</span><span class="special">,</span> <span class="identifier">T2</span> <span class="keyword">const</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span>
- <a class="link" href="boost/conversion/pack_id35975535.html" title="Function template pack"><span class="identifier">pack</span></a><span class="special">(</span><span class="identifier">T1</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">T2</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
+ <a class="link" href="boost/conversion/pack_id35975985.html" title="Function template pack"><span class="identifier">pack</span></a><span class="special">(</span><span class="identifier">T1</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">T2</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T1<span class="special">,</span> <span class="keyword">typename</span> T2<span class="special">&gt;</span>
       <a class="link" href="boost/conversion/result_of/pack2.html" title="Struct template pack2">boost::conversion::result_of::pack2</a><span class="special">&lt;</span> <span class="identifier">T1</span> <span class="keyword">const</span><span class="special">,</span> <span class="identifier">T2</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span>
- <a class="link" href="boost/conversion/pack_id35975568.html" title="Function template pack"><span class="identifier">pack</span></a><span class="special">(</span><span class="identifier">T1</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">T2</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
+ <a class="link" href="boost/conversion/pack_id35976018.html" title="Function template pack"><span class="identifier">pack</span></a><span class="special">(</span><span class="identifier">T1</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">T2</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T1<span class="special">,</span> <span class="keyword">typename</span> T2<span class="special">,</span> <span class="keyword">typename</span> T3<span class="special">&gt;</span>
       <a class="link" href="boost/conversion/result_of/pack3.html" title="Struct template pack3">boost::conversion::result_of::pack3</a><span class="special">&lt;</span> <span class="identifier">T1</span> <span class="keyword">const</span><span class="special">,</span> <span class="identifier">T2</span> <span class="keyword">const</span><span class="special">,</span> <span class="identifier">T3</span> <span class="keyword">const</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span>
- <a class="link" href="boost/conversion/pack_id35975600.html" title="Function template pack"><span class="identifier">pack</span></a><span class="special">(</span><span class="identifier">T1</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">T2</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">T3</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
+ <a class="link" href="boost/conversion/pack_id35976051.html" title="Function template pack"><span class="identifier">pack</span></a><span class="special">(</span><span class="identifier">T1</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">T2</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">T3</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T1<span class="special">,</span> <span class="keyword">typename</span> T2<span class="special">,</span> <span class="keyword">typename</span> T3<span class="special">&gt;</span>
       <a class="link" href="boost/conversion/result_of/pack3.html" title="Struct template pack3">boost::conversion::result_of::pack3</a><span class="special">&lt;</span> <span class="identifier">T1</span> <span class="keyword">const</span><span class="special">,</span> <span class="identifier">T2</span> <span class="keyword">const</span><span class="special">,</span> <span class="identifier">T3</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span>
- <a class="link" href="boost/conversion/pack_id35975643.html" title="Function template pack"><span class="identifier">pack</span></a><span class="special">(</span><span class="identifier">T1</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">T2</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">T3</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
+ <a class="link" href="boost/conversion/pack_id35976094.html" title="Function template pack"><span class="identifier">pack</span></a><span class="special">(</span><span class="identifier">T1</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">T2</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">T3</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T1<span class="special">,</span> <span class="keyword">typename</span> T2<span class="special">,</span> <span class="keyword">typename</span> T3<span class="special">&gt;</span>
       <a class="link" href="boost/conversion/result_of/pack3.html" title="Struct template pack3">boost::conversion::result_of::pack3</a><span class="special">&lt;</span> <span class="identifier">T1</span> <span class="keyword">const</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">,</span> <span class="identifier">T3</span> <span class="keyword">const</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span>
- <a class="link" href="boost/conversion/pack_id35975686.html" title="Function template pack"><span class="identifier">pack</span></a><span class="special">(</span><span class="identifier">T1</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">T2</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">T3</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
+ <a class="link" href="boost/conversion/pack_id35976136.html" title="Function template pack"><span class="identifier">pack</span></a><span class="special">(</span><span class="identifier">T1</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">T2</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">T3</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T1<span class="special">,</span> <span class="keyword">typename</span> T2<span class="special">,</span> <span class="keyword">typename</span> T3<span class="special">&gt;</span>
       <a class="link" href="boost/conversion/result_of/pack3.html" title="Struct template pack3">boost::conversion::result_of::pack3</a><span class="special">&lt;</span> <span class="identifier">T1</span> <span class="keyword">const</span><span class="special">,</span> <span class="identifier">T2</span><span class="special">,</span> <span class="identifier">T3</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span>
- <a class="link" href="boost/conversion/pack_id35975728.html" title="Function template pack"><span class="identifier">pack</span></a><span class="special">(</span><span class="identifier">T1</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">T2</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">T3</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
+ <a class="link" href="boost/conversion/pack_id35976179.html" title="Function template pack"><span class="identifier">pack</span></a><span class="special">(</span><span class="identifier">T1</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">T2</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">T3</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
     <span class="keyword">namespace</span> <span class="identifier">result_of</span> <span class="special">{</span>
       <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T1<span class="special">,</span> <span class="keyword">typename</span> T2<span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="boost/conversion/result_of/pack2.html" title="Struct template pack2">pack2</a><span class="special">;</span>
       <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T1<span class="special">,</span> <span class="keyword">typename</span> T2<span class="special">,</span> <span class="keyword">typename</span> T3 <span class="special">=</span> <span class="identifier">fusion</span><span class="special">::</span><span class="identifier">void_</span><span class="special">&gt;</span>
@@ -1385,12 +1398,10 @@
 <p>The user can add the <code class="computeroutput">try_assign_to</code> overloading on the namespace of the Source or Target classes. But sometimes as it is the case for the standard classes, we can not add new functions on the std namespace, so we need a different technique.</p>
 <p>The technique consists in partially specialize on the function <code class="computeroutput">try_assign_to</code> on the <code class="computeroutput">boost::conversion</code> namespace. For compilers for which we can not partially specialize a function a trick is used: instead of calling directly to the <code class="computeroutput">try_assign_to</code> member function, <code class="computeroutput">try_assign_to</code> calls to the static operation apply on a class with the same name in the namespace <code class="computeroutput">overload_workaround</code>. Thus the user can specialize partially this class. </p>
 <pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Target<span class="special">,</span> <span class="keyword">typename</span> Source<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="boost/try_assign_to_id35975967.html" title="Function template try_assign_to"><span class="identifier">try_assign_to</span></a><span class="special">(</span><span class="identifier">Target</span> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Source</span> <span class="special">&amp;</span><span class="special">,</span>
- <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">boost::dummy::base_tag</a><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="special">=</span> <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">boost::dummy::base_tag</a><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
   <span class="keyword">namespace</span> <span class="identifier">conversion</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> To<span class="special">,</span> <span class="keyword">typename</span> From<span class="special">&gt;</span>
- <span class="keyword">bool</span> <a class="link" href="boost/conversion/try_assign_to_id35975910.html" title="Function template try_assign_to"><span class="identifier">try_assign_to</span></a><span class="special">(</span><span class="identifier">To</span> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">From</span> <span class="special">&amp;</span><span class="special">,</span> <a class="link" href="boost/dummy/type_tag.html" title="Struct template type_tag">dummy::type_tag</a><span class="special">&lt;</span> <span class="identifier">To</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
+ <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Target<span class="special">,</span> <span class="keyword">typename</span> Source<span class="special">&gt;</span>
+ <span class="keyword">bool</span> <a class="link" href="boost/conversion/try_assign_to_id35976374.html" title="Function template try_assign_to"><span class="identifier">try_assign_to</span></a><span class="special">(</span><span class="identifier">Target</span> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">Source</span> <span class="special">&amp;</span><span class="special">,</span>
+ <a class="link" href="boost/conversion/dummy/base_tag.html" title="Struct template base_tag">dummy::base_tag</a><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="special">=</span> <a class="link" href="boost/conversion/dummy/base_tag.html" title="Struct template base_tag">dummy::base_tag</a><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
     <span class="keyword">namespace</span> <span class="identifier">overload_workaround</span> <span class="special">{</span>
       <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> To<span class="special">,</span> <span class="keyword">typename</span> From<span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="boost/conversion/overload_workaround/try_assign_to.html" title="Struct template try_assign_to">try_assign_to</a><span class="special">;</span>
     <span class="special">}</span>
@@ -1402,7 +1413,7 @@
 <a name="header.boost.conversion.try_convert_to_hpp"></a>Header &lt;boost/conversion/try_convert_to.hpp&gt;</h4></div></div></div>
 <p>Defines the free function <code class="computeroutput">try_convert_to</code>. </p>
 <p>The <code class="computeroutput">try_convert_to</code> function converts the <code class="computeroutput">from</code> parameter to a <code class="computeroutput">To</code> type and returns an optional&lt;To&gt;, uninitialized if conversion fails.</p>
-<p>The default implementation applies the conversion <code class="computeroutput">To</code> operator of the <code class="computeroutput">From</code> class or the copy constructor of the <code class="computeroutput">To</code> class on a try-catch block and returns optional with the converted value if suceeds and an uninitialized optional otherwise. Of course if both exist the conversion is ambiguous. A user adapting specific types could need to specialize the <code class="computeroutput">try_convert_to</code> free function if the default behavior is not satisfactory or if the specialization can perform better.</p>
+<p>The default implementation applies the conversion <code class="computeroutput">To</code> operator of the <code class="computeroutput">From</code> class or the copy constructor of the <code class="computeroutput">To</code> class on a try-catch block and returns optional with the converted value if succeeds and an uninitialized optional otherwise. Of course if both exist the conversion is ambiguous. A user adapting specific types could need to specialize the <code class="computeroutput">try_convert_to</code> free function if the default behavior is not satisfactory or if the specialization can perform better.</p>
 <p>The user can add the <code class="computeroutput">try_convert_to</code> overloading on any namespace found by ADL from the <code class="computeroutput">Source</code> or the <code class="computeroutput">Target</code>. A trick is used to overload on the return type by adding a dummy parameter having the Target.</p>
 <p>But sometimes, as it is the case for the standard classes, we can not add new functions on the std namespace, so we need a different technique.</p>
 <p>The technique consists in partially specialize on the function <code class="computeroutput">try_convert_to</code> on the <code class="computeroutput">boost::conversion</code> namespace. For compilers for which we can not partially specialize a function a trick is used: instead of calling directly to the <code class="computeroutput">try_convert_to</code> member function, <code class="computeroutput">try_convert_to</code> calls to the static operation apply on a class with the same name in the namespace <code class="computeroutput">overload_workaround</code>. Thus the user can specialize partially this class. </p>
@@ -1410,17 +1421,15 @@
   <span class="keyword">namespace</span> <span class="identifier">conversion</span> <span class="special">{</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Target<span class="special">,</span> <span class="keyword">typename</span> Source<span class="special">&gt;</span>
       <span class="identifier">optional</span><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span>
- <a class="link" href="boost/conversion/try_convert_to_id35976188.html" title="Function template try_convert_to"><span class="identifier">try_convert_to</span></a><span class="special">(</span><span class="identifier">Source</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
- <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">boost::dummy::base_tag</a><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="special">=</span> <a class="link" href="boost/dummy/base_tag.html" title="Struct template base_tag">boost::dummy::base_tag</a><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
+ <a class="link" href="boost/conversion/try_convert_to_id35976690.html" title="Function template try_convert_to"><span class="identifier">try_convert_to</span></a><span class="special">(</span><span class="identifier">Source</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
+ <a class="link" href="boost/conversion/dummy/base_tag.html" title="Struct template base_tag">dummy::base_tag</a><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="special">=</span> <a class="link" href="boost/conversion/dummy/base_tag.html" title="Struct template base_tag">dummy::base_tag</a><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
     <span class="keyword">namespace</span> <span class="identifier">overload_workaround</span> <span class="special">{</span>
+ <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Target<span class="special">,</span> <span class="keyword">typename</span> Source<span class="special">&gt;</span>
+ <span class="keyword">struct</span> <a class="link" href="boost/conversion/overload_workaround/convert_to_Target__Sour_id35976538.html" title="Struct template convert_to&lt;Target, Source, typename enable_if&lt; typename conversion::detail::is_optional&lt; Target &gt;::type &gt;::type&gt;">convert_to</a><span class="special">&lt;</span><span class="identifier">Target</span><span class="special">,</span> <span class="identifier">Source</span><span class="special">,</span> <span class="keyword">typename</span> <span class="identifier">enable_if</span><span class="special">&lt;</span> <span class="keyword">typename</span> <span class="identifier">conversion</span><span class="special">::</span><span class="identifier">detail</span><span class="special">::</span><span class="identifier">is_optional</span><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span><span class="special">::</span><span class="identifier">type</span> <span class="special">&gt;</
span><span class="special">::</span><span class="identifier">type</span><span class="special">&gt;</span><span class="special">;</span>
+
       <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> To<span class="special">,</span> <span class="keyword">typename</span> From<span class="special">&gt;</span> <span class="keyword">struct</span> <a class="link" href="boost/conversion/overload_workaround/try_convert_to.html" title="Struct template try_convert_to">try_convert_to</a><span class="special">;</span>
     <span class="special">}</span>
   <span class="special">}</span>
- <span class="keyword">namespace</span> <span class="identifier">conversion_2</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> To<span class="special">,</span> <span class="keyword">typename</span> From<span class="special">&gt;</span>
- <span class="identifier">optional</span><span class="special">&lt;</span> <span class="identifier">To</span> <span class="special">&gt;</span>
- <a class="link" href="boost/conversion_2/try_convert_to_id35976260.html" title="Function template try_convert_to"><span class="identifier">try_convert_to</span></a><span class="special">(</span><span class="keyword">const</span> <span class="identifier">From</span> <span class="special">&amp;</span><span class="special">,</span> <a class="link" href="boost/dummy/type_tag.html" title="Struct template type_tag">dummy::type_tag</a><span class="special">&lt;</span> <span class="identifier">To</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
- <span class="special">}</span>
 <span class="special">}</span></pre>
 </div>
 </div>
@@ -1479,16 +1488,6 @@
 <div class="titlepage"><div><div><h4 class="title">
 <a name="header.boost.array_hpp"></a>Header &lt;boost/array.hpp&gt;</h4></div></div></div>
 <p>Include this file when using conversions between <code class="computeroutput">boost::array&lt;&gt;</code> of convertible types. </p>
-<pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T1<span class="special">,</span> <span class="keyword">typename</span> T2<span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> N<span class="special">&gt;</span>
- <span class="identifier">array</span><span class="special">&lt;</span> <span class="identifier">T1</span><span class="special">,</span> <span class="identifier">N</span> <span class="special">&gt;</span>
- <a class="link" href="boost/convert_to_id35972629.html" title="Function template convert_to"><span class="identifier">convert_to</span></a><span class="special">(</span><span class="identifier">array</span><span class="special">&lt;</span> <span class="identifier">T2</span><span class="special">,</span> <span class="identifier">N</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">array</span><span class="special">&lt;</span> <span class="identifier">T1</span><span class="special">,</span> <span class="identifier">N</span> <span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T1<span class="special">,</span> <span class="keyword">typename</span> T2<span class="special">,</span> <span class="identifier">std</span><span class="special">::</span><span class="identifier">size_t</span> N<span class="special">&gt;</span>
- <span class="identifier">array</span><span class="special">&lt;</span> <span class="identifier">T1</span><span class="special">,</span> <span class="identifier">N</span> <span class="special">&gt;</span> <span class="special">&amp;</span>
- <a class="link" href="boost/assign_to_id35972676.html" title="Function template assign_to"><span class="identifier">assign_to</span></a><span class="special">(</span><span class="identifier">array</span><span class="special">&lt;</span> <span class="identifier">T1</span><span class="special">,</span> <span class="identifier">N</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">,</span> <span class="identifier">array</span><span class="special">&lt;</span> <span class="identifier">T2</span><span class="special">,</span> <span class="identifier">N</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">array</span><span class="special">&lt;</span> <span class="identifier">T1</span><span class="special">,</span> <span class="identifier">N</span> <span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
-<span class="special">}</span></pre>
 </div>
 <div class="section">
 <div class="titlepage"><div><div><h4 class="title">
@@ -1498,22 +1497,20 @@
   <span class="keyword">namespace</span> <span class="identifier">chrono</span> <span class="special">{</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Rep<span class="special">,</span> <span class="keyword">typename</span> Period<span class="special">&gt;</span>
       <span class="identifier">posix_time</span><span class="special">::</span><span class="identifier">time_duration</span>
- <a class="link" href="boost/chrono/convert_to_id35972763.html" title="Function template convert_to"><span class="identifier">convert_to</span></a><span class="special">(</span><span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">posix_time</span><span class="special">::</span><span class="identifier">time_duration</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
+ <a class="link" href="boost/chrono/convert_to_id35973076.html" title="Function template convert_to"><span class="identifier">convert_to</span></a><span class="special">(</span><span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
+ <span class="identifier">conversion</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">posix_time</span><span class="special">::</span><span class="identifier">time_duration</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Rep<span class="special">,</span> <span class="keyword">typename</span> Period<span class="special">&gt;</span>
       <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span> <span class="special">&gt;</span> <span class="special">&amp;</span>
- <a class="link" href="boost/chrono/assign_to_id35972810.html" title="Function template assign_to"><span class="identifier">assign_to</span></a><span class="special">(</span><span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">,</span>
- <span class="keyword">const</span> <span class="identifier">posix_time</span><span class="special">::</span><span class="identifier">time_duration</span> <span class="special">&amp;</span><span class="special">,</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span> <span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
+ <a class="link" href="boost/chrono/assign_to_id35973125.html" title="Function template assign_to"><span class="identifier">assign_to</span></a><span class="special">(</span><span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">,</span>
+ <span class="keyword">const</span> <span class="identifier">posix_time</span><span class="special">::</span><span class="identifier">time_duration</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
   <span class="special">}</span>
   <span class="keyword">namespace</span> <span class="identifier">posix_time</span> <span class="special">{</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Duration<span class="special">&gt;</span>
- <span class="identifier">Duration</span> <a class="link" href="boost/posix_time/convert_to_id35972880.html" title="Function template convert_to"><span class="identifier">convert_to</span></a><span class="special">(</span><span class="identifier">time_duration</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">Duration</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
+ <span class="identifier">Duration</span> <a class="link" href="boost/posix_time/convert_to_id35973189.html" title="Function template convert_to"><span class="identifier">convert_to</span></a><span class="special">(</span><span class="identifier">time_duration</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
+ <span class="identifier">conversion</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">Duration</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Rep<span class="special">,</span> <span class="keyword">typename</span> Period<span class="special">&gt;</span>
       <span class="identifier">time_duration</span> <span class="special">&amp;</span>
- <a class="link" href="boost/posix_time/assign_to_id35972927.html" title="Function template assign_to"><span class="identifier">assign_to</span></a><span class="special">(</span><span class="identifier">time_duration</span> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">,</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">posix_time</span><span class="special">::</span><span class="identifier">time_duration</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
+ <a class="link" href="boost/posix_time/assign_to_id35973236.html" title="Function template assign_to"><span class="identifier">assign_to</span></a><span class="special">(</span><span class="identifier">time_duration</span> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">duration</span><span class="special">&lt;</span> <span class="identifier">Rep</span><span class="special">,</span> <span class="identifier">Period</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
   <span class="special">}</span>
 <span class="special">}</span></pre>
 </div>
@@ -1525,21 +1522,20 @@
   <span class="keyword">namespace</span> <span class="identifier">chrono</span> <span class="special">{</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Clock<span class="special">,</span> <span class="keyword">typename</span> Duration<span class="special">&gt;</span>
       <span class="identifier">posix_time</span><span class="special">::</span><span class="identifier">ptime</span>
- <a name="boost.chrono.convert_to_id35973016"></a><span class="identifier">convert_to</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span> <span class="special">&gt;</span> <span class="special">&amp;</span> from<span class="special">,</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">posix_time</span><span class="special">::</span><span class="identifier">ptime</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
+ <a name="boost.chrono.convert_to_id35973319"></a><span class="identifier">convert_to</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span> <span class="special">&gt;</span> <span class="special">&amp;</span> from<span class="special">,</span>
+ <span class="identifier">conversion</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">posix_time</span><span class="special">::</span><span class="identifier">ptime</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Clock<span class="special">,</span> <span class="keyword">typename</span> Duration<span class="special">&gt;</span>
       <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span> <span class="special">&gt;</span> <span class="special">&amp;</span>
- <a name="boost.chrono.assign_to_id35973044"></a><span class="identifier">assign_to</span><span class="special">(</span><span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span> <span class="special">&gt;</span> <span class="special">&amp;</span> to<span class="special">,</span>
- <span class="keyword">const</span> <span class="identifier">posix_time</span><span class="special">::</span><span class="identifier">ptime</span> <span class="special">&amp;</span> from<span class="special">,</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span> <span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
+ <a name="boost.chrono.assign_to_id35973347"></a><span class="identifier">assign_to</span><span class="special">(</span><span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span> <span class="special">&gt;</span> <span class="special">&amp;</span> to<span class="special">,</span>
+ <span class="keyword">const</span> <span class="identifier">posix_time</span><span class="special">::</span><span class="identifier">ptime</span> <span class="special">&amp;</span> from<span class="special">)</span><span class="special">;</span>
   <span class="special">}</span>
   <span class="keyword">namespace</span> <span class="identifier">posix_time</span> <span class="special">{</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> TP<span class="special">&gt;</span>
- <span class="identifier">TP</span> <a name="boost.posix_time.convert_to_id35973080"></a><span class="identifier">convert_to</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ptime</span> <span class="special">&amp;</span> from<span class="special">,</span> <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">TP</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
+ <span class="identifier">TP</span> <a name="boost.posix_time.convert_to_id35973377"></a><span class="identifier">convert_to</span><span class="special">(</span><span class="keyword">const</span> <span class="identifier">ptime</span> <span class="special">&amp;</span> from<span class="special">,</span>
+ <span class="identifier">conversion</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">TP</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Clock<span class="special">,</span> <span class="keyword">typename</span> Duration<span class="special">&gt;</span>
- <span class="identifier">ptime</span> <span class="special">&amp;</span> <a name="boost.posix_time.assign_to_id35973103"></a><span class="identifier">assign_to</span><span class="special">(</span><span class="identifier">ptime</span> <span class="special">&amp;</span> to<span class="special">,</span>
- <span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span> <span class="special">&gt;</span> <span class="special">&amp;</span> from<span class="special">,</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">posix_time</span><span class="special">::</span><span class="identifier">ptime</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
+ <span class="identifier">ptime</span> <span class="special">&amp;</span> <a name="boost.posix_time.assign_to_id35973400"></a><span class="identifier">assign_to</span><span class="special">(</span><span class="identifier">ptime</span> <span class="special">&amp;</span> to<span class="special">,</span>
+ <span class="keyword">const</span> <span class="identifier">chrono</span><span class="special">::</span><span class="identifier">time_point</span><span class="special">&lt;</span> <span class="identifier">Clock</span><span class="special">,</span> <span class="identifier">Duration</span> <span class="special">&gt;</span> <span class="special">&amp;</span> from<span class="special">)</span><span class="special">;</span>
   <span class="special">}</span>
 <span class="special">}</span></pre>
 </div>
@@ -1551,12 +1547,11 @@
   <span class="keyword">namespace</span> <span class="identifier">numeric</span> <span class="special">{</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> PT<span class="special">,</span> <span class="keyword">typename</span> U<span class="special">,</span> <span class="keyword">typename</span> PU<span class="special">&gt;</span>
       <span class="identifier">interval</span><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">PT</span> <span class="special">&gt;</span>
- <a class="link" href="boost/numeric/convert_to_id35973151.html" title="Function template convert_to"><span class="identifier">convert_to</span></a><span class="special">(</span><span class="identifier">interval</span><span class="special">&lt;</span> <span class="identifier">U</span><span class="special">,</span> <span class="identifier">PU</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">interval</span><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">PT</span> <span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
+ <a class="link" href="boost/numeric/convert_to_id35973443.html" title="Function template convert_to"><span class="identifier">convert_to</span></a><span class="special">(</span><span class="identifier">interval</span><span class="special">&lt;</span> <span class="identifier">U</span><span class="special">,</span> <span class="identifier">PU</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
+ <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">conversion</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">interval</span><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">PT</span> <span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="special">=</span> <span class="special">::</span><span class="identifier">boost</span><span class="special">::</span><span class="identifier">conversion</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">interval</
span><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">PT</span> <span class="special">&gt;</span> <span class="special">&gt;</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
     <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> PT<span class="special">,</span> <span class="keyword">typename</span> U<span class="special">,</span> <span class="keyword">typename</span> PU<span class="special">&gt;</span>
       <span class="identifier">interval</span><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">PT</span> <span class="special">&gt;</span> <span class="special">&amp;</span>
- <a name="boost.numeric.assign_to_id35971986"></a><span class="identifier">assign_to</span><span class="special">(</span><span class="identifier">interval</span><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">PT</span> <span class="special">&gt;</span> <span class="special">&amp;</span> to<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">interval</span><span class="special">&lt;</span> <span class="identifier">U</span><span class="special">,</span> <span class="identifier">PU</span> <span class="special">&gt;</span> <span class="special">&amp;</span> from<span class="special">,</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">interval</span><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">PT</span> <span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
+ <a name="boost.numeric.assign_to_id35973498"></a><span class="identifier">assign_to</span><span class="special">(</span><span class="identifier">interval</span><span class="special">&lt;</span> <span class="identifier">T</span><span class="special">,</span> <span class="identifier">PT</span> <span class="special">&gt;</span> <span class="special">&amp;</span> to<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">interval</span><span class="special">&lt;</span> <span class="identifier">U</span><span class="special">,</span> <span class="identifier">PU</span> <span class="special">&gt;</span> <span class="special">&amp;</span> from<span class="special">)</span><span class="special">;</span>
   <span class="special">}</span>
 <span class="special">}</span></pre>
 </div>
@@ -1566,17 +1561,11 @@
 <p>Include this file when using conversions between <code class="computeroutput">boost::optional&lt;&gt;</code> of convertible types. </p>
 <pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Target<span class="special">,</span> <span class="keyword">typename</span> Source<span class="special">&gt;</span>
- <span class="identifier">optional</span><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span>
- <a class="link" href="boost/convert_to_id35976383.html" title="Function template convert_to"><span class="identifier">convert_to</span></a><span class="special">(</span><span class="identifier">optional</span><span class="special">&lt;</span> <span class="identifier">Source</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">optional</span><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
- <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Target<span class="special">,</span> <span class="keyword">typename</span> Source<span class="special">&gt;</span>
- <span class="identifier">optional</span><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span>
- <a class="link" href="boost/convert_to_id35976434.html" title="Function template convert_to"><span class="identifier">convert_to</span></a><span class="special">(</span><span class="identifier">Source</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">optional</span><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
+ <span class="emphasis"><em><span class="identifier">unspecified</span></em></span> <a class="link" href="boost/convert_to_id35973547.html" title="Function template convert_to"><span class="identifier">convert_to</span></a><span class="special">(</span><span class="identifier">optional</span><span class="special">&lt;</span> <span class="identifier">Source</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
+ <span class="identifier">conversion</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">conversion</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> Target<span class="special">,</span> <span class="keyword">typename</span> Source<span class="special">&gt;</span>
     <span class="identifier">optional</span><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span> <span class="special">&amp;</span>
- <a class="link" href="boost/assign_to_id35976485.html" title="Function template assign_to"><span class="identifier">assign_to</span></a><span class="special">(</span><span class="identifier">optional</span><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">optional</span><span class="special">&lt;</span> <span class="identifier">Source</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">,</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">optional</span><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
+ <a class="link" href="boost/assign_to_id35972319.html" title="Function template assign_to"><span class="identifier">assign_to</span></a><span class="special">(</span><span class="identifier">optional</span><span class="special">&lt;</span> <span class="identifier">Target</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">,</span> <span class="keyword">const</span> <span class="identifier">optional</span><span class="special">&lt;</span> <span class="identifier">Source</span> <span class="special">&gt;</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
 <span class="special">}</span></pre>
 </div>
 <div class="section">
@@ -1585,13 +1574,10 @@
 <p>Include this file when using conversions between <code class="computeroutput">boost::rational&lt;&gt;</code> of convertible types. </p>
 <pre class="synopsis"><span class="keyword">namespace</span> <span class="identifier">boost</span> <span class="special">{</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> U<span class="special">&gt;</span>
- <span class="identifier">rational</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span>
- <a class="link" href="boost/convert_to_id35976560.html" title="Function template convert_to"><span class="identifier">convert_to</span></a><span class="special">(</span><span class="identifier">rational</span><span class="special">&lt;</span> <span class="identifier">U</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">rational</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
+ <span class="emphasis"><em><span class="identifier">unspecified</span></em></span> <a class="link" href="boost/convert_to_id35976822.html" title="Function template convert_to"><span class="identifier">convert_to</span></a><span class="special">(</span><span class="identifier">rational</span><span class="special">&lt;</span> <span class="identifier">U</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">,</span>
+ <span class="identifier">conversion</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span> <span class="special">=</span> <span class="identifier">conversion</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span><span class="special">(</span><span class="special">)</span><span class="special">)</span><span class="special">;</span>
   <span class="keyword">template</span><span class="special">&lt;</span><span class="keyword">typename</span> T<span class="special">,</span> <span class="keyword">typename</span> U<span class="special">&gt;</span>
- <span class="identifier">rational</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span> <span class="special">&amp;</span>
- <a name="boost.assign_to_id35976604"></a><span class="identifier">assign_to</span><span class="special">(</span><span class="identifier">rational</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span> <span class="special">&amp;</span> to<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">rational</span><span class="special">&lt;</span> <span class="identifier">U</span> <span class="special">&gt;</span> <span class="special">&amp;</span> from<span class="special">,</span>
- <span class="identifier">boost</span><span class="special">::</span><span class="identifier">dummy</span><span class="special">::</span><span class="identifier">type_tag</span><span class="special">&lt;</span> <span class="identifier">rational</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span> <span class="special">&gt;</span> <span class="keyword">const</span> <span class="special">&amp;</span><span class="special">)</span><span class="special">;</span>
+ <span class="identifier">rational</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span> <span class="special">&amp;</span> <a name="boost.assign_to_id35976870"></a><span class="identifier">assign_to</span><span class="special">(</span><span class="identifier">rational</span><span class="special">&lt;</span> <span class="identifier">T</span> <span class="special">&gt;</span> <span class="special">&amp;</span> to<span class="special">,</span> <span class="keyword">const</span> <span class="identifier">rational</span><span class="special">&lt;</span> <span class="identifier">U</span> <span class="special">&gt;</span> <span class="special">&amp;</span> from<span class="special">)</span><span class="special">;</span>
 <span class="special">}</span></pre>
 </div>
 <div class="section">
@@ -1853,7 +1839,7 @@
 <a name="boost.conversion.appendices.rationale"></a><a class="link" href="index.html#boost.conversion.appendices.rationale" title="Appendix B: Rationale">Appendix B: Rationale</a>
 </h3></div></div></div>
 <a name="boost.conversion.appendices.rationale.trick_to_avoid_recursion_on_the_convert_to_calls"></a><h5>
-<a name="id36377583"></a>
+<a name="id36376402"></a>
         <a class="link" href="index.html#boost.conversion.appendices.rationale.trick_to_avoid_recursion_on_the_convert_to_calls">Trick
         to avoid recursion on the convert_to calls</a>
       </h5>
@@ -1909,7 +1895,7 @@
 <span class="special">}</span>
 </pre>
 <a name="boost.conversion.appendices.rationale.trick_to_avoid_the_use_of_the_tag_on_the_user_side"></a><h5>
-<a name="id36378460"></a>
+<a name="id36377414"></a>
         <a class="link" href="index.html#boost.conversion.appendices.rationale.trick_to_avoid_the_use_of_the_tag_on_the_user_side">Trick
         to avoid the use of the tag on the user side</a>
       </h5>
@@ -1931,7 +1917,7 @@
 <pre class="programlisting"><span class="identifier">a</span><span class="special">=</span> <span class="identifier">convert_to</span><span class="special">&lt;</span><span class="identifier">A</span><span class="special">&gt;(</span><span class="identifier">b</span><span class="special">);</span>
 </pre>
 <a name="boost.conversion.appendices.rationale.mathematical_background"></a><h5>
-<a name="id36378784"></a>
+<a name="id36377739"></a>
         <a class="link" href="index.html#boost.conversion.appendices.rationale.mathematical_background">Mathematical
         background</a>
       </h5>
@@ -1985,7 +1971,7 @@
         The library provides a convert_to_via function which helps to implement that.
       </p>
 <a name="boost.conversion.appendices.rationale.ambiguity_of_multiple_overloadins"></a><h5>
-<a name="id36379274"></a>
+<a name="id36378229"></a>
         <a class="link" href="index.html#boost.conversion.appendices.rationale.ambiguity_of_multiple_overloadins">Ambiguity
         of multiple overloadins</a>
       </h5>
@@ -2005,7 +1991,7 @@
       C: Implementation Notes</a>
 </h3></div></div></div>
 <a name="boost.conversion.appendices.implementation.why__code__phrase_role__identifier__convert_to__phrase___code__between_tuples_is_not_implemented_using__code__phrase_role__identifier__boost__phrase__phrase_role__special______phrase__phrase_role__identifier__fusion__phrase__phrase_role__special______phrase__phrase_role__identifier__transform__phrase___code__"></a><h5>
-<a name="id36379316"></a>
+<a name="id36378271"></a>
         <a class="link" href="index.html#boost.conversion.appendices.implementation.why__code__phrase_role__identifier__convert_to__phrase___code__between_tuples_is_not_implemented_using__code__phrase_role__identifier__boost__phrase__phrase_role__special______phrase__phrase_role__identifier__fusion__phrase__phrase_role__special______phrase__phrase_role__identifier__transform__phrase___code__">Why
         <code class="computeroutput"><span class="identifier">convert_to</span></code> between tuples
         is not implemented using <code class="computeroutput"><span class="identifier">boost</span><span class="special">::</span><span class="identifier">fusion</span><span class="special">::</span><span class="identifier">transform</span></code>?</a>
@@ -3156,12 +3142,12 @@
       plans</a>
 </h3></div></div></div>
 <a name="boost.conversion.appendices.todo.tasks_to_do_before_review"></a><h5>
-<a name="id36381707"></a>
+<a name="id36380657"></a>
         <a class="link" href="index.html#boost.conversion.appendices.todo.tasks_to_do_before_review">Tasks
         to do before review</a>
       </h5>
 <a name="boost.conversion.appendices.todo.for_later_releases"></a><h5>
-<a name="id36381726"></a>
+<a name="id36380676"></a>
         <a class="link" href="index.html#boost.conversion.appendices.todo.for_later_releases">For later
         releases</a>
       </h5>
@@ -3174,7 +3160,7 @@
           </li>
 </ul></div>
 <a name="boost.conversion.appendices.todo.make_a_proposal_to_the_c___standard"></a><h5>
-<a name="id36381763"></a>
+<a name="id36380713"></a>
         <a class="link" href="index.html#boost.conversion.appendices.todo.make_a_proposal_to_the_c___standard">Make
         a proposal to the C++ standard</a>
       </h5>
@@ -3238,7 +3224,7 @@
 </div>
 </div>
 <table xmlns:rev="http://www.cs.rpi.edu/~gregod/boost/tools/doc/revision" width="100%"><tr>
-<td align="left"><p><small>Last revised: May 25, 2011 at 22:15:20 GMT</small></p></td>
+<td align="left"><p><small>Last revised: May 31, 2011 at 09:59:03 GMT</small></p></td>
 <td align="right"><div class="copyright-footer"></div></td>
 </tr></table>
 <hr>

Modified: sandbox/conversion/libs/conversion_ext/doc/html/standalone_HTML.manifest
==============================================================================
--- sandbox/conversion/libs/conversion_ext/doc/html/standalone_HTML.manifest (original)
+++ sandbox/conversion/libs/conversion_ext/doc/html/standalone_HTML.manifest 2011-05-31 06:05:43 EDT (Tue, 31 May 2011)
@@ -1,54 +1,51 @@
 index.html
 boost/conversion/overload_workaround/assign_to.html
-boost/conversion/assign_to_id35974124.html
-boost/conversion_2/assign_to_id35974194.html
+boost/conversion/assign_to_id35974515.html
 boost/conversion/ca_wrapper.html
 boost/mca.html
+boost/conversion/dummy/base_tag.html
+boost/conversion/dummy/type_tag.html
 boost/conversion/overload_workaround/convert_to.html
 boost/conversion/enable_functor.html
-boost/conversion/convert_to_id35974710.html
-boost/dummy/base_tag.html
-boost/dummy/type_tag.html
-boost/conversion/enable_functor_T__typen_id35974986.html
-boost/conversion/convert_to_id35975024.html
+boost/conversion/convert_to_id35975289.html
+boost/conversion/enable_functor_T__typen_id35975418.html
+boost/conversion/make_converter_to.html
+boost/conversion/convert_to_id35975523.html
 boost/conversion/overload_workaround/convert_to_or_fallback.html
-boost/conversion/convert_to_or_fallback_id35975263.html
-boost/convert_to_or_fallback_id35975332.html
+boost/conversion/convert_to_or_fallback_id35975775.html
 boost/conversion/result_of/pack2.html
 boost/conversion/result_of/pack3.html
-boost/conversion/pack_id35975535.html
-boost/conversion/pack_id35975568.html
-boost/conversion/pack_id35975600.html
-boost/conversion/pack_id35975643.html
-boost/conversion/pack_id35975686.html
-boost/conversion/pack_id35975728.html
+boost/conversion/pack_id35975985.html
+boost/conversion/pack_id35976018.html
+boost/conversion/pack_id35976051.html
+boost/conversion/pack_id35976094.html
+boost/conversion/pack_id35976136.html
+boost/conversion/pack_id35976179.html
 boost/conversion/overload_workaround/try_assign_to.html
-boost/conversion/try_assign_to_id35975910.html
-boost/try_assign_to_id35975967.html
+boost/conversion/try_assign_to_id35976374.html
+boost/conversion/overload_workaround/convert_to_Target__Sour_id35976538.html
 boost/conversion/overload_workaround/try_convert_to.html
-boost/conversion/try_convert_to_id35976188.html
-boost/conversion_2/try_convert_to_id35976260.html
-boost/conversion/overload_workaround/convert_to_std_complex__id35973887.html
-boost/conversion/overload_workaround/assign_to_std_complex_T_id35973920.html
-boost/conversion/overload_workaround/convert_to_std_pair_T1__id35973976.html
-boost/conversion/overload_workaround/assign_to_std_pair_T1___id35973205.html
-boost/conversion/overload_workaround/convert_to_std_basic_st_id35973273.html
-boost/conversion/overload_workaround/convert_to_T__std_basic_id35971993.html
-boost/conversion/overload_workaround/assign_to_std_basic_str_id35972039.html
-boost/conversion/overload_workaround/assign_to_T__std_basic__id35972089.html
-boost/conversion/overload_workaround/convert_to_std_string___id35972140.html
-boost/conversion/overload_workaround/convert_to_bool__std_st_id35972165.html
-boost/conversion/overload_workaround/convert_to_std_vector_T_id35972210.html
-boost/conversion/overload_workaround/assign_to_std_vector_T1_id35972258.html
-boost/conversion/overload_workaround/convert_to_std_vector_T_id35972313.html
-boost/convert_to_id35972629.html
-boost/assign_to_id35972676.html
-boost/chrono/convert_to_id35972763.html
-boost/chrono/assign_to_id35972810.html
-boost/posix_time/convert_to_id35972880.html
-boost/posix_time/assign_to_id35972927.html
-boost/numeric/convert_to_id35973151.html
-boost/convert_to_id35976383.html
-boost/convert_to_id35976434.html
-boost/assign_to_id35976485.html
-boost/convert_to_id35976560.html
+boost/conversion/try_convert_to_id35976690.html
+boost/conversion/overload_workaround/convert_to_std_complex__id35974287.html
+boost/conversion/overload_workaround/assign_to_std_complex_T_id35974320.html
+boost/conversion/overload_workaround/convert_to_std_pair_T1__id35974376.html
+boost/conversion/overload_workaround/assign_to_std_pair_T1___id35973624.html
+boost/conversion/overload_workaround/convert_to_std_basic_st_id35973692.html
+boost/conversion/overload_workaround/convert_to_T__std_basic_id35972354.html
+boost/conversion/overload_workaround/assign_to_std_basic_str_id35972399.html
+boost/conversion/overload_workaround/assign_to_T__std_basic__id35972450.html
+boost/conversion/overload_workaround/convert_to_std_string___id35972501.html
+boost/conversion/overload_workaround/convert_to_bool__std_st_id35972526.html
+boost/conversion/overload_workaround/convert_to_std_vector_T_id35972571.html
+boost/conversion/overload_workaround/assign_to_std_vector_T1_id35972619.html
+boost/conversion/overload_workaround/convert_to_std_vector_T_id35972674.html
+boost/conversion/overload_workaround/convert_to_array_T1__N__id35972932.html
+boost/conversion/overload_workaround/assign_to_array_T1__N___id35972989.html
+boost/chrono/convert_to_id35973076.html
+boost/chrono/assign_to_id35973125.html
+boost/posix_time/convert_to_id35973189.html
+boost/posix_time/assign_to_id35973236.html
+boost/numeric/convert_to_id35973443.html
+boost/convert_to_id35973547.html
+boost/assign_to_id35972319.html
+boost/convert_to_id35976822.html


Boost-Commit list run by bdawes at acm.org, david.abrahams at rcn.com, gregod at cs.rpi.edu, cpdaniel at pacbell.net, john at johnmaddock.co.uk