Documentation update

[SVN r52266]

doc/BOOST_THROW_EXCEPTION.html

@@ -25,13 +25,13 @@
 <div class="RenoIncludeDIV"><pre>#if !defined( BOOST_EXCEPTION_DISABLE )
     #include &lt;<span class="RenoLink"><a href="exception_exception_hpp.html">boost/exception/exception.hpp</a></span>&gt;
     #include &lt;boost/current_function.hpp&gt;
-    #define <span class="RenoLink"><a href="BOOST_THROW_EXCEPTION.html">BOOST_THROW_EXCEPTION</a></span>(x)\
+    #define <span class="RenoLink">BOOST_THROW_EXCEPTION</span>(x)\
         ::boost::<span class="RenoLink"><a href="throw_exception.html">throw_exception</a></span>( ::boost::<span class="RenoLink"><a href="enable_error_info.html">enable_error_info</a></span>(x) &lt;&lt;\
         ::boost::<span class="RenoLink"><a href="exception_exception_hpp.html">throw_function</a></span>(BOOST_CURRENT_FUNCTION) &lt;&lt;\
         ::boost::<span class="RenoLink"><a href="exception_exception_hpp.html">throw_file</a></span>(__FILE__) &lt;&lt;\
         ::boost::<span class="RenoLink"><a href="exception_exception_hpp.html">throw_line</a></span>((int)__LINE__) )
 #else
-    #define <span class="RenoLink"><a href="BOOST_THROW_EXCEPTION.html">BOOST_THROW_EXCEPTION</a></span>(x) ::boost::<span class="RenoLink"><a href="throw_exception.html">throw_exception</a></span>(x)
+    #define <span class="RenoLink">BOOST_THROW_EXCEPTION</span>(x) ::boost::<span class="RenoLink"><a href="throw_exception.html">throw_exception</a></span>(x)
 #endif</pre>
 </div></div><p>This macro takes an exception object, records BOOST_CURRENT_FUNCTION, __FILE__ and __LINE__ in it, and forwards it to <span class="RenoLink"><a href="throw_exception.html">throw_exception</a></span>. To recover this information at the catch site, use <span class="RenoLink"><a href="get_error_info.html">get_error_info</a></span>; the information is also included in the message returned by <span class="RenoLink"><a href="diagnostic_information.html">diagnostic_information</a></span>.</p>
 </div><div class="RenoAutoDIV"><div class="RenoHR"><hr/></div>

doc/copy_exception.html

@@ -26,7 +26,7 @@
 boost
     {
 <span class="RenoIncludeSPAN">    template &lt;class T&gt;
-    <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span> <span class="RenoLink"><a href="copy_exception.html">copy_exception</a></span>( T const &amp; e );</span>
+    <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span> <span class="RenoLink">copy_exception</span>( T const &amp; e );</span>
     }</pre>
 </div><h4>Effects:</h4>
 <p>As if</p>

doc/current_exception.html

@@ -25,10 +25,10 @@
 <pre>namespace
 boost
     {
-<span class="RenoIncludeSPAN">    <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span> <span class="RenoLink"><a href="current_exception.html">current_exception</a></span>();</span>
+<span class="RenoIncludeSPAN">    <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span> <span class="RenoLink">current_exception</span>();</span>
     }</pre>
 </div><h4>Requirements:</h4>
-<p>The <span class="RenoLink"><a href="current_exception.html">current_exception</a></span> function must not be called outside of a catch block.</p>
+<p>The <span class="RenoLink">current_exception</span> function must not be called outside of a catch block.</p>
 <h4>Returns:</h4>
 <div><ul><li> An <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span> that refers to the currently handled exception or a copy of the currently handled exception.</li>
 <li> If the function needs to allocate memory and the attempt fails, it returns an <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span> that refers to an instance of std::bad_alloc.</li>
@@ -36,8 +36,8 @@ boost
 <h4>Throws:</h4>
 <p>Nothing.</p>
 <h4>Notes:</h4>
