Added threading models

[SVN r13824]
Removed Mixins & Policies
2002-05-11 15:44:38 +00:00 · 2002-05-11 15:41:14 +00:00 · 2002-05-11 15:33:00 +00:00 · 2002-04-30 20:05:33 +00:00 · 2002-04-30 20:05:32 +00:00 · 2002-04-30 19:41:37 +00:00
30 changed files with 1204 additions and 1396 deletions
--- a/doc/faq.html
+++ b/doc/faq.html
@ -34,14 +34,11 @@ void g() { return f(); }
 <h2>Q: Why (function) cloning? </h2>
 <p> In November and December of 2000, the issue of cloning vs. reference counting was debated at length and it was decided that cloning gave more predictable semantics. I won't rehash the discussion here, but if it cloning is incorrect for a particular application a reference-counting allocator could be used. 

-<h2>Q: How do I assign from a member function?</h2>
-<p> Member function assignments are not included directly in <code>boost::function</code> because they do not conform to the syntax of function objects. Several libraries exist to wrap member functions in a function object and/or bind the first argument to the member function (the <code>this</code> pointer). A few libraries are <a href="tutorial.html#member_func">described</a> in the <a href="../index.html">Boost.Function</a> documentation.
-
    <hr>
    <address><a href="mailto:gregod@cs.rpi.edu">Doug Gregor</a></address>
 <!-- Created: Fri Feb 16 09:30:41 EST 2001 -->
 <!-- hhmts start -->
-Last modified: Sat Jul 14 16:00:11 EDT 2001
+Last modified: Wed Nov  7 15:11:52 EST 2001
 <!-- hhmts end -->
  </body>
 </html>
