Documentation fixes, helper headers added.

[SVN r12804]

include/boost/bind/apply.hpp

@@ -0,0 +1,75 @@
+#ifndef BOOST_BIND_APPLY_HPP_INCLUDED
+#define BOOST_BIND_APPLY_HPP_INCLUDED
+
+//
+//  apply.hpp
+//
+//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//
+//  Permission to copy, use, modify, sell and distribute this software
+//  is granted provided this copyright notice appears in all copies.
+//  This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+//
+
+namespace boost
+{
+
+template<class R> struct apply
+{
+    typedef R result_type;
+
+    template<class F> result_type operator()(F f) const
+    {
+        return f();
+    }
+
+    template<class F, class A1> result_type operator()(F f, A1 & a1) const
+    {
+        return f(a1);
+    }
+
+    template<class F, class A1, class A2> result_type operator()(F f, A1 & a1, A2 & a2) const
+    {
+        return f(a1, a2);
+    }
+
+    template<class F, class A1, class A2, class A3> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3) const
+    {
+        return f(a1, a2, a3);
+    }
+
+    template<class F, class A1, class A2, class A3, class A4> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
+    {
+        return f(a1, a2, a3, a4);
+    }
+
+    template<class F, class A1, class A2, class A3, class A4, class A5> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
+    {
+        return f(a1, a2, a3, a4, a5);
+    }
+
+    template<class F, class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
+    {
+        return f(a1, a2, a3, a4, a5, a6);
+    }
+
+    template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
+    {
+        return f(a1, a2, a3, a4, a5, a6, a7);
+    }
+
+    template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
+    {
+        return f(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+    template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
+    {
+        return f(a1, a2, a3, a4, a5, a6, a7, a8, a9);
+    }
+};
+
+} // namespace boost
+
+#endif // #ifndef BOOST_BIND_APPLY_HPP_INCLUDED

include/boost/bind/make_adaptable.hpp

@@ -0,0 +1,172 @@
+#ifndef BOOST_BIND_MAKE_ADAPTABLE_HPP_INCLUDED
+#define BOOST_BIND_MAKE_ADAPTABLE_HPP_INCLUDED
+
+//
+//  make_adaptable.hpp
+//
+//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//
+//  Permission to copy, use, modify, sell and distribute this software
+//  is granted provided this copyright notice appears in all copies.
+//  This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+//
+
+namespace boost
+{
+
+namespace _bi
+{
+
+template<class F> void instantiate(F)
+{
+}
+
+template<class R, class F> class af0
+{
+public:
+
+    typedef R result_type;
+
+    explicit af0(F f): f_(f)
+    {
+    }
+
+    result_type operator()()
+    {
+        return f_();
+    }
+
+private:
+
+    F f_;
+};
+
+template<class R, class A1, class F> class af1
+{
+public:
+
+    typedef R result_type;
+    typedef A1 argument_type;
+    typedef A1 arg1_type;
+
+    explicit af1(F f): f_(f)
+    {
+    }
+
+    result_type operator()(A1 a1)
+    {
+        return f_(a1);
+    }
+
+private:
+
+    F f_;
+};
+
+template<class R, class A1, class A2, class F> class af2
+{
+public:
+
+    typedef R result_type;
+    typedef A1 first_argument_type;
+    typedef A2 second_argument_type;
+    typedef A1 arg1_type;
+    typedef A2 arg2_type;
+
+    explicit af2(F f): f_(f)
+    {
+    }
+
+    result_type operator()(A1 a1, A2 a2)
+    {
+        return f_(a1, a2);
+    }
+
+private:
+
+    F f_;
+};
+
+template<class R, class A1, class A2, class A3, class F> class af3
+{
+public:
+
+    typedef R result_type;
+    typedef A1 arg1_type;
+    typedef A2 arg2_type;
+    typedef A3 arg3_type;
+
+    explicit af3(F f): f_(f)
+    {
+    }
+
+    result_type operator()(A1 a1, A2 a2, A3 a3)
+    {
+        return f_(a1, a2, a3);
+    }
+
+private:
+
+    F f_;
+};
+
+template<class R, class A1, class A2, class A3, class A4, class F> class af4
+{
+public:
+
+    typedef R result_type;
+    typedef A1 arg1_type;
+    typedef A2 arg2_type;
+    typedef A3 arg3_type;
+    typedef A4 arg4_type;
+
+    explicit af4(F f): f_(f)
+    {
+    }
+
+    result_type operator()(A1 a1, A2 a2, A3 a3, A4 a4)
+    {
+        return f_(a1, a2, a3, a4);
+    }
+
+private:
+
+    F f_;
+};
+
+} // namespace _bi
+
+template<class R, class F> _bi::af0<R, F> make_adaptable(F f)
+{
+    _bi::instantiate( &_bi::af0<R, F>::operator() ); // for early error detection
+    return _bi::af0<R, F>(f);
+}
+
+template<class R, class A1, class F> _bi::af1<R, A1, F> make_adaptable(F f)
+{
+    instantiate( &_bi::af1<R, A1, F>::operator() );
+    return _bi::af1<R, A1, F>(f);
+}
+
+template<class R, class A1, class A2, class F> _bi::af2<R, A1, A2, F> make_adaptable(F f)
+{
+    instantiate( &_bi::af2<R, A1, A2, F>::operator() );
+    return _bi::af2<R, A1, A2, F>(f);
+}
+
+template<class R, class A1, class A2, class A3, class F> _bi::af3<R, A1, A2, A3, F> make_adaptable(F f)
+{
+    instantiate( &_bi::af3<R, A1, A2, A3, F>::operator() );
+    return _bi::af3<R, A1, A2, A3, F>(f);
+}
+
+template<class R, class A1, class A2, class A3, class A4, class F> _bi::af4<R, A1, A2, A3, A4, F> make_adaptable(F f)
+{
+    instantiate( &_bi::af4<R, A1, A2, A3, A4, F>::operator() );
+    return _bi::af4<R, A1, A2, A3, A4, F>(f);
+}
+
+} // namespace boost
+
+#endif // #ifndef BOOST_BIND_MAKE_ADAPTABLE_HPP_INCLUDED

include/boost/bind/protect.hpp

@@ -0,0 +1,145 @@
+#ifndef BOOST_BIND_PROTECT_HPP_INCLUDED
+#define BOOST_BIND_PROTECT_HPP_INCLUDED
+
+//
+//  protect.hpp
+//
+//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//
+//  Permission to copy, use, modify, sell and distribute this software
+//  is granted provided this copyright notice appears in all copies.
+//  This software is provided "as is" without express or implied
+//  warranty, and with no claim as to its suitability for any purpose.
+//
+
+namespace boost
+{
+
+namespace _bi
+{
+
+template<class F> class protected_bind_t
+{
+public:
+
+    typedef typename F::result_type result_type;
+
+    explicit protected_bind_t(F f): f_(f)
+    {
+    }
+
+    result_type operator()()
+    {
+        return f_();
+    }
+
+    result_type operator()() const
+    {
+        return f_();
+    }
+
+    template<class A1> result_type operator()(A1 & a1)
+    {
+        return f_(a1);
+    }
+
+    template<class A1> result_type operator()(A1 & a1) const
+    {
+        return f_(a1);
+    }
+
+    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
+    {
+        return f_(a1, a2);
+    }
+
+    template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2) const
+    {
+        return f_(a1, a2);
+    }
+
+    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
+    {
+        return f_(a1, a2, a3);
+    }
+
+    template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3) const
+    {
+        return f_(a1, a2, a3);
+    }
+
+    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
+    {
+        return f_(a1, a2, a3, a4);
+    }
+
+    template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
+    {
+        return f_(a1, a2, a3, a4);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
+    {
+        return f_(a1, a2, a3, a4, a5);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
+    {
+        return f_(a1, a2, a3, a4, a5);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
+    {
+        return f_(a1, a2, a3, a4, a5, a6);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
+    {
+        return f_(a1, a2, a3, a4, a5, a6);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
+    {
+        return f_(a1, a2, a3, a4, a5, a6, a7);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
+    {
+        return f_(a1, a2, a3, a4, a5, a6, a7);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
+    {
+        return f_(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
+    {
+        return f_(a1, a2, a3, a4, a5, a6, a7, a8);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
+    {
+        return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
+    }
+
+    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
+    {
+        return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
+    }
+
+private:
+
+    F f_;
+};
+
+} // namespace _bi
+
+template<class F> _bi::protected_bind_t<F> protect(F f)
+{
+    return _bi::protected_bind_t<F>(f);
+}
+
+} // namespace boost
+
+#endif // #ifndef BOOST_BIND_PROTECT_HPP_INCLUDED

mem_fn.html

@@ -1,20 +1,16 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
-
 <html>
-
 	<head>
-	<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 		<title>Boost: mem_fn.hpp documentation</title>
+		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 	</head>
-
+	<body bgcolor="white" style="MARGIN-LEFT: 5%; MARGIN-RIGHT: 5%">
-<body bgcolor="White" style="margin-left: 5%; margin-right: 5%;">
-
 		<table border="0" width="100%">
 			<tr>
 				<td width="277">
 					<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86">
 				</td>
-	<td align="center">
+				<td align="middle">
 					<h1>mem_fn.hpp</h1>
 				</td>
 			</tr>
@@ -22,94 +18,77 @@
 				<td colspan="2" height="64">&nbsp;</td>
 			</tr>
 		</table>
-
 		<h2>Contents</h2>
-
+		<h3 style="MARGIN-LEFT: 20pt"><a href="#Purpose">Purpose</a></h3>
-<h3 style="margin-left: 20pt;"><a href="#Purpose">Purpose</a></h3>
+		<h3 style="MARGIN-LEFT: 20pt"><a href="#FAQ">Frequently Asked Questions</a></h3>
-<h3 style="margin-left: 20pt;"><a href="#FAQ">Frequently Asked Questions</a></h3>
+		<h4 style="MARGIN-LEFT: 40pt"><a href="#Q1">Can <b>mem_fn</b> be used instead of the 
-<h4 style="margin-left: 40pt;"><a href="#Q1">Can <b>mem_fn</b> be used instead of the standard
+				standard <b>std::mem_fun[_ref]</b> adaptors?</a></h4>
-<b>std::mem_fun[_ref]</b> adaptors?</a></h4>
+		<h4 style="MARGIN-LEFT: 40pt"><a href="#Q2">Should I replace every occurence of <b>std::mem_fun[_ref]</b>
-<h4 style="margin-left: 40pt;"><a href="#Q2">Should I replace every occurence of <b>std::mem_fun[_ref]</b>
 				with <b>mem_fn</b> in my existing code?</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#Q3">Does <b>mem_fn</b> work with COM methods?</a></h4>
+		<h4 style="MARGIN-LEFT: 40pt"><a href="#Q3">Does <b>mem_fn</b> work with COM methods?</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#Q4">Why isn't BOOST_MEM_FN_ENABLE_STDCALL defined automatically?</a></h4>
+		<h4 style="MARGIN-LEFT: 40pt"><a href="#Q4">Why isn't BOOST_MEM_FN_ENABLE_STDCALL 
-<h3 style="margin-left: 20pt;"><a href="#Interface">Interface</a></h3>
+				defined automatically?</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#Synopsis">Synopsis</a></h4>
+		<h3 style="MARGIN-LEFT: 20pt"><a href="#Interface">Interface</a></h3>
-<h4 style="margin-left: 40pt;"><a href="#CommonRequirements">Common requirements</a></h4>
+		<h4 style="MARGIN-LEFT: 40pt"><a href="#Synopsis">Synopsis</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#get_pointer">get_pointer</a></h4>
+		<h4 style="MARGIN-LEFT: 40pt"><a href="#CommonRequirements">Common requirements</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#mem_fn">mem_fn</a></h4>
+		<h4 style="MARGIN-LEFT: 40pt"><a href="#get_pointer">get_pointer</a></h4>
-<h3 style="margin-left: 20pt;"><a href="#Implementation">Implementation</a></h3>
+		<h4 style="MARGIN-LEFT: 40pt"><a href="#mem_fn">mem_fn</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#Files">Files</a></h4>
+		<h3 style="MARGIN-LEFT: 20pt"><a href="#Implementation">Implementation</a></h3>
-<h4 style="margin-left: 40pt;"><a href="#Dependencies">Dependencies</a></h4>
+		<h4 style="MARGIN-LEFT: 40pt"><a href="#Files">Files</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#NumberOfArguments">Number of Arguments</a></h4>
+		<h4 style="MARGIN-LEFT: 40pt"><a href="#Dependencies">Dependencies</a></h4>
-<h4 style="margin-left: 40pt;"><a href="#stdcall">&quot;__stdcall&quot; Support</a></h4>
+		<h4 style="MARGIN-LEFT: 40pt"><a href="#NumberOfArguments">Number of Arguments</a></h4>
-<h3 style="margin-left: 20pt;"><a href="#Acknowledgements">Acknowledgements</a></h3>
+		<h4 style="MARGIN-LEFT: 40pt"><a href="#stdcall">"__stdcall" Support</a></h4>
-
+		<h3 style="MARGIN-LEFT: 20pt"><a href="#Acknowledgements">Acknowledgements</a></h3>
 		<h2><a name="Purpose">Purpose</a></h2>
-
 		<p>
-<b>boost::mem_fn</b> is a generalization of the standard functions
+			<b>boost::mem_fn</b> is a generalization of the standard functions <b>std::mem_fun</b>
-<b>std::mem_fun</b> and <b>std::mem_fun_ref</b>. It supports member
+			and <b>std::mem_fun_ref</b>. It supports member function pointers with more 
-function pointers with more than one argument, and the returned function
+			than one argument, and the returned function object can take a pointer, a 
-object can take a pointer, a reference, or a smart pointer to an object
+			reference, or a smart pointer to an object instance as its first argument.
-instance as its first argument.
 		</p>
-
 		<p>
 			The purpose of <b>mem_fn</b> is twofold. First, it allows users to invoke a 
 			member function on a container with the familiar
 		</p>
-
 		<pre>
     std::for_each(v.begin(), v.end(), boost::mem_fn(&amp;Shape::draw));
 </pre>
-
 		<p>
 			syntax, even when the container stores smart pointers.
 		</p>
-
 		<p>
-Second, it can be used as a building block by library developers that want
+			Second, it can be used as a building block by library developers that want to 
-to treat a pointer to member function as a function object. A library might
+			treat a pointer to member function as a function object. A library might define 
-define an enhanced <b>for_each</b> algorithm with an overload of the form:
+			an enhanced <b>for_each</b> algorithm with an overload of the form:
 		</p>
-
 		<pre>
 template&lt;class It, class R, class T&gt; void for_each(It first, It last, R (T::*pmf) ())
 {
     std::for_each(first, last, boost::mem_fn(pmf));
 }
 </pre>
-
 		<p>
 			that will allow the convenient syntax:
 		</p>
-
 		<pre>
     for_each(v.begin(), v.end(), &amp;Shape::draw);
 </pre>
-
 		<p>
 			When documenting the feature, the library author will simply state:
 		</p>
-
+		<h4 style="MARGIN-LEFT: 20pt">template&lt;class It, class R, class T&gt; void 
-<h4 style="margin-left: 20pt;">template&lt;class It, class R, class T&gt; void for_each(It first, It last, R (T::*pmf) ());</h4>
+			for_each(It first, It last, R (T::*pmf) ());</h4>
-
+		<p style="MARGIN-LEFT: 20pt">
-<p style="margin-left: 20pt;">
 			<b>Effects:</b> equivalent to std::for_each(first, last, boost::mem_fn(pmf));
 		</p>
-
 		<p>
-where <b>boost::mem_fn</b> can be a link to this page. See
+			where <b>boost::mem_fn</b> can be a link to this page. See <a href="bind.html">the 
-<a href="bind.html">the documentation of <b>bind</b></a> for an example.
+				documentation of <b>bind</b></a> for an example.
 		</p>
-
 		<p>
-<b>mem_fn</b> takes one argument, a pointer to a member function, and
+			<b>mem_fn</b> takes one argument, a pointer to a member function, and returns a 
-returns a function object suitable for use with standard or user-defined
+			function object suitable for use with standard or user-defined algorithms:
-algorithms:
 		</p>
-
 		<pre>
 struct X
 {
@@ -131,98 +110,73 @@ void k(std::vector&lt;boost::shared_ptr&lt;X&gt; &gt; const &amp; v)
     std::for_each(v.begin(), v.end(), boost::mem_fn(&amp;X::f));
 };
 </pre>
-
 		<p>
 			The returned function object takes the same arguments as the input member 
 			function plus a "flexible" first argument that represents the object instance.
 		</p>
-
 		<p>
 			When the function object is invoked with a first argument <b>x</b> that is 
 			neither a pointer nor a reference to the appropriate class (<b>X</b> in the 
-example above), it uses <tt>get_pointer(x)</tt> to obtain a pointer from
+			example above), it uses <tt>get_pointer(x)</tt> to obtain a pointer from <b>x</b>. 
-<b>x</b>. Library authors can "register" their smart pointer classes by
+			Library authors can "register" their smart pointer classes by supplying an 
-supplying an appropriate <b>get_pointer</b> overload, allowing <b>mem_fn</b>
+			appropriate <b>get_pointer</b> overload, allowing <b>mem_fn</b> to recognize 
-to recognize and support them.
+			and support them.
 		</p>
-
-<p>
-A <b>get_pointer</b> overload for <b>boost::shared_ptr</b> is supplied.
-</p>
-
 		<p>
 			[Note: <b>get_pointer</b> is not restricted to return a pointer. Any object 
-that can be used in a member function call expression <tt>(x->*pmf)(...)</tt>
+			that can be used in a member function call expression <tt>(x-&gt;*pmf)(...)</tt>
 			will work.]
 		</p>
-
 		<p>
 			[Note: the library uses an unqualified call to <b>get_pointer</b>. Therefore, 
 			it will find, through argument-dependent lookup, <b>get_pointer</b> overloads 
 			that are defined in the same namespace as the corresponding smart pointer 
 			class, in addition to any <b>boost::get_pointer</b> overloads.]
 		</p>
-
 		<p>
-All function objects returned by <b>mem_fn</b> expose a <b>result_type</b>
+			All function objects returned by <b>mem_fn</b> expose a <b>result_type</b> typedef 
-typedef that represents the return type of the member function.
+			that represents the return type of the member function.
 		</p>
-
 		<h2><a name="FAQ">Frequently Asked Questions</a></h2>
-
+		<h3><a name="Q1">Can <b>mem_fn</b> be used instead of the standard <b>std::mem_fun[_ref]</b>
-<h3><a name="Q1">Can <b>mem_fn</b> be used instead of the standard
+				adaptors?</a></h3>
-<b>std::mem_fun[_ref]</b> adaptors?</a></h3>
-
 		<p>
-Yes. For simple uses, <b>mem_fn</b> provides additional functionality that
+			Yes. For simple uses, <b>mem_fn</b> provides additional functionality that the 
-the standard adaptors do not. Complicated expressions that use <b>std::bind1st</b>,
+			standard adaptors do not. Complicated expressions that use <b>std::bind1st</b>, <b>std::bind2nd</b>
-<b>std::bind2nd</b> or <a href="../compose/index.htm"><b>Boost.Compose</b></a>
+			or <a href="../compose/index.htm"><b>Boost.Compose</b></a> along with the 
-along with the standard adaptors can be rewritten using
+			standard adaptors can be rewritten using <a href="bind.html"><b>boost::bind</b></a>
-<a href="bind.html"><b>boost::bind</b></a> that automatically takes advantage of
+			that automatically takes advantage of <b>mem_fn</b>.
-<b>mem_fn</b>.
 		</p>
-
+		<h3><a name="Q2">Should I replace every occurence of <b>std::mem_fun[_ref]</b> with <b>mem_fn</b>
-<h3><a name="Q2">Should I replace every occurence of <b>std::mem_fun[_ref]</b>
+				in my existing code?</a></h3>
-with <b>mem_fn</b> in my existing code?</a></h3>
-
 		<p>
 			No, unless you have good reasons to do so. <b>mem_fn</b> is not 100% compatible 
-with the standard adaptors, although it comes pretty close. In particular,
+			with the standard adaptors, although it comes pretty close. In particular, <b>mem_fn</b>
-<b>mem_fn</b> does not return objects of type
+			does not return objects of type <b>std::[const_]mem_fun[1][_ref]_t</b>, as the 
-<b>std::[const_]mem_fun[1][_ref]_t</b>, as the standard adaptors do, and it is
+			standard adaptors do, and it is not possible to fully describe the type of the 
-not possible to fully describe the type of the first argument using the standard
+			first argument using the standard <b>argument_type</b> and <b>first_argument_type</b>
-<b>argument_type</b> and <b>first_argument_type</b> nested typedefs. Libraries
+			nested typedefs. Libraries that need adaptable function objects in order to 
-that need adaptable function objects in order to function might not like
+			function might not like <b>mem_fn</b>.
-<b>mem_fn</b>.
 		</p>
-
 		<h3><a name="Q3">Does <b>mem_fn</b> work with COM methods?</a></h3>
-
 		<p>
 			Yes, if you <a href="#stdcall">#define BOOST_MEM_FN_ENABLE_STDCALL</a>.
 		</p>
-
 		<h3><a name="Q4">Why isn't BOOST_MEM_FN_ENABLE_STDCALL defined automatically?</a></h3>
-
 		<p>
 			Non-portable extensions, in general, should default to off to prevent vendor 
 			lock-in. Had BOOST_MEM_FN_ENABLE_STDCALL been defined automatically, you could 
 			have accidentally taken advantage of it without realizing that your code is, 
 			perhaps, no longer portable.
 		</p>
-
 		<h2><a name="Interface">Interface</a></h2>
-
 		<h3><a name="Synopsis">Synopsis</a></h3>
-
 		<pre>
 namespace boost
 {
 
 template&lt;class T&gt; T * <a href="#get_pointer_1">get_pointer</a> (T * p);
 
-template&lt;class T&gt; T * <a href="#get_pointer_2">get_pointer</a>(shared_ptr&lt;T&gt; const &amp; p);
-
 template&lt;class R, class T&gt; <i>implementation-defined-1</i> <a href="#mem_fn_1">mem_fn</a>(R (T::*pmf) ());
 
 template&lt;class R, class T&gt; <i>implementation-defined-2</i> <a href="#mem_fn_2">mem_fn</a>(R (T::*pmf) () const);
@@ -239,189 +193,179 @@ template&lt;class R, class T, class A1, class A2&gt; <i>implementation-defined-6
 
 }
 </pre>
-
 		<h3><a name="CommonRequirements">Common requirements</a></h3>
-
 		<p>
-All <tt><i>implementation-defined-N</i></tt> types mentioned in the Synopsis are
+			All <tt><i>implementation-defined-N</i></tt> types mentioned in the Synopsis 
-<b>CopyConstructible</b> and <b>Assignable</b>.
+			are <b>CopyConstructible</b> and <b>Assignable</b>. Their copy constructors and 
-Their copy constructors and assignment operators do not throw exceptions.
+			assignment operators do not throw exceptions. <tt><i>implementation-defined-N</i>::result_type</tt>
-<tt><i>implementation-defined-N</i>::result_type</tt> is defined as
+			is defined as the return type of the member function pointer passed as an 
-the return type of the member function pointer passed as an argument to <b>mem_fn</b>
+			argument to <b>mem_fn</b> (<b>R</b> in the Synopsis.)
-(<b>R</b> in the Synopsis.)
 		</p>
-
 		<h3><a name="get_pointer">get_pointer</a></h3>
-
 		<h4><a name="get_pointer_1">template&lt;class T&gt; T * get_pointer(T * p)</a></h4>
-
+		<blockquote>
 			<p>
 				<b>Returns:</b> <tt>p</tt>.
 			</p>
 			<p>
 				<b>Throws:</b> Nothing.
 			</p>
-
+		</blockquote>
-<h4><a name="get_pointer_2">template&lt;class T&gt; T * get_pointer(shared_ptr&lt;T&gt; const &amp; p)</a></h4>
-
-<p>
-<b>Returns:</b> <tt>p.get()</tt>.
-</p>
-<p>
-<b>Throws:</b> Nothing.
-</p>
-
 		<h3><a name="mem_fn">mem_fn</a></h3>
-
+		<h4><a name="mem_fn_1">template&lt;class R, class T&gt; <i>implementation-defined-1</i> 
-<h4><a name="mem_fn_1">template&lt;class R, class T&gt; <i>implementation-defined-1</i> mem_fn(R (T::*pmf) ())</a></h4>
+				mem_fn(R (T::*pmf) ())</a></h4>
-
+		<blockquote>
 			<p>
-<b>Returns:</b> a function object <i>f</i> such that the expression
+				<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t)</i></tt>
-<tt><i>f(t)</i></tt> is equivalent to <tt>(t.*pmf)()</tt> when <i>t</i>
+				is equivalent to <tt>(t.*pmf)()</tt> when <i>t</i> is an l-value of type <STRONG>T </STRONG>
-is an l-value of type <b>T</b>, <tt>(get_pointer(t)->*pmf)()</tt> otherwise.
+				or derived, <tt>(get_pointer(t)-&gt;*pmf)()</tt> otherwise.
 			</p>
 			<p>
 				<b>Throws:</b> Nothing.
 			</p>
-
+		</blockquote>
-<h4><a name="mem_fn_2">template&lt;class R, class T&gt; <i>implementation-defined-2</i> mem_fn(R (T::*pmf) () const)</a></h4>
+		<h4><a name="mem_fn_2">template&lt;class R, class T&gt; <i>implementation-defined-2</i> 
-
+				mem_fn(R (T::*pmf) () const)</a></h4>
+		<blockquote>
 			<p>
-<b>Returns:</b> a function object <i>f</i> such that the expression
+				<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t)</i></tt>
-<tt><i>f(t)</i></tt> is equivalent to <tt>(t.*pmf)()</tt> when <i>t</i>
+				is equivalent to <tt>(t.*pmf)()</tt> when <i>t</i> is of type <STRONG>T</STRONG>
-is of type <b>T <i>[</i>const<i>]</i></b>, <tt>(get_pointer(t)->*pmf)()</tt> otherwise.
+				<EM>[const]<STRONG> </STRONG></EM>or derived, <tt>(get_pointer(t)-&gt;*pmf)()</tt>
+				otherwise.
 			</p>
 			<p>
 				<b>Throws:</b> Nothing.
 			</p>
-
+		</blockquote>
-<h4><a name="mem_fn_3">template&lt;class R, class T, class A1&gt; <i>implementation-defined-3</i> mem_fn(R (T::*pmf) (A1))</a></h4>
+		<h4><a name="mem_fn_3">template&lt;class R, class T, class A1&gt; <i>implementation-defined-3</i>
-
+				mem_fn(R (T::*pmf) (A1))</a></h4>
+		<blockquote>
 			<p>
-<b>Returns:</b> a function object <i>f</i> such that the expression
+				<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t, a1)</i></tt>
-<tt><i>f(t, a1)</i></tt> is equivalent to <tt>(t.*pmf)(a1)</tt> when <i>t</i>
+				is equivalent to <tt>(t.*pmf)(a1)</tt> when <i>t</i> is an l-value of type <STRONG>T
-is an l-value of type <b>T</b>, <tt>(get_pointer(t)->*pmf)(a1)</tt> otherwise.
+				</STRONG>or derived, <tt>(get_pointer(t)-&gt;*pmf)(a1)</tt> otherwise.
 			</p>
 			<p>
 				<b>Throws:</b> Nothing.
 			</p>
-
+		</blockquote>
-<h4><a name="mem_fn_4">template&lt;class R, class T, class A1&gt; <i>implementation-defined-4</i> mem_fn(R (T::*pmf) (A1) const)</a></h4>
+		<h4><a name="mem_fn_4">template&lt;class R, class T, class A1&gt; <i>implementation-defined-4</i>
-
+				mem_fn(R (T::*pmf) (A1) const)</a></h4>
+		<blockquote>
 			<p>
-<b>Returns:</b> a function object <i>f</i> such that the expression
+				<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t, a1)</i></tt>
-<tt><i>f(t, a1)</i></tt> is equivalent to <tt>(t.*pmf)(a1)</tt> when <i>t</i>
+				is equivalent to <tt>(t.*pmf)(a1)</tt> when <i>t</i> is of type <STRONG>T</STRONG>
-is of type <b>T <i>[</i>const<i>]</i></b>, <tt>(get_pointer(t)->*pmf)(a1)</tt> otherwise.
+				<EM>[const]<STRONG> </STRONG></EM>or derived, <tt>(get_pointer(t)-&gt;*pmf)(a1)</tt>
+				otherwise.
 			</p>
 			<p>
 				<b>Throws:</b> Nothing.
 			</p>
-
+		</blockquote>
-<h4><a name="mem_fn_5">template&lt;class R, class T, class A1, class A2&gt; <i>implementation-defined-5</i> mem_fn(R (T::*pmf) (A1, A2))</a></h4>
+		<h4><a name="mem_fn_5">template&lt;class R, class T, class A1, class A2&gt; <i>implementation-defined-5</i>
-
+				mem_fn(R (T::*pmf) (A1, A2))</a></h4>
+		<blockquote>
 			<p>
-<b>Returns:</b> a function object <i>f</i> such that the expression
+				<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t, a1, a2)</i></tt>
-<tt><i>f(t, a1, a2)</i></tt> is equivalent to <tt>(t.*pmf)(a1, a2)</tt> when <i>t</i>
+				is equivalent to <tt>(t.*pmf)(a1, a2)</tt> when <i>t</i> is an l-value of type <STRONG>
-is an l-value of type <b>T</b>, <tt>(get_pointer(t)->*pmf)(a1, a2)</tt> otherwise.
+					T</STRONG> or derived, <tt>(get_pointer(t)-&gt;*pmf)(a1, a2)</tt> otherwise.
 			</p>
 			<p>
 				<b>Throws:</b> Nothing.
 			</p>
-
+		</blockquote>
-<h4><a name="mem_fn_6">template&lt;class R, class T, class A1, class A2&gt; <i>implementation-defined-6</i> mem_fn(R (T::*pmf) (A1, A2) const)</a></h4>
+		<h4><a name="mem_fn_6">template&lt;class R, class T, class A1, class A2&gt; <i>implementation-defined-6</i>
-
+				mem_fn(R (T::*pmf) (A1, A2) const)</a></h4>
+		<blockquote>
 			<p>
-<b>Returns:</b> a function object <i>f</i> such that the expression
+				<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t, a1, a2)</i></tt>
-<tt><i>f(t, a1, a2)</i></tt> is equivalent to <tt>(t.*pmf)(a1, a2)</tt> when <i>t</i>
+				is equivalent to <tt>(t.*pmf)(a1, a2)</tt> when <i>t</i> is of type <STRONG>T</STRONG>
-is of type <b>T <i>[</i>const<i>]</i></b>, <tt>(get_pointer(t)->*pmf)(a1, a2)</tt> otherwise.
+				<EM>[const]</EM> or derived, <tt>(get_pointer(t)-&gt;*pmf)(a1, a2)</tt> otherwise.
 			</p>
 			<p>
 				<b>Throws:</b> Nothing.
 			</p>
-
+		</blockquote>
 		<h2><a name="Implementation">Implementation</a></h2>
-
 		<h3><a name="Files">Files</a></h3>
 		<ul>
-<li><a href="../../boost/mem_fn.hpp">boost/mem_fn.hpp</a> (main header)
+			<li>
-<li><a href="../../boost/bind/mem_fn_cc.hpp">boost/bind/mem_fn_cc.hpp</a> (used by mem_fn.hpp, do not include directly)
+				<a href="../../boost/mem_fn.hpp">boost/mem_fn.hpp</a>
-<li><a href="../../boost/bind/mem_fn_vw.hpp">boost/bind/mem_fn_vw.hpp</a> (used by mem_fn.hpp, do not include directly)
+			(main header)
-<li><a href="../../boost/bind/mem_fn_template.hpp">boost/bind/mem_fn_template.hpp</a> (used by mem_fn.hpp, do not include directly)
+			<li>
-<li><a href="mem_fn_test.cpp">libs/bind/mem_fn_test.cpp</a> (test)
+				<a href="../../boost/bind/mem_fn_cc.hpp">boost/bind/mem_fn_cc.hpp</a>
-<li><a href="mem_fn_stdcall_test.cpp">libs/bind/mem_fn_stdcall_test.cpp</a> (test for __stdcall)
+			(used by mem_fn.hpp, do not include directly)
-<li><a href="mem_fn_void_test.cpp">libs/bind/mem_fn_void_test.cpp</a> (test for void returns)
+			<li>
+				<a href="../../boost/bind/mem_fn_vw.hpp">boost/bind/mem_fn_vw.hpp</a>
+			(used by mem_fn.hpp, do not include directly)
+			<li>
+				<a href="../../boost/bind/mem_fn_template.hpp">boost/bind/mem_fn_template.hpp</a>
+			(used by mem_fn.hpp, do not include directly)
+			<li>
+				<a href="mem_fn_test.cpp">libs/bind/mem_fn_test.cpp</a>
+			(test)
+			<li>
+				<a href="mem_fn_stdcall_test.cpp">libs/bind/mem_fn_stdcall_test.cpp</a>
+			(test for __stdcall)
+			<li>
+				<a href="mem_fn_void_test.cpp">libs/bind/mem_fn_void_test.cpp</a> (test for 
+				void returns)</li>
 		</ul>
-
 		<h3><a name="Dependencies">Dependencies</a></h3>
 		<ul>
-<li><a href="../config/config.htm">Boost.Config</a>
+			<li>
+				<a href="../config/config.htm">Boost.Config</a></li>
 		</ul>
-
 		<h3><a name="NumberOfArguments">Number of Arguments</a></h3>
-
 		<p>
-This implementation supports member functions with up to eight arguments.
+			This implementation supports member functions with up to eight arguments. This 
-This is not an inherent limitation of the design, but an implementation
+			is not an inherent limitation of the design, but an implementation detail.
-detail.
 		</p>
-
+		<h3><a name="stdcall">"__stdcall" Support</a></h3>
-<h3><a name="stdcall">&quot;__stdcall&quot; Support</a></h3>
-
 		<p>
-Some platforms allow several types of member functions that differ by their
+			Some platforms allow several types of member functions that differ by their <b>calling 
-<b>calling convention</b> (the rules by which the function is invoked: how
+				convention</b> (the rules by which the function is invoked: how are 
-are arguments passed, how is the return value handled, and who cleans up the
+			arguments passed, how is the return value handled, and who cleans up the stack 
-stack - if any.)
+			- if any.)
 		</p>
-
 		<p>
 			For example, Windows API functions and COM interface member functions use a 
 			calling convention known as <b>__stdcall</b>.
 		</p>
-
 		<p>
-To use <b>mem_fn</b> with <b>__stdcall</b> member functions, <b>#define</b>
+			To use <b>mem_fn</b> with <b>__stdcall</b> member functions, <b>#define</b> the 
-the macro <b>BOOST_MEM_FN_ENABLE_STDCALL</b> before including, directly or
+			macro <b>BOOST_MEM_FN_ENABLE_STDCALL</b> before including, directly or 
 			indirectly, <b>&lt;boost/mem_fn.hpp&gt;</b>.
 		</p>
-
 		<p>
 			[Note: this is a non-portable extension. It is not part of the interface.]
 		</p>
-
 		<p>
 			[Note: Some compilers provide only minimal support for the <b>__stdcall</b> keyword.]
 		</p>
-
-
 		<h2><a name="Acknowledgements">Acknowledgements</a></h2>
-
 		<p>
-Rene Jager's initial suggestion of using traits classes to make
+			Rene Jager's initial suggestion of using traits classes to make <b>mem_fn</b> adapt 
-<b>mem_fn</b> adapt to user-defined smart pointers inspired the
+			to user-defined smart pointers inspired the <b>get_pointer</b>-based design.
-<b>get_pointer</b>-based design.
 		</p>
-
 		<p>
-Numerous improvements were suggested during the formal review period by
+			Numerous improvements were suggested during the formal review period by Richard 
-Richard Crossley, Jens Maurer, Ed Brey, and others. Review manager
+			Crossley, Jens Maurer, Ed Brey, and others. Review manager was Darin Adler.
-was Darin Adler.
 		</p>
-
 		<p>
 			Steve Anichini pointed out that COM interfaces use <b>__stdcall</b>.
 		</p>
-
 		<p>
-Dave Abrahams modified <b>bind</b> and <b>mem_fn</b> to support void returns
+			Dave Abrahams modified <b>bind</b> and <b>mem_fn</b> to support void returns on 
-on deficient compilers.
+			deficient compilers.
 		</p>
-
+		<p><br>
-<p><br><br><br><small>Copyright &copy; 2001 by Peter Dimov and Multi Media
+			<br>
-Ltd. Permission to copy, use, modify, sell and distribute this document is
+			<br>
-granted provided this copyright notice appears in all copies. This document
+			<small>Copyright <20> 2001, 2002&nbsp;by Peter Dimov and Multi Media Ltd. Permission 
-is provided &quot;as is&quot; without express or implied warranty, and with
+				to copy, use, modify, sell and distribute this document is granted provided 
-no claim as to its suitability for any purpose.</small></p>
+				this copyright notice appears in all copies. This document is provided "as is" 
-
+				without express or implied warranty, and with no claim as to its suitability 
+				for any purpose.</small></p>
 	</body>
 </html>

ref.html

@@ -1,14 +1,10 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
-
 <html>
-
 	<head>
 		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
 		<title>Boost: ref.hpp documentation</title>
 	</head>
-
 	<body bgcolor="White">
-
 		<table border="0" width="100%">
 			<tr>
 				<td width="277">
@@ -16,8 +12,13 @@
 				</td>
 				<td align="center">
 					<table border="0">
-			<tr><td nowrap><h1>ref.hpp</h1></td></tr>
+						<tr>
-			<tr><td align="right" nowrap><small>&nbsp;1.00.0004 (2002-01-27)</small></td></tr>
+							<td nowrap><h1>ref.hpp</h1>
+							</td>
+						</tr>
+						<tr>
+							<td align="right" nowrap><small>&nbsp;1.00.0004 (2002-01-27)</small></td>
+						</tr>
 					</table>
 				</td>
 			</tr>
@@ -25,56 +26,49 @@
 				<td colspan="2" height="64">&nbsp;</td>
 			</tr>
 		</table>
-
 		<h2>Files</h2>
 		<ul>
-<li><a href="../../boost/ref.hpp">ref.hpp</a>
+			<li>
+				<a href="../../boost/ref.hpp">ref.hpp</a>
 		</ul>
-
 		<h2>Purpose</h2>
-
 		<p>
-The header <a href="../../boost/ref.hpp">boost/ref.hpp</a> defines the class template
+			The header <a href="../../boost/ref.hpp">boost/ref.hpp</a> defines the class 
-<b>boost::reference_wrapper&lt;T&gt;</b>, the two functions <b>boost::ref</b> and
+			template <b>boost::reference_wrapper&lt;T&gt;</b>, the two functions <b>boost::ref</b>
-<b>boost::cref</b> that return instances of
+			and <b>boost::cref</b> that return instances of <b>boost::reference_wrapper&lt;T&gt;</b>, 
-<b>boost::reference_wrapper&lt;T&gt;</b>, and the two traits classes <b>boost::is_reference_wrapper&lt;T&gt;</b> and <b>boost::unwrap_reference&lt;T&gt;</b>.
+			and the two traits classes <b>boost::is_reference_wrapper&lt;T&gt;</b> and <b>boost::unwrap_reference&lt;T&gt;</b>.
 		</p>
-
 		<p>
-The purpose of <b>boost::reference_wrapper&lt;T&gt;</b> is to contain a reference to
+			The purpose of <b>boost::reference_wrapper&lt;T&gt;</b> is to contain a 
-an object of type <b>T</b>. It is primarily used to "feed" references to
+			reference to an object of type <b>T</b>. It is primarily used to "feed" 
-function templates (algorithms) that take their parameter by value.
+			references to function templates (algorithms) that take their parameter by 
+			value.
 		</p>
-
 		<p>
-To support this usage, <b>boost::reference_wrapper&lt;T&gt;</b> provides an implicit
+			To support this usage, <b>boost::reference_wrapper&lt;T&gt;</b> provides an 
-conversion to <b>T &amp;</b>. This usually allows the function templates to
+			implicit conversion to <b>T &amp;</b>. This usually allows the function 
-work on references unmodified.
+			templates to work on references unmodified.
 		</p>
-
 		<p>
-<b>boost::reference_wrapper&lt;T&gt;</b> is both <b>CopyConstructible</b> and
+			<b>boost::reference_wrapper&lt;T&gt;</b> is both <b>CopyConstructible</b> and <b>Assignable</b>
-<b>Assignable</b> (ordinary references are not <b>Assignable</b>).
+			(ordinary references are not <b>Assignable</b>).
 		</p>
-
 		<p>
 			The expression <b>boost::ref(x)</b> returns a <b>boost::reference_wrapper&lt;X&gt;(x)</b>
-where <b>X</b> is the type of <b>x</b>. Similarly, <b>boost::cref(x)</b>
+			where <b>X</b> is the type of <b>x</b>. Similarly, <b>boost::cref(x)</b> returns 
-returns a <b>boost::reference_wrapper&lt;X const&gt;(x)</b>.
+			a <b>boost::reference_wrapper&lt;X const&gt;(x)</b>.
+		</p>
+		<p>
+			The expression <b>boost::is_reference_wrapper&lt;T&gt;::value</b> is <b>true</b> 
+			if <b>T</b> is a <b>reference_wrapper</b>, and <b>false</b>
+			otherwise.
+		</p>
+		<p>
+			The type-expression <b>boost::unwrap_reference&lt;T&gt;::type</b> is <b>T::type</b>
+			if <b>T</b> is a <b>reference_wrapper</b>, <b>T</b> otherwise.
 		</p>
-
-<p>The expression <b>boost::is_reference_wrapper&lt;T&gt;::value</b> is
-<b>true</b> if <b>T</b> is a
-<b>reference_wrapper</b>, and <b>false</b> otherwise.
-
-<p>The type-expression <b>boost::unwrap_reference&lt;T&gt;::type</b>
-is <b>T::type</b> if <b>T</b> is a
-<b>reference_wrapper</b>, <b>T</b> otherwise.
-
 			<h2>Interface</h2>
-
 			<h3>Synopsis</h3>
-
 			<pre>
 namespace boost
 {
@@ -85,9 +79,7 @@ namespace boost
     template&lt;class T&gt; class unwrap_reference&lt;T const&gt;;
 }
 </pre>
-
 			<h3><a name="reference_wrapper">reference_wrapper</a></h3>
-
 			<pre>
 template&lt;class T&gt; class reference_wrapper
 {
@@ -101,20 +93,17 @@ public:
     T &amp; <a href="#rt_get">get</a>() const;
 };
 </pre>
-
 			<h4><a name="rt_construct">explicit reference_wrapper(T &amp; t)</a></h4>
-
 			<blockquote>
 				<p>
-<b>Effects:</b> Constructs a <b>reference_wrapper</b> object that stores a reference to <b>t</b>.
+					<b>Effects:</b> Constructs a <b>reference_wrapper</b> object that stores a 
+					reference to <b>t</b>.
 				</p>
 				<p>
 					<b>Throws:</b> Nothing.
 				</p>
 			</blockquote>
-
 			<h4><a name="rt_operator">operator T &amp; () const</a></h4>
-
 			<blockquote>
 				<p>
 					<b>Returns:</b> the stored reference.
@@ -123,9 +112,7 @@ public:
 					<b>Throws:</b> Nothing.
 				</p>
 			</blockquote>
-
 			<h4><a name="rt_get">T &amp; get() const</a></h4>
-
 			<blockquote>
 				<p>
 					<b>Returns:</b> the stored reference.
@@ -134,13 +121,10 @@ public:
 					<b>Throws:</b> Nothing.
 				</p>
 			</blockquote>
-
 			<h3><a name="ref">ref</a></h3>
-
 			<pre>
 template&lt;class T&gt; reference_wrapper&lt;T&gt; ref(T &amp; t);
 </pre>
-
 			<blockquote>
 				<p>
 					<b>Returns:</b> <tt>reference_wrapper&lt;T&gt;(t)</tt>.
@@ -149,13 +133,10 @@ template&lt;class T&gt; reference_wrapper&lt;T&gt; ref(T &amp; t);
 					<b>Throws:</b> Nothing.
 				</p>
 			</blockquote>
-
 			<h3><a name="cref">cref</a></h3>
-
 			<pre>
 template&lt;class T&gt; reference_wrapper&lt;T const&gt; cref(T const &amp; t);
 </pre>
-
 			<blockquote>
 				<p>
 					<b>Returns:</b> <tt>reference_wrapper&lt;T const&gt;(t)</tt>.
@@ -164,9 +145,7 @@ template&lt;class T&gt; reference_wrapper&lt;T const&gt; cref(T const &amp; t);
 					<b>Throws:</b> Nothing.
 				</p>
 			</blockquote>
-
 			<h3><a name="is_reference_wrapper">is_reference_wrapper</a></h3>
-
 			<pre>
 template&lt;class T&gt; class is_reference_wrapper&lt;T const&gt;
 {
@@ -175,7 +154,6 @@ template&lt;class T&gt; class is_reference_wrapper&lt;T const&gt;
 };
 </pre>
 			Value is <b>true</b> iff <tt>T</tt> is a specialization of <tt>reference_wrapper</tt>.
-
 			<h3><a name="unwrap_reference">unwrap_reference</a></h3>
 			<pre>
 template&lt;class T&gt; class unwrap_reference&lt;T const&gt;
@@ -184,27 +162,24 @@ template&lt;class T&gt; class unwrap_reference&lt;T const&gt;
     typedef <i>unspecified</i> type;
 };
 </pre>
-<tt>type</tt> is equivalent to <tt>T::type</tt> if <tt>T</tt> is a specialization of <tt>reference_wrapper</tt>. Otherwise <tt>type</tt> is equivalent to <tt>T</tt>.
+			<tt>type</tt> is equivalent to <tt>T::type</tt> if <tt>T</tt> is a 
-
+			specialization of <tt>reference_wrapper</tt>. Otherwise <tt>type</tt> is 
+			equivalent to <tt>T</tt>.
 			<h2>Acknowledgements</h2>
-
 		<p>
-<b>ref</b> and <b>cref</b> were originally part of the Boost.Tuple
+			<b>ref</b> and <b>cref</b> were originally part of the Boost.Tuple library by <a href="../../people/jaakko_jarvi.htm">
-library by <a href="../../people/jaakko_jarvi.htm"> Jaakko
+				Jaakko J&auml;rvi</a>. They were "promoted to <b>boost::</b> status" by <a href="../../people/peter_dimov.htm">
-J&auml;rvi</a>.  They were "promoted to <b>boost::</b> status" by <a
+				Peter Dimov</a> because they are generally useful. <a href="../../people/doug_gregor.html">
-href="../../people/peter_dimov.htm">Peter Dimov</a> because they are
+				Douglas Gregor</a> and <a href="../../people/dave_abrahams.htm">Dave Abrahams</a>
-generally useful.  <a href="../../people/doug_gregor.html">Douglas
+			contributed <tt>is_reference_wrapper</tt> and <tt>unwrap_reference</tt>.
-Gregor</a> and <a href="../../people/dave_abrahams.htm">Dave
-Abrahams</a> contributed <tt>is_reference_wrapper</tt> and
-<tt>unwrap_reference</tt>.
 		</p>
-
+		<p><br>
-
+			<br>
-<p><br><br><br><small>Copyright &copy; 2001 by Peter Dimov and Multi Media
+			<br>
-Ltd. Permission to copy, use, modify, sell and distribute this document is
+			<small>Copyright &copy; 2001 by Peter Dimov and Multi Media Ltd. Permission to 
-granted provided this copyright notice appears in all copies. This document
+				copy, use, modify, sell and distribute this document is granted provided this 
-is provided &quot;as is&quot; without express or implied warranty, and with
+				copyright notice appears in all copies. This document is provided &quot;as 
-no claim as to its suitability for any purpose.</small></p>
+				is&quot; without express or implied warranty, and with no claim as to its 
-
+				suitability for any purpose.</small></p>
 	</body>
 </html>