-<div><ul><li> It is unspecified whether the return values of two successive calls to <span class="RenoLink"><a href="current_exception.html">current_exception</a></span> refer to the same exception object.</li>
+<div><ul><li> It is unspecified whether the return values of two successive calls to <span class="RenoLink">current_exception</span> refer to the same exception object.</li>
-<li> Correct implementation of <span class="RenoLink"><a href="current_exception.html">current_exception</a></span> may require compiler support, unless <span class="RenoLink"><a href="enable_current_exception.html">enable_current_exception</a></span> was used at the time the currently handled exception object was passed to throw. If <span class="RenoLink"><a href="enable_current_exception.html">enable_current_exception</a></span> was not used, and if the compiler does not provide the necessary support, then <span class="RenoLink"><a href="current_exception.html">current_exception</a></span> may return an <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span> that refers to an instance of <span class="RenoLink"><a href="unknown_exception.html">unknown_exception</a></span>. In this case, if the original exception object derives from boost::<span class="RenoLink"><a href="exception.html">exception</a></span>, then the boost::<span class="RenoLink"><a href="exception.html">exception</a></span> sub-object of the <span class="RenoLink"><a href="unknown_exception.html">unknown_exception</a></span> object is initialized by the boost::<span class="RenoLink"><a href="exception.html">exception</a></span> copy constructor.</li>
+<li> Correct implementation of <span class="RenoLink">current_exception</span> may require compiler support, unless <span class="RenoLink"><a href="enable_current_exception.html">enable_current_exception</a></span> was used at the time the currently handled exception object was passed to throw. If <span class="RenoLink"><a href="enable_current_exception.html">enable_current_exception</a></span> was not used, and if the compiler does not provide the necessary support, then <span class="RenoLink">current_exception</span> may return an <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span> that refers to an instance of <span class="RenoLink"><a href="unknown_exception.html">unknown_exception</a></span>. In this case, if the original exception object derives from boost::<span class="RenoLink"><a href="exception.html">exception</a></span>, then the boost::<span class="RenoLink"><a href="exception.html">exception</a></span> sub-object of the <span class="RenoLink"><a href="unknown_exception.html">unknown_exception</a></span> object is initialized by the boost::<span class="RenoLink"><a href="exception.html">exception</a></span> copy constructor.</li>
 </ul></div>
 </div><div class="RenoAutoDIV"><div class="RenoHR"><hr/></div>
 <h3>See Also:</h3>

doc/current_exception_cast.html

@@ -25,7 +25,7 @@
 boost
     {
 <span class="RenoIncludeSPAN">    template &lt;class E&gt;
-    E * <span class="RenoLink"><a href="current_exception_cast.html">current_exception_cast</a></span>();</span>
+    E * <span class="RenoLink">current_exception_cast</span>();</span>
     }</pre>
 </div><h4>Requirements:</h4>
 <p>This function must not be called outside of a catch block.</p>

doc/current_exception_diagnostic_information.html

@@ -25,13 +25,13 @@
 <pre>namespace
 boost
     {
-<span class="RenoIncludeSPAN">    std::string <span class="RenoLink"><a href="current_exception_diagnostic_information.html">current_exception_diagnostic_information</a></span>();</span>
+<span class="RenoIncludeSPAN">    std::string <span class="RenoLink">current_exception_diagnostic_information</span>();</span>
     }</pre>
 </div><h4>Requirements:</h4>
 <p>This function must not be called outside of a catch block.</p>
 <h4>Returns:</h4>
 <p>If the current exception object can be converted to boost::<span class="RenoLink"><a href="exception.html">exception</a></span> or std::exception, this function returns the same string value returned by <span class="RenoLink"><a href="diagnostic_information.html">diagnostic_information</a></span> for the current exception object. Otherwise, an unspecified non-empty string is returned.</p>
-<p>Typical use is to call <span class="RenoLink"><a href="current_exception_diagnostic_information.html">current_exception_diagnostic_information</a></span> from a top-level function to output diagnostic information about unhandled exceptions:</p>
+<p>Typical use is to call <span class="RenoLink">current_exception_diagnostic_information</span> from a top-level function to output diagnostic information about unhandled exceptions:</p>
 <pre>int
 main()
     {
@@ -48,7 +48,7 @@ main()
     ...)
         {
         std::cerr &lt;&lt; "Unhandled exception!" &lt;&lt; std::endl &lt;&lt;
-            boost::<span class="RenoLink"><a href="current_exception_diagnostic_information.html">current_exception_diagnostic_information</a></span>();
+            boost::<span class="RenoLink">current_exception_diagnostic_information</span>();
         }
     }</pre>
 </div><div class="RenoAutoDIV"><div class="RenoHR"><hr/></div>

doc/diagnostic_information.html

@@ -26,7 +26,7 @@
 boost
     {
 <span class="RenoIncludeSPAN">    template &lt;class E&gt;
-    std::string <span class="RenoLink"><a href="diagnostic_information.html">diagnostic_information</a></span>( E const &amp; e );</span>
+    std::string <span class="RenoLink">diagnostic_information</span>( E const &amp; e );</span>
     }</pre>
 </div><h4>Returns:</h4>
 <p>A string value that contains varying amount of implementation-specific diagnostic information about the passed exception object:</p>
@@ -35,21 +35,21 @@ boost
 <li>otherwise the returned value contains the what() string.</li>
 </ul></div>
 </li>