--- a/doc/reference.html
+++ b/doc/reference.html
@ -15,8 +15,10 @@
 <b>namespace</b> boost {
  <b>class</b> <a href="#function_base">function_base</a>
  {
+    <b>typedef</b> <em>implementation-defined</em> safe_bool;
    <a href="#empty"><b>bool</b> empty() <b>const</b></a>;
-    <a href="#bool"><b>operator</b> <b>bool</b>() <b>const</b></a>;
+    <a href="#bool"><b>operator</b> safe_bool() <b>const</b></a>;
+    <a href="#not">safe_bool <b>operator!</b>() <b>const</b></a>;
  };

  // For <i>N</i> in [0, <i>MAX_ARGS</i>]
@ -30,7 +32,7 @@
 	   <b>typename</b> Allocator = std::allocator&lt;function_base&gt; &gt;
  <b>class</b> <a href="#functionN">function<i>N</i></a> : <b>public</b> <a href="#function_base">function_base</a>, <b>public</b> Mixin
  {
-    <b>typedef</b> ResultType result_type;
+    <b>typedef</b> ResultType result_type; <em>// <a href="#novoid">[1]</a></em>
    <b>typedef</b> Policy     policy_type;
    <b>typedef</b> Mixin      mixin_type;
    <b>typedef</b> Allocator  allocator_type;
@ -43,13 +45,15 @@
    <i>// Construction</i>
    <a href="#functionN_default"><b>explicit</b> function<i>N</i>(<b>const</b> Mixin<b>&amp;</b> = Mixin())</a>;
    <a href="#functionN_copy">function<i>N</i>(<b>const</b> function<i>N</i><b>&amp;</b>)</a>;
-    <a href="#functionN_target"><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i>(<b>const</b> F<b>&amp;</b>, <b>const</b> Mixin<b>&amp;</b> = Mixin())</a>;
+    <a href="#functionN_target"><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i>(F, <b>const</b> Mixin<b>&amp;</b> = Mixin())</a>;
+    <a href="#functionN_target_ref"><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i>(reference_wrapper&lt;F&gt;)</a>;
    
    <i>// Assignment</i>
    <a href="#functionN_copy_assn">function<i>N</i><b>&amp;</b> <b>operator</b>=(<b>const</b> function<i>N</i><b>&amp;</b>)</a>;
-    <a href="#functionN_target_assn"><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i><b>&amp;</b> <b>operator</b>=(<b>const</b> F<b>&amp;</b>)</a>;
+    <a href="#functionN_target_assn"><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i><b>&amp;</b> <b>operator</b>=(F)</a>;
+    <a href="#functionN_target_ref_assn"><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i><b>&amp;</b> <b>operator</b>=(reference_wrapper&lt;F&gt;)</a>;
    <a href="#functionN_copy_set"><b>void</b> set(<b>const</b> function<i>N</i><b>&amp;</b>)</a>;
-    <a href="#functionN_target_set"><b>template</b>&lt;<b>typename</b> F&gt; <b>void</b> set(<b>const</b> F<b>&amp;</b>)</a>;
+    <a href="#functionN_target_set"><b>template</b>&lt;<b>typename</b> F&gt; <b>void</b> set(F)</a>;
    <a href="#functionN_swap"><b>void</b> swap(function<i>N</i><b>&amp;</b>)</a>;
    <a href="#functionN_clear"><b>void</b> clear()</a>;

@ -65,8 +69,8 @@
           <b>typename</b> Policy,
           <b>typename</b> Mixin,
           <b>typename</b> Allocator&gt;
-  <b>void</b> <a href="#swap_functionN">swap</a>(<b>const</b> function&lt;Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator&gt;<b>&amp;</b>,
-            <b>const</b> function&lt;Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator&gt;<b>&amp;</b>);
+  <b>void</b> <a href="#swap_functionN">swap</a>(function<em>N</em>&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator&gt;<b>&amp;</b>,
+            function<em>N</em>&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator&gt;<b>&amp;</b>);

  // For any <i>N</i> in [0, <i>MAX_ARGS</i>]
  <b>template</b>&lt;<b>typename</b> ResultType,
@ -78,21 +82,21 @@
           <b>typename</b> Arg<i>N+2</i> = <i>implementation-defined</i>,
 	   <i>...</i>
 	   <b>typename</b> Arg<i>MAX_ARGS</i> = <i>implementation-defined</i>&gt;
-  <b>class</b> <a href="#function">function</a> : <b>public</b> <a href="#functionN">function<i>N</i></a>&lt;Arg1, Arg2, <i>...</i>, Arg<i>N</i>&gt;
+  <b>class</b> <a href="#function">function</a> : <b>public</b> <a href="#functionN">function<i>N</i></a>&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>&gt;
  {
    <i>// Construction</i>
    function();
    function(<b>const</b> function<b>&amp;</b>);
-    function<i>N</i>(<b>const</b> function<i>N</i><b>&amp;</b>);
-    <b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i>(<b>const</b> F<b>&amp;</b>);
+    function(<b>const</b> function<i>N</i>&lt;ResultType, Arg1, Arg2, ..., Arg<i>N</i>&gt;<b>&amp;</b>);
+    <b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i>(F);
    
    <i>// Assignment</i>
    function<b>&amp;</b> <b>operator</b>=(<b>const</b> function<b>&amp;</b>);
-    function<i>N</i><b>&amp;</b> <b>operator</b>=(<b>const</b> function<i>N</i><b>&amp;</b>);
-    <b>template</b>&lt;<b>typename</b> F&gt; function<b>&amp;</b> <b>operator</b>=(<b>const</b> F<b>&amp;</b>);
+    function<b>&amp;</b> <b>operator</b>=(<b>const</b> function<i>N</i>&lt;ResultType, Arg1, Arg2, ..., Arg<i>N</i>&gt;<b>&amp;</b>);
+    <b>template</b>&lt;<b>typename</b> F&gt; function<b>&amp;</b> <b>operator</b>=(F);
    <b>void</b> set(<b>const</b> function<b>&amp;</b>);
-    <b>void</b> set(<b>const</b> function<i>N</i><b>&amp;</b>);
-    <b>template</b>&lt;<b>typename</b> F&gt; <b>void</b> set(<b>const</b> F<b>&amp;</b>);
+    <b>void</b> set(<b>const</b> function<i>N</i>&lt;ResultType, Arg1, Arg2, ..., Arg<i>N</i>&gt;<b>&amp;</b>);
+    <b>template</b>&lt;<b>typename</b> F&gt; <b>void</b> set(F);
  };

  <b>template</b>&lt;<b>typename</b> ResultType,
@ -100,11 +104,39 @@
 	   <b>typename</b> Arg2,
           <i>...</i>
 	   <b>typename</b> Arg<i>MAX_ARGS</i>&gt;
-  <b>void</b> <a href="#swap_function">swap</a>(<b>const</b> function&lt;Arg1, Arg2, <i>...</i>, Arg<i>MAX_ARGS</i>&gt;<b>&amp;</b>,
-            <b>const</b> function&lt;Arg1, Arg2, <i>...</i>, Arg<i>MAX_ARGS</i>&gt;<b>&amp;</b>);
+  <b>void</b> <a href="#swap_function">swap</a>(function&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>MAX_ARGS</i>&gt;<b>&amp;</b>,
+            function&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>MAX_ARGS</i>&gt;<b>&amp;</b>);
 }	   
 </pre>

+<h2>Definitions</h2>
+<p>
+<ul>
+  <li><a name="compatible"></a>A function object <code>f</code> is <em>compatible</em> if for the given set of argument types <code>Arg1</code>, <code>Arg2</code>, ..., <code>Arg<em>N</em></code> and a return type <code>ResultType</code>, the appropriate following function is well-formed:
+<pre>
+  <em>// if ResultType is not <b>void</b></em>
+  ResultType foo(Arg1 arg1, Arg2 arg2, ..., Arg<em>N</em> arg<em>N</em>)
+  {
+    <b>return</b> f(arg1, arg2, ..., arg<em>N</em>);
+  }
+
+  <em>// if ResultType is <b>void</b></em>
+  ResultType foo(Arg1 arg1, Arg2 arg2, ..., Arg<em>N</em> arg<em>N</em>)
+  {
+    f(arg1, arg2, ..., arg<em>N</em>);
+  }
+</pre>
+        <p> A special provision is made for pointers to member functions. Though they are not function objects, Boost.Function will adapt them internally to function objects. This requires that a pointer to member function of the form <code>R (X::*mf)(Arg1, Arg2, ..., Arg<em>N</em>) <em>cv-quals</em></code> be adapted to a function object with the following function call operator overloads:
+<pre>
+  <b>template</b>&lt;<b>typename P</b>&gt;
+  R <b>operator</b>()(<em>cv-quals</em> P&amp; x, Arg1 arg1, Arg2 arg2, ..., Arg<em>N</em> arg<em>N</em>) <b>const</b>
+  {
+    <b>return</b> (*x).*mf(arg1, arg2, ..., arg<em>N</em>);
+  }
+</pre>
+  <li><a name="stateless"></a>A function object <code>f</code> of type <code>F</code> is <em>stateless</em> if it is a function pointer or if <a href="../../type_traits/index.htm#properties"><code>boost::is_stateless&lt;T&gt;</code></a> is true. The construction of or copy to a Boost.Function object from a stateless function object will not cause exceptions to be thrown and will not allocate any storage.</li>
+</ul>
+
 <h2><a name="function_base">Class <code>function_base</code></a></h2>
 <p> Class <code>function_base</code> is the common base class for all Boost.Function objects. Objects of type <code>function_base</code> may not be created directly. 

@ -114,10 +146,18 @@
  <li><b>Throws</b>: will not throw.</li>
 </ul>

-<p> <a name="bool"><code><b>operator</b> <b>bool</b>() <b>const</b></code></a>
+<p> <a name="bool"><code><b>operator</b> safe_bool() <b>const</b></code></a>
 <ul>
-  <li><b>Returns</b>: <code>!<a href="#empty">empty</a>()</code></li>
+  <li><b>Returns</b>: <code>safe_bool</code> equivalent of <code>!<a href="#empty">empty</a>()</code></li>
  <li><b>Throws</b>: will not throw.</li>
+  <li><b>Notes</b>: The <code>safe_bool</code> type can be used in contexts where a <b>bool</b> is expected (e.g., an <b>if</b> condition); however, implicit conversions (e.g., to <b>int</b>) that can occur with <b>bool</b> are not allowed, eliminating some sources of user error.
+</ul>
+
+<p> <a name="not"><code>safe_bool <b>operator!</b>() <b>const</b></code></a>
+<ul>
+  <li><b>Returns</b>: <code>safe_bool</code> equivalent of <code><a href="#empty">empty</a>()</code></li>
+  <li><b>Throws</b>: will not throw.</li>
+  <li><b>Notes</b>: See <a href="#bool"><code>safe_bool</code> conversion</a>
 </ul>

 <h2><a name="functionN">Class template <code>function<i>N</i></code></a></h2>
@ -127,34 +167,52 @@
 <ul>
  <li><b>Effects</b>: Constructs the <code>Mixin</code> subobject with the given mixin.</li>
  <li><b>Postconditions</b>: <code>f.<a href="#empty">empty</a>()</code>.</li>
-  <li><b>Throws</b>: will not throw.</li>
+  <li><b>Throws</b>: will not throw unless construction of the <code>Mixin</code> subobject throws.</li>
 </ul>

 <p> <a name="functionN_copy"><code>function<i>N</i>(<b>const</b> function<i>N</i><b>&amp;</b> g);</code></a>
 <ul>
  <li><b>Postconditions</b>: <code>f</code> contains a copy of the <code>g</code>'s target, if it has one, or is empty if <code>g.<a href="#empty">empty</a>()</code>. The mixin for the <code>f</code> is copy-constructed from the mixin of <code>g</code>.</li>
+  <li><b>Throws</b>: will not throw unless copying the target of <code>g</code> or construction of the <code>Mixin</code> subobject throws.</li>
 </ul>

-<p> <a name="functionN_target"><code><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i>(<b>const</b> F<b>&amp;</b> g, <b>const</b> Mixin<b>&amp;</b> = Mixin());</code></a>
+<p> <a name="functionN_target"><code><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i>(F g, <b>const</b> Mixin<b>&amp;</b> = Mixin());</code></a>
 <ul>
-  <li><b>Requires</b>: <code>g</code> is a compatible function object.</li>
+  <li><b>Requires</b>: <code>g</code> is a <a href="#compatible">compatible</a> function object.</li>
  <li><b>Effects</b>: Constructs the <code>Mixin</code> subobject from the given mixin.</li>
  <li><b>Postconditions</b>: <code>f</code> targets a copy of <code>g</code> if <code>g</code> is nonempty, or <code>f.<a href="#empty">empty</a>()</code> if <code>g</code> is empty.</li>
-  <li><b>Rationale</b>: <code>g</code> is a reference-to-<code><b>const</b></code> because it is a portable, efficient, and concise way to accept any function object or function pointer. In the case of a function pointer, the type of <code>g</code> is reference-to-<code><b>const</b></code> pointer-to-function.</li>
+  <li><b>Throws</b>: will not throw when <code>g</code> is a <a href="#stateless">stateless</a> function object unless construction of the <code>Mixin</code> subobject throws.</li>
+</ul>
+
+<p> <a name="functionN_target_ref"><code><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i>(<a href="../../bind/ref.html">reference_wrapper</a>&lt;F&gt; g);</code></a>
+<ul>
+  <li><b>Requires</b>: <code>g.get()</code> is a <a href="#compatible">compatible</a> function object.</li>
+  <li><b>Effects</b>: Constructs the <code>Mixin</code> subobject from the given mixin.</li>
+  <li><b>Postconditions</b>: <code>this</code> object targets <code>g</code> (<em>not</em> a copy of <code>g.get()</code>) if <code>g.get()</code> is nonempty, or <code>this-&gt;empty()</code> if <code>g.get()</code> is empty.</li>
+  <li><b>Throws</b>: will not throw unless the construction of the <code>Mixin</code> subobject throws.</li>
 </ul>

 <p> <a name="functionN_copy_assn"><code>function<i>N</i><b>&amp;</b> <b>operator</b>=(<b>const</b> function<i>N</i><b>&amp;</b> g);</code></a>
 <ul>
  <li><b>Postconditions</b>: <code>f</code> targets a copy of <code>g</code>'s target, if it has one, or is empty if <code>g.<a href="#empty">empty</a>()</code>. The mixin for <code>f</code> is assigned the value of the mixin for <code>g</code>.</li>
  <li><b>Returns</b>: <code>*this</code>.</li>
+  <li><b>Throws</b>: will not throw when the target of <code>g</code> is a <a href="#stateless">stateless</a> function object or a reference to the function object, unless the copy of the <code>Mixin</code> subobject throws.</li>
 </ul>

-<p> <a name="functionN_target_assn"><code><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i><b>&amp;</b> <b>operator</b>=(<b>const</b> F<b>&amp;</b> g);</code></a>
+<p> <a name="functionN_target_assn"><code><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i><b>&amp;</b> <b>operator</b>=(F g);</code></a>
 <ul>
-  <li><b>Requires</b>: <code>g</code> is a compatible function object.</li>
+  <li><b>Requires</b>: <code>g</code> is a <a href="#compatible">compatible</a> function object.</li>
  <li><b>Postconditions</b>: <code>f</code> targets a copy of <code>g</code> if <code>g</code> is nonempty, or <code>f.<a href="#empty">empty</a>()</code> if <code>g</code> is empty.</li>
  <li><b>Returns</b>: <code>*this</code>.</li>
-  <li><b>Rationale</b>: <code>g</code> is a reference-to-<code><b>const</b></code> because it is a portable, efficient, and concise way to accept any function object or function pointer. In the case of a function pointer, the type of <code>g</code> is reference-to-<code><b>const</b></code> pointer-to-function.</li>
+  <li><b>Throws</b>: will not throw when <code>g</code> is a <a href="#stateless">stateless</a> function object.</li>
+</ul>
+
+<p> <a name="functionN_target_ref_assn"><code><b>template</b>&lt;<b>typename</b> F&gt; function<i>N</i><b>&amp;</b> <b>operator</b>=(<a href="../../bind/ref.html">reference_wrapper</a>&lt;F&gt; g);</code></a>
+<ul>
+  <li><b>Requires</b>: <code>g.get()</code> is a <a href="#compatible">compatible</a> function object.</li>
+  <li><b>Postconditions</b>: <code>f</code> targets <code>g.get()</code> (not a copy of <code>g.get()</code>) if <code>g.get()</code> is nonempty, or <code>f.<a href="#empty">empty</a>()</code> if <code>g.get()</code> is empty.</li>
+  <li><b>Returns</b>: <code>*this</code>.</li>
+  <li><b>Throws</b>: will throw only if the destruction or deallocation of the target of <code>this</code> throws.</li>
 </ul>

 <p> <a name="functionN_copy_set"><code><b>void</b> set(<b>const</b> function<i>N</i><b>&amp;</b> g);</code></a>
@ -162,7 +220,7 @@
  <li><b>Effects</b>: <code><a href="#functionN_copy_assn">*this = g</a></code>.</li>
 </ul>

-<p> <a name="functionN_target_set"><code><b>template</b>&lt;<b>typename</b> F&gt; <b>void</b> set(<b>const</b> F<b>&amp;</b> g);</code></a>
+<p> <a name="functionN_target_set"><code><b>template</b>&lt;<b>typename</b> F&gt; <b>void</b> set(F g);</code></a>
 <ul>
  <li><b>Effects</b>: <code><a href="#functionN_target_assn">*this = g</a></code>.</li>
 </ul>
@ -208,8 +266,8 @@
         <b>typename</b> Policy,
         <b>typename</b> Mixin,
         <b>typename</b> Allocator&gt;
-<b>void</b> <a name="swap_functionN">swap</a>(<b>const</b> function<i>N</i>&lt;Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator&gt;<b>&amp;</b> f,
-          <b>const</b> function<i>N</i>&lt;Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator&gt;<b>&amp;</b> g);
+<b>void</b> <a name="swap_functionN">swap</a>(function<i>N</i>&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator&gt;<b>&amp;</b> f,
+          function<i>N</i>&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>N</i>, Policy, Mixin, Allocator&gt;<b>&amp;</b> g);
 </pre>
 <ul>
  <li><b>Effects</b>: <code>f.<a href="#functionN_swap">swap</a>(g);</code></li>
@ -222,18 +280,20 @@
 	 <b>typename</b> Arg2,
         <i>...</i>
 	 <b>typename</b> Arg<i>MAX_ARGS</i>&gt;
-<b>void</b> <a name="swap_function">swap</a>(<b>const</b> function&lt;Arg1, Arg2, <i>...</i>, Arg<i>MAX_ARGS</i>&gt;<b>&amp;</b> f,
-          <b>const</b> function&lt;Arg1, Arg2, <i>...</i>, Arg<i>MAX_ARGS</i>&gt;<b>&amp;</b> g);
+<b>void</b> <a name="swap_function">swap</a>(function&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>MAX_ARGS</i>&gt;<b>&amp;</b> f,
+          function&lt;ResultType, Arg1, Arg2, <i>...</i>, Arg<i>MAX_ARGS</i>&gt;<b>&amp;</b> g);
 </pre>
 <ul>
  <li><b>Effects</b>: <code>f.<a href="#functionN_swap">swap</a>(g);</code></li>
 </ul>

    <hr>
+<p><a name="novoid">[1]</a> On compilers not supporting void returns, when the <code>ReturnType</code> is <b>void</b>, the <code>result_type</code> of a Boost.Function object is implementation-defined.
+    <hr>
    <address><a href="mailto:gregod@cs.rpi.edu">Douglas Gregor</a></address>
 <!-- Created: Fri Jul 13 10:57:20 EDT 2001 -->
 <!-- hhmts start -->
-Last modified: Sun Jul 22 01:29:50 EDT 2001
+Last modified: Thu Jan 31 21:55:35 EST 2002
 <!-- hhmts end -->
  </body>
 </html>
--- a/doc/tutorial.html
+++ b/doc/tutorial.html
@ -60,14 +60,30 @@ else
 <p> Free function pointers can be considered singleton function objects with const function call operators, and can therefore be directly used with the function object wrappers:
 <pre>
  float mul_ints(int x, int y) { return ((float)x) * y; }
-  f = &mul_ints;
+  f = &amp;mul_ints;
 </pre>

+<p> Note that the <code>&amp;</code> isn't really necessary unless you happen to be using Microsoft Visual C++ version 6.
+
 <h3>Member functions</h3>
 <a name="member_func">
 <p> In many systems, callbacks often call to member functions of a particular
-object. Handling argument binding is beyond the scope of Boost.Function. However, there are several libraries that perform 'argument binding', including
+object. This is often referred to as "argument binding", and is beyond the scope of Boost.Function. The use of member functions directly, however, is supported, so the following code is valid:
+<pre>
+  struct X {
+    int foo(int);
+  };
+
+  boost::function&lt;int, X*, int&gt; f;
+  f = &amp;X::foo;
+  
+  X x;
+  f(&amp;x, 5);
+</pre>
+<p> Several libraries exist that support argument binding. Three such libraries are summarized below:
 <ul>
+  <li> <a href="../../bind/bind.html">Boost.Bind</a>. This library allows binding of arguments for any function object. It is lightweight and very portable.</li>
+
  <li> The C++ Standard library. Using <code>std::bind1st</code> and <code>std::mem_fun</code> together one can bind the object of a pointer-to-member function for use with Boost.Function:
 <pre>
  struct X {
@ -81,12 +97,34 @@ object. Handling argument binding is beyond the scope of Boost.Function. However
  f(5); // Call x.foo(5)</pre></li>

  <li><a href="http://lambda.cs.utu.fi/">The Lambda library</a>. This library provides a powerful composition mechanism to construct function objects that uses very natural C++ syntax. Lambda requires a compiler that is reasonably conformant to the C++ standard. Note that it is not a Boost library.</li>
-
-  <li>Peter Dimov's <a href="http://groups.yahoo.com/group/boost/files/bind/bind.hpp">bind</a> library. It has a smaller scope than the Lambda Library but is more tolerant of broken compilers. It is an unreviewed library in development.</li>
 </ul>

+<h3>References to Functions</h3>
+<p> In some cases it is expensive (or semantically incorrect) to have
+Boost.Function clone a function object. In such cases, it is possible
+to request that Boost.Function keep only a reference to the actual
+function object. This is done using the <a
+href="../../bind/ref.html"><code>ref</code></a> and <a
+href="../../bind/ref.html"><code>cref</code></a> functions to wrap a
+reference to a function object:
+
+<pre>
+  stateful_type a_function_object;
+  boost::function&lt;int, int&gt; f;
+  f = ref(a_function_object);
+
+  boost::function&lt;int, int&gt; f2(f);
+</pre>
+
+Here, <code>f</code> will not make a copy of
+<code>a_function_object</code>, nor will <code>f2</code> when it is
+targeted to <code>f</code>'s reference to
+<code>a_function_object</code>. Additionally, when using references to
+function objects, Boost.Function will not throw exceptions during
+    assignment or construction.
+ 
 <h2><a name="family">The <code>function</code> family</a></h2>
-<p> The header &lt;<a href="../../boost/function.hpp">boost/function.hpp</a>&gt; defines the primary entry point to the function object wrappers, the class template <code>boost::function</code>. This class template is essentially a thin wrapper around a set of similar numbered function object wrappers, <code>boost::function0</code>, <code>boost::function1</code>, etc., where the number indicates the number of arguments passed to the function object target. The declaration of <code>f</code> above could also be written as:
+<p> The header &lt;<a href="../../../boost/function.hpp">boost/function.hpp</a>&gt; defines the primary entry point to the function object wrappers, the class template <code>boost::function</code>. This class template is essentially a thin wrapper around a set of similar numbered function object wrappers, <code>boost::function0</code>, <code>boost::function1</code>, etc., where the number indicates the number of arguments passed to the function object target. The declaration of <code>f</code> above could also be written as:
 <pre>
 boost::function2&lt;float, int, int&gt; f;
 </pre>
@ -161,7 +199,7 @@ boost::function2&lt;float, int, int, SynchronizedPolicy, SynchronizedMixin&gt; f
    <address><a href="mailto:gregod@cs.rpi.edu">Douglas Gregor</a></address>
 <!-- Created: Fri Jul 13 12:47:11 EDT 2001 -->
 <!-- hhmts start -->
-Last modified: Fri Jul 13 23:58:17 EDT 2001
+Last modified: Fri Dec 14 19:58:14 EST 2001
 <!-- hhmts end -->
  </body>
 </html>
--- a/example/sum_avg.cpp
+++ b/example/sum_avg.cpp
@ -27,7 +27,9 @@ void do_sum_avg(int values[], int n, int& sum, float& avg)
 int
 main()
 {
-  boost::function<void, int[], int, int&, float&> sum_avg;
+  // The second parameter should be int[], but some compilers (e.g., GCC)
+  // complain about this 
+  boost::function<void, int*, int, int&, float&> sum_avg;

  sum_avg = &do_sum_avg;

--- a/include/boost/function.hpp
+++ b/include/boost/function.hpp
@ -1,6 +1,6 @@
 // Boost.Function library

-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
+// Copyright (C) 2001-2002 Doug Gregor (gregod@cs.rpi.edu)
 //
 // Permission to copy, use, sell and distribute this software is granted
 // provided this copyright notice appears in all copies.
@ -53,13 +53,12 @@ namespace boost {
          typename T8,
          typename T9,
          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
+          typename ThreadingPolicy,
+          typename Allocator
        >
        struct params
        {
-          typedef function0<R, Policy, Mixin, Allocator> type;
+          typedef function0<R, ThreadingPolicy, Allocator> type;
        };
      };

@ -78,13 +77,12 @@ namespace boost {
          typename T8,
          typename T9,
          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
+          typename ThreadingPolicy,
+          typename Allocator
        >
        struct params
        {
-          typedef function1<R, T1, Policy, Mixin, Allocator> type;
+          typedef function1<R, T1, ThreadingPolicy, Allocator> type;
        };
      };

@ -103,13 +101,12 @@ namespace boost {
          typename T8,
          typename T9,
          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
+          typename ThreadingPolicy,
+          typename Allocator
        >
        struct params
        {
-          typedef function2<R, T1, T2, Policy, Mixin, Allocator> type;
+          typedef function2<R, T1, T2, ThreadingPolicy, Allocator> type;
        };
      };

@ -128,13 +125,12 @@ namespace boost {
          typename T8,
          typename T9,
          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
+          typename ThreadingPolicy,
+          typename Allocator
        >
        struct params
        {
-          typedef function3<R, T1, T2, T3, Policy, Mixin, Allocator> type;
+          typedef function3<R, T1, T2, T3, ThreadingPolicy, Allocator> type;
        };
      };

@ -153,13 +149,12 @@ namespace boost {
          typename T8,
          typename T9,
          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
+          typename ThreadingPolicy,
+          typename Allocator
        >
        struct params
        {
-          typedef function4<R, T1, T2, T3, T4, Policy, Mixin, Allocator> type;
+          typedef function4<R, T1, T2, T3, T4, ThreadingPolicy, Allocator> type;
        };
      };

@ -178,13 +173,12 @@ namespace boost {
          typename T8,
          typename T9,
          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
+          typename ThreadingPolicy,
+          typename Allocator
        >
        struct params
        {
-          typedef function5<R, T1, T2, T3, T4, T5, Policy, Mixin, Allocator> 
+          typedef function5<R, T1, T2, T3, T4, T5, ThreadingPolicy, Allocator> 
          type;
        };
      };
@ -204,13 +198,12 @@ namespace boost {
          typename T8,
          typename T9,
          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
+          typename ThreadingPolicy,
+          typename Allocator
        >
        struct params
        {
-          typedef function6<R, T1, T2, T3, T4, T5, T6, Policy, Mixin, Allocator>
+          typedef function6<R, T1, T2, T3, T4, T5, T6, ThreadingPolicy, Allocator>
          type;
        };
      };
@ -230,13 +223,12 @@ namespace boost {
          typename T8,
          typename T9,
          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
+          typename ThreadingPolicy,
+          typename Allocator
        >
        struct params
        {
-          typedef function7<R, T1, T2, T3, T4, T5, T6, T7, Policy, Mixin, 
+          typedef function7<R, T1, T2, T3, T4, T5, T6, T7, ThreadingPolicy, 
                            Allocator> type;
        };
      };
@ -256,13 +248,12 @@ namespace boost {
          typename T8,
          typename T9,
          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
+          typename ThreadingPolicy,
+          typename Allocator
        >
        struct params
        {
-          typedef function8<R, T1, T2, T3, T4, T5, T6, T7, T8, Policy, Mixin, 
+          typedef function8<R, T1, T2, T3, T4, T5, T6, T7, T8, ThreadingPolicy, 
                            Allocator> type;
        };
      };
@ -282,14 +273,13 @@ namespace boost {
          typename T8,
          typename T9,
          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
+          typename ThreadingPolicy,
+          typename Allocator
        >
        struct params
        {
-          typedef function9<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, Policy, 
-                            Mixin, Allocator> type;
+          typedef function9<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, 
+                            ThreadingPolicy, Allocator> type;
        };
      };

@ -308,14 +298,13 @@ namespace boost {
          typename T8,
          typename T9,
          typename T10,
-          typename Policy = empty_function_policy,
-          typename Mixin = empty_function_mixin,
-          typename Allocator = std::allocator<function_base>
+          typename ThreadingPolicy,
+          typename Allocator
        >
        struct params
        {
          typedef function10<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, 
-                             Policy, Mixin, Allocator> type;
+                             ThreadingPolicy, Allocator> type;
        };
      };

@ -331,16 +320,15 @@ namespace boost {
        typename T8, 
        typename T9,
        typename T10,
-        typename Policy = empty_function_policy,
-        typename Mixin = empty_function_mixin,
-        typename Allocator = std::allocator<function_base> 
+        typename ThreadingPolicy = BOOST_FUNCTION_DEFAULT_THREADING_POLICY,
+        typename Allocator = BOOST_FUNCTION_DEFAULT_ALLOCATOR 
      >
      struct get_function_impl
      {
        typedef typename real_get_function_impl<
          (count_used_args<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value)
          >::template params<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, 
-                             Policy, Mixin, Allocator>::type
+                             ThreadingPolicy, Allocator>::type
        type;
      };

@ -356,55 +344,37 @@ namespace boost {
    typename T8, 
    typename T9,
    typename T10,
-    typename MyPolicy = empty_function_policy,
-    typename MyMixin = empty_function_mixin,
-    typename MyAllocator = std::allocator<function_base> 
+    typename MyThreadingPolicy = BOOST_FUNCTION_DEFAULT_THREADING_POLICY,
+    typename MyAllocator = BOOST_FUNCTION_DEFAULT_ALLOCATOR 
  >
  struct function_traits_builder
  {
    typedef typename get_function_impl<R, T1, T2, T3, T4, T5, T6, T7, 
-                                       T8, T9, T10, MyPolicy, MyMixin, 
+                                       T8, T9, T10, MyThreadingPolicy,
                                       MyAllocator>::type
      type;

-    typedef MyPolicy    policy_type;
-    typedef MyMixin     mixin_type;
+    typedef MyThreadingPolicy threading_policy_type;
    typedef MyAllocator allocator_type;

 #ifndef BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
-    template<typename Policy>
-    struct policy : 
+    template<typename ThreadingPolicy>
+    struct threading_policy : 
        public function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7, T8, T9,
-                                       T10, Policy, mixin_type, 
-                                       allocator_type> {};
-
-    template<typename Mixin>
-    struct mixin : 
-        public function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7, T8, T9,
-                                       T10, policy_type, Mixin, 
+                                       T10, ThreadingPolicy,
                                       allocator_type> {};

    template<typename Allocator>
    struct allocator : 
        public function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7, T8, T9,
-                                       T10, policy_type, mixin_type, 
+                                       T10, threading_policy_type,
                                       Allocator> {};
 #else
-    template<typename Policy>
-    struct policy 
+    template<typename ThreadingPolicy>
+    struct threading_policy 
    {
      typedef typename function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7,
-                                               T8, T9, T10, Policy, 
-                                               mixin_type, 
-                                               allocator_type>::type
-        type;
-    };
-
-    template<typename Mixin>
-    struct mixin
-    {
-      typedef typename function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7,
-                                               T8, T9, T10, policy_type, Mixin,
+                                               T8, T9, T10, ThreadingPolicy, 
                                               allocator_type>::type
        type;
    };
@ -413,8 +383,9 @@ namespace boost {
    struct allocator
    {
      typedef typename function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7,
-                                               T8, T9, T10, policy_type, 
-                                               mixin_type, Allocator>::type
+                                               T8, T9, T10, 
+                                               threading_policy_type, 
+                                               Allocator>::type
        type;
    };
 #endif
@ -448,74 +419,35 @@ namespace boost {
      base_type;

  public:
-    typedef typename base_type::policy_type policy_type;
-    typedef typename base_type::mixin_type mixin_type;
+    typedef typename base_type::threading_policy_type policy_type;
    typedef typename base_type::allocator_type allocator_type;              
    typedef function self_type;                                     
                                                                            
    function() : base_type() {}                                     
                                                                            
    template<typename Functor>                                              
-    function(const Functor& f) : base_type(f) {}
+    function(Functor BOOST_FUNCTION_TARGET_FIX(const &) f) : base_type(f) {}
                      
-#ifdef __BORLANDC__
-    template<typename Functor>
-    function(Functor* f) : base_type(f) {}
-#endif // __BORLANDC__
-                                                      
    function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
         
    template<typename Functor>
-    function& operator=(const Functor& f)
+    self_type& operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
    {
-      self_type(f).swap(*this);
+      base_type::operator=(f);
      return *this;
    }

-#ifdef __BORLANDC__
-    template<typename Functor>
-    self_type& operator=(Functor* f)
-    {
-      self_type(f).swap(*this);
-      return *this;
-    }
-#endif // __BORLANDC__
-
    self_type& operator=(const base_type& f)
    {
-      self_type(f).swap(*this);
+      base_type::operator=(f);
      return *this;
    }

-    self_type& operator=(const self_type& f)                                  
+    self_type& operator=(const self_type& f)
    {   
-      self_type(f).swap(*this);
-      return *this;                                                         
-    }                                                           
-
-    template<typename Functor>
-    void set(const Functor& f)
-    {
-      self_type(f).swap(*this);
+      base_type::operator=(static_cast<const base_type&>(f));
+      return *this;
    }
-
-#ifdef __BORLANDC__
-    template<typename Functor>
-    void set(Functor* f)
-    {
-      self_type(f).swap(*this);
-    }
-#endif // __BORLANDC__
- 
-    void set(const base_type& f)
-    {
-      self_type(f).swap(*this);
-    }
-
-    void set(const self_type& f)                             
-    {
-      self_type(f).swap(*this);
-    }   
  };

  template<typename R,
--- a/include/boost/function/function0.hpp
+++ b/include/boost/function/function0.hpp
@ -1,5 +1,5 @@
 // Boost.Function library
-
+//
 // Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
 //
 // Permission to copy, use, sell and distribute this software is granted
@ -10,50 +10,28 @@
 //
 // This software is provided "as is" without express or implied warranty,
 // and with no claim as to its suitability for any purpose.
-
+ 
 // For more information, see http://www.boost.org

-#ifndef BOOST_FUNCTION0_HPP
-#define BOOST_FUNCTION0_HPP
-
-#include <boost/function/function_base.hpp>
+#ifndef BOOST_FUNCTION_FUNCTION0_HEADER
+#define BOOST_FUNCTION_FUNCTION0_HEADER

 #define BOOST_FUNCTION_NUM_ARGS 0
-#define BOOST_FUNCTION_COMMA 
 #define BOOST_FUNCTION_TEMPLATE_PARMS 
 #define BOOST_FUNCTION_TEMPLATE_ARGS 
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS 
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS 
 #define BOOST_FUNCTION_PARMS 
 #define BOOST_FUNCTION_ARGS 
-#define BOOST_FUNCTION_FUNCTION function0
-#define BOOST_FUNCTION_BASE function0_base
-#define BOOST_FUNCTION_INVOKER_BASE invoker_base0
-#define BOOST_FUNCTION_FUNCTION_INVOKER function_invoker0
-#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER void_function_invoker0
-#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER function_obj_invoker0
-#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER void_function_obj_invoker0
-#define BOOST_FUNCTION_GET_FUNCTION_INVOKER get_function_invoker0
-#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER get_function_obj_invoker0
+#define BOOST_FUNCTION_NOT_0_PARMS 
+#define BOOST_FUNCTION_NOT_0_ARGS 

 #include <boost/function/function_template.hpp>

-#undef BOOST_FUNCTION_NUM_ARGS
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_NOT_0_ARGS
+#undef BOOST_FUNCTION_NOT_0_PARMS
 #undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_BASE
-#undef BOOST_FUNCTION_INVOKER_BASE
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#undef BOOST_FUNCTION_NUM_ARGS

-#endif // BOOST_FUNCTION0_HPP
+#endif // BOOST_FUNCTION_FUNCTION0_HEADER
--- a/include/boost/function/function1.hpp
+++ b/include/boost/function/function1.hpp
@ -1,5 +1,5 @@
 // Boost.Function library
-
+//
 // Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
 //
 // Permission to copy, use, sell and distribute this software is granted
@ -10,50 +10,28 @@
 //
 // This software is provided "as is" without express or implied warranty,
 // and with no claim as to its suitability for any purpose.
-
+ 
 // For more information, see http://www.boost.org

-#ifndef BOOST_FUNCTION1_HPP
-#define BOOST_FUNCTION1_HPP
-
-#include <boost/function/function_base.hpp>
+#ifndef BOOST_FUNCTION_FUNCTION1_HEADER
+#define BOOST_FUNCTION_FUNCTION1_HEADER

 #define BOOST_FUNCTION_NUM_ARGS 1
-#define BOOST_FUNCTION_COMMA ,
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1
-#define BOOST_FUNCTION_PARMS T1 a1
-#define BOOST_FUNCTION_ARGS a1
-#define BOOST_FUNCTION_FUNCTION function1
-#define BOOST_FUNCTION_BASE function1_base
-#define BOOST_FUNCTION_INVOKER_BASE invoker_base1
-#define BOOST_FUNCTION_FUNCTION_INVOKER function_invoker1
-#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER void_function_invoker1
-#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER function_obj_invoker1
-#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER void_function_obj_invoker1
-#define BOOST_FUNCTION_GET_FUNCTION_INVOKER get_function_invoker1
-#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER get_function_obj_invoker1
+#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0
+#define BOOST_FUNCTION_TEMPLATE_ARGS T0
+#define BOOST_FUNCTION_PARMS T0 a0
+#define BOOST_FUNCTION_ARGS a0
+#define BOOST_FUNCTION_NOT_0_PARMS 
+#define BOOST_FUNCTION_NOT_0_ARGS 

 #include <boost/function/function_template.hpp>

-#undef BOOST_FUNCTION_NUM_ARGS
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_NOT_0_ARGS
+#undef BOOST_FUNCTION_NOT_0_PARMS
 #undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_BASE
-#undef BOOST_FUNCTION_INVOKER_BASE
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#undef BOOST_FUNCTION_NUM_ARGS

-#endif // BOOST_FUNCTION1_HPP
+#endif // BOOST_FUNCTION_FUNCTION1_HEADER
--- a/include/boost/function/function10.hpp
+++ b/include/boost/function/function10.hpp
@ -1,5 +1,5 @@
 // Boost.Function library
-
+//
 // Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
 //
 // Permission to copy, use, sell and distribute this software is granted
@ -10,50 +10,28 @@
 //
 // This software is provided "as is" without express or implied warranty,
 // and with no claim as to its suitability for any purpose.
-
+ 
 // For more information, see http://www.boost.org

-#ifndef BOOST_FUNCTION10_HPP
-#define BOOST_FUNCTION10_HPP
-
-#include <boost/function/function_base.hpp>
+#ifndef BOOST_FUNCTION_FUNCTION10_HEADER
+#define BOOST_FUNCTION_FUNCTION10_HEADER

 #define BOOST_FUNCTION_NUM_ARGS 10
-#define BOOST_FUNCTION_COMMA ,
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1, typename OtherT2, typename OtherT3, typename OtherT4, typename OtherT5, typename OtherT6, typename OtherT7, typename OtherT8, typename OtherT9, typename OtherT10
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2, OtherT3, OtherT4, OtherT5, OtherT6, OtherT7, OtherT8, OtherT9, OtherT10
-#define BOOST_FUNCTION_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8, T9 a9, T10 a10
-#define BOOST_FUNCTION_ARGS a1, a2, a3, a4, a5, a6, a7, a8, a9, a10
-#define BOOST_FUNCTION_FUNCTION function10
-#define BOOST_FUNCTION_BASE function10_base
-#define BOOST_FUNCTION_INVOKER_BASE invoker_base10
-#define BOOST_FUNCTION_FUNCTION_INVOKER function_invoker10
-#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER void_function_invoker10
-#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER function_obj_invoker10
-#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER void_function_obj_invoker10
-#define BOOST_FUNCTION_GET_FUNCTION_INVOKER get_function_invoker10
-#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER get_function_obj_invoker10
+#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9
+#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
+#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8, T9 a9
+#define BOOST_FUNCTION_ARGS a0, a1, a2, a3, a4, a5, a6, a7, a8, a9
+#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8, T9 a9
+#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3, a4, a5, a6, a7, a8, a9

 #include <boost/function/function_template.hpp>

-#undef BOOST_FUNCTION_NUM_ARGS
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_NOT_0_ARGS
+#undef BOOST_FUNCTION_NOT_0_PARMS
 #undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_BASE
-#undef BOOST_FUNCTION_INVOKER_BASE
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#undef BOOST_FUNCTION_NUM_ARGS

-#endif // BOOST_FUNCTION10_HPP
+#endif // BOOST_FUNCTION_FUNCTION10_HEADER
--- a/include/boost/function/function2.hpp
+++ b/include/boost/function/function2.hpp
@ -1,5 +1,5 @@
 // Boost.Function library
-
+//
 // Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
 //
 // Permission to copy, use, sell and distribute this software is granted
@ -10,50 +10,28 @@
 //
 // This software is provided "as is" without express or implied warranty,
 // and with no claim as to its suitability for any purpose.
-
+ 
 // For more information, see http://www.boost.org

-#ifndef BOOST_FUNCTION2_HPP
-#define BOOST_FUNCTION2_HPP
-
-#include <boost/function/function_base.hpp>
+#ifndef BOOST_FUNCTION_FUNCTION2_HEADER
+#define BOOST_FUNCTION_FUNCTION2_HEADER

 #define BOOST_FUNCTION_NUM_ARGS 2
-#define BOOST_FUNCTION_COMMA ,
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1, typename T2
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1, T2
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1, typename OtherT2
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2
-#define BOOST_FUNCTION_PARMS T1 a1, T2 a2
-#define BOOST_FUNCTION_ARGS a1, a2
-#define BOOST_FUNCTION_FUNCTION function2
-#define BOOST_FUNCTION_BASE function2_base
-#define BOOST_FUNCTION_INVOKER_BASE invoker_base2
-#define BOOST_FUNCTION_FUNCTION_INVOKER function_invoker2
-#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER void_function_invoker2
-#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER function_obj_invoker2
-#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER void_function_obj_invoker2
-#define BOOST_FUNCTION_GET_FUNCTION_INVOKER get_function_invoker2
-#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER get_function_obj_invoker2
+#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1
+#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1
+#define BOOST_FUNCTION_PARMS T0 a0, T1 a1
+#define BOOST_FUNCTION_ARGS a0, a1
+#define BOOST_FUNCTION_NOT_0_PARMS T1 a1
+#define BOOST_FUNCTION_NOT_0_ARGS a1

 #include <boost/function/function_template.hpp>

-#undef BOOST_FUNCTION_NUM_ARGS
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_NOT_0_ARGS
+#undef BOOST_FUNCTION_NOT_0_PARMS
 #undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_BASE
-#undef BOOST_FUNCTION_INVOKER_BASE
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#undef BOOST_FUNCTION_NUM_ARGS

-#endif // BOOST_FUNCTION2_HPP
+#endif // BOOST_FUNCTION_FUNCTION2_HEADER
--- a/include/boost/function/function3.hpp
+++ b/include/boost/function/function3.hpp
@ -1,5 +1,5 @@
 // Boost.Function library
-
+//
 // Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
 //
 // Permission to copy, use, sell and distribute this software is granted
@ -10,50 +10,28 @@
 //
 // This software is provided "as is" without express or implied warranty,
 // and with no claim as to its suitability for any purpose.
-
+ 
 // For more information, see http://www.boost.org

-#ifndef BOOST_FUNCTION3_HPP
-#define BOOST_FUNCTION3_HPP
-
-#include <boost/function/function_base.hpp>
+#ifndef BOOST_FUNCTION_FUNCTION3_HEADER
+#define BOOST_FUNCTION_FUNCTION3_HEADER

 #define BOOST_FUNCTION_NUM_ARGS 3
-#define BOOST_FUNCTION_COMMA ,
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1, typename T2, typename T3
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1, T2, T3
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1, typename OtherT2, typename OtherT3
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2, OtherT3
-#define BOOST_FUNCTION_PARMS T1 a1, T2 a2, T3 a3
-#define BOOST_FUNCTION_ARGS a1, a2, a3
-#define BOOST_FUNCTION_FUNCTION function3
-#define BOOST_FUNCTION_BASE function3_base
-#define BOOST_FUNCTION_INVOKER_BASE invoker_base3
-#define BOOST_FUNCTION_FUNCTION_INVOKER function_invoker3
-#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER void_function_invoker3
-#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER function_obj_invoker3
-#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER void_function_obj_invoker3
-#define BOOST_FUNCTION_GET_FUNCTION_INVOKER get_function_invoker3
-#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER get_function_obj_invoker3
+#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2
+#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2
+#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2
+#define BOOST_FUNCTION_ARGS a0, a1, a2
+#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2
+#define BOOST_FUNCTION_NOT_0_ARGS a1, a2

 #include <boost/function/function_template.hpp>

-#undef BOOST_FUNCTION_NUM_ARGS
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_NOT_0_ARGS
+#undef BOOST_FUNCTION_NOT_0_PARMS
 #undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_BASE
-#undef BOOST_FUNCTION_INVOKER_BASE
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#undef BOOST_FUNCTION_NUM_ARGS

-#endif // BOOST_FUNCTION3_HPP
+#endif // BOOST_FUNCTION_FUNCTION3_HEADER
--- a/include/boost/function/function4.hpp
+++ b/include/boost/function/function4.hpp
@ -1,5 +1,5 @@
 // Boost.Function library
-
+//
 // Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
 //
 // Permission to copy, use, sell and distribute this software is granted
@ -10,50 +10,28 @@
 //
 // This software is provided "as is" without express or implied warranty,
 // and with no claim as to its suitability for any purpose.
-
+ 
 // For more information, see http://www.boost.org

-#ifndef BOOST_FUNCTION4_HPP
-#define BOOST_FUNCTION4_HPP
-
-#include <boost/function/function_base.hpp>
+#ifndef BOOST_FUNCTION_FUNCTION4_HEADER
+#define BOOST_FUNCTION_FUNCTION4_HEADER

 #define BOOST_FUNCTION_NUM_ARGS 4
-#define BOOST_FUNCTION_COMMA ,
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1, typename T2, typename T3, typename T4
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1, T2, T3, T4
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1, typename OtherT2, typename OtherT3, typename OtherT4
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2, OtherT3, OtherT4
-#define BOOST_FUNCTION_PARMS T1 a1, T2 a2, T3 a3, T4 a4
-#define BOOST_FUNCTION_ARGS a1, a2, a3, a4
-#define BOOST_FUNCTION_FUNCTION function4
-#define BOOST_FUNCTION_BASE function4_base
-#define BOOST_FUNCTION_INVOKER_BASE invoker_base4
-#define BOOST_FUNCTION_FUNCTION_INVOKER function_invoker4
-#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER void_function_invoker4
-#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER function_obj_invoker4
-#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER void_function_obj_invoker4
-#define BOOST_FUNCTION_GET_FUNCTION_INVOKER get_function_invoker4
-#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER get_function_obj_invoker4
+#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3
+#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2, T3
+#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2, T3 a3
+#define BOOST_FUNCTION_ARGS a0, a1, a2, a3
+#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3
+#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3

 #include <boost/function/function_template.hpp>

-#undef BOOST_FUNCTION_NUM_ARGS
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_NOT_0_ARGS
+#undef BOOST_FUNCTION_NOT_0_PARMS
 #undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_BASE
-#undef BOOST_FUNCTION_INVOKER_BASE
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#undef BOOST_FUNCTION_NUM_ARGS

-#endif // BOOST_FUNCTION4_HPP
+#endif // BOOST_FUNCTION_FUNCTION4_HEADER
--- a/include/boost/function/function5.hpp
+++ b/include/boost/function/function5.hpp
@ -1,5 +1,5 @@
 // Boost.Function library
-
+//
 // Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
 //
 // Permission to copy, use, sell and distribute this software is granted
@ -10,50 +10,28 @@
 //
 // This software is provided "as is" without express or implied warranty,
 // and with no claim as to its suitability for any purpose.
-
+ 
 // For more information, see http://www.boost.org

-#ifndef BOOST_FUNCTION5_HPP
-#define BOOST_FUNCTION5_HPP
-
-#include <boost/function/function_base.hpp>
+#ifndef BOOST_FUNCTION_FUNCTION5_HEADER
+#define BOOST_FUNCTION_FUNCTION5_HEADER

 #define BOOST_FUNCTION_NUM_ARGS 5
-#define BOOST_FUNCTION_COMMA ,
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1, typename T2, typename T3, typename T4, typename T5
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1, T2, T3, T4, T5
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1, typename OtherT2, typename OtherT3, typename OtherT4, typename OtherT5
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2, OtherT3, OtherT4, OtherT5
-#define BOOST_FUNCTION_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5
-#define BOOST_FUNCTION_ARGS a1, a2, a3, a4, a5
-#define BOOST_FUNCTION_FUNCTION function5
-#define BOOST_FUNCTION_BASE function5_base
-#define BOOST_FUNCTION_INVOKER_BASE invoker_base5
-#define BOOST_FUNCTION_FUNCTION_INVOKER function_invoker5
-#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER void_function_invoker5
-#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER function_obj_invoker5
-#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER void_function_obj_invoker5
-#define BOOST_FUNCTION_GET_FUNCTION_INVOKER get_function_invoker5
-#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER get_function_obj_invoker5
+#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3, typename T4
+#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2, T3, T4
+#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2, T3 a3, T4 a4
+#define BOOST_FUNCTION_ARGS a0, a1, a2, a3, a4
+#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3, T4 a4
+#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3, a4

 #include <boost/function/function_template.hpp>

-#undef BOOST_FUNCTION_NUM_ARGS
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_NOT_0_ARGS
+#undef BOOST_FUNCTION_NOT_0_PARMS
 #undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_BASE
-#undef BOOST_FUNCTION_INVOKER_BASE
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#undef BOOST_FUNCTION_NUM_ARGS

-#endif // BOOST_FUNCTION5_HPP
+#endif // BOOST_FUNCTION_FUNCTION5_HEADER
--- a/include/boost/function/function6.hpp
+++ b/include/boost/function/function6.hpp
@ -1,5 +1,5 @@
 // Boost.Function library
-
+//
 // Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
 //
 // Permission to copy, use, sell and distribute this software is granted
@ -10,50 +10,28 @@
 //
 // This software is provided "as is" without express or implied warranty,
 // and with no claim as to its suitability for any purpose.
-
+ 
 // For more information, see http://www.boost.org

-#ifndef BOOST_FUNCTION6_HPP
-#define BOOST_FUNCTION6_HPP
-
-#include <boost/function/function_base.hpp>
+#ifndef BOOST_FUNCTION_FUNCTION6_HEADER
+#define BOOST_FUNCTION_FUNCTION6_HEADER

 #define BOOST_FUNCTION_NUM_ARGS 6
-#define BOOST_FUNCTION_COMMA ,
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1, typename T2, typename T3, typename T4, typename T5, typename T6
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1, T2, T3, T4, T5, T6
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1, typename OtherT2, typename OtherT3, typename OtherT4, typename OtherT5, typename OtherT6
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2, OtherT3, OtherT4, OtherT5, OtherT6
-#define BOOST_FUNCTION_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6
-#define BOOST_FUNCTION_ARGS a1, a2, a3, a4, a5, a6
-#define BOOST_FUNCTION_FUNCTION function6
-#define BOOST_FUNCTION_BASE function6_base
-#define BOOST_FUNCTION_INVOKER_BASE invoker_base6
-#define BOOST_FUNCTION_FUNCTION_INVOKER function_invoker6
-#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER void_function_invoker6
-#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER function_obj_invoker6
-#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER void_function_obj_invoker6
-#define BOOST_FUNCTION_GET_FUNCTION_INVOKER get_function_invoker6
-#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER get_function_obj_invoker6
+#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3, typename T4, typename T5
+#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2, T3, T4, T5
+#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5
+#define BOOST_FUNCTION_ARGS a0, a1, a2, a3, a4, a5
+#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5
+#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3, a4, a5

 #include <boost/function/function_template.hpp>

-#undef BOOST_FUNCTION_NUM_ARGS
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_NOT_0_ARGS
+#undef BOOST_FUNCTION_NOT_0_PARMS
 #undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_BASE
-#undef BOOST_FUNCTION_INVOKER_BASE
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#undef BOOST_FUNCTION_NUM_ARGS

-#endif // BOOST_FUNCTION6_HPP
+#endif // BOOST_FUNCTION_FUNCTION6_HEADER
--- a/include/boost/function/function7.hpp
+++ b/include/boost/function/function7.hpp
@ -1,5 +1,5 @@
 // Boost.Function library
-
+//
 // Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
 //
 // Permission to copy, use, sell and distribute this software is granted
@ -10,50 +10,28 @@
 //
 // This software is provided "as is" without express or implied warranty,
 // and with no claim as to its suitability for any purpose.
-
+ 
 // For more information, see http://www.boost.org

-#ifndef BOOST_FUNCTION7_HPP
-#define BOOST_FUNCTION7_HPP
-
-#include <boost/function/function_base.hpp>
+#ifndef BOOST_FUNCTION_FUNCTION7_HEADER
+#define BOOST_FUNCTION_FUNCTION7_HEADER

 #define BOOST_FUNCTION_NUM_ARGS 7
-#define BOOST_FUNCTION_COMMA ,
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1, T2, T3, T4, T5, T6, T7
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1, typename OtherT2, typename OtherT3, typename OtherT4, typename OtherT5, typename OtherT6, typename OtherT7
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2, OtherT3, OtherT4, OtherT5, OtherT6, OtherT7
-#define BOOST_FUNCTION_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7
-#define BOOST_FUNCTION_ARGS a1, a2, a3, a4, a5, a6, a7
-#define BOOST_FUNCTION_FUNCTION function7
-#define BOOST_FUNCTION_BASE function7_base
-#define BOOST_FUNCTION_INVOKER_BASE invoker_base7
-#define BOOST_FUNCTION_FUNCTION_INVOKER function_invoker7
-#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER void_function_invoker7
-#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER function_obj_invoker7
-#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER void_function_obj_invoker7
-#define BOOST_FUNCTION_GET_FUNCTION_INVOKER get_function_invoker7
-#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER get_function_obj_invoker7
+#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6
+#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2, T3, T4, T5, T6
+#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6
+#define BOOST_FUNCTION_ARGS a0, a1, a2, a3, a4, a5, a6
+#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6
+#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3, a4, a5, a6

 #include <boost/function/function_template.hpp>

-#undef BOOST_FUNCTION_NUM_ARGS
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_NOT_0_ARGS
+#undef BOOST_FUNCTION_NOT_0_PARMS
 #undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_BASE
-#undef BOOST_FUNCTION_INVOKER_BASE
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#undef BOOST_FUNCTION_NUM_ARGS

-#endif // BOOST_FUNCTION7_HPP
+#endif // BOOST_FUNCTION_FUNCTION7_HEADER
--- a/include/boost/function/function8.hpp
+++ b/include/boost/function/function8.hpp
@ -1,5 +1,5 @@
 // Boost.Function library
-
+//
 // Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
 //
 // Permission to copy, use, sell and distribute this software is granted
@ -10,50 +10,28 @@
 //
 // This software is provided "as is" without express or implied warranty,
 // and with no claim as to its suitability for any purpose.
-
+ 
 // For more information, see http://www.boost.org

-#ifndef BOOST_FUNCTION8_HPP
-#define BOOST_FUNCTION8_HPP
-
-#include <boost/function/function_base.hpp>
+#ifndef BOOST_FUNCTION_FUNCTION8_HEADER
+#define BOOST_FUNCTION_FUNCTION8_HEADER

 #define BOOST_FUNCTION_NUM_ARGS 8
-#define BOOST_FUNCTION_COMMA ,
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1, T2, T3, T4, T5, T6, T7, T8
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1, typename OtherT2, typename OtherT3, typename OtherT4, typename OtherT5, typename OtherT6, typename OtherT7, typename OtherT8
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2, OtherT3, OtherT4, OtherT5, OtherT6, OtherT7, OtherT8
-#define BOOST_FUNCTION_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8
-#define BOOST_FUNCTION_ARGS a1, a2, a3, a4, a5, a6, a7, a8
-#define BOOST_FUNCTION_FUNCTION function8
-#define BOOST_FUNCTION_BASE function8_base
-#define BOOST_FUNCTION_INVOKER_BASE invoker_base8
-#define BOOST_FUNCTION_FUNCTION_INVOKER function_invoker8
-#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER void_function_invoker8
-#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER function_obj_invoker8
-#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER void_function_obj_invoker8
-#define BOOST_FUNCTION_GET_FUNCTION_INVOKER get_function_invoker8
-#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER get_function_obj_invoker8
+#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7
+#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2, T3, T4, T5, T6, T7
+#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7
+#define BOOST_FUNCTION_ARGS a0, a1, a2, a3, a4, a5, a6, a7
+#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7
+#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3, a4, a5, a6, a7

 #include <boost/function/function_template.hpp>

-#undef BOOST_FUNCTION_NUM_ARGS
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_NOT_0_ARGS
+#undef BOOST_FUNCTION_NOT_0_PARMS
 #undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_BASE
-#undef BOOST_FUNCTION_INVOKER_BASE
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#undef BOOST_FUNCTION_NUM_ARGS

-#endif // BOOST_FUNCTION8_HPP
+#endif // BOOST_FUNCTION_FUNCTION8_HEADER
--- a/include/boost/function/function9.hpp
+++ b/include/boost/function/function9.hpp
@ -1,5 +1,5 @@
 // Boost.Function library
-
+//
 // Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
 //
 // Permission to copy, use, sell and distribute this software is granted
@ -10,50 +10,28 @@
 //
 // This software is provided "as is" without express or implied warranty,
 // and with no claim as to its suitability for any purpose.
-
+ 
 // For more information, see http://www.boost.org

-#ifndef BOOST_FUNCTION9_HPP
-#define BOOST_FUNCTION9_HPP
-
-#include <boost/function/function_base.hpp>
+#ifndef BOOST_FUNCTION_FUNCTION9_HEADER
+#define BOOST_FUNCTION_FUNCTION9_HEADER

 #define BOOST_FUNCTION_NUM_ARGS 9
-#define BOOST_FUNCTION_COMMA ,
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1, T2, T3, T4, T5, T6, T7, T8, T9
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1, typename OtherT2, typename OtherT3, typename OtherT4, typename OtherT5, typename OtherT6, typename OtherT7, typename OtherT8, typename OtherT9
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2, OtherT3, OtherT4, OtherT5, OtherT6, OtherT7, OtherT8, OtherT9
-#define BOOST_FUNCTION_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8, T9 a9
-#define BOOST_FUNCTION_ARGS a1, a2, a3, a4, a5, a6, a7, a8, a9
-#define BOOST_FUNCTION_FUNCTION function9
-#define BOOST_FUNCTION_BASE function9_base
-#define BOOST_FUNCTION_INVOKER_BASE invoker_base9
-#define BOOST_FUNCTION_FUNCTION_INVOKER function_invoker9
-#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER void_function_invoker9
-#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER function_obj_invoker9
-#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER void_function_obj_invoker9
-#define BOOST_FUNCTION_GET_FUNCTION_INVOKER get_function_invoker9
-#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER get_function_obj_invoker9
+#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8
+#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2, T3, T4, T5, T6, T7, T8
+#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8
+#define BOOST_FUNCTION_ARGS a0, a1, a2, a3, a4, a5, a6, a7, a8
+#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8
+#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3, a4, a5, a6, a7, a8

 #include <boost/function/function_template.hpp>

-#undef BOOST_FUNCTION_NUM_ARGS
-#undef BOOST_FUNCTION_COMMA
-#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_OTHER_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_NOT_0_ARGS
+#undef BOOST_FUNCTION_NOT_0_PARMS
 #undef BOOST_FUNCTION_ARGS
-#undef BOOST_FUNCTION_FUNCTION
-#undef BOOST_FUNCTION_BASE
-#undef BOOST_FUNCTION_INVOKER_BASE
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
-#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_PARMS
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
+#undef BOOST_FUNCTION_NUM_ARGS

-#endif // BOOST_FUNCTION9_HPP
+#endif // BOOST_FUNCTION_FUNCTION9_HEADER
--- a/include/boost/function/function_base.hpp
+++ b/include/boost/function/function_base.hpp
@ -1,6 +1,6 @@
 // Boost.Function library

-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
+// Copyright (C) 2001-2002 Doug Gregor (gregod@cs.rpi.edu)
 //
 // Permission to copy, use, sell and distribute this software is granted
 // provided this copyright notice appears in all copies.
@ -19,54 +19,35 @@
 #include <string>
 #include <stdexcept>
 #include <memory>
+#include <new>
+#include <typeinfo>
 #include <boost/config.hpp>
 #include <boost/type_traits.hpp>
+#include <boost/ref.hpp>
+#include <boost/function/threading/single.hpp>
+#include <boost/pending/ct_if.hpp>
+
+#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406
+#  define BOOST_FUNCTION_TARGET_FIX(x) x
+#else
+#  define BOOST_FUNCTION_TARGET_FIX(x)
+#endif // not MSVC
+
+#ifndef BOOST_FUNCTION_DEFAULT_THREADING_POLICY
+#  define BOOST_FUNCTION_DEFAULT_THREADING_POLICY single_threaded
+#endif
+
+// Type of the default allocator
+#ifndef BOOST_NO_STD_ALLOCATOR
+#  define BOOST_FUNCTION_DEFAULT_ALLOCATOR std::allocator<function_base>
+#else
+#  define BOOST_FUNCTION_DEFAULT_ALLOCATOR int
+#endif // BOOST_NO_STD_ALLOCATOR

 namespace boost {
  namespace detail {
    namespace function {
-      /*
-       * The IF implementation is temporary code. When a Boost metaprogramming
-       * library is introduced, Boost.Function will use it instead. 
-       */
-      namespace intimate {
-        struct SelectThen 
-        {       
-          template<typename Then, typename Else>
-          struct Result
-          {       
-            typedef Then type;
-          };
-        };
- 
-        struct SelectElse
-        {
-          template<typename Then, typename Else>
-          struct Result
-          { 
-            typedef Else type;
-          };
-        };
- 
-        template<bool Condition>
-        struct Selector
-        {
-          typedef SelectThen type;
-        };
- 
-        template<>
-        struct Selector<false>
-        {
-          typedef SelectElse type;
-        };
-      } // end namespace intimate 
- 
-      template<bool Condition, typename Then, typename Else>
-      struct IF
-      {
-        typedef typename intimate::Selector<Condition>::type select;
-        typedef typename select::template Result<Then,Else>::type type;
-      };
+      template<bool> struct truth {};

      /**
       * A union of a function pointer and a void pointer. This is necessary
@ -78,9 +59,11 @@ namespace boost {
      union any_pointer 
      {
        void* obj_ptr;
+        const void* const_obj_ptr;
        void (*func_ptr)();

        explicit any_pointer(void* p) : obj_ptr(p) {}
+        explicit any_pointer(const void* p) : const_obj_ptr(p) {}
        explicit any_pointer(void (*p)()) : func_ptr(p) {}
      };

@ -109,13 +92,50 @@ namespace boost {
      };

      // The operation type to perform on the given functor/function pointer
-      enum functor_manager_operation_type { clone_functor, destroy_functor };
+      enum functor_manager_operation_type { 
+        clone_functor_tag, 
+        destroy_functor_tag
+      };

-      // Tags used to decide between function and function object pointers.
+      // Tags used to decide between different types of functions
      struct function_ptr_tag {};
      struct function_obj_tag {};
+      struct member_ptr_tag {};
+      struct function_obj_ref_tag {};
+      struct stateless_function_obj_tag {};
+
+      template<typename F>
+      class get_function_tag
+      {
+        typedef typename ct_if<(is_pointer<F>::value),
+                            function_ptr_tag,
+                            function_obj_tag>::type ptr_or_obj_tag;
+
+        typedef typename ct_if<(is_member_pointer<F>::value),
+                            member_ptr_tag,
+                            ptr_or_obj_tag>::type ptr_or_obj_or_mem_tag;
+
+        typedef typename ct_if<(is_reference_wrapper<F>::value),
+                             function_obj_ref_tag,
+                             ptr_or_obj_or_mem_tag>::type or_ref_tag;
+
+      public:
+        typedef typename ct_if<(is_stateless<F>::value),
+                            stateless_function_obj_tag,
+                            or_ref_tag>::type type;
+      };
+
+      // The trivial manager does nothing but return the same pointer (if we
+      // are cloning) or return the null pointer (if we are deleting).
+      inline any_pointer trivial_manager(any_pointer f, 
+                                         functor_manager_operation_type op)
+      {
+        if (op == clone_functor_tag)
+          return f;
+        else
+          return any_pointer(reinterpret_cast<void*>(0));
+      }

-#ifndef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
      /**
       * The functor_manager class contains a static function "manage" which
       * can clone or destroy the given function/function object pointer. 
@ -125,20 +145,14 @@ namespace boost {
      {
      private:
        typedef Functor functor_type;
-#  ifndef BOOST_NO_STD_ALLOCATOR
-        typedef typename Allocator::template rebind<functor_type>::other 
-          allocator_type;
-        typedef typename allocator_type::pointer pointer_type;
-#  else
-        typedef functor_type* pointer_type;
-#  endif // BOOST_NO_STD_ALLOCATOR

        // For function pointers, the manager is trivial
        static inline any_pointer
-        manager(any_pointer function_ptr, functor_manager_operation_type op,
+        manager(any_pointer function_ptr, 
+                functor_manager_operation_type op,
                function_ptr_tag)
        {
-          if (op == clone_functor)
+          if (op == clone_functor_tag)
            return function_ptr;
          else
            return any_pointer(static_cast<void (*)()>(0));
@ -151,11 +165,19 @@ namespace boost {
                functor_manager_operation_type op,
                function_obj_tag)
        {
+#ifndef BOOST_NO_STD_ALLOCATOR
+        typedef typename Allocator::template rebind<functor_type>::other 
+          allocator_type;
+        typedef typename allocator_type::pointer pointer_type;
+#else
+        typedef functor_type* pointer_type;
+#endif // BOOST_NO_STD_ALLOCATOR
+
 #  ifndef BOOST_NO_STD_ALLOCATOR
          allocator_type allocator;
 #  endif // BOOST_NO_STD_ALLOCATOR

-          if (op == clone_functor) {
+          if (op == clone_functor_tag) {
            functor_type* f = 
              static_cast<functor_type*>(function_obj_ptr.obj_ptr);

@ -191,21 +213,16 @@ namespace boost {
            return any_pointer(static_cast<void*>(0));
          }
        }
-
      public:
        /* Dispatch to an appropriate manager based on whether we have a
           function pointer or a function object pointer. */
        static any_pointer
        manage(any_pointer functor_ptr, functor_manager_operation_type op)
        {
-          typedef typename IF<(is_pointer<functor_type>::value),
-                              function_ptr_tag,
-                              function_obj_tag>::type tag_type;
-
+          typedef typename get_function_tag<functor_type>::type tag_type;
          return manager(functor_ptr, op, tag_type());
        }
      };
-#endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS

      // value=1 if the given type is not "unusable"
      template<typename T>
@ -251,29 +268,22 @@ namespace boost {
   */
  class function_base 
  {
-#ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-  public:
-    function_base() : impl(0) {}
-
-    bool empty() const { return impl == 0; }
-
-    
-  protected:
-    void* impl; // Derived class is responsible for knowing the real type
-#else
  public:
    function_base() : manager(0), functor(static_cast<void*>(0)) {}
    
    // Is this function empty?
    bool empty() const { return !manager; }
    
-  protected:
+  public: // should be protected, but GCC 2.95.3 will fail to allow access
    detail::function::any_pointer (*manager)(
                           detail::function::any_pointer, 
                           detail::function::functor_manager_operation_type);
    detail::function::any_pointer functor;
-#endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS

+#if (defined __SUNPRO_CC) && (__SUNPRO_CC <= 0x530) && !(defined BOOST_NO_COMPILER_CONFIG)
+    // Sun C++ 5.3 can't handle the safe_bool idiom, so don't use it
+    operator bool () const { return !this->empty(); }
+#else
  private:
    struct dummy {
      void nonnull() {};
@ -284,6 +294,7 @@ namespace boost {
  public:
    operator safe_bool () const 
      { return (this->empty())? 0 : &dummy::nonnull; }
+#endif

    safe_bool operator!() const
      { return (this->empty())? &dummy::nonnull : 0; }
@ -300,112 +311,35 @@ namespace boost {

  namespace detail {
    namespace function {
-      /**
-       * Determine if the given target is empty.
-       */
+      // The result is not a Boost.Function object, so we assume that this
+      // target is not empty
+      template<typename FunctionObj>
+      inline bool has_empty_target(const FunctionObj&, truth<false>)
+      {
+        return false;
+      }

-      // Fallback - assume target is not empty
-      inline bool has_empty_target(...) 
+      // The result is a Boost.Function object, so query whether it is empty
+      // or not
+      template<typename FunctionObj>
+      inline bool has_empty_target(const FunctionObj& f, truth<true>)
      { 
-        return false; 
-      }
-    
-      // If the target is a 'function', query the empty() method
-      inline bool has_empty_target(const function_base* af) 
-      { 
-        return af->empty();
+        return f.empty();
      }

-      // If the target is a 'function', query the empty() method
-      inline bool has_empty_target(const function_base& af) 
-      { 
-        return af.empty();
-      }
-    
-      // A function pointer is empty if it is null
-      template<typename R>
-      inline bool has_empty_target(R (*f)())
+      template<typename Lock, typename Mixin>
+      struct scoped_double_lock
      {
-        return f == 0;
-      }
-    
-      template<typename R, typename T1>
-      inline bool has_empty_target(R (*f)(T1))
-      {
-        return f == 0;
-      }
-    
-      template<typename R, typename T1, typename T2>
-      inline bool has_empty_target(R (*f)(T1, T2))
-      {
-        return f == 0;
-      }
-    
-      template<typename R, typename T1, typename T2, typename T3>
-      inline bool has_empty_target(R (*f)(T1, T2, T3))
-      {
-        return f == 0;
-      }
-
-      template<typename R, typename T1, typename T2, typename T3, typename T4>
-      inline bool has_empty_target(R (*f)(T1, T2, T3, T4))
-      {
-        return f == 0;
-      }
-
-      template<typename R, typename T1, typename T2, typename T3, typename T4, 
-               typename T5>
-      inline bool has_empty_target(R (*f)(T1, T2, T3, T4, T5))
-      {
-        return f == 0;
-      }
-
-      template<typename R, typename T1, typename T2, typename T3, typename T4, 
-               typename T5, typename T6>
-      inline bool has_empty_target(R (*f)(T1, T2, T3, T4, T5, T6))
-      {
-        return f == 0;
-      }
-
-      template<typename R, typename T1, typename T2, typename T3, typename T4, 
-               typename T5, typename T6, typename T7>
-      inline bool has_empty_target(R (*f)(T1, T2, T3, T4, T5, T6, T7))
-      {
-        return f == 0;
-      }
-
-      template<typename R, typename T1, typename T2, typename T3, typename T4, 
-               typename T5, typename T6, typename T7, typename T8>
-      inline bool has_empty_target(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8))
-      {
-        return f == 0;
-      }
-
-      template<typename R, typename T1, typename T2, typename T3, typename T4, 
-               typename T5, typename T6, typename T7, typename T8, typename T9>
-      inline bool has_empty_target(R (*f)(T1, T2, T3, T4, T5, T6, T7, T8, T9))
-      {
-        return f == 0;
-      }
+        scoped_double_lock(const Mixin& m1, const Mixin& m2) :
+          lock1(&m1 < &m2? m1 : m2), lock2(!(&m1 < &m2)? m1 : m2)
+        {
+        }
+        
+        Lock lock1;
+        Lock lock2;
+      };
    } // end namespace function
  } // end namespace detail
-
-  // The default function policy is to do nothing before and after the call.
-  struct empty_function_policy
-  {
-    inline void precall(const function_base*) {}
-    inline void postcall(const function_base*) {}
-  };
-
-  // The default function mixin does nothing. The assignment and copy-construction operators
-  // are all defined because MSVC defines broken versions.
-  struct empty_function_mixin {
-    empty_function_mixin() {};
-    empty_function_mixin(const empty_function_mixin&) {};
-
-    empty_function_mixin& operator=(const empty_function_mixin&) 
-    {return *this; }
-  };
 }

 #endif // BOOST_FUNCTION_BASE_HEADER
--- a/include/boost/function/function_template.hpp
+++ b/include/boost/function/function_template.hpp
@ -1,6 +1,6 @@
 // Boost.Function library

-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
+// Copyright (C) 2001-2002 Doug Gregor (gregod@cs.rpi.edu)
 //
 // Permission to copy, use, sell and distribute this software is granted
 // provided this copyright notice appears in all copies.
@ -13,179 +13,71 @@

 // For more information, see http://www.boost.org

-/* Note: this header is a header template and must NOT have multiple-inclusion
-   protection. */
+// Note: this header is a header template and must NOT have multiple-inclusion
+// protection. 

-#include <cassert>
-#include <algorithm>
+#ifndef BOOST_FUNCTION_FUNCTION_TEMPLATE_HPP
+#define BOOST_FUNCTION_FUNCTION_TEMPLATE_HPP
+#  include <cassert>
+#  include <algorithm>
+#  include <boost/config.hpp>
+#  include <boost/function/function_base.hpp>
+#  include <boost/mem_fn.hpp>
+#endif // BOOST_FUNCTION_FUNCTION_TEMPLATE_HPP

-// Zero-initialize the "invoker" member of the functionN object.
-// The invoker member only exists when we aren't using the virtual
-// function implementation
-#ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-#  define BOOST_FUNCTION_INIT
+// Comma if nonzero number of arguments
+#if BOOST_FUNCTION_NUM_ARGS == 0
+#  define BOOST_FUNCTION_COMMA 
 #else
-#  define BOOST_FUNCTION_INIT , invoker(0)
-#endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
+#  define BOOST_FUNCTION_COMMA ,
+#endif // BOOST_FUNCTION_NUM_ARGS > 0
+
+// Class names used in this version of the code
+#define BOOST_FUNCTION_FUNCTION BOOST_JOIN(function,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_FUNCTION_INVOKER \
+  BOOST_JOIN(function_invoker,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_VOID_FUNCTION_INVOKER \
+  BOOST_JOIN(void_function_invoker,BOOST_FUNCTION_NUM_ARGS) 
+#define BOOST_FUNCTION_FUNCTION_OBJ_INVOKER \
+  BOOST_JOIN(function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER \
+  BOOST_JOIN(void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_STATELESS_FUNCTION_OBJ_INVOKER \
+  BOOST_JOIN(stateless_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_INVOKER \
+  BOOST_JOIN(stateless_void_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_GET_FUNCTION_INVOKER \
+  BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER \
+  BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER \
+  BOOST_JOIN(get_stateless_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)

 namespace boost {
  namespace detail {
    namespace function {
-#ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-      template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
-      struct BOOST_FUNCTION_INVOKER_BASE
-      {
-        virtual ~BOOST_FUNCTION_INVOKER_BASE() {}
-        virtual R call(BOOST_FUNCTION_PARMS) const = 0;
-        virtual BOOST_FUNCTION_INVOKER_BASE* clone() const = 0;
-        virtual void destroy(BOOST_FUNCTION_INVOKER_BASE*) = 0;
-      };
-#endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-
      template<
        typename FunctionPtr,
-#ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-        typename Allocator,
-#endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
        typename R BOOST_FUNCTION_COMMA
        BOOST_FUNCTION_TEMPLATE_PARMS
        >
      struct BOOST_FUNCTION_FUNCTION_INVOKER
-#ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-        : public BOOST_FUNCTION_INVOKER_BASE<
-                   R BOOST_FUNCTION_COMMA
-                   BOOST_FUNCTION_TEMPLATE_ARGS
-                 >
-#endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
      {
-#ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-        explicit BOOST_FUNCTION_FUNCTION_INVOKER(FunctionPtr f) : 
-          function_ptr(f) {}
-
-        virtual R call(BOOST_FUNCTION_PARMS) const
-        {
-          return function_ptr(BOOST_FUNCTION_ARGS);
-        }
-
-        virtual BOOST_FUNCTION_FUNCTION_INVOKER* clone() const
-        {
-#  ifdef BOOST_NO_STD_ALLOCATOR
-          return new BOOST_FUNCTION_FUNCTION_INVOKER(function_ptr);
-#  else
-          typedef typename Allocator::
-            template rebind<BOOST_FUNCTION_FUNCTION_INVOKER>::other 
-            allocator_type;
-          typedef typename allocator_type::pointer pointer_type;
-          allocator_type allocator;
-
-          pointer_type copy = allocator.allocate(1);
-          allocator.construct(copy, *this);
-          return static_cast<BOOST_FUNCTION_FUNCTION_INVOKER*>(copy);
-#  endif // BOOST_NO_STD_ALLOCATOR
-        }
-
-        virtual void destroy(BOOST_FUNCTION_INVOKER_BASE<
-                               R BOOST_FUNCTION_COMMA
-                               BOOST_FUNCTION_TEMPLATE_ARGS
-                             >* p)
-        {
-#  ifdef BOOST_NO_STD_ALLOCATOR
-          delete p;
-#  else
-          BOOST_FUNCTION_FUNCTION_INVOKER* victim = 
-            dynamic_cast<BOOST_FUNCTION_FUNCTION_INVOKER*>(p);
-
-          typedef typename Allocator::
-            template rebind<BOOST_FUNCTION_FUNCTION_INVOKER>::other 
-            allocator_type;
-          typedef typename allocator_type::pointer pointer_type;
-          allocator_type allocator;
-
-          allocator.destroy(victim);
-          allocator.deallocate(victim, 1);
-#  endif // BOOST_NO_STD_ALLOCATOR
-        }
-
-      private:
-        FunctionPtr function_ptr;
-#else
        static R invoke(any_pointer function_ptr BOOST_FUNCTION_COMMA
                        BOOST_FUNCTION_PARMS)
        {
          FunctionPtr f = reinterpret_cast<FunctionPtr>(function_ptr.func_ptr);
          return f(BOOST_FUNCTION_ARGS);
        }
-#endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
      };

      template<
        typename FunctionPtr,
-#  ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-        typename Allocator,
-#  endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
        typename R BOOST_FUNCTION_COMMA
        BOOST_FUNCTION_TEMPLATE_PARMS
        >
      struct BOOST_FUNCTION_VOID_FUNCTION_INVOKER
-#  ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-        : public BOOST_FUNCTION_INVOKER_BASE<
-                   unusable BOOST_FUNCTION_COMMA
-                   BOOST_FUNCTION_TEMPLATE_ARGS
-                 >
-#  endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
      {
-#  ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-        explicit BOOST_FUNCTION_VOID_FUNCTION_INVOKER(FunctionPtr f) : 
-          function_ptr(f) {}
-
-        virtual unusable call(BOOST_FUNCTION_PARMS) const
-        {
-          function_ptr(BOOST_FUNCTION_ARGS);
-          return unusable();
-        }
-
-        virtual BOOST_FUNCTION_VOID_FUNCTION_INVOKER* clone() const
-        {
-#    ifdef BOOST_NO_STD_ALLOCATOR
-          return new BOOST_FUNCTION_VOID_FUNCTION_INVOKER(function_ptr);
-#    else
-          typedef typename Allocator::
-            template rebind<BOOST_FUNCTION_VOID_FUNCTION_INVOKER>::other
-            allocator_type;
-          typedef typename allocator_type::pointer pointer_type;
-          allocator_type allocator;
-
-          pointer_type copy = allocator.allocate(1);
-          allocator.construct(copy, *this);
-          return static_cast<BOOST_FUNCTION_VOID_FUNCTION_INVOKER*>(copy);
-#    endif // BOOST_NO_STD_ALLOCATOR
-        }
-
-        virtual void destroy(BOOST_FUNCTION_INVOKER_BASE<
-                               unusable BOOST_FUNCTION_COMMA
-                               BOOST_FUNCTION_TEMPLATE_ARGS
-                             >* p)
-        {
-#    ifdef BOOST_NO_STD_ALLOCATOR
-          delete p;
-#    else
-          BOOST_FUNCTION_VOID_FUNCTION_INVOKER* victim =
-            dynamic_cast<BOOST_FUNCTION_VOID_FUNCTION_INVOKER*>(p);
-
-          typedef typename Allocator::
-            template rebind<BOOST_FUNCTION_VOID_FUNCTION_INVOKER>::other
-            allocator_type;
-          typedef typename allocator_type::pointer pointer_type;
-          allocator_type allocator;
-
-          allocator.destroy(victim);
-          allocator.deallocate(victim, 1);
-#    endif // BOOST_NO_STD_ALLOCATOR
-        }
-
-      private:
-        FunctionPtr function_ptr;
-#  else
        static unusable invoke(any_pointer function_ptr BOOST_FUNCTION_COMMA
                               BOOST_FUNCTION_PARMS)

@ -194,188 +86,88 @@ namespace boost {
          f(BOOST_FUNCTION_ARGS);
          return unusable();
        }
-#  endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
      };

      template<
        typename FunctionObj,
-#ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-        typename Allocator,
-#endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
        typename R BOOST_FUNCTION_COMMA
        BOOST_FUNCTION_TEMPLATE_PARMS
      >
      struct BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
-#ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-        : public BOOST_FUNCTION_INVOKER_BASE<
-                   R BOOST_FUNCTION_COMMA
-                   BOOST_FUNCTION_TEMPLATE_ARGS
-                 >
-#endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
      {
-#ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-        explicit BOOST_FUNCTION_FUNCTION_OBJ_INVOKER(const FunctionObj& f) :
-          function_obj(f) {}
-
-        virtual R call(BOOST_FUNCTION_PARMS) const
-        {
-          return function_obj(BOOST_FUNCTION_ARGS);
-        }
-
-        virtual BOOST_FUNCTION_FUNCTION_OBJ_INVOKER* clone() const
-        {
-#ifdef BOOST_NO_STD_ALLOCATOR
-          return new BOOST_FUNCTION_FUNCTION_OBJ_INVOKER(function_obj);
-#else
-          typedef typename Allocator::
-            template rebind<BOOST_FUNCTION_FUNCTION_OBJ_INVOKER>::other
-            allocator_type;
-          typedef typename allocator_type::pointer pointer_type;
-          allocator_type allocator;
-
-          pointer_type copy = allocator.allocate(1);
-          allocator.construct(copy, *this);
-          return static_cast<BOOST_FUNCTION_FUNCTION_OBJ_INVOKER*>(copy);
-#endif // BOOST_NO_STD_ALLOCATOR
-        }
-
-        virtual void destroy(BOOST_FUNCTION_INVOKER_BASE<
-                               R BOOST_FUNCTION_COMMA
-                               BOOST_FUNCTION_TEMPLATE_ARGS
-                             >* p)
-        {
-#ifdef BOOST_NO_STD_ALLOCATOR
-          delete p;
-#else
-          BOOST_FUNCTION_FUNCTION_OBJ_INVOKER* victim =
-            dynamic_cast<BOOST_FUNCTION_FUNCTION_OBJ_INVOKER*>(p);
-
-          typedef typename Allocator::
-            template rebind<BOOST_FUNCTION_FUNCTION_OBJ_INVOKER>::other 
-            allocator_type;
-          typedef typename allocator_type::pointer pointer_type;
-          allocator_type allocator;
-
-          allocator.destroy(victim);
-          allocator.deallocate(victim, 1);
-#endif // BOOST_NO_STD_ALLOCATOR
-        }
-
-      private:
-        mutable FunctionObj function_obj;
-#else
        static R invoke(any_pointer function_obj_ptr BOOST_FUNCTION_COMMA
                        BOOST_FUNCTION_PARMS)

        {
-          FunctionObj* f = static_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          FunctionObj* f = (FunctionObj*)(function_obj_ptr.obj_ptr);
          return (*f)(BOOST_FUNCTION_ARGS);
        }
-#endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
      };

      template<
        typename FunctionObj,
-#  ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-        typename Allocator,
-#  endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
        typename R BOOST_FUNCTION_COMMA
        BOOST_FUNCTION_TEMPLATE_PARMS
      >
      struct BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
-#  ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-        : public BOOST_FUNCTION_INVOKER_BASE<
-                   unusable BOOST_FUNCTION_COMMA
-                   BOOST_FUNCTION_TEMPLATE_ARGS
-                 >
-#  endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
      {
-#  ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-        explicit BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER(const FunctionObj& f)
-          : function_obj(f) {}
-
-        virtual unusable call(BOOST_FUNCTION_PARMS) const
-        {
-          function_obj(BOOST_FUNCTION_ARGS);
-          return unusable();
-        }
-
-        virtual BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER* clone() const
-        {
-#  ifdef BOOST_NO_STD_ALLOCATOR
-          return new BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER(function_obj);
-#  else
-          typedef typename Allocator::
-            template rebind<BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER>::other
-            allocator_type;
-          typedef typename allocator_type::pointer pointer_type;
-          allocator_type allocator;
-
-          pointer_type copy = allocator.allocate(1);
-          allocator.construct(copy, *this);
-          return static_cast<BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER*>(copy);
-#  endif // BOOST_NO_STD_ALLOCATOR
-        }
-
-        virtual void destroy(BOOST_FUNCTION_INVOKER_BASE<
-                               unusable BOOST_FUNCTION_COMMA
-                               BOOST_FUNCTION_TEMPLATE_ARGS
-                             >* p)
-        {
-#  ifdef BOOST_NO_STD_ALLOCATOR
-          delete p;
-#  else
-          BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER* victim =
-            dynamic_cast<BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER*>(p);
-
-          typedef typename Allocator::
-            template rebind<BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER>::other
-            allocator_type;
-          typedef typename allocator_type::pointer pointer_type;
-          allocator_type allocator;
-
-          allocator.destroy(victim);
-          allocator.deallocate(victim, 1);
-#  endif // BOOST_NO_STD_ALLOCATOR
-        }
-
-      private:
-        mutable FunctionObj function_obj;
-#  else
        static unusable invoke(any_pointer function_obj_ptr 
                               BOOST_FUNCTION_COMMA
                               BOOST_FUNCTION_PARMS)

        {
-          FunctionObj* f = static_cast<FunctionObj*>(function_obj_ptr.obj_ptr);
+          FunctionObj* f = (FunctionObj*)(function_obj_ptr.obj_ptr);
          (*f)(BOOST_FUNCTION_ARGS);
          return unusable();
        }
-#  endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
+      };
+
+      template<
+        typename FunctionObj,
+        typename R BOOST_FUNCTION_COMMA
+        BOOST_FUNCTION_TEMPLATE_PARMS
+      >
+      struct BOOST_FUNCTION_STATELESS_FUNCTION_OBJ_INVOKER
+      {
+        static R invoke(any_pointer BOOST_FUNCTION_COMMA BOOST_FUNCTION_PARMS)
+        {
+          FunctionObj f = FunctionObj();
+          return f(BOOST_FUNCTION_ARGS);
+        }
+      };
+
+      template<
+        typename FunctionObj,
+        typename R BOOST_FUNCTION_COMMA
+        BOOST_FUNCTION_TEMPLATE_PARMS
+      >
+      struct BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_INVOKER
+      {
+        static unusable invoke(any_pointer BOOST_FUNCTION_COMMA 
+                               BOOST_FUNCTION_PARMS)
+
+        {
+          FunctionObj f = FunctionObj();
+          f(BOOST_FUNCTION_ARGS);
+          return unusable();
+        }
      };

      template<
        typename FunctionPtr,
-        typename Allocator,
        typename R BOOST_FUNCTION_COMMA
        BOOST_FUNCTION_TEMPLATE_PARMS
      >
      struct BOOST_FUNCTION_GET_FUNCTION_INVOKER
      {
-        typedef typename IF<(is_void<R>::value),
+        typedef typename ct_if<(is_void<R>::value),
                            BOOST_FUNCTION_VOID_FUNCTION_INVOKER<
                            FunctionPtr,
-#ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-                            Allocator,
-#endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
                            R BOOST_FUNCTION_COMMA
                            BOOST_FUNCTION_TEMPLATE_ARGS
                          >,
                          BOOST_FUNCTION_FUNCTION_INVOKER<
                            FunctionPtr,
-#ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-                            Allocator,
-#endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
                            R BOOST_FUNCTION_COMMA
                            BOOST_FUNCTION_TEMPLATE_ARGS
                          >
@ -384,125 +176,126 @@ namespace boost {

      template<
        typename FunctionObj,
-        typename Allocator,
        typename R BOOST_FUNCTION_COMMA
        BOOST_FUNCTION_TEMPLATE_PARMS
       >
      struct BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
      {
-        typedef typename IF<(is_void<R>::value),
+        typedef typename ct_if<(is_void<R>::value),
                            BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER<
                            FunctionObj,
-#ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-                            Allocator,
-#endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
                            R BOOST_FUNCTION_COMMA
                            BOOST_FUNCTION_TEMPLATE_ARGS
                          >,
                          BOOST_FUNCTION_FUNCTION_OBJ_INVOKER<
                            FunctionObj,
-#ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-                            Allocator,
-#endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
                            R BOOST_FUNCTION_COMMA
                            BOOST_FUNCTION_TEMPLATE_ARGS
                          >
                       >::type type;
      };
+
+      template<
+        typename FunctionObj,
+        typename R BOOST_FUNCTION_COMMA
+        BOOST_FUNCTION_TEMPLATE_PARMS
+       >
+      struct BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER
+      {
+        typedef typename ct_if<(is_void<R>::value),
+                            BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_INVOKER<
+                            FunctionObj,
+                            R BOOST_FUNCTION_COMMA
+                            BOOST_FUNCTION_TEMPLATE_ARGS
+                          >,
+                          BOOST_FUNCTION_STATELESS_FUNCTION_OBJ_INVOKER<
+                            FunctionObj,
+                            R BOOST_FUNCTION_COMMA
+                            BOOST_FUNCTION_TEMPLATE_ARGS
+                          >
+                       >::type type;
+      };
+
    } // end namespace function
  } // end namespace detail

  template<
    typename R BOOST_FUNCTION_COMMA
    BOOST_FUNCTION_TEMPLATE_PARMS,
-    typename Policy    = empty_function_policy,
-    typename Mixin     = empty_function_mixin,
-    typename Allocator = std::allocator<function_base>
+    typename ThreadingPolicy = BOOST_FUNCTION_DEFAULT_THREADING_POLICY,
+    typename Allocator = BOOST_FUNCTION_DEFAULT_ALLOCATOR
  >
-  class BOOST_FUNCTION_FUNCTION : public function_base, public Mixin
+  class BOOST_FUNCTION_FUNCTION : public function_base,
+                                  public ThreadingPolicy::mixin
  {
+    typedef typename detail::function::function_return_type<R>::type 
+      internal_result_type;
+
+    typedef typename ThreadingPolicy::mixin threading_mixin;
+    typedef typename ThreadingPolicy::lock lock;
+
  public:
    BOOST_STATIC_CONSTANT(int, args = BOOST_FUNCTION_NUM_ARGS);
    
 #if BOOST_FUNCTION_NUM_ARGS == 1
-    typedef T1 argument_type;
+    typedef T0 argument_type;
 #elif BOOST_FUNCTION_NUM_ARGS == 2
-    typedef T1 first_argument_type;
-    typedef T2 second_argument_type;
+    typedef T0 first_argument_type;
+    typedef T1 second_argument_type;
 #endif
-    typedef typename detail::function::function_return_type<R>::type 
-      result_type;
-    typedef Policy    policy_type;
-    typedef Mixin     mixin_type;
+
+#ifndef BOOST_NO_VOID_RETURNS
+    typedef R         result_type;
+#else
+    typedef internal_result_type result_type;
+#endif // BOOST_NO_VOID_RETURNS
    typedef Allocator allocator_type;
    typedef BOOST_FUNCTION_FUNCTION self_type;
+    typedef ThreadingPolicy threading_policy_type;

-  private:    
-#ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-    typedef detail::function::BOOST_FUNCTION_INVOKER_BASE<
-                                result_type BOOST_FUNCTION_COMMA
-                                BOOST_FUNCTION_TEMPLATE_ARGS
-                              >
-          impl_type;
-#endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-
-  public:
-    explicit BOOST_FUNCTION_FUNCTION(const Mixin& m = Mixin()) : 
-      function_base(), Mixin(m) BOOST_FUNCTION_INIT 
-    {
-    }
+    BOOST_FUNCTION_FUNCTION() : function_base(), invoker(0) {}

    // MSVC chokes if the following two constructors are collapsed into
    // one with a default parameter.
    template<typename Functor>
-    BOOST_FUNCTION_FUNCTION(const Functor& f) :
-      function_base(), Mixin() BOOST_FUNCTION_INIT
+    BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f) :
+      function_base(), invoker(0)
    {
      this->assign_to(f);
    }

-    template<typename Functor>
-    BOOST_FUNCTION_FUNCTION(const Functor& f, const Mixin& m) :
-      function_base(), Mixin(m) BOOST_FUNCTION_INIT
-    {
-      this->assign_to(f);
-    }
-
-#ifdef __BORLANDC__
-    template<typename Functor>
-    BOOST_FUNCTION_FUNCTION(Functor* f, const Mixin& m = Mixin()) : 
-      function_base(), Mixin(m) BOOST_FUNCTION_INIT
-    {
-      this->assign_to(f);
-    }
-#endif // __BORLANDC__
-
    BOOST_FUNCTION_FUNCTION(const BOOST_FUNCTION_FUNCTION& f) :
-      function_base(), Mixin(static_cast<const Mixin&>(f))
-      BOOST_FUNCTION_INIT
+      function_base(), invoker(0)
    {
+      // Lock the other function object so it can't change during assignment
+      lock l(static_cast<const self_type&>(f));
+      (void)l;
      this->assign_to_own(f);
    }

-    ~BOOST_FUNCTION_FUNCTION() { clear(); }
+    ~BOOST_FUNCTION_FUNCTION() 
+    { 
+      lock l(static_cast<const threading_mixin&>(*this));
+      (void)l;
+      clear(); 
+    }

    result_type operator()(BOOST_FUNCTION_PARMS) const
    {
+      // Make sure this function can't change while it is being invoked
+      lock l(static_cast<const threading_mixin&>(*this));
+      (void)l;
      assert(!this->empty());

-      policy_type policy;
-      policy.precall(this);
+      internal_result_type result = invoker(function_base::functor 
+                                            BOOST_FUNCTION_COMMA
+                                            BOOST_FUNCTION_ARGS);

-#ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-      const impl_type* i = reinterpret_cast<const impl_type*>(impl);
-      result_type result = i->call(BOOST_FUNCTION_ARGS);
+#ifndef BOOST_NO_VOID_RETURNS
+      return static_cast<result_type>(result);
 #else
-      result_type result = invoker(functor BOOST_FUNCTION_COMMA
-                                   BOOST_FUNCTION_ARGS);
-#endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-
-      policy.postcall(this);
      return result;
+#endif // BOOST_NO_VOID_RETURNS
    }

    // The distinction between when to use BOOST_FUNCTION_FUNCTION and
@ -511,108 +304,73 @@ namespace boost {
    // handle BOOST_FUNCTION_FUNCTION as the type of the temporary to 
    // construct.
    template<typename Functor>
-    BOOST_FUNCTION_FUNCTION& operator=(const Functor& f)
+    BOOST_FUNCTION_FUNCTION& 
+    operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
    {
-      self_type(f, static_cast<const Mixin&>(*this)).swap(*this);
+      self_type other(f);
+      lock l(static_cast<const threading_mixin&>(*this));
+      (void)l;
+      other.unlocked_swap(*this);
      return *this;
    }

-#ifdef __BORLANDC__
-    template<typename Functor>
-    BOOST_FUNCTION_FUNCTION& operator=(Functor* f)
-    {
-      self_type(f, static_cast<const Mixin&>(*this)).swap(*this);
-      return *this;
-    }
-#endif // __BORLANDC__
-
-    template<typename Functor>
-    void set(const Functor& f)
-    {
-      self_type(f, static_cast<const Mixin&>(*this)).swap(*this);
-    }
-
-#ifdef __BORLANDC__
-    template<typename Functor>
-    void set(Functor* f)
-    {
-      self_type(f, static_cast<const Mixin&>(*this)).swap(*this);
-    }
-#endif // __BORLANDC__
-
    // Assignment from another BOOST_FUNCTION_FUNCTION
    BOOST_FUNCTION_FUNCTION& operator=(const BOOST_FUNCTION_FUNCTION& f)
    {
      if (&f == this)
        return *this;

-      self_type(f).swap(*this);
+      self_type other(f);
+      lock l(static_cast<const threading_mixin&>(*this));
+      (void)l;
+      other.unlocked_swap(*this);
+
      return *this;
    }

-    // Assignment from another BOOST_FUNCTION_FUNCTION
-    void set(const BOOST_FUNCTION_FUNCTION& f)
-    {
-      if (&f == this)
-        return;
-
-      self_type(f).swap(*this);
-    }
-
    void swap(BOOST_FUNCTION_FUNCTION& other)
    {
      if (&other == this)
        return;

-#ifndef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-      std::swap(manager, other.manager);
-      std::swap(functor, other.functor);
-      std::swap(invoker, other.invoker);
-#else
-      std::swap(impl, other.impl);
-#endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-      std::swap(static_cast<Mixin&>(*this),static_cast<Mixin&>(other));
+      detail::function::scoped_double_lock<lock, threading_mixin> l(*this, 
+                                                                    other);
+      (void)l;
+
+      unlocked_swap(other);
    }

    // Clear out a target, if there is one
    void clear()
    {
-#ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-      if (impl) {
-        impl_type* i = reinterpret_cast<impl_type*>(impl);
-        i->destroy(i);
-        impl = 0;
+      lock l(static_cast<const threading_mixin&>(*this));
+      (void)l;
+
+      if (function_base::manager) {
+        function_base::functor = 
+	  function_base::manager(function_base::functor, 
+				 detail::function::destroy_functor_tag);
      }
-#else
-      if (manager)
-        functor = manager(functor, detail::function::destroy_functor);
-    
-      manager = 0;
+
+      function_base::manager = 0;
      invoker = 0;
-#endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
    }

  private:
    void assign_to_own(const BOOST_FUNCTION_FUNCTION& f)
    {
      if (!f.empty()) {
-#  ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-        impl_type* other_impl = reinterpret_cast<impl_type*>(f.impl);
-        impl = static_cast<void*>(other_impl->clone());
-#  else
        invoker = f.invoker;
-        manager = f.manager;
-        functor = f.manager(f.functor, detail::function::clone_functor);
-#  endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS      
-      }          
+        function_base::manager = f.manager;
+        function_base::functor = 
+	  f.manager(f.functor, detail::function::clone_functor_tag);
+      }
    }

    template<typename Functor>
-    void assign_to(const Functor& f)
+    void assign_to(Functor f)
    {
-      typedef typename detail::function::IF<(is_pointer<Functor>::value),
-                         detail::function::function_ptr_tag,
-                         detail::function::function_obj_tag>::type tag;
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
      this->assign_to(f, tag());
    }

@ -624,105 +382,155 @@ namespace boost {
      if (f) {
        typedef typename detail::function::BOOST_FUNCTION_GET_FUNCTION_INVOKER<
                           FunctionPtr,
-                           Allocator,
                           R BOOST_FUNCTION_COMMA
                           BOOST_FUNCTION_TEMPLATE_ARGS
                         >::type
          invoker_type;
    
-#  ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-#    ifdef BOOST_NO_STD_ALLOCATOR
-        impl_type* i = new invoker_type(f);
-#    else
-        typedef typename Allocator::template rebind<invoker_type>::other
-          allocator_type;
-        typedef typename allocator_type::pointer pointer_type;
-        allocator_type allocator;
-    
-        pointer_type copy = allocator.allocate(1);
-        new (copy) invoker_type(f);
-        impl_type* i = static_cast<impl_type*>(copy);
-#    endif // BOOST_NO_STD_ALLOCATOR
-        impl = static_cast<void*>(i);
-#  else
        invoker = &invoker_type::invoke;
-        manager = &detail::function::functor_manager<FunctionPtr, 
-                                                     Allocator>::manage;
-        functor = manager(detail::function::any_pointer(
-                            reinterpret_cast<void (*)()>(f)
+        function_base::manager = 
+	  &detail::function::functor_manager<FunctionPtr, Allocator>::manage;
+        function_base::functor = 
+	  function_base::manager(detail::function::any_pointer(
+                            // should be a reinterpret cast, but some compilers
+                            // insist on giving cv-qualifiers to free functions
+                            (void (*)())(f)
                          ),
-                          detail::function::clone_functor);
-#  endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
+                          detail::function::clone_functor_tag);
      }
    }  
+
+#if BOOST_FUNCTION_NUM_ARGS > 0
+    template<typename MemberPtr>
+    void assign_to(MemberPtr f, detail::function::member_ptr_tag)
+    {
+      this->assign_to(mem_fn(f));
+    }
+#endif // BOOST_FUNCTION_NUM_ARGS > 0
        
    template<typename FunctionObj>
-    void assign_to(const FunctionObj& f, detail::function::function_obj_tag)
+    void assign_to(FunctionObj f, detail::function::function_obj_tag)
    {
-      if (!detail::function::has_empty_target(&f)) {
+      typedef detail::function::truth<
+                boost::is_base_and_derived<function_base, FunctionObj>::value>
+	is_boost_function;
+
+      if (!detail::function::has_empty_target(f, is_boost_function())) {
        typedef 
          typename detail::function::BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
                                       FunctionObj,
-                                       Allocator,
                                       R BOOST_FUNCTION_COMMA
                                       BOOST_FUNCTION_TEMPLATE_ARGS
                                     >::type
          invoker_type;
    
-#  ifdef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-#    ifdef BOOST_NO_STD_ALLOCATOR
-        impl_type* i = new invoker_type(f);
-#    else
-        typedef typename Allocator::template rebind<invoker_type>::other
+        invoker = &invoker_type::invoke;
+        function_base::manager = &detail::function::functor_manager<
+	                            FunctionObj, Allocator>::manage;
+#ifndef BOOST_NO_STD_ALLOCATOR
+        typedef typename Allocator::template rebind<FunctionObj>::other 
          allocator_type;
        typedef typename allocator_type::pointer pointer_type;
-        allocator_type allocator;
-    
-        pointer_type copy = allocator.allocate(1);
-        new (copy) invoker_type(f);
-        impl_type* i = static_cast<impl_type*>(copy);
-#    endif // BOOST_NO_STD_ALLOCATOR
-        impl = static_cast<void*>(i);
-#  else
-        invoker = &invoker_type::invoke;
-        manager = &detail::function::functor_manager<FunctionObj, 
-                                                     Allocator>::manage;
-        functor = 
-          manager(detail::function::any_pointer(const_cast<FunctionObj*>(&f)),
-                  detail::function::clone_functor);
-#  endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
+	allocator_type allocator;
+	pointer_type copy = allocator.allocate(1);
+	allocator.construct(copy, f);
+
+	// Get back to the original pointer type
+	FunctionObj* new_f = static_cast<FunctionObj*>(copy);
+#else
+	FunctionObj* new_f = new FunctionObj(f);
+#endif // BOOST_NO_STD_ALLOCATOR
+        function_base::functor = 
+	  detail::function::any_pointer(static_cast<void*>(new_f));
      }
    }
    
-#ifndef BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
-    typedef result_type (*invoker_type)(detail::function::any_pointer
-                                        BOOST_FUNCTION_COMMA
-                                        BOOST_FUNCTION_TEMPLATE_ARGS);
+    template<typename FunctionObj>
+    void assign_to(const reference_wrapper<FunctionObj>& f, 
+                   detail::function::function_obj_ref_tag)
+    {
+      typedef detail::function::truth<
+                boost::is_base_and_derived<function_base, FunctionObj>::value>
+	is_boost_function;
+
+      if (!detail::function::has_empty_target(f.get(), is_boost_function())) {
+        typedef 
+          typename detail::function::BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
+                                       FunctionObj,
+                                       R BOOST_FUNCTION_COMMA
+                                       BOOST_FUNCTION_TEMPLATE_ARGS
+                                     >::type
+          invoker_type;
+    
+        invoker = &invoker_type::invoke;
+        function_base::manager = &detail::function::trivial_manager;
+        function_base::functor = 
+          function_base::manager(
+            detail::function::any_pointer(
+              const_cast<FunctionObj*>(f.get_pointer())),
+	    detail::function::clone_functor_tag);
+      }
+    }
+    
+    template<typename FunctionObj>
+    void assign_to(FunctionObj, detail::function::stateless_function_obj_tag)
+    {
+      typedef 
+          typename detail::function::
+                     BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER<
+                       FunctionObj,
+                       R BOOST_FUNCTION_COMMA
+                       BOOST_FUNCTION_TEMPLATE_ARGS
+                     >::type
+          invoker_type;
+      invoker = &invoker_type::invoke;
+      function_base::manager = &detail::function::trivial_manager;
+      function_base::functor = detail::function::any_pointer(this);
+    }
+
+    void unlocked_swap(BOOST_FUNCTION_FUNCTION& other)
+    {
+      std::swap(function_base::manager, other.manager);
+      std::swap(function_base::functor, other.functor);
+      std::swap(invoker, other.invoker);
+    }
+
+    typedef internal_result_type (*invoker_type)(detail::function::any_pointer
+                                                 BOOST_FUNCTION_COMMA
+                                                 BOOST_FUNCTION_TEMPLATE_ARGS);
    
    invoker_type invoker;
-#endif // BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS
  };

  template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
-           typename Policy, typename Mixin, typename Allocator>
+           typename ThreadingPolicy, typename Allocator>
  inline void swap(BOOST_FUNCTION_FUNCTION<
                     R BOOST_FUNCTION_COMMA
                     BOOST_FUNCTION_TEMPLATE_ARGS ,
-                     Policy,
-                     Mixin,
+                     ThreadingPolicy,
                     Allocator
                   >& f1,
                   BOOST_FUNCTION_FUNCTION<
                     R BOOST_FUNCTION_COMMA 
                     BOOST_FUNCTION_TEMPLATE_ARGS,
-                     Policy,
-                     Mixin,
+                     ThreadingPolicy,
                     Allocator
                   >& f2)
  {
    f1.swap(f2);
-  }                   
+  }
 }

 // Cleanup after ourselves...
-#undef BOOST_FUNCTION_INIT
+#undef BOOST_FUNCTION_COMMA
+#undef BOOST_FUNCTION_FUNCTION
+#undef BOOST_FUNCTION_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_STATELESS_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_STATELESS_VOID_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_GET_STATELESS_FUNCTION_OBJ_INVOKER
+#undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
--- a/include/boost/function/gen_function_N.pl
+++ b/include/boost/function/gen_function_N.pl
@ -0,0 +1,111 @@
+#!/usr/bin/perl -w
+#
+# Boost.Function library
+#
+# Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
+#
+# Permission to copy, use, sell and distribute this software is granted
+# provided this copyright notice appears in all copies.
+# Permission to modify the code and to distribute modified code is granted
+# provided this copyright notice appears in all copies, and a notice
+# that the code was modified is included with the copyright notice.
+#
+# This software is provided "as is" without express or implied warranty,
+# and with no claim as to its suitability for any purpose.
+#
+# For more information, see http://www.boost.org
+use English;
+
+if ($#ARGV < 0) {
+  print "Usage: perl gen_function_N <number of arguments>\n";
+  exit;
+}
+
+
+$totalNumArgs = $ARGV[0];
+for ($numArgs = 0; $numArgs <= $totalNumArgs; ++$numArgs) {
+  open OUT, ">function$numArgs.hpp";
+  print OUT "// Boost.Function library\n";
+  print OUT "//\n";
+  print OUT "// Copyright (C) 2001 Doug Gregor (gregod\@cs.rpi.edu)\n";
+  print OUT "//\n";
+  print OUT "// Permission to copy, use, sell and distribute this software is granted\n";
+  print OUT "// provided this copyright notice appears in all copies.\n";
+  print OUT "// Permission to modify the code and to distribute modified code is granted\n";
+  print OUT "// provided this copyright notice appears in all copies, and a notice\n";
+  print OUT "// that the code was modified is included with the copyright notice.\n";
+  print OUT "//\n";
+  print OUT "// This software is provided \"as is\" without express or implied warranty,\n";
+  print OUT "// and with no claim as to its suitability for any purpose.\n";
+  print OUT " \n";
+  print OUT "// For more information, see http://www.boost.org\n";
+  print OUT "\n";
+  print OUT "#ifndef BOOST_FUNCTION_FUNCTION" . $numArgs . "_HEADER\n";
+  print OUT "#define BOOST_FUNCTION_FUNCTION" , $numArgs . "_HEADER\n";
+  print OUT "\n";
+  print OUT "#define BOOST_FUNCTION_NUM_ARGS $numArgs\n";
+
+  $templateParms = "";
+  for ($i = 0; $i < $numArgs; ++$i) {
+    if ($i > 0) {
+      $templateParms .= ", ";
+    }
+    $templateParms .= "typename T$i";
+  }
+  print OUT "#define BOOST_FUNCTION_TEMPLATE_PARMS $templateParms\n";
+
+  $_ = $templateParms;
+  s/typename //g;
+  $templateArgs = $_;
+  print OUT "#define BOOST_FUNCTION_TEMPLATE_ARGS $templateArgs\n";
+
+  $parms = "";
+  for ($i = 0; $i < $numArgs; ++$i) {
+    if ($i > 0) {
+      $parms .= ", ";
+    }
+    $parms .= "T$i a$i";
+  }
+  print OUT "#define BOOST_FUNCTION_PARMS $parms\n";
+
+  $args = "";
+  for ($i = 0; $i < $numArgs; ++$i) {
+    if ($i > 0) {
+      $args .= ", ";
+    }
+    $args .= "a$i";
+  }
+  print OUT "#define BOOST_FUNCTION_ARGS $args\n";
+
+  $not0Parms = "";
+  for ($i = 1; $i < $numArgs; ++$i) {
+    if ($i > 1) {
+      $not0Parms .= ", ";
+    }
+    $not0Parms .= "T$i a$i";
+  }
+  print OUT "#define BOOST_FUNCTION_NOT_0_PARMS $not0Parms\n";
+
+  $not0Args = "";
+  for ($i = 1; $i < $numArgs; ++$i) {
+    if ($i > 1) {
+      $not0Args .= ", ";
+    }
+    $not0Args .= "a$i";
+  }
+  print OUT "#define BOOST_FUNCTION_NOT_0_ARGS $not0Args\n";
+
+  print OUT "\n";
+  print OUT "#include <boost/function/function_template.hpp>\n";
+  print OUT "\n";
+  print OUT "#undef BOOST_FUNCTION_NOT_0_ARGS\n";
+  print OUT "#undef BOOST_FUNCTION_NOT_0_PARMS\n";
+  print OUT "#undef BOOST_FUNCTION_ARGS\n";
+  print OUT "#undef BOOST_FUNCTION_PARMS\n";
+  print OUT "#undef BOOST_FUNCTION_TEMPLATE_ARGS\n";
+  print OUT "#undef BOOST_FUNCTION_TEMPLATE_PARMS\n";
+  print OUT "#undef BOOST_FUNCTION_NUM_ARGS\n";
+  print OUT "\n";
+  print OUT "#endif // BOOST_FUNCTION_FUNCTION" . $numArgs . "_HEADER\n";
+  close OUT;
+}
--- a/include/boost/function/threading/detail/mutex_mixin.hpp
+++ b/include/boost/function/threading/detail/mutex_mixin.hpp
@ -0,0 +1,48 @@
+// Copyright (C) 2002
+// Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to use, copy, modify, distribute and sell this software
+// and its documentation for any purpose is hereby granted without fee,
+// provided that the above copyright notice appear in all copies and
+// that both that copyright notice and this permission notice appear
+// in supporting documentation.  William E. Kempf makes no representations
+// about the suitability of this software for any purpose.
+// It is provided "as is" without express or implied warranty.
+#ifndef BOOST_THREAD_MODEL_DETAIL_MUTEX_MIXIN_HPP
+#define BOOST_THREAD_MODEL_DETAIL_MUTEX_MIXIN_HPP
+
+namespace boost {
+namespace detail {
+
+template<typename Mutex>
+class mutex_mixin
+{
+public:
+  mutex_mixin(const mutex_mixin&) {}
+  mutex_mixin& operator=(const mutex_mixin&) { return *this; }
+
+  operator const Mutex&() const { return mutex; }
+  operator Mutex&() { return mutex; }
+
+private:
+  Mutex mutex;
+};
+
+template<typename Mutex>
+class static_mutex_mixin
+{
+public:
+  static_mutex_mixin(const mutex_mixin&) {}
+  static_mutex_mixin& operator=(const mutex_mixin&) { return *this; }
+
+  operator const Mutex&() const { return mutex; }
+  operator Mutex&() { return mutex; }
+
+private:
+  static Mutex mutex;
+};
+
+} // end namespace detail
+} // end namespace boost
+
+#endif // BOOST_THREAD_MODEL_DETAIL_MUTEX_MIXIN_HPP
--- a/include/boost/function/threading/per_class.hpp
+++ b/include/boost/function/threading/per_class.hpp
@ -0,0 +1,28 @@
+// Copyright (C) 2002
+// Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to use, copy, modify, distribute and sell this software
+// and its documentation for any purpose is hereby granted without fee,
+// provided that the above copyright notice appear in all copies and
+// that both that copyright notice and this permission notice appear
+// in supporting documentation.  William E. Kempf makes no representations
+// about the suitability of this software for any purpose.
+// It is provided "as is" without express or implied warranty.
+#ifndef BOOST_THREAD_MODEL_PER_CLASS_HPP
+#define BOOST_THREAD_MODEL_PER_CLASS_HPP
+
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/model/detail/mutex_mixin.hpp>
+
+namespace boost {
+
+  template<typename Mutex = boost::mutex>
+  struct per_class_locking
+  {
+    typedef detail::static_mutex_mixin<Mutex> mixin;
+    typedef typename Mutex::scoped_lock lock;
+  };
+
+} // end namespace boost
+
+#endif // BOOST_THREAD_MODEL_PER_CLASS_HPP
--- a/include/boost/function/threading/per_object.hpp
+++ b/include/boost/function/threading/per_object.hpp
@ -0,0 +1,28 @@
+// Copyright (C) 2002
+// Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to use, copy, modify, distribute and sell this software
+// and its documentation for any purpose is hereby granted without fee,
+// provided that the above copyright notice appear in all copies and
+// that both that copyright notice and this permission notice appear
+// in supporting documentation.  William E. Kempf makes no representations
+// about the suitability of this software for any purpose.
+// It is provided "as is" without express or implied warranty.
+#ifndef BOOST_THREAD_MODEL_PER_OBJECT_HPP
+#define BOOST_THREAD_MODEL_PER_OBJECT_HPP
+
+#include <boost/thread/mutex.hpp>
+#include <boost/thread/model/detail/mutex_mixin.hpp>
+
+namespace boost {
+
+  template<typename Mutex = boost::mutex>
+  struct per_object_locking
+  {
+    typedef detail::mutex_mixin<Mutex> mixin;
+    typedef typename Mutex::scoped_lock lock;
+  };
+
+} // end namespace boost
+
+#endif // BOOST_THREAD_MODEL_PER_OBJECT_HPP
--- a/include/boost/function/threading/single.hpp
+++ b/include/boost/function/threading/single.hpp
@ -0,0 +1,27 @@
+// Copyright (C) 2002
+// Doug Gregor (gregod@cs.rpi.edu)
+//
+// Permission to use, copy, modify, distribute and sell this software
+// and its documentation for any purpose is hereby granted without fee,
+// provided that the above copyright notice appear in all copies and
+// that both that copyright notice and this permission notice appear
+// in supporting documentation.  William E. Kempf makes no representations
+// about the suitability of this software for any purpose.
+// It is provided "as is" without express or implied warranty.
+#ifndef BOOST_THREAD_MODEL_SINGLE_HPP
+#define BOOST_THREAD_MODEL_SINGLE_HPP
+
+namespace boost {
+
+struct single_threaded {
+  struct mixin {};
+
+  struct lock 
+  {
+    lock(const mixin&) {}
+  };
+};
+
+} // end namespace boost
+
+#endif // BOOST_THREAD_MODEL_SINGLE_HPP
--- a/index.html
+++ b/index.html
@ -50,13 +50,13 @@ And, of course, function pointers have several advantages over Boost.Function:
 <p> Function object wrappers will be the size of two function pointers plus one function pointer or data pointer (whichever is larger). On common 32-bit platforms, this amounts to 12 bytes per wrapper. Additionally, the function object target will be allocated on the heap.

 <h3>Copying efficiency</h3>
-<p> Copying function object wrappers requires allocating member for a copy of the function object target. The default allocator may be replaced with a faster custom allocator if the cost of this cloning becomes prohibitive.
+<p> Copying function object wrappers may require allocating memory for a copy of the function object target. The default allocator may be replaced with a faster custom allocator or one may choose to allow the function object wrappers to only store function object targets by reference (using <a href="../bind/ref.html"><code>ref</code></a>) if the cost of this cloning becomes prohibitive.

 <h3>Invocation efficiency</h3>
 <p> With a properly inlining compiler, an invocation of a function object requires one call through a function pointer. If the call is to a free function pointer, an additional call must be made to that function pointer (unless the compiler has very powerful interprocedural analysis).

 <h2><a name="portability">Portability</a></h2>
-<p> The function object wrappers have been designed to be as portable as possible, and to support many compilers even when they do not support the C++ standard well. The following compilers have passed all of the testcases included with <code>boost::function</code>.
+<p> The function object wrappers have been designed to be as portable as possible, and to support many compilers even when they do not support the C++ standard well. The following compilers have passed all of the test cases included with <code>boost::function</code>.
 <ul>
  <li>GCC 2.95.3</li>
  <li>GCC 3.0</li>
@ -80,12 +80,10 @@ And, of course, function pointers have several advantages over Boost.Function:

 <p> In Boost.Function, an alternative but equivalent approach was taken using free functions instead of virtual functions. The Boost.Function object essentially holds two pointers to make a valid target call: a void pointer to the function object it contains and a void pointer to an "invoker" that can call the function object, given the function pointer. This invoker function performs the argument and return value conversions Boost.Function provides. A third pointer points to a free function called the "manager", which handles the cloning and destruction of function objects. The scheme is typesafe because the only functions that actually handle the function object, the invoker and the manager, are instantiated given the type of the function object, so they can safely cast the incoming void pointer (the function object pointer) to the appropriate type.

-<p> A compiler with strong interprocedural analysis could significantly reduce the overhead associated with virtual function calls such that the alternative used by Boost.Function is less efficient. No compiler has yet been found where this is true, but when it does occur the BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS macro can be defined to revert to the simpler implementation based on virtual functions.
-
 <h2><a name="acknowledgements">Acknowledgements</a></h2>
 <p> Many people were involved in the construction of this library. William Kempf, Jesse Jones and Karl Nelson were all extremely helpful in isolating an interface and scope for the library. John Maddock managed the formal review, and many reviewers gave excellent comments on interface, implementation, and documentation. 

    <hr>
    <address><a href="mailto:gregod@cs.rpi.edu">Doug Gregor</a></address>
  </body>
-</html>
+</html>
--- a/test/defarg_test.cpp
+++ b/test/defarg_test.cpp
@ -1,56 +0,0 @@
-// Boost.Function library
-
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-#include <boost/function.hpp>
-#include <functional>
-#include <cassert>
-#include <string>
-
-using namespace std;
-using namespace boost;
-
-static int sub_ints(int x = 5, int y = 3, int z = 1) { return x-y-z; }
-
-static void 
-test_zero_args()
-{
-  function<int> one(&sub_ints);
-  BOOST_TEST(one() == 1);
-}
-
-static void
-test_one_arg()
-{
-  function<int, int> minus_four(&sub_ints);
-  BOOST_TEST(minus_four(7) == 3);
-}
-
-static void
-test_two_args()
-{
-  function<int, int, int> sub(&sub_ints);
-  BOOST_TEST(sub(10, 2) == 7);
-}
-
-int
-test_main(int, char* [])
-{
-  test_zero_args();
-  test_one_arg();
-  test_two_args();
-  return 0;
-}
--- a/test/function_n_test.cpp
+++ b/test/function_n_test.cpp
@ -1,6 +1,6 @@
 // Boost.Function library

-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
+// Copyright (C) 2001-2002 Doug Gregor (gregod@cs.rpi.edu)
 //
 // Permission to copy, use, sell and distribute this software is granted
 // provided this copyright notice appears in all copies.
@ -44,6 +44,15 @@ struct write_const_1_nonconst_2
  void operator()() const { global_int = 1; }
 };

+struct add_to_obj
+{
+  add_to_obj(int v) : value(v) {}
+
+  int operator()(int x) const { return value + x; }
+
+  int value;
+};
+
 static void
 test_zero_args()
 {
@ -84,7 +93,7 @@ test_zero_args()

  // Invocation and self-assignment
  global_int = 0;
-  v1.set(v1);
+  v1 = (v1);
  v1();
  BOOST_TEST(global_int == 5);

@ -93,7 +102,7 @@ test_zero_args()
  BOOST_TEST(v1.empty());

  // Assignment to an empty function from a free function
-  v1 = &write_five;
+  v1 = write_five;
  BOOST_TEST(!v1.empty());

  // Invocation
@ -120,7 +129,7 @@ test_zero_args()
  BOOST_TEST(global_int == 5);

  // Assignment to a non-empty function from a free function
-  v1 = &write_three;
+  v1 = write_three;
  BOOST_TEST(!v1.empty());

  // Invocation
@ -143,7 +152,7 @@ test_zero_args()
  BOOST_TEST(global_int == 3);

  // Assignment to a non-empty function
-  v2.set(five);
+  v2 = (five);

  // Invocation
  global_int = 0;
@ -154,7 +163,7 @@ test_zero_args()
  BOOST_TEST(v2.empty());

  // Assignment to an empty function from a free function
-  v2.set(&write_five);
+  v2 = (&write_five);
  BOOST_TEST(v2);

  // Invocation
@ -527,8 +536,15 @@ test_one_arg()
  function1<string, string> id(&identity_str);
  BOOST_TEST(id("str") == "str");

-  function1<std::string, char*> id2(&identity_str);
+  function1<std::string, const char*> id2(&identity_str);
  BOOST_TEST(id2("foo") == "foo");
+
+  add_to_obj add_to(5);
+  function1<int, int> f2(add_to);
+  BOOST_TEST(f2(3) == 8);
+
+  const function1<int, int> cf2(add_to);
+  BOOST_TEST(cf2(3) == 8);
 }

 static void
@ -556,12 +572,74 @@ test_emptiness()
  BOOST_TEST(f3.empty());
 }

-int
-test_main(int, char* [])
+struct X {
+  X(int v) : value(v) {}
+
+  int twice() const { return 2*value; }
+  int plus(int v) { return value + v; }
+
+  int value;
+};
+
+static void
+test_member_functions()
+{
+
+  boost::function1<int, X*> f1(&X::twice);
+  
+  X one(1);
+  X five(5);
+
+  BOOST_TEST(f1(&one) == 2);
+  BOOST_TEST(f1(&five) == 10);
+
+  boost::function1<int, X*> f1_2;
+  f1_2 = &X::twice;
+
+  BOOST_TEST(f1_2(&one) == 2);
+  BOOST_TEST(f1_2(&five) == 10);
+
+  boost::function2<int, X&, int> f2(&X::plus);
+  BOOST_TEST(f2(one, 3) == 4);
+  BOOST_TEST(f2(five, 4) == 9);
+}
+
+struct add_with_throw_on_copy {
+  int operator()(int x, int y) const { return x+y; }
+
+  add_with_throw_on_copy() {}
+
+  add_with_throw_on_copy(const add_with_throw_on_copy&)
+  {
+    throw std::runtime_error("But this CAN'T throw");
+  }
+
+  add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
+  {
+    throw std::runtime_error("But this CAN'T throw");
+  }
+};
+
+static void
+test_ref()
+{
+  add_with_throw_on_copy atc;
+  try {
+    boost::function2<int, int, int> f(ref(atc));
+    BOOST_TEST(f(1, 3) == 4);
+  }
+  catch(std::runtime_error e) {
+    BOOST_ERROR("Nonthrowing constructor threw an exception");
+  }
+}
+
+int test_main(int, char* [])
 {
  test_zero_args();
  test_one_arg();
  test_two_args();
  test_emptiness();
+  test_member_functions();
+  test_ref();
  return 0;
 }
--- a/test/function_test.cpp
+++ b/test/function_test.cpp
@ -1,6 +1,6 @@
 // Boost.Function library

-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
+// Copyright (C) 2001-2002 Doug Gregor (gregod@cs.rpi.edu)
 //
 // Permission to copy, use, sell and distribute this software is granted
 // provided this copyright notice appears in all copies.
@ -44,6 +44,15 @@ struct write_const_1_nonconst_2
  void operator()() const { global_int = 1; }
 };

+struct add_to_obj
+{
+  add_to_obj(int v) : value(v) {}
+
+  int operator()(int x) const { return value + x; }
+
+  int value;
+};
+
 static void
 test_zero_args()
 {
@ -84,7 +93,7 @@ test_zero_args()

  // Invocation and self-assignment
  global_int = 0;
-  v1.set(v1);
+  v1 = (v1);
  v1();
  BOOST_TEST(global_int == 5);

@ -93,7 +102,7 @@ test_zero_args()
  BOOST_TEST(v1.empty());

  // Assignment to an empty function from a free function
-  v1 = &write_five;
+  v1 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
  BOOST_TEST(!v1.empty());

  // Invocation
@ -102,7 +111,7 @@ test_zero_args()
  BOOST_TEST(global_int == 5);

  // Assignment to a non-empty function from a free function
-  v1 = &write_three;
+  v1 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
  BOOST_TEST(!v1.empty());

  // Invocation
@ -143,7 +152,7 @@ test_zero_args()
  BOOST_TEST(global_int == 3);

  // Assignment to a non-empty function
-  v2.set(five);
+  v2 = (five);

  // Invocation
  global_int = 0;
@ -154,7 +163,7 @@ test_zero_args()
  BOOST_TEST(v2.empty());

  // Assignment to an empty function from a free function
-  v2.set(&write_five);
+  v2 = (BOOST_FUNCTION_TARGET_FIX(&) write_five);
  BOOST_TEST(v2);

  // Invocation
@ -163,7 +172,7 @@ test_zero_args()
  BOOST_TEST(global_int == 5);

  // Assignment to a non-empty function from a free function
-  v2 = &write_three;
+  v2 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
  BOOST_TEST(!v2.empty());

  // Invocation
@ -218,7 +227,7 @@ test_zero_args()
  BOOST_TEST(global_int == 3);

  // Assign to a function from a function with a function
-  v2 = &write_five;
+  v2 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
  v1 = v2;
  BOOST_TEST(!v1.empty());
  BOOST_TEST(!v2.empty());
@ -527,8 +536,15 @@ test_one_arg()
  function<string, string> id(&identity_str);
  BOOST_TEST(id("str") == "str");

-  function<std::string, char*> id2(&identity_str);
+  function<std::string, const char*> id2(&identity_str);
  BOOST_TEST(id2("foo") == "foo");
+
+  add_to_obj add_to(5);
+  function<int, int> f2(add_to);
+  BOOST_TEST(f2(3) == 8);
+
+  const function<int, int> cf2(add_to);
+  BOOST_TEST(cf2(3) == 8);
 }

 static void
@ -556,12 +572,74 @@ test_emptiness()
  BOOST_TEST(f3.empty());
 }

-int
-test_main(int, char* [])
+struct X {
+  X(int v) : value(v) {}
+
+  int twice() const { return 2*value; }
+  int plus(int v) { return value + v; }
+
+  int value;
+};
+
+static void
+test_member_functions()
+{
+  boost::function<int, X*> f1(&X::twice);
+  
+  X one(1);
+  X five(5);
+
+  BOOST_TEST(f1(&one) == 2);
+  BOOST_TEST(f1(&five) == 10);
+
+  boost::function<int, X*> f1_2;
+  f1_2 = &X::twice;
+
+  BOOST_TEST(f1_2(&one) == 2);
+  BOOST_TEST(f1_2(&five) == 10);
+
+  boost::function<int, X&, int> f2(&X::plus);
+  BOOST_TEST(f2(one, 3) == 4);
+  BOOST_TEST(f2(five, 4) == 9);
+}
+
+struct add_with_throw_on_copy {
+  int operator()(int x, int y) const { return x+y; }
+
+  add_with_throw_on_copy() {}
+
+  add_with_throw_on_copy(const add_with_throw_on_copy&)
+  {
+    throw std::runtime_error("But this CAN'T throw");
+  }
+
+  add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
+  {
+    throw std::runtime_error("But this CAN'T throw");
+  }
+};
+
+static void
+test_ref()
+{
+  add_with_throw_on_copy atc;
+  try {
+    boost::function<int, int, int> f(ref(atc));
+    BOOST_TEST(f(1, 3) == 4);
+  }
+  catch(std::runtime_error e) {
+    BOOST_ERROR("Nonthrowing constructor threw an exception");
+  }
+}
+
+int test_main(int, char* [])
 {
  test_zero_args();
  test_one_arg();
  test_two_args();
  test_emptiness();
+  test_member_functions();
+  test_ref();
+
  return 0;
 }
--- a/test/mixin_test.cpp
+++ b/test/mixin_test.cpp
@ -1,60 +0,0 @@
-// Boost.Function library
-
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-#include <cassert>
-#include <functional>
-#include <boost/function.hpp>
-
-struct id_mixin
-{	
-  id_mixin(const id_mixin& rhs) : id(rhs.id) {}
-  id_mixin& operator=(const id_mixin& rhs){id = rhs.id; return *this;}
-  id_mixin(int i = 0){ id = i;}
-  int id;
-};
-
-static int do_plus(int x, int y) { return x+y; }
-
-typedef boost::function<int,int,int>::mixin<id_mixin>::type func;
-
-int test_main(int, char*[])
-{
-  func f(id_mixin(3));  
-  f = std::plus<int>();
-  BOOST_TEST(f.id == 3);
-  
-  f = &do_plus;
-  BOOST_TEST(f.id == 3);
-
-  f.clear();
-  f.id = 7;    
-  BOOST_TEST(f.id == 7);
-    
-  func g(f);
-  BOOST_TEST(g.id == 7);
-
-  f.id = 21;    
-  BOOST_TEST(f.id == 21);
-	  
-  boost::swap(f,g);  
-  BOOST_TEST(f.id == 7);
-  BOOST_TEST(g.id == 21);
-
-  g = f;	  
-  BOOST_TEST(g.id == 7);  
-  return 0;
-}
--- a/test/regression.cfg
+++ b/test/regression.cfg
@ -5,11 +5,10 @@


 run libs/function/test/allocator_test.cpp
-run libs/function/test/defarg_test.cpp
 run libs/function/test/function_n_test.cpp
 run libs/function/test/function_test.cpp
 compile-fail libs/function/test/function_test_fail1.cpp
 compile-fail libs/function/test/function_test_fail2.cpp
 run libs/function/test/mixin_test.cpp
 run libs/function/test/policy_test.cpp
-
+run libs/function/test/stateless_test.cpp
--- a/test/stateless_test.cpp
+++ b/test/stateless_test.cpp
@ -15,33 +15,33 @@

 #define BOOST_INCLUDE_MAIN
 #include <boost/test/test_tools.hpp>
-#include <cassert>
-#include <iostream>
-#include <functional>
 #include <boost/function.hpp>
+#include <stdexcept>

-using namespace std;
-using namespace boost;
+struct stateless_integer_add {
+  int operator()(int x, int y) const { return x+y; }

-struct counting_policy
-{
-  static int count;
+  void* operator new(std::size_t, stateless_integer_add*)
+  {
+    throw std::runtime_error("Cannot allocate a stateless_integer_add");
+  }

-  void precall(const function_base*) { count++; }
-  void postcall(const function_base*) { count+=2; }
+  void operator delete(void*, stateless_integer_add*)
+  {
+  }
 };

-int counting_policy::count = 0;
+namespace boost {
+  template<>
+  struct is_stateless<stateless_integer_add> {
+    BOOST_STATIC_CONSTANT(bool, value = true);
+  };
+}

-int
-test_main(int, char*[])
+int test_main(int, char*[])
 {
-  function<int, int, int>::policy<counting_policy>::type f; 
-
-  f = plus<int>();
-
-  BOOST_TEST(5 == f(2,3));
-  BOOST_TEST(counting_policy::count==3);
+  boost::function<int, int, int> f;
+  f = stateless_integer_add();

  return 0;
 }
Author	SHA1	Message	Date
Douglas Gregor	5d7f4aae46	Added threading models [SVN r13824]	2002-05-11 15:44:38 +00:00
Douglas Gregor	9a4d7447a7	Removed Mixins & Policies Added ThreadingPolicy with (untested) thread safety [SVN r13823]	2002-05-11 15:41:14 +00:00
Douglas Gregor	83481662bb	Mixins and policies are no longer supported [SVN r13822]	2002-05-11 15:33:00 +00:00
nobody	64b6e85a94	This commit was manufactured by cvs2svn to create branch 'function_v2'. [SVN r13596]	2002-04-30 20:05:33 +00:00
Douglas Gregor	57ee7e962a	function.hpp: - Remove default parameters in real_get_function_impl (Fixed Borland C++ Builder 6) [SVN r13595]	2002-04-30 20:05:32 +00:00
Douglas Gregor	48943fec83	Removed some unused macros [SVN r13594]	2002-04-30 19:41:37 +00:00
Douglas Gregor	a0b89d0a30	function_base.hpp: - Workaround for Sun CC [SVN r13566]	2002-04-26 17:45:53 +00:00
Douglas Gregor	82226cb9d6	Changed IF to ct_if because IF is sometimes used as a macro (ewww) [SVN r13420]	2002-04-10 04:10:06 +00:00
Douglas Gregor	28984e4f23	function_base.hpp: - has_empty_target modified to deal only with function objects, and to not require pointers to the function objects. function_template.hpp: - Don't use '&' operation on incoming function objects [SVN r13318]	2002-03-30 18:45:28 +00:00
Douglas Gregor	02f5d9d0e0	reference.html: - Document non-voidness of result_type when on a broken compiler [SVN r12616]	2002-02-01 02:55:22 +00:00
Douglas Gregor	1774c0646d	function_template.hpp: - Handle compilers without void returns in a sensible manner [SVN r12615]	2002-02-01 02:51:48 +00:00
Douglas Gregor	4b430a5414	function_template.hpp: - Make functionN<void, ...> really have a void return value [SVN r12613]	2002-01-31 22:56:16 +00:00
Douglas Gregor	7b0f465f33	Reverting member function pointer optimization [SVN r12580]	2002-01-30 15:04:08 +00:00
Douglas Gregor	6882358627	function_base.hpp: function_template.hpp: - Add support for storing member function pointers directly within the Boost.Function object, without allocating any extra memory [SVN r12568]	2002-01-30 04:33:45 +00:00
Douglas Gregor	39f6d34db8	reference.html: - Document exception behavior of assignments/construction from stateless objects - Document what the term "stateless" means in this context [SVN r12567]	2002-01-30 03:54:18 +00:00
Douglas Gregor	812ef599bd	function_template.hpp: - Fix unused parameter warning [SVN r12565]	2002-01-30 03:39:44 +00:00
Douglas Gregor	8c198b1c90	function_template.hpp: - Ensure initialization of stateless function objects [SVN r12561]	2002-01-30 03:18:15 +00:00
Douglas Gregor	5a07d4b262	regression.cfg: - Add stateless_test [SVN r12560]	2002-01-30 03:17:40 +00:00
Douglas Gregor	11187bcf3a	function_base.hpp: - Switch over to using is_reference_wrapper instead of homegrown is_ref - Identify stateless function objects function_template.hpp: - Optimize away construction/allocator for stateless function objects. [SVN r12559]	2002-01-30 01:59:49 +00:00
Douglas Gregor	aaa7f61b9e	stateless_test.cpp: - Test function's ability to optimize away allocations for stateless function objects [SVN r12557]	2002-01-30 01:58:28 +00:00
Douglas Gregor	a250f9c140	Lots of documentation fixes - thanks Dave [SVN r12505]	2002-01-25 15:00:37 +00:00
Douglas Gregor	4f33ea7665	function_base.hpp: - Fixed for Intel on Windows _and_ MSVC 7.0 [SVN r12472]	2002-01-24 04:06:05 +00:00
Douglas Gregor	51c376c4ee	function_base.hpp: - Fixed for Intel C++, I hope? [SVN r12469]	2002-01-23 21:17:40 +00:00
Douglas Gregor	8e123d2a97	sum_avg.cpp: - Portability fix for GCC [SVN r12464]	2002-01-23 18:24:58 +00:00
Douglas Gregor	58656b40b1	Try to fix for MSVC 7.0 [SVN r12456]	2002-01-23 14:01:28 +00:00
Dave Abrahams	2fa9ee040b	Fixes for Intel, added version cutoff for obsolete MWERKS workaround [SVN r12434]	2002-01-22 13:11:05 +00:00
Douglas Gregor	8635632937	untabified [SVN r12336]	2002-01-17 15:57:26 +00:00
Douglas Gregor	96f7184528	Untabified [SVN r12335]	2002-01-17 15:57:13 +00:00
Douglas Gregor	647693dfc9	function_base.hpp: - Make manager and functor members of function_base public instead of protected, because attempt to make HP aCC compile Boost.Function function_template.hpp: - HP aCC seems to believe that the functor and manager members inherited from function_base are inaccessible. So qualify them with the function_base base class. [SVN r12298]	2002-01-13 16:12:26 +00:00
Douglas Gregor	d48fa26030	Renamed BOOST_MSVC_ONLY to BOOST_FUNCTION_TARGET_FIX [SVN r12145]	2001-12-24 17:11:11 +00:00
Douglas Gregor	d3daf6db42	Renamed BOOST_MSVC_ONLY to BOOST_FUNCTION_TARGET_FIX Metrowerks needs the BOOST_FUNCTION_TARGET_FIX workaround [SVN r12144]	2001-12-24 17:10:47 +00:00
Douglas Gregor	fb26630e37	index.html: - Fix "Copying Efficiency" section to not imply that memory is ALWAYS allocated on copy. [SVN r12062]	2001-12-15 01:11:32 +00:00
Douglas Gregor	794b728603	tutorial.html: - State that ref(...) function objects won't throw during construction, either. [SVN r12061]	2001-12-15 00:58:47 +00:00
Douglas Gregor	ce68cb8999	function_template.hpp: - Use a C-style cast to deal with constness easily [SVN r12060]	2001-12-15 00:43:56 +00:00
John Maddock	47599fb625	Added inline modifier to trivial_manager - without this, some compilers (VC6) generate linker errors, in any case it is an ODR violation to define this function in every translation unit. [SVN r11984]	2001-12-09 12:49:09 +00:00
Douglas Gregor	1a7478bbd1	Updated docs to reflect changes in code: - assignments/constructors that took const F& now take F - no need to use &free_function for assignment from free functions, unless using MSVC6.5 [SVN r11946]	2001-12-05 23:16:39 +00:00
Douglas Gregor	db5399d447	Remove spurious semicolon [SVN r11944]	2001-12-05 22:39:33 +00:00
Douglas Gregor	083767f67a	Taking function objects by value instead of as references-to-const. This does not work on MSVC6.5, so the BOOST_MSVC_ONLY macro was added to make them references-to-const for only that compiler. - Borland C++ no longer requires hacks to make function pointers work - On any compiler other than MSVC, free functions can be assigned to Boost.Function objects without the explicit '&' [SVN r11943]	2001-12-05 22:35:32 +00:00
Douglas Gregor	8cbd121969	function_base.hpp: - Add trivial_manager that does nothing but copy object pointers - Add is_ref to determine if a type is a reference_wrapper - Add function_obj_ref_tag for reference_wrappers - Teach get_function_tag about reference_wrappers function_template.hpp: - Add assign_to overload for reference_wrappers (these don't throw) [SVN r11875]	2001-12-03 16:28:33 +00:00
Douglas Gregor	2e67e2126b	reference.html: - Document semantics of reference_wrapper usage tutorial.html: - Add short discussion and example of ref() and cref() [SVN r11874]	2001-12-03 16:26:19 +00:00
Douglas Gregor	1512df77b1	function_n_test: function_test: - Add testcases using ref() wrapper [SVN r11873]	2001-12-03 16:25:00 +00:00
Douglas Gregor	2265421357	General cleanups [SVN r11791]	2001-11-27 23:11:44 +00:00
Douglas Gregor	c64a2f3492	function_template.hpp: - Changed reinterpret_casts between pointers to member functions to C-style casts for MIPSpro. [SVN r11767]	2001-11-22 00:34:29 +00:00
Douglas Gregor	a657e5c812	Reversed prior commit - tests passing references for the implicit object parameter to an unbound member function pointer have been added again. [SVN r11732]	2001-11-19 20:57:57 +00:00
Douglas Gregor	cc3a33a19c	function_template.hpp: - Use boost::mem_fn internally to deal with calls to unbound member functions. [SVN r11731]	2001-11-19 20:56:52 +00:00
Douglas Gregor	a4c09a92d1	Generates the functionN.hpp headers [SVN r11730]	2001-11-19 20:32:07 +00:00
Douglas Gregor	b8e4cdab2f	function_base.hpp: - Updated any_pointer and manager classes to deal with member function pointers directly, so no allocation is required when using them. - Removed include of boost/mem_fn.hpp function_template.hpp: - Many macros that were in the functionN.hpp headers have been moved here and are now generated on-the-fly using BOOST_JOIN - Added invokers for pointers to member functions - Revised pointer to member function handling code to not perform any allocations/deallocations - Added guards so that multiple inclusion of function_template.hpp will only include its dependencies once. functionN.hpp: - Headers regenerated [SVN r11729]	2001-11-19 20:30:18 +00:00
Douglas Gregor	d37d210685	function_n_test.cpp: function_test.cpp: - Removed use of (previously existing) ability to use references for the first parameter to an unbound pointer-to-member function. Only pointer-like entities are allowed. [SVN r11728]	2001-11-19 20:19:23 +00:00
Douglas Gregor	11c56da46f	index.html: - Removed reference to BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS [SVN r11727]	2001-11-19 14:57:08 +00:00
Douglas Gregor	3f13d39604	function_base.hpp: function_template.hpp: - Removed implementation based on virtual functions. Such an implementation can't meet exception safety requirements made by the manager/invoker version. [SVN r11726]	2001-11-19 14:52:04 +00:00
Douglas Gregor	dd76ed757b	Removed question about member function pointers since they are now supported [SVN r11628]	2001-11-07 20:16:09 +00:00
Douglas Gregor	e5ff80fb52	Documented new feature in tutorial: automatic adaptation of pointers to member functions Updated reference documentation: - Adaptation of pointers to member functions - No longer lie about safe_bool - Added documentation for operator! - Defined "compatible" [SVN r11458]	2001-10-28 04:52:37 +00:00
Douglas Gregor	6bdc663932	String literals should be const [SVN r11457]	2001-10-28 04:04:26 +00:00
Douglas Gregor	3c5579ccbc	Removed function_cast() and .target_type() [SVN r11443]	2001-10-25 20:56:14 +00:00
Douglas Gregor	d7ac137669	Remove checks for function_cast and .target_type() [SVN r11442]	2001-10-25 20:55:56 +00:00
Douglas Gregor	e6011abb87	Added tests for member functions [SVN r11394]	2001-10-16 19:24:04 +00:00
Douglas Gregor	08d727df21	Added ability to handle member function pointers natively, e.g., boost::function<int, X*, int> f(&X::foo); [SVN r11393]	2001-10-16 19:23:37 +00:00
Douglas Gregor	07390a35e3	Check the const function_cast function [SVN r11364]	2001-10-08 13:55:55 +00:00
Douglas Gregor	e00d8f0afb	Fixes for MSVC [SVN r11363]	2001-10-08 13:49:02 +00:00
Douglas Gregor	a81c30d130	regression.cfg: Removed defarg_test.cpp entry [SVN r11362]	2001-10-08 13:34:00 +00:00
Douglas Gregor	4147c42599	defarg_test.cpp: removed (it is incorrect) function_n_test.cpp: function_test.cpp: Updated with tests of target_type() and casting [SVN r11361]	2001-10-08 13:33:14 +00:00
Douglas Gregor	1d4282c706	Added support for target_type() member function (returns an std::type_info of the underlying function object) and casting to retrieve the underyling target. [SVN r11360]	2001-10-08 13:32:24 +00:00
Douglas Gregor	62d3c6d426	Fix for BOOST_NO_STD_ALLOCATOR when std::allocator doesn't even exist [SVN r11349]	2001-10-06 20:28:27 +00:00
Darin Adler	a30aa907d2	Add a missing space. [SVN r11152]	2001-09-19 15:07:56 +00:00
Douglas Gregor	b240e7efca	Split default and mixin constructor into separate constructors (instead of using default value) because of MSVC 7.0b2 (Peter Dimov) [SVN r11139]	2001-09-18 14:48:51 +00:00
Beman Dawes	50fb80c253	Fix broken hyperlink [SVN r10896]	2001-08-19 15:08:33 +00:00