-<li>Otherwise, the boost::<span class="RenoLink"><a href="diagnostic_information.html">diagnostic_information</a></span> template is not available.</li>
+<li>Otherwise, the boost::<span class="RenoLink">diagnostic_information</span> template is not available.</li>
 </ul></div>
 <p>The string representation of each <span class="RenoLink"><a href="error_info.html">error_info</a></span> object is deduced by a function call that is bound at the time the <span class="RenoLink"><a href="error_info.html">error_info</a></span>&lt;Tag,T&gt; template is instantiated. The following overload resolutions are attempted in order:</p>
 <div><ol><li>Unqualified call to to_string(x), where x is of type <span class="RenoLink"><a href="error_info.html">error_info</a></span>&lt;Tag,T&gt; (the return value is expected to be of type std::string.)</li>
 <li>Unqualified call to to_string(x.<span class="RenoLink"><a href="error_info_value.html">value</a></span>()) (the return value is expected to be of type std::string.)</li>
 <li>Unqualified call to s &lt;&lt; x.<span class="RenoLink"><a href="error_info_value.html">value</a></span>(), where s is a std::ostringstream.</li>
 </ol></div>
-<p>The first successfully bound function is used at the time <span class="RenoLink"><a href="diagnostic_information.html">diagnostic_information</a></span> is called; if all 3 overload resolutions are unsuccessful, the system is unable to convert the <span class="RenoLink"><a href="error_info.html">error_info</a></span> object to string, and <i>an unspecified stub string value is used without issuing a compile error.</i></p>
+<p>The first successfully bound function is used at the time <span class="RenoLink">diagnostic_information</span> is called; if all 3 overload resolutions are unsuccessful, the system is unable to convert the <span class="RenoLink"><a href="error_info.html">error_info</a></span> object to string, and <i>an unspecified stub string value is used without issuing a compile error.</i></p>
 <h4>Notes:</h4>
 <div><ul><li>The format of the returned string is unspecified.</li>
 <li>The returned string is <i>not</i> user-friendly.</li>
 <li>The returned string may include additional platform-specific diagnostic information.</li>
 </ul></div>
 <div class="RenoIncludeDIV"><h4>Example:</h4>
-<p>this is a possible output from the <span class="RenoLink"><a href="diagnostic_information.html">diagnostic_information</a></span> function, as used in <i>libs/exception/example/example_io.cpp:</i></p>
+<p>this is a possible output from the <span class="RenoLink">diagnostic_information</span> function, as used in <i>libs/exception/example/example_io.cpp:</i></p>
 <pre>example_io.cpp(83): Throw in function class boost::shared_ptr&lt;struct _iobuf&gt; __cdecl my_fopen(const char *,const char *)
 Dynamic exception type: class boost::exception_detail::clone_impl&lt;class fopen_error&gt;
 std::exception::what: example_io error

doc/enable_current_exception.html

@@ -26,7 +26,7 @@
 boost
     {
 <span class="RenoIncludeSPAN">    template &lt;class T&gt;
-    ---unspecified--- <span class="RenoLink"><a href="enable_current_exception.html">enable_current_exception</a></span>( T const &amp; e );</span>
+    ---unspecified--- <span class="RenoLink">enable_current_exception</span>( T const &amp; e );</span>
     }</pre>
 </div><h4>Requirements:</h4>
 <p>T must be a class with an accessible no-throw copy constructor.</p>
@@ -41,8 +41,8 @@ my_exception:
     };
 
 ....
-throw boost::<span class="RenoLink"><a href="enable_current_exception.html">enable_current_exception</a></span>(my_exception());</pre>
+throw boost::<span class="RenoLink">enable_current_exception</span>(my_exception());</pre>
-<p>Unless <span class="RenoLink"><a href="enable_current_exception.html">enable_current_exception</a></span> is called at the time an exception object is used in a throw-expression, an attempt to copy it using <span class="RenoLink"><a href="current_exception.html">current_exception</a></span> may return an <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span> which refers to an instance of <span class="RenoLink"><a href="unknown_exception.html">unknown_exception</a></span>. See <span class="RenoLink"><a href="current_exception.html">current_exception</a></span> for details.</p>
+<p>Unless <span class="RenoLink">enable_current_exception</span> is called at the time an exception object is used in a throw-expression, an attempt to copy it using <span class="RenoLink"><a href="current_exception.html">current_exception</a></span> may return an <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span> which refers to an instance of <span class="RenoLink"><a href="unknown_exception.html">unknown_exception</a></span>. See <span class="RenoLink"><a href="current_exception.html">current_exception</a></span> for details.</p>
 <h4>Note:</h4>
 <p>Instead of using the throw keyword directly, it is preferable to call boost::<span class="RenoLink"><a href="throw_exception.html">throw_exception</a></span>. This is guaranteed to throw an exception that derives from boost::<span class="RenoLink"><a href="exception.html">exception</a></span> and supports the <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span> functionality.</p>
 </div><div class="RenoAutoDIV"><div class="RenoHR"><hr/></div>

doc/enable_error_info.html

@@ -26,7 +26,7 @@
 boost
     {
 <span class="RenoIncludeSPAN">    template &lt;class T&gt;
-    ---unspecified--- <span class="RenoLink"><a href="enable_error_info.html">enable_error_info</a></span>( T const &amp; x );</span>
+    ---unspecified--- <span class="RenoLink">enable_error_info</span>( T const &amp; x );</span>
     }</pre>
 </div><h4>Requirements:</h4>
 <p>T must be a class with an accessible no-throw copy constructor as per (15.5.1).</p>

doc/error_info.html

@@ -27,7 +27,7 @@ boost
     {
 <span class="RenoIncludeSPAN">    template &lt;class Tag,class T&gt;
     class
-    <span class="RenoLink"><a href="error_info.html">error_info</a></span>
+    <span class="RenoLink">error_info</span>
         {
         public:
     
@@ -40,17 +40,17 @@ boost
 </div><h4>Requirements:</h4>
 <p>T must have accessible copy constructor and must not be a reference (there is no requirement that T's copy constructor does not throw.)</p>
 <h4>Description:</h4>
-<p>This class template is used to associate a Tag type with a value type T. Objects of type <span class="RenoLink"><a href="error_info.html">error_info</a></span>&lt;Tag,T&gt; can be passed to <span class="RenoLink"><a href="exception_operator_shl.html">operator&lt;&lt;</a></span> to be stored in objects of type boost::<span class="RenoLink"><a href="exception.html">exception</a></span>.</p>
+<p>This class template is used to associate a Tag type with a value type T. Objects of type <span class="RenoLink">error_info</span>&lt;Tag,T&gt; can be passed to <span class="RenoLink"><a href="exception_operator_shl.html">operator&lt;&lt;</a></span> to be stored in objects of type boost::<span class="RenoLink"><a href="exception.html">exception</a></span>.</p>
 <h4>Usage:</h4>
-<p>The header &lt;<span class="RenoLink"><a href="exception_error_info_value_hpp.html">boost/exception/error_info.hpp</a></span>&gt; provides a declaration of the <span class="RenoLink"><a href="error_info.html">error_info</a></span> template, which is sufficient for the purpose of typedefing an instance for specific Tag and T, for example:</p>
+<p>The header &lt;<span class="RenoLink"><a href="exception_error_info_value_hpp.html">boost/exception/error_info.hpp</a></span>&gt; provides a declaration of the <span class="RenoLink">error_info</span> template, which is sufficient for the purpose of typedefing an instance for specific Tag and T, for example:</p>
 <pre>#include &lt;<span class="RenoLink"><a href="exception_error_info_value_hpp.html">boost/exception/error_info.hpp</a></span>&gt;
 
 struct tag_errno;
-typedef boost::<span class="RenoLink"><a href="error_info.html">error_info</a></span>&lt;tag_errno,int&gt; errno_info;</pre>
+typedef boost::<span class="RenoLink">error_info</span>&lt;tag_errno,int&gt; errno_info;</pre>
 <p>Or, the shorter equivalent:</p>
 <pre>#include &lt;<span class="RenoLink"><a href="exception_error_info_value_hpp.html">boost/exception/error_info.hpp</a></span>&gt;
 
-typedef boost::<span class="RenoLink"><a href="error_info.html">error_info</a></span>&lt;struct tag_errno,int&gt; errno_info;</pre>
+typedef boost::<span class="RenoLink">error_info</span>&lt;struct tag_errno,int&gt; errno_info;</pre>
 <p>This errno_info typedef can be passed to <span class="RenoLink"><a href="exception_operator_shl.html">operator&lt;&lt;</a></span> (#include &lt;<span class="RenoLink"><a href="exception_error_info_hpp.html">boost/exception/info.hpp</a></span>&gt; first) to store an int named tag_errno in exceptions of types that derive from boost::<span class="RenoLink"><a href="exception.html">exception</a></span>:</p>
 <pre>throw file_read_error() <span class="RenoLink"><a href="exception_operator_shl.html">&lt;&lt;</a></span> errno_info(errno);</pre>
 <p>It can also be passed to <span class="RenoLink"><a href="get_error_info.html">get_error_info</a></span> (#include &lt;<span class="RenoLink"><a href="exception_get_error_info_hpp.html">boost/exception/get_error_info.hpp</a></span>&gt; first) to retrieve the tag_errno int from a boost::<span class="RenoLink"><a href="exception.html">exception</a></span>:</p>

doc/error_info_error_info.html

@@ -22,7 +22,7 @@
 <div class="RenoIncludeDIV"><div class="RenoAutoDIV"><h3>error_info::error_info</h3>
 </div>
 <div class="RenoIncludeDIV"><p><span class="RenoEscape">&#35;<!--<wiki>`&#35;</wiki>--></span>include &lt;<span class="RenoLink"><a href="exception_error_info_hpp.html">boost/exception/info.hpp</a></span>&gt;</p>
-<pre><span class="RenoIncludeSPAN"><span class="RenoLink"><a href="error_info_error_info.html">error_info</a></span>( <span class="RenoLink"><a href="error_info_value_type.html">value_type</a></span> const &amp; v );</span></pre>
+<pre><span class="RenoIncludeSPAN"><span class="RenoLink">error_info</span>( <span class="RenoLink"><a href="error_info_value_type.html">value_type</a></span> const &amp; v );</span></pre>
 </div><h4>Effects:</h4>
 <p>Stores a copy of v in the <span class="RenoLink"><a href="error_info.html">error_info</a></span> object.</p>
 <div class="RenoIncludeDIV"><h4>Throws:</h4>

doc/error_info_value.html

@@ -22,7 +22,7 @@
 <div class="RenoIncludeDIV"><div class="RenoAutoDIV"><h3>error_info::value</h3>
 </div>
 <div class="RenoIncludeDIV"><p><span class="RenoEscape">&#35;<!--<wiki>`&#35;</wiki>--></span>include &lt;<span class="RenoLink"><a href="exception_error_info_hpp.html">boost/exception/info.hpp</a></span>&gt;</p>
-<pre><span class="RenoIncludeSPAN"><span class="RenoLink"><a href="error_info_value_type.html">value_type</a></span> const &amp; <span class="RenoLink"><a href="error_info_value.html">value</a></span>() const;</span></pre>
+<pre><span class="RenoIncludeSPAN"><span class="RenoLink"><a href="error_info_value_type.html">value_type</a></span> const &amp; <span class="RenoLink">value</span>() const;</span></pre>
 </div><h4>Description:</h4>
 <p>Returns a const reference to the copy of the value passed to <span class="RenoLink"><a href="error_info.html">error_info</a></span>'s constructor stored in the <span class="RenoLink"><a href="error_info.html">error_info</a></span> object.</p>
 <h4>Throws:</h4>

doc/error_info_value_type.html

@@ -22,14 +22,15 @@
 <div class="RenoIncludeDIV"><div class="RenoAutoDIV"><h3>error_info::value_type</h3>
 </div>
 <div class="RenoIncludeDIV"><p><span class="RenoEscape">&#35;<!--<wiki>`&#35;</wiki>--></span>include &lt;<span class="RenoLink"><a href="exception_error_info_hpp.html">boost/exception/info.hpp</a></span>&gt;</p>
-<pre><span class="RenoIncludeSPAN">typedef T <span class="RenoLink"><a href="error_info_value_type.html">value_type</a></span>;</span></pre>
+<pre><span class="RenoIncludeSPAN">typedef T <span class="RenoLink">value_type</span>;</span></pre>
 </div><h4>Definition:</h4>
-<p>The expression <span class="RenoLink"><a href="error_info.html">error_info</a></span>&lt;Tag,T&gt;::<span class="RenoLink"><a href="error_info_value_type.html">value_type</a></span> evaluates to T.</p>
+<p>The expression <span class="RenoLink"><a href="error_info.html">error_info</a></span>&lt;Tag,T&gt;::<span class="RenoLink">value_type</span> evaluates to T.</p>
 </div><div class="RenoAutoDIV"><div class="RenoHR"><hr/></div>
 <h3>See Also:</h3>
 <div class="RenoPageList"><a href="error_info.html">error_info<br/>
 </a><a href="error_info_error_info.html">error_info::error_info<br/>
 </a><a href="error_info_value.html">error_info::value<br/>
+</a><a href="get_error_info.html">get_error_info<br/>
 </a></div>
 </div>
 <!-- Copyright (c) 2006-2009 Emil Dotchevski and Reverge Studios, Inc. -->

doc/exception.html

@@ -26,18 +26,18 @@
 boost
     {
 <span class="RenoIncludeSPAN">    class
-    <span class="RenoLink"><a href="exception.html">exception</a></span>
+    <span class="RenoLink">exception</span>
         {
         protected:
     
     <span class="RenoIncludeSPAN">    <span class="RenoLink"><a href="exception_constructors.html">exception</a></span>();
-        <span class="RenoLink"><a href="exception_constructors.html">exception</a></span>( <span class="RenoLink"><a href="exception.html">exception</a></span> const &amp; x );</span>    
+        <span class="RenoLink"><a href="exception_constructors.html">exception</a></span>( <span class="RenoLink">exception</span> const &amp; x );</span>    
     <span class="RenoIncludeSPAN">    <span class="RenoLink"><a href="exception_destructor.html">~exception</a></span>();</span>    
         };</span>
     }</pre>
-</div><p>Class boost::<span class="RenoLink"><a href="exception.html">exception</a></span> is designed to be used as a universal base for user-defined exception types.</p>
+</div><p>Class boost::<span class="RenoLink">exception</span> is designed to be used as a universal base for user-defined exception types.</p>
-<p>An object of any type deriving from boost::<span class="RenoLink"><a href="exception.html">exception</a></span> can store data of arbitrary types, using the <span class="RenoLink"><a href="error_info.html">error_info</a></span> wrapper and <span class="RenoLink"><a href="exception_operator_shl.html">operator&lt;&lt;</a></span>.</p>
+<p>An object of any type deriving from boost::<span class="RenoLink">exception</span> can store data of arbitrary types, using the <span class="RenoLink"><a href="error_info.html">error_info</a></span> wrapper and <span class="RenoLink"><a href="exception_operator_shl.html">operator&lt;&lt;</a></span>.</p>
-<p>To retrieve data from a boost::<span class="RenoLink"><a href="exception.html">exception</a></span> object, use the <span class="RenoLink"><a href="get_error_info.html">get_error_info</a></span> function template.</p>
+<p>To retrieve data from a boost::<span class="RenoLink">exception</span> object, use the <span class="RenoLink"><a href="get_error_info.html">get_error_info</a></span> function template.</p>
 </div><div class="RenoHR"><hr/></div>
 <h3>See Also:</h3>
 <div class="RenoPageList"><a href="boost-exception.html">Boost Exception<br/>

doc/exception_constructors.html

@@ -21,8 +21,8 @@
 <!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <div class="RenoIncludeDIV"><div class="RenoAutoDIV"><h3>exception::exception</h3>
 </div>
-<div class="RenoIncludeDIV"><pre><span class="RenoLink"><a href="exception_constructors.html">exception</a></span>();
+<div class="RenoIncludeDIV"><pre><span class="RenoLink">exception</span>();
-<span class="RenoLink"><a href="exception_constructors.html">exception</a></span>( <span class="RenoLink"><a href="exception.html">exception</a></span> const &amp; x );</pre>
+<span class="RenoLink">exception</span>( <span class="RenoLink"><a href="exception.html">exception</a></span> const &amp; x );</pre>
 </div><h4>Effects:</h4>
 <div><ul><li> Default constructor: initializes an empty boost::<span class="RenoLink"><a href="exception.html">exception</a></span> object.</li>
 <li> Copy constructor: initializes a boost::<span class="RenoLink"><a href="exception.html">exception</a></span> object which shares ownership with x of all data added through <span class="RenoLink"><a href="exception_operator_shl.html">operator&lt;&lt;</a></span>, including data that is added at a future time.</li>

doc/exception_destructor.html

@@ -21,7 +21,7 @@
 <!-- file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt) -->
 <div class="RenoIncludeDIV"><div class="RenoAutoDIV"><h3>exception::~exception</h3>
 </div>
-<div class="RenoIncludeDIV"><pre><span class="RenoLink"><a href="exception_destructor.html">~exception</a></span>();</pre>
+<div class="RenoIncludeDIV"><pre><span class="RenoLink">~exception</span>();</pre>
 </div><h4>Effects:</h4>
 <p>Frees all resources associated with a boost::<span class="RenoLink"><a href="exception.html">exception</a></span> object.</p>
 <h4>Throws:</h4>

doc/exception_get_error_info_hpp.html

@@ -28,7 +28,7 @@ namespace
 boost
     {
 <span class="RenoIncludeSPAN">    <span class="RenoIncludeSPAN">template &lt;class ErrorInfo,class E&gt;
-    typename ErrorInfo::value_type const * <span class="RenoLink"><a href="get_error_info.html">get_error_info</a></span>( E const &amp; x );</span></span>
+    typename ErrorInfo::<span class="RenoLink"><a href="error_info_value_type.html">value_type</a></span> const * <span class="RenoLink"><a href="get_error_info.html">get_error_info</a></span>( E const &amp; x );</span></span>
     }</pre>
 </div></div><div class="RenoAutoDIV"><div class="RenoHR"><hr/></div>
 <h3>See Also:</h3>

doc/exception_operator_shl.html

@@ -26,7 +26,7 @@
 boost
     {
 <span class="RenoIncludeSPAN">    template &lt;class E, class Tag, class T&gt;
-    E const &amp; <span class="RenoLink"><a href="exception_operator_shl.html">operator&lt;&lt;</a></span>( E const &amp; x, <span class="RenoLink"><a href="error_info.html">error_info</a></span>&lt;Tag,T&gt; const &amp; v );</span>
+    E const &amp; <span class="RenoLink">operator&lt;&lt;</span>( E const &amp; x, <span class="RenoLink"><a href="error_info.html">error_info</a></span>&lt;Tag,T&gt; const &amp; v );</span>
     }</pre>
 </div><h4>Requirements:</h4>
 <p>E must be boost::<span class="RenoLink"><a href="exception.html">exception</a></span>, or a type that derives (indirectly) from boost::<span class="RenoLink"><a href="exception.html">exception</a></span>.</p>

doc/exception_ptr.html

@@ -25,14 +25,14 @@
 <pre>namespace
 boost
     {
-<span class="RenoIncludeSPAN">    typedef ---unspecified--- <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span>;</span>
+<span class="RenoIncludeSPAN">    typedef ---unspecified--- <span class="RenoLink">exception_ptr</span>;</span>
     }</pre>
-</div><p>The <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span> type can be used to refer to a copy of an exception object. It is Default Constructible, Copy Constructible, Assignable and Equality Comparable; <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span>'s operations do not throw.</p>
+</div><p>The <span class="RenoLink">exception_ptr</span> type can be used to refer to a copy of an exception object. It is Default Constructible, Copy Constructible, Assignable and Equality Comparable; <span class="RenoLink">exception_ptr</span>'s operations do not throw.</p>
-<p>Two instances of <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span> are equivalent and compare equal if and only if they refer to the same exception.</p>
+<p>Two instances of <span class="RenoLink">exception_ptr</span> are equivalent and compare equal if and only if they refer to the same exception.</p>
-<p>The default constructor of <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span> produces the null value of the type. The null value is equivalent only to itself.</p>
+<p>The default constructor of <span class="RenoLink">exception_ptr</span> produces the null value of the type. The null value is equivalent only to itself.</p>
 <h4>Thread safety</h4>
-<div><ul><li> It is legal for multiple threads to hold <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span> references to the same exception object.</li>
+<div><ul><li> It is legal for multiple threads to hold <span class="RenoLink">exception_ptr</span> references to the same exception object.</li>
-<li> It is illegal for multiple threads to modify the same <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span> object concurrently.</li>
+<li> It is illegal for multiple threads to modify the same <span class="RenoLink">exception_ptr</span> object concurrently.</li>
 <li> While calling <span class="RenoLink"><a href="current_exception.html">current_exception</a></span> makes a copy of the current exception object, it is still possible for the two copies to share internal state. Therefore, in general it is not safe to call <span class="RenoLink"><a href="rethrow_exception.html">rethrow_exception</a></span> concurrently to throw the same exception object into multiple threads.</li>
 </ul></div>
 </div><div class="RenoAutoDIV"><div class="RenoHR"><hr/></div>

doc/get_error_info.html

@@ -25,7 +25,7 @@
 boost
     {
 <span class="RenoIncludeSPAN">    template &lt;class ErrorInfo,class E&gt;
-    typename ErrorInfo::value_type const * <span class="RenoLink"><a href="get_error_info.html">get_error_info</a></span>( E const &amp; x );</span>
+    typename ErrorInfo::<span class="RenoLink"><a href="error_info_value_type.html">value_type</a></span> const * <span class="RenoLink">get_error_info</span>( E const &amp; x );</span>
     }</pre>
 </div><h4>Requirements:</h4>
 <div><ul><li> ErrorInfo must be an instance of the <span class="RenoLink"><a href="error_info.html">error_info</a></span> template.</li>
@@ -33,12 +33,12 @@ boost
 </ul></div>
 <h4>Returns:</h4>
 <div><ul><li> If dynamic_cast&lt;boost::<span class="RenoLink"><a href="exception.html">exception</a></span> const *&gt;(&amp;x) is 0, or if x does not store an object of type ErrorInfo, the returned value is null.</li>
-<li> Otherwise, the returned pointer points to the stored value (use <span class="RenoLink"><a href="exception_operator_shl.html">operator&lt;&lt;</a></span> to store values in exception objects.) When x is destroyed, any pointers returned by <span class="RenoLink"><a href="get_error_info.html">get_error_info</a></span> become invalid.</li>
+<li> Otherwise, the returned pointer points to the stored value (use <span class="RenoLink"><a href="exception_operator_shl.html">operator&lt;&lt;</a></span> to store values in exception objects.) When x is destroyed, any pointers returned by <span class="RenoLink">get_error_info</span> become invalid.</li>
 </ul></div>
 <h4>Throws:</h4>
 <p>Nothing.</p>
 <h4>Note:</h4>
-<p>The interface of <span class="RenoLink"><a href="get_error_info.html">get_error_info</a></span> may be affected by the build <span class="RenoLink"><a href="configuration_macros.html">configuration macros</a></span>.</p>
+<p>The interface of <span class="RenoLink">get_error_info</span> may be affected by the build <span class="RenoLink"><a href="configuration_macros.html">configuration macros</a></span>.</p>
 </div><div class="RenoAutoDIV"><div class="RenoHR"><hr/></div>
 <h3>See Also:</h3>
 <div class="RenoPageList"><a href="BOOST_THROW_EXCEPTION.html">BOOST_THROW_EXCEPTION<br/>

doc/rethrow_exception.html

@@ -25,7 +25,7 @@
 <pre>namespace
 boost
     {
-<span class="RenoIncludeSPAN">    void <span class="RenoLink"><a href="rethrow_exception.html">rethrow_exception</a></span>( <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span> const &amp; ep );</span>
+<span class="RenoIncludeSPAN">    void <span class="RenoLink">rethrow_exception</span>( <span class="RenoLink"><a href="exception_ptr.html">exception_ptr</a></span> const &amp; ep );</span>
     }</pre>
 </div><h4>Precondition:</h4>
 <p>ep shall not be null.</p>

doc/throw_exception.html

@@ -26,17 +26,17 @@
 boost
     {
 <span class="RenoIncludeSPAN">#ifdef BOOST_NO_EXCEPTIONS
-    void <span class="RenoLink"><a href="throw_exception.html">throw_exception</a></span>( std::exception const &amp; e ); // user defined
+    void <span class="RenoLink">throw_exception</span>( std::exception const &amp; e ); // user defined
 #else
     template &lt;class E&gt;
-    void <span class="RenoLink"><a href="throw_exception.html">throw_exception</a></span>( E const &amp; e );
+    void <span class="RenoLink">throw_exception</span>( E const &amp; e );
 #endif</span>
     }</pre>
 </div><h4>Requirements:</h4>
 <p>E must derive publicly from std::exception.</p>
 <h4>Effects:</h4>
-<div><ul><li> If BOOST_NO_EXCEPTIONS is not defined, boost::<span class="RenoLink"><a href="throw_exception.html">throw_exception</a></span>(e) is equivalent to throw boost::<span class="RenoLink"><a href="enable_current_exception.html">enable_current_exception</a></span>(boost::<span class="RenoLink"><a href="enable_error_info.html">enable_error_info</a></span>(e)), unless BOOST_EXCEPTION_DISABLE is defined, in which case boost::<span class="RenoLink"><a href="throw_exception.html">throw_exception</a></span>(e) is equivalent to throw e;</li>
+<div><ul><li> If BOOST_NO_EXCEPTIONS is not defined, boost::<span class="RenoLink">throw_exception</span>(e) is equivalent to throw boost::<span class="RenoLink"><a href="enable_current_exception.html">enable_current_exception</a></span>(boost::<span class="RenoLink"><a href="enable_error_info.html">enable_error_info</a></span>(e)), unless BOOST_EXCEPTION_DISABLE is defined, in which case boost::<span class="RenoLink">throw_exception</span>(e) is equivalent to throw e;</li>
-<li> If BOOST_NO_EXCEPTIONS is defined, the function is left undefined, and the user is expected to supply an appropriate definition. Callers of <span class="RenoLink"><a href="throw_exception.html">throw_exception</a></span> are allowed to assume that the function never returns; therefore, if the user-defined <span class="RenoLink"><a href="throw_exception.html">throw_exception</a></span> returns, the behavior is undefined.</li>
+<li> If BOOST_NO_EXCEPTIONS is defined, the function is left undefined, and the user is expected to supply an appropriate definition. Callers of <span class="RenoLink">throw_exception</span> are allowed to assume that the function never returns; therefore, if the user-defined <span class="RenoLink">throw_exception</span> returns, the behavior is undefined.</li>
 </ul></div>
 </div><div class="RenoAutoDIV"><div class="RenoHR"><hr/></div>
 <h3>See Also:</h3>

doc/tuple_operator_shl.html

@@ -26,7 +26,7 @@
 boost
     {
 <span class="RenoIncludeSPAN">    template &lt;class E, class Tag1, class T1, ..., class TagN, class TN&gt;
-    E const &amp; <span class="RenoLink"><a href="tuple_operator_shl.html">operator&lt;&lt;</a></span>( E const &amp; x,
+    E const &amp; <span class="RenoLink">operator&lt;&lt;</span>( E const &amp; x,
         <span class="RenoLink"><a href="http://www.boost.org/libs/tuple/doc/tuple_users_guide.html">tuple</a></span>&lt;
             <span class="RenoLink"><a href="error_info.html">error_info</a></span>&lt;Tag1,T1&gt;,
             ...,

doc/unknown_exception.html

@@ -26,7 +26,7 @@
 boost
     {
 <span class="RenoIncludeSPAN">    class
-    <span class="RenoLink"><a href="unknown_exception.html">unknown_exception</a></span>:
+    <span class="RenoLink">unknown_exception</span>:
         public std::exception
         public boost::<span class="RenoLink"><a href="exception.html">exception</a></span>
         {