This commit was manufactured by cvs2svn to create branch

'python-v2-dev'. [SVN r14785]
function_base.hpp:
2002-08-12 13:35:54 +00:00 · 2002-08-09 14:34:23 +00:00 · 2002-08-06 14:20:08 +00:00 · 2002-08-05 15:07:34 +00:00 · 2002-08-05 15:05:57 +00:00 · 2002-08-05 15:05:34 +00:00
29 changed files with 2957 additions and 1637 deletions
--- a/doc/faq.html
+++ b/doc/faq.html
@ -5,7 +5,7 @@
  </head>
  <body bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080">
-<h1><IMG SRC="../../c++boost.gif" WIDTH="276" HEIGHT="86">boost::function Frequently Asked Questions</h1>
+<h1><IMG SRC="../../../c++boost.gif" WIDTH="276" HEIGHT="86">boost::function Frequently Asked Questions</h1>
 <h2>Q: I see void pointers; is this [mess] type safe?</h2>
 <p>Yes, <code>boost::function</code> is type safe even though it uses void pointers and pointers to functions returning void and taking no arguments. Essentially, all type information is encoded in the functions that manage and invoke function pointers and function objects. Only these functions are instantiated with the exact type that is pointed to by the void pointer or pointer to void function. The reason that both are required is that one may cast between void pointers and object pointers safely or between different types of function pointers (provided you don't invoke a function pointer with the wrong type). 
@ -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="index.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: Sun Jun 17 10:06:31 EDT 2001
+Last modified: Wed Nov  7 15:11:52 EST 2001
 <!-- hhmts end -->
  </body>
 </html>
--- a/doc/reference.html
+++ b/doc/reference.html
@ -0,0 +1,289 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
  <head>
    <title>Boost.Function Reference Manual</title>
  </head>
  <body bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080">
  <h1><IMG SRC="../../../c++boost.gif" WIDTH="276" HEIGHT="86">Boost.Function Reference Manual</h1>
 <h2><a name="header">Header <code>&lt;<a href="../../../boost/function.hpp">boost/function.hpp</a>&gt;</code> synopsis</a></h2>
 <p> Here <code><i>MAX_ARGS</i></code> is an implementation-defined constant that defines the maximum number of function arguments supported by Boost.Function and will be at least 10. The <code><i>MAX_ARGS</i></code> constant referred to in this document need not have any direct representation in the library.
 <pre>
 <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> 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>]
  <b>template</b>&lt;<b>typename</b> Signature,
           <b>typename</b> Arg1,
 	   <b>typename</b> Arg2,
           <i>...</i>
           <b>typename</b> Arg<i>N</i>,
 	   <b>typename</b> Policy    = empty_function_policy, <em>// Deprecated</em>
 	   <b>typename</b> Mixin     = empty_function_mixin, <em>// Deprecated</em>
 	   <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; <em>// <a href="#novoid">[1]</a></em>
    <b>typedef</b> Policy     policy_type; <em>// Deprecated</em>
    <b>typedef</b> Mixin      mixin_type; <em>// Deprecated</em>
    <b>typedef</b> Allocator  allocator_type;
    <b>typedef</b> Arg1 argument_type;        <i>// If N == 1</i>
    <b>typedef</b> Arg1 first_argument_type;  <i>// If N == 2</i>
    <b>typedef</b> Arg2 second_argument_type; <i>// If N == 2</i>
    <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>(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>=(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>; <em>// Deprecated</em>
    <a href="#functionN_target_set"><b>template</b>&lt;<b>typename</b> F&gt; <b>void</b> set(F)</a>; <em>// Deprecated</em>
    <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>;
    <i>// Invocation</i>
    <a href="#functionN_call_const">result_type <b>operator</b>()(Arg1 a1, Arg2 a2, <i>...</i>, Arg<i>N</i> a<i>N</i>) <b>const</b></a>;
  };
  <b>template</b>&lt;<b>typename</b> ResultType,
           <b>typename</b> Arg1,
 	   <b>typename</b> Arg2,
           <i>...</i>
 	   <b>typename</b> Arg<i>N</i>,
           <b>typename</b> Policy, <em>// Deprecated</em>
           <b>typename</b> Mixin, <em>// Deprecated</em>
           <b>typename</b> Allocator&gt;
  <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> Signature, <em>// Function type: ResultType (Arg1, Arg2, ..., Arg<em>N</em>)</em>
 	   <b>typename</b> Policy    = empty_function_policy, <em>// Deprecated</em>
 	   <b>typename</b> Mixin     = empty_function_mixin, <em>// Deprecated</em>
 	   <b>typename</b> Allocator = std::allocator&lt;function_base&gt; &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(<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<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>); <em>// Deprecated</em>
    <b>void</b> set(<b>const</b> function<i>N</i>&lt;ResultType, Arg1, Arg2, ..., Arg<i>N</i>&gt;<b>&amp;</b>); <em>// Deprecated</em>
    <b>template</b>&lt;<b>typename</b> F&gt; <b>void</b> set(F); <em>// Deprecated</em>
  };
  <b>template</b>&lt;<b>typename</b> Signature, <b>typename</b> Policy, <b>typename</b> Mixin, <b>typename</b> Allocator&gt;
  <b>void</b> <a href="#swap_function">swap</a>(function&lt;Signature, Policy, Mixin, Allocator&gt;<b>&amp;</b>,
            function&lt;Signature, Policy, Mixin, Allocator&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. 
 <p> <a name="empty"><code><b>bool</b> empty() <b>const</b></code></a>
 <ul>
  <li><b>Returns</b>: <code>true</code> if the function object has a target, <code>false</code> otherwise.</li>
  <li><b>Throws</b>: will not throw.</li>
 </ul>
 <p> <a name="bool"><code><b>operator</b> safe_bool() <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>: 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>
 <p> Class template <code>function<i>N</i></code> is actually a family of related classes <code>function0</code>, <code>function1</code>, etc., up to some implementation-defined maximum. In this context, <code><i>N</i></code> refers to the number of parameters and <code>f</code> refers to the implicit object parameter.
 <p> <a name="functionN_default"><code><b>explicit</b> function<i>N</i>(<b>const</b> Mixin<b>&amp;</b> = Mixin());</code></a>
 <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 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>(F g, <b>const</b> Mixin<b>&amp;</b> = Mixin());</code></a>
 <ul>
  <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>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>=(F g);</code></a>
 <ul>
  <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>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>
 <ul>
  <li><b>Effects</b>: <code><a href="#functionN_copy_assn">*this = g</a></code>.</li>
  <li><b>Note</b>: This function is deprecated and will be removed in future versions of Boost.Function. Please use the assignment operator instead.</li>
 </ul>
 <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>
  <li><b>Note</b>: This function is deprecated and will be removed in future versions of Boost.Function. Please use the assignment operator instead.</li>
 </ul>
 <p> <a name="functionN_swap"><code><b>void</b> swap(function<i>N</i><b>&amp;</b> g);</code></a>
 <ul>
  <li><b>Effects</b>: interchanges the targets of <code>f</code> and <code>g</code> and swaps the mixins of <code>f</code> and <code>g</code>.</li>
  <li><b>Throws</b>: will not throw.</li>
 </ul>
 <p> <a name="functionN_clear"><code><b>void</b> clear(); </code></a>
 <ul>
  <li><b>Effects</b>: If <code>!<a href="#empty">empty</a>()</code>, deallocates current target.</li>
  <li><b>Postconditions</b>: <code><a href="#empty">empty</a>()</code>.</li>
 </ul>
 <p> <a name="functionN_call_const"><code> result_type <b>operator</b>()(Arg1 a1, Arg2 a2, <i>...</i>, Arg<i>N</i> a<i>N</i>) <b>const</b>;</code></a>
 <ul>
  <li><b>Requires</b>: <code>!<a href="#empty">empty</a>()</code>.</li>
  <li><b>Effects</b>: <i>target</i> is the underlying function target. It is not <code><b>const</b></code> or <code><b>volatile</b></code> qualified.
    <ol>
      <li><code>policy_type policy;</code></li>
      <li><code>policy.precall(this);</code></li>
      <li><code><i>target</i>(a1, a2, <i>...</i>, a<i>N</i>);</code></li>
      <li><code>policy.postcall(this);</code></li>
    </ol>
  <li><b>Returns</b>: the value returned by <i>target</i>.</li>
  <li><b>Note</b>: invocation policies have been deprecated and will be removed in a later release.</li>
 </ul>
 <h2><a name="function">Class template <code>function</code></a></h2>
 <p> Class template <code>function</code> is a thin wrapper around the numbered class templates <code>function0</code>, <code>function1</code>, etc. It accepts up to <i>MAX_ARGS</i> arguments, but when passed <i>N</i> arguments it will derive from <code>function<i>N</i></code> specialized with the arguments it receives.
 <p> The semantics of all operations in class template <code>function</code> are equivalent to that of the underlying <code>function<i>N</i></code> object, although additional member functions are required to allow proper copy construction and copy assignment of <code>function</code> objects.
 <h2><a name="operations">Operations</a></h2>
 <p>
 <pre>
 <b>template</b>&lt;<b>typename</b> ResultType,
         <b>typename</b> Arg1,
 	 <b>typename</b> Arg2,
         <i>...</i>
 	 <b>typename</b> Arg<i>N</i>,
         <b>typename</b> Policy, <em>// Deprecated</em>
         <b>typename</b> Mixin, <em>// Deprecated</em>
         <b>typename</b> Allocator&gt;
 <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>
 </ul>
 <p>
 <pre>
 <b>template</b>&lt;<b>typename</b> Signature, <b>typename</b> Policy, <b>typename</b> Mixin, <b>typename</b> Allocator&gt;
 <b>void</b> <a name="swap_function">swap</a>(function&lt;Signature, Policy, Mixin, Allocator&gt;<b>&amp;</b> f,
          function&lt;Signature, 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>
 </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: Fri Jul 19 16:40:00 EDT 2002
 <!-- hhmts end -->
  </body>
 </html>
--- a/doc/tutorial.html
+++ b/doc/tutorial.html
@ -0,0 +1,258 @@
 <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
 <html>
  <head>
    <title>Boost.Function Tutorial</title>
  </head>
  <body bgcolor="#FFFFFF" text="#000000" link="#0000FF" vlink="#800080">
    <h1><IMG SRC="../../../c++boost.gif" WIDTH="276" HEIGHT="86">Boost.Function Tutorial</h1>
 <p> Boost.Function has two syntactical forms: the preferred form and the compatibility form. The preferred form fits more closely with the C++ language and reduces the number of separate template parameters that need to be considered, often improving readability; however, the preferred form is not supported on all platforms due to compiler bugs. The compatible form will work on all compilers supported by Boost.Function. Consult the table below to determine which syntactic form to use for your compiler.
    <center>
      <table border=1 cellspacing=1>
          <tr><th bgcolor="#008080">Preferred Syntax</th><th bgcolor="#008080">Compatible Syntax</th></tr>
          <tr>
            <td>
              <ul>
                <li>GNU C++ 2.95.x, 3.0.x, 3.1.x</li>
                <li>Comeau C++ 4.2.45.2</li>
                <li>SGI MIPSpro 7.3.0</li>
                <li>Intel C++ 5.0, 6.0</li>
                <li>Compaq's cxx 6.2</li>
              </ul>
            </td>
            <td>
              <ul>
                <li>Microsoft Visual C++ 6.0, 7.0</li>
                <li>Borland C++ 5.5.1</li>
                <li>Sun WorkShop 6 update 2 C++ 5.3</li>
                <li>Metrowerks CodeWarrior 8.1</li>
              </ul>
            </td>
          </tr>
      </table>
      </center>
 <p> If your compiler does not appear in this list, please try the preferred syntax and report your results to the Boost list so that we can keep this table up-to-date.
 <a name="preferred"><h2>Basic Usage</h2></a>
 <p> A function wrapper is defined simply by instantiating the <code>function</code> class template with the desired return type and argument types, formulated as a C++ function type. Any number of arguments may be supplied, up to some implementation-defined limit (10 is the default maximum). The following declares a function object wrapper <code>f</code> that takes two <code>int</code> parameters and returns a <code>float</code>:
 <center>
 <table border=1 cellspacing=1>
        <tr><th bgcolor="#008080">Preferred Syntax</th><th bgcolor="#008080">Compatible Syntax</th></tr>
        <tr>
          <td>
            <pre>
 boost::<a href="reference.html#function">function</a>&lt;float (int x, int y)&gt; f;
            </pre>
          </td>
          <td>
            <pre>
 boost::<a href="reference.html#functionN">function2</a>&lt;float, int, int&gt; f;
            </pre>
          </td>
        </tr>
 </table>
 </center>
 <p> By default, function object wrappers are empty, so we can create a 
 function object to assign to <code>f</code>:
 <pre>
 struct int_div { 
  float operator()(int x, int y) const { return ((float)x)/y; }; 
 };
 f = int_div();
 </pre>
 <p> Now we can use <code>f</code> to execute the underlying function object
 <code>int_div</code>:
 <pre>
 std::cout &lt;&lt; f(5, 3) &gt;&gt; std::endl;
 </pre>
 <p> We are free to assign any compatible function object to <code>f</code>. If <code>int_div</code> had been declared to take two <code>long</code> operands,
 the implicit conversions would have been applied to the arguments without any user interference. The only limit on the types of arguments is that they be CopyConstructible, so we can even use references and arrays:
 <center>
 <table border=1 cellspacing=1>
        <tr><th bgcolor="#008080">Preferred Syntax</th><th bgcolor="#008080">Compatible Syntax</th></tr>
          <tr>
            <td>
              <pre>
 boost::function&lt;void (int values[], int n, int&amp; sum, float&amp; avg)&gt; sum_avg;
              </pre>
            </td>
            <td>
              <pre>
 boost::function4&lt;void, int[], int, int&amp;, float&gt; sum_avg;
              </pre>
            </td>
          </tr>
 </table>
 </center>
 <pre>
 void do_sum_avg(int values[], int n, int& sum, float&amp; avg)
 {
  sum = 0;
  for (int i = 0; i &lt; n; i++)
    sum += values[i];
  avg = (float)sum / n;
 }
 sum_avg = &amp;do_sum_avg;
 </pre>
 <p> Invoking a function object wrapper that does not actually contain a function object is a precondition violation, much like trying to call through a null function pointer. We can check for an empty function object wrapper by querying its <code><a href="reference.html#empty">empty</a>()</code> method or, more succinctly, by using it in a boolean context: if it evaluates true, it contains a function object target, i.e.,
 <pre>
 if (f)
  std::cout &lt;&lt; f(5, 3) &lt;&lt; std::endl;
 else
  std::cout &lt;&lt; "f has no target, so it is unsafe to call" &lt;&lt; std::endl;
 </pre>
 <p> We can clear out a function target using the <code><a href="reference.html#functionN_clear">clear</a>()</code> member function.
 <h3>Free functions</h3>
 <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 = &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. 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:
 <center>
 <table border=1 cellspacing=1>
        <tr><th bgcolor="#008080">Preferred Syntax</th><th bgcolor="#008080">Compatible Syntax</th></tr>
          <tr>
            <td>
 <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>
            </td>
            <td>
 <pre>
 struct X {
  int foo(int);
 };
 boost::function2&lt;int, X*, int&gt; f;
 f = &amp;X::foo;
 X x;
 f(&amp;x, 5);
 </pre>
            </td>
          </tr>
 </table>
 </center>
 <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:
 <center>
 <table border=1 cellspacing=1>
        <tr><th bgcolor="#008080">Preferred Syntax</th><th bgcolor="#008080">Compatible Syntax</th></tr>
          <tr>
            <td>
 <pre>
  struct X {
    int foo(int);
  };
  boost::function&lt;int (int)&gt; f;
  X x;
  f = std::bind1st(std::mem_fun(&amp;X::foo), &amp;x);
  f(5); // Call x.foo(5)</pre>
            </td>
            <td>
 <pre>
  struct X {
    int foo(int);
  };
  boost::function1&lt;int, int&gt; f;
  X x;
  f = std::bind1st(std::mem_fun(&amp;X::foo), &amp;x);
  f(5); // Call x.foo(5)</pre>
            </td>
          </tr>
 </table>
 </center>
 </li>
  <li><a href="../../lambda/doc/index.html">The Boost.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. </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:
 <center>
 <table border=1 cellspacing=1>
        <tr><th bgcolor="#008080">Preferred Syntax</th><th bgcolor="#008080">Compatible Syntax</th></tr>
          <tr>
            <td>
 <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>
            </td>
            <td>
 <pre>
  stateful_type a_function_object;
  boost::function1&lt;int, int&gt; f;
  f = ref(a_function_object);
  boost::function1&lt;int, int&gt; f2(f);
 </pre>
            </td>
          </tr>
 </table>
 </center>
 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.
    <hr>
    <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: Mon Aug  5 11:07:17 EDT 2002
 <!-- hhmts end -->
  </body>
 </html>
--- a/test/defarg_test.cpp
+++ b/test/defarg_test.cpp
@ -1,4 +1,4 @@
-// Boost.Function library
+// Boost.Function library examples
 // Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
 //
@ -13,28 +13,26 @@
 // For more information, see http://www.boost.org
-#define BOOST_INCLUDE_MAIN
+#include <iostream>
 #include <boost/test/test_tools.hpp>
 #include <boost/function.hpp>
 #include <functional>
 #include <cassert>
 #include <string>
-using namespace std;
+struct X {
-using namespace boost;
+  X(int val) : value(val) {}
-static int sub_ints(int x = 0, int y = 0, int z = 0) { return x-y-z; }
+  int foo(int x) { return x * value; }
  int value;
 };
 static void
 test_two_args()
 {
  function<int, int, int> sub(&sub_ints);
  BOOST_TEST(sub(10, 2) == 8);
 }
 int
-test_main(int, char* [])
+main()
 {
-  test_two_args();
+  boost::function<int, int> f;
  X x(7);
  f = std::bind1st(std::mem_fun(&X::foo), &x);
  std::cout << f(5) << std::endl; // Call x.foo(5)
  return 0;
 }
--- a/example/int_div.cpp
+++ b/example/int_div.cpp
@ -0,0 +1,32 @@
 // Boost.Function library examples
 // 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
 #include <iostream>
 #include <boost/function.hpp>
 struct int_div { 
  float operator()(int x, int y) const { return ((float)x)/y; }; 
 };
 int
 main()
 {
  boost::function<float, int, int> f;
  f = int_div();
  std::cout << f(5, 3) << std::endl; // 1.66667
  return 0;
 }
--- a/example/sum_avg.cpp
+++ b/example/sum_avg.cpp
@ -0,0 +1,44 @@
 // Boost.Function library examples
 // 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
 #include <iostream>
 #include <boost/function.hpp>
 void do_sum_avg(int values[], int n, int& sum, float& avg)
 {
  sum = 0;
  for (int i = 0; i < n; i++)
    sum += values[i];
  avg = (float)sum / n;
 }
 int
 main()
 {
  // 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;
  int values[5] = { 1, 1, 2, 3, 5 };
  int sum;
  float avg;
  sum_avg(values, 5, sum, avg);
  std::cout << "sum = " << sum << std::endl;
  std::cout << "avg = " << avg << std::endl;
  return 0;
 }
--- 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.
@ -20,6 +20,10 @@
 #define BOOST_FUNCTION_HPP
 #include <boost/function/function_base.hpp>
 #include <boost/type_traits/function_traits.hpp>
 #include <boost/type_traits/same_traits.hpp>
 #include <boost/type_traits/transform_traits.hpp>
 #include <boost/type_traits/ice.hpp>
 #include <boost/function/function0.hpp>
 #include <boost/function/function1.hpp>
 #include <boost/function/function2.hpp>
@ -32,6 +36,11 @@
 #include <boost/function/function9.hpp>
 #include <boost/function/function10.hpp>
 // Don't compile any of this code if we've asked not to include the deprecated
 // syntax and we don't have partial specialization, because none of this code
 // can work.
 #if !defined (BOOST_FUNCTION_NO_DEPRECATED) || !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
 namespace boost {
  namespace detail {
    namespace function {
@ -53,13 +62,19 @@ namespace boost {
          typename T8,
          typename T9,
          typename T10,
-          typename Policy = empty_function_policy,
+#ifndef BOOST_FUNCTION_NO_DEPRECATED
-          typename Mixin = empty_function_mixin,
+          typename Policy,
-          typename Allocator = std::allocator<function_base>
+          typename Mixin,
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
          typename Allocator
        >
        struct params
        {
-          typedef function0<R, Policy, Mixin, Allocator> type;
+          typedef function0<R, 
 #ifndef BOOST_FUNCTION_NO_DEPRECATED
                            Policy, Mixin, 
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
                            Allocator> type;
        };
      };
@ -78,13 +93,19 @@ namespace boost {
          typename T8,
          typename T9,
          typename T10,
-          typename Policy = empty_function_policy,
+#ifndef BOOST_FUNCTION_NO_DEPRECATED
-          typename Mixin = empty_function_mixin,
+          typename Policy,
-          typename Allocator = std::allocator<function_base>
+          typename Mixin,
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
          typename Allocator
        >
        struct params
        {
-          typedef function1<R, T1, Policy, Mixin, Allocator> type;
+          typedef function1<R, T1, 
 #ifndef BOOST_FUNCTION_NO_DEPRECATED
                            Policy, Mixin, 
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
                            Allocator> type;
        };
      };
@ -103,13 +124,19 @@ namespace boost {
          typename T8,
          typename T9,
          typename T10,
-          typename Policy = empty_function_policy,
+#ifndef BOOST_FUNCTION_NO_DEPRECATED
-          typename Mixin = empty_function_mixin,
+          typename Policy,
-          typename Allocator = std::allocator<function_base>
+          typename Mixin,
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
          typename Allocator
        >
        struct params
        {
-          typedef function2<R, T1, T2, Policy, Mixin, Allocator> type;
+          typedef function2<R, T1, T2, 
 #ifndef BOOST_FUNCTION_NO_DEPRECATED
                            Policy, Mixin, 
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
                            Allocator> type;
        };
      };
@ -128,13 +155,19 @@ namespace boost {
          typename T8,
          typename T9,
          typename T10,
-          typename Policy = empty_function_policy,
+#ifndef BOOST_FUNCTION_NO_DEPRECATED
-          typename Mixin = empty_function_mixin,
+          typename Policy,
-          typename Allocator = std::allocator<function_base>
+          typename Mixin,
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
          typename Allocator
        >
        struct params
        {
-          typedef function3<R, T1, T2, T3, Policy, Mixin, Allocator> type;
+          typedef function3<R, T1, T2, T3, 
 #ifndef BOOST_FUNCTION_NO_DEPRECATED
                            Policy, Mixin, 
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
                            Allocator> type;
        };
      };
@ -153,13 +186,19 @@ namespace boost {
          typename T8,
          typename T9,
          typename T10,
-          typename Policy = empty_function_policy,
+#ifndef BOOST_FUNCTION_NO_DEPRECATED
-          typename Mixin = empty_function_mixin,
+          typename Policy,
-          typename Allocator = std::allocator<function_base>
+          typename Mixin,
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
          typename Allocator
        >
        struct params
        {
-          typedef function4<R, T1, T2, T3, T4, Policy, Mixin, Allocator> type;
+          typedef function4<R, T1, T2, T3, T4, 
 #ifndef BOOST_FUNCTION_NO_DEPRECATED
                            Policy, Mixin, 
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
                            Allocator> type;
        };
      };
@ -178,13 +217,19 @@ namespace boost {
          typename T8,
          typename T9,
          typename T10,
-          typename Policy = empty_function_policy,
+#ifndef BOOST_FUNCTION_NO_DEPRECATED
-          typename Mixin = empty_function_mixin,
+          typename Policy,
-          typename Allocator = std::allocator<function_base>
+          typename Mixin,
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
          typename Allocator
        >
        struct params
        {
-          typedef function5<R, T1, T2, T3, T4, T5, Policy, Mixin, Allocator> 
+          typedef function5<R, T1, T2, T3, T4, T5, 
 #ifndef BOOST_FUNCTION_NO_DEPRECATED
                            Policy, Mixin, 
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
                            Allocator> 
          type;
        };
      };
@ -204,13 +249,19 @@ namespace boost {
          typename T8,
          typename T9,
          typename T10,
-          typename Policy = empty_function_policy,
+#ifndef BOOST_FUNCTION_NO_DEPRECATED
-          typename Mixin = empty_function_mixin,
+          typename Policy,
-          typename Allocator = std::allocator<function_base>
+          typename Mixin,
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
          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, 
 #ifndef BOOST_FUNCTION_NO_DEPRECATED
                            Policy, Mixin, 
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
                            Allocator>
          type;
        };
      };
@ -230,13 +281,18 @@ namespace boost {
          typename T8,
          typename T9,
          typename T10,
-          typename Policy = empty_function_policy,
+#ifndef BOOST_FUNCTION_NO_DEPRECATED
-          typename Mixin = empty_function_mixin,
+          typename Policy,
-          typename Allocator = std::allocator<function_base>
+          typename Mixin,
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
          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, 
 #ifndef BOOST_FUNCTION_NO_DEPRECATED
                            Policy, Mixin, 
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
                            Allocator> type;
        };
      };
@ -256,13 +312,18 @@ namespace boost {
          typename T8,
          typename T9,
          typename T10,
-          typename Policy = empty_function_policy,
+#ifndef BOOST_FUNCTION_NO_DEPRECATED
-          typename Mixin = empty_function_mixin,
+          typename Policy,
-          typename Allocator = std::allocator<function_base>
+          typename Mixin,
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
          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, 
 #ifndef BOOST_FUNCTION_NO_DEPRECATED
                            Policy, Mixin, 
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
                            Allocator> type;
        };
      };
@ -282,14 +343,19 @@ namespace boost {
          typename T8,
          typename T9,
          typename T10,
-          typename Policy = empty_function_policy,
+#ifndef BOOST_FUNCTION_NO_DEPRECATED
-          typename Mixin = empty_function_mixin,
+          typename Policy,
-          typename Allocator = std::allocator<function_base>
+          typename Mixin,
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
          typename Allocator
        >
        struct params
        {
-          typedef function9<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, Policy, 
+          typedef function9<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, 
-                            Mixin, Allocator> type;
+#ifndef BOOST_FUNCTION_NO_DEPRECATED
                            Policy, Mixin, 
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
                            Allocator> type;
        };
      };
@ -308,65 +374,366 @@ namespace boost {
          typename T8,
          typename T9,
          typename T10,
-          typename Policy = empty_function_policy,
+#ifndef BOOST_FUNCTION_NO_DEPRECATED
-          typename Mixin = empty_function_mixin,
+          typename Policy,
-          typename Allocator = std::allocator<function_base>
+          typename Mixin,
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
          typename Allocator
        >
        struct params
        {
          typedef function10<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, 
-                             Policy, Mixin, Allocator> type;
+#ifndef BOOST_FUNCTION_NO_DEPRECATED
                             Policy, Mixin, 
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
                             Allocator> type;
        };
      };
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
      template<bool GetIt, typename Traits> 
      struct get_arg1_type
      {
        typedef unusable type;
      };
      template<typename Traits> 
      struct get_arg1_type<true, Traits>
      {
        typedef typename Traits::arg1_type type;
      };
      template<bool GetIt, typename Traits> 
      struct get_arg2_type
      {
        typedef unusable type;
      };
      template<typename Traits> 
      struct get_arg2_type<true, Traits>
      {
        typedef typename Traits::arg2_type type;
      };
      template<bool GetIt, typename Traits> 
      struct get_arg3_type
      {
        typedef unusable type;
      };
      template<typename Traits> 
      struct get_arg3_type<true, Traits>
      {
        typedef typename Traits::arg3_type type;
      };
      template<bool GetIt, typename Traits> 
      struct get_arg4_type
      {
        typedef unusable type;
      };
      template<typename Traits> 
      struct get_arg4_type<true, Traits>
      {
        typedef typename Traits::arg4_type type;
      };
      template<bool GetIt, typename Traits> 
      struct get_arg5_type
      {
        typedef unusable type;
      };
      template<typename Traits> 
      struct get_arg5_type<true, Traits>
      {
        typedef typename Traits::arg5_type type;
      };
      template<bool GetIt, typename Traits> 
      struct get_arg6_type
      {
        typedef unusable type;
      };
      template<typename Traits> 
      struct get_arg6_type<true, Traits>
      {
        typedef typename Traits::arg6_type type;
      };
      template<bool GetIt, typename Traits> 
      struct get_arg7_type
      {
        typedef unusable type;
      };
      template<typename Traits> 
      struct get_arg7_type<true, Traits>
      {
        typedef typename Traits::arg7_type type;
      };
      template<bool GetIt, typename Traits> 
      struct get_arg8_type
      {
        typedef unusable type;
      };
      template<typename Traits> 
      struct get_arg8_type<true, Traits>
      {
        typedef typename Traits::arg8_type type;
      };
      template<bool GetIt, typename Traits> 
      struct get_arg9_type
      {
        typedef unusable type;
      };
      template<typename Traits> 
      struct get_arg9_type<true, Traits>
      {
        typedef typename Traits::arg9_type type;
      };
      template<bool GetIt, typename Traits> 
      struct get_arg10_type
      {
        typedef unusable type;
      };
      template<typename Traits> 
      struct get_arg10_type<true, Traits>
      {
        typedef typename Traits::arg10_type type;
      };
      template<int X, int Y> 
      struct gte
      {
        BOOST_STATIC_CONSTANT(bool, value = (X >= Y));
      };
      template<bool IsFunction,
               typename InR, 
               typename InT1, 
               typename InT2, 
               typename InT3, 
               typename InT4,
               typename InT5, 
               typename InT6, 
               typename InT7, 
               typename InT8, 
               typename InT9,
               typename InT10,
 #ifndef BOOST_FUNCTION_NO_DEPRECATED
               typename InPolicy,
               typename InMixin,
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
               typename InAllocator>
      struct maybe_decode_function_args
      {
        typedef function_traits<InR> traits;
        typedef typename traits::result_type R;
        typedef typename get_arg1_type<(gte<(traits::arity), 1>::value), 
                                       traits>::type T1;
        typedef typename get_arg2_type<(gte<(traits::arity), 2>::value), 
                                       traits>::type T2;
        typedef typename get_arg3_type<(gte<(traits::arity), 3>::value), 
                                       traits>::type T3;
        typedef typename get_arg4_type<(gte<(traits::arity), 4>::value), 
                                       traits>::type T4;
        typedef typename get_arg5_type<(gte<(traits::arity), 5>::value), 
                                       traits>::type T5;
        typedef typename get_arg6_type<(gte<(traits::arity), 6>::value), 
                                       traits>::type T6;
        typedef typename get_arg7_type<(gte<(traits::arity), 7>::value), 
                                       traits>::type T7;
        typedef typename get_arg8_type<(gte<(traits::arity), 8>::value), 
                                       traits>::type T8;
        typedef typename get_arg9_type<(gte<(traits::arity), 9>::value), 
                                       traits>::type T9;
        typedef typename get_arg10_type<(gte<(traits::arity), 10>::value), 
                                        traits>::type T10;
 #ifndef BOOST_FUNCTION_NO_DEPRECATED
        typedef typename ct_if<(is_same<InT1, unusable>::value),
                               empty_function_policy,
                               InT1>::type Policy;
        typedef typename ct_if<(is_same<InT2, unusable>::value),
                               empty_function_mixin,
                               InT2>::type Mixin;
        typedef typename ct_if<(is_same<InT3, unusable>::value),
                               std::allocator<function_base>,
                               InT3>::type Allocator;
 #else
        typedef typename ct_if<(is_same<InT1, unusable>::value),
                               std::allocator<function_base>,
                               InT1>::type Allocator;
 #endif // BOOST_FUNCTION_NO_DEPRECATED
      };
 #ifndef BOOST_FUNCTION_NO_DEPRECATED
      template<typename InR, 
               typename InT1, 
               typename InT2, 
               typename InT3, 
               typename InT4,
               typename InT5, 
               typename InT6, 
               typename InT7, 
               typename InT8, 
               typename InT9,
               typename InT10,
 #ifndef BOOST_FUNCTION_NO_DEPRECATED
               typename InPolicy,
               typename InMixin,
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
               typename InAllocator>
      struct maybe_decode_function_args<false, InR, InT1, InT2, InT3, InT4,
                                        InT5, InT6, InT7, InT8, InT9, InT10,
 #ifndef BOOST_FUNCTION_NO_DEPRECATED
                                        InPolicy, InMixin,
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED 
                                        InAllocator>
      {
        // Not a function, so just map the types directly
        typedef InR R;
        typedef InT1 T1;
        typedef InT2 T2;
        typedef InT3 T3;
        typedef InT4 T4;
        typedef InT5 T5;
        typedef InT6 T6;
        typedef InT7 T7;
        typedef InT8 T8;
        typedef InT9 T9;
        typedef InT10 T10;
 #ifndef BOOST_FUNCTION_NO_DEPRECATED
        typedef InPolicy Policy;
        typedef InMixin Mixin;
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
        typedef InAllocator Allocator;
      };
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
 #endif // ndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
      template<
-        typename R, 
+        typename InR, 
-        typename T1, 
+        typename InT1, 
-        typename T2, 
+        typename InT2, 
-        typename T3, 
+        typename InT3, 
-        typename T4,
+        typename InT4,
-        typename T5, 
+        typename InT5, 
-        typename T6, 
+        typename InT6, 
-        typename T7, 
+        typename InT7, 
-        typename T8, 
+        typename InT8, 
-        typename T9,
+        typename InT9,
-        typename T10,
+        typename InT10,
-        typename Policy = empty_function_policy,
+        typename InPolicy = empty_function_policy,
-        typename Mixin = empty_function_mixin,
+        typename InMixin = empty_function_mixin,
-        typename Allocator = std::allocator<function_base> 
+        typename InAllocator = std::allocator<function_base> 
      >
      struct get_function_impl
      {
 #ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
        typedef maybe_decode_function_args<(is_function<InR>::value),
                                           InR, InT1, InT2, InT3, InT4, InT5,
                                           InT6, InT7, InT8, InT9, InT10,
 #ifndef BOOST_FUNCTION_NO_DEPRECATED
                                           InPolicy, InMixin, 
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
                                           InAllocator> decoder;
        typedef typename decoder::R R;
        typedef typename decoder::T1 T1;
        typedef typename decoder::T2 T2;
        typedef typename decoder::T3 T3;
        typedef typename decoder::T4 T4;
        typedef typename decoder::T5 T5;
        typedef typename decoder::T6 T6;
        typedef typename decoder::T7 T7;
        typedef typename decoder::T8 T8;
        typedef typename decoder::T9 T9;
        typedef typename decoder::T10 T10;
 #ifndef BOOST_FUNCTION_NO_DEPRECATED
        typedef typename decoder::Policy Policy;
        typedef typename decoder::Mixin Mixin;
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
        typedef typename decoder::Allocator Allocator;
 #else
        typedef InR R;
        typedef InT1 T1;
        typedef InT2 T2;
        typedef InT3 T3;
        typedef InT4 T4;
        typedef InT5 T5;
        typedef InT6 T6;
        typedef InT7 T7;
        typedef InT8 T8;
        typedef InT9 T9;
        typedef InT10 T10;
        typedef InPolicy Policy;
        typedef InMixin Mixin;
        typedef InAllocator Allocator;
 #endif // def BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
        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
+#ifndef BOOST_FUNCTION_NO_DEPRECATED
                             Policy, Mixin, 
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
                             Allocator>::type
        type;
      };
 #ifndef BOOST_FUNCTION_NO_DEPRECATED
  template<
-    typename R, 
+    typename InR, 
-    typename T1, 
+    typename InT1, 
-    typename T2, 
+    typename InT2, 
-    typename T3, 
+    typename InT3, 
-    typename T4,
+    typename InT4,
-    typename T5, 
+    typename InT5, 
-    typename T6, 
+    typename InT6, 
-    typename T7, 
+    typename InT7, 
-    typename T8, 
+    typename InT8, 
-    typename T9,
+    typename InT9,
-    typename T10,
+    typename InT10,
-    typename MyPolicy = empty_function_policy,
+    typename InMyPolicy = empty_function_policy,
-    typename MyMixin = empty_function_mixin,
+    typename InMyMixin = empty_function_mixin,
-    typename MyAllocator = std::allocator<function_base> 
+    typename InMyAllocator = std::allocator<function_base> 
  >
-  struct function_traits_builder
+  class function_traits_builder
  {
-    typedef typename get_function_impl<R, T1, T2, T3, T4, T5, T6, T7, 
+    typedef get_function_impl<InR, InT1, InT2, InT3, InT4, InT5, InT6, InT7, 
-                                       T8, T9, T10, MyPolicy, MyMixin, 
+                              InT8, InT9, InT10, InMyPolicy, InMyMixin, 
-                                       MyAllocator>::type
+                              InMyAllocator>
-      type;
+      impl;
    typedef typename impl::R MyR;
    typedef typename impl::T1 MyT1;
    typedef typename impl::T2 MyT2;
    typedef typename impl::T3 MyT3;
    typedef typename impl::T4 MyT4;
    typedef typename impl::T5 MyT5;
    typedef typename impl::T6 MyT6;
    typedef typename impl::T7 MyT7;
    typedef typename impl::T8 MyT8;
    typedef typename impl::T9 MyT9;
    typedef typename impl::T10 MyT10;
    typedef typename impl::Policy MyPolicy;
    typedef typename impl::Mixin MyMixin;
    typedef typename impl::Allocator MyAllocator;
  public:
    typedef typename impl::type type;
    typedef MyPolicy    policy_type;
    typedef MyMixin     mixin_type;
    typedef MyAllocator allocator_type;
@ -374,28 +741,28 @@ namespace boost {
 #ifndef BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
    template<typename Policy>
    struct policy : 
-        public function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7, T8, T9,
+        public function_traits_builder<MyR, MyT1, MyT2, MyT3, MyT4, MyT5, MyT6,
-                                       T10, Policy, mixin_type, 
+                                       MyT7, MyT8, MyT9, MyT10, Policy, 
-                                       allocator_type> {};
+                                       mixin_type, allocator_type> {};
    template<typename Mixin>
    struct mixin : 
-        public function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7, T8, T9,
+        public function_traits_builder<MyR, MyT1, MyT2, MyT3, MyT4, MyT5, MyT6,
-                                       T10, policy_type, Mixin, 
+                                       MyT7, MyT8, MyT9, MyT10, policy_type, 
-                                       allocator_type> {};
+                                       Mixin, allocator_type> {};
    template<typename Allocator>
    struct allocator : 
-        public function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7, T8, T9,
+        public function_traits_builder<MyR, MyT1, MyT2, MyT3, MyT4, MyT5, MyT6,
-                                       T10, policy_type, mixin_type, 
+                                       MyT7, MyT8, MyT9, MyT10, policy_type, 
-                                       Allocator> {};
+                                       mixin_type, Allocator> {};
 #else
    template<typename Policy>
    struct policy 
    {
-      typedef typename function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7,
+      typedef typename function_traits_builder<MyR, MyT1, MyT2, MyT3, MyT4, 
-                                               T8, T9, T10, Policy, 
+                                               MyT5, MyT6, MyT7, MyT8, MyT9, 
-                                               mixin_type, 
+                                               MyT10, Policy, mixin_type, 
                                               allocator_type>::type
        type;
    };
@ -403,8 +770,9 @@ namespace boost {
    template<typename Mixin>
    struct mixin
    {
-      typedef typename function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7,
+      typedef typename function_traits_builder<MyR, MyT1, MyT2, MyT3, MyT4, 
-                                               T8, T9, T10, policy_type, Mixin,
+                                               MyT5, MyT6, MyT7, MyT8, MyT9, 
                                               MyT10, policy_type, Mixin,
                                               allocator_type>::type
        type;
    };
@ -412,14 +780,15 @@ namespace boost {
    template<typename Allocator>
    struct allocator
    {
-      typedef typename function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7,
+      typedef typename function_traits_builder<MyR, MyT1, MyT2, MyT3, MyT4, 
-                                               T8, T9, T10, policy_type, 
+                                               MyT5, MyT6, MyT7, MyT8, MyT9, 
-                                               mixin_type, Allocator>::type
+                                               MyT10, policy_type, mixin_type,
                                               Allocator>::type
        type;
    };
-#endif
+#endif // ndef NO_DEPENDENT_NESTED_DERIVATIONS
  };
-
+#endif // ndef BOOST_FUNCTION_NO_DEPRECATED
    } // end namespace function
  } // end namespace detail
@ -438,9 +807,11 @@ namespace boost {
  >
  class function :
    public detail::function::get_function_impl<R, T1, T2, T3, T4, T5, T6, T7, 
-                                               T8, T9, T10>::type,
+                                               T8, T9, T10>::type
-    public detail::function::function_traits_builder<R, T1, T2, T3, T4, T5, T6,
+#ifndef BOOST_FUNCTION_NO_DEPRECATED
-                                                     T7, T8, T9, T10>
+    , public detail::function::function_traits_builder<R, T1, T2, T3, T4, T5, 
                                                       T6, T7, T8, T9, T10>
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
  {
    typedef typename detail::function::get_function_impl<R, T1, T2, T3, T4, T5,
                                                         T6, T7, T8, T9, T10
@ -448,74 +819,62 @@ namespace boost {
      base_type;
  public:
 #ifndef BOOST_FUNCTION_NO_DEPRECATED
    typedef typename base_type::policy_type policy_type;
    typedef typename base_type::mixin_type mixin_type;
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
    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__
+    function(const self_type& f) : base_type(static_cast<const base_type&>(f)){}
    template<typename Functor>
    function(Functor* f) : base_type(f) {}
 #endif // __BORLANDC__
    function(const function& 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)
    {
-      this->assign_to(f);
+      self_type(f).swap(*this);
      return *this;
    }
-#ifdef __BORLANDC__
+    self_type& operator=(const base_type& f)
    template<typename Functor>
    function& operator=(Functor* f)
    {
-      this->assign_to(f);
+      self_type(f).swap(*this);
      return *this;
    }
 #endif // __BORLANDC__
    function& operator=(const base_type& f)
    {
      this->assign_to_own(f);
      return *this;
    }
-    function& operator=(const function& f)                                  
+    self_type& operator=(const self_type& f)
    {   
-      this->assign_to_own(f);
+      self_type(f).swap(*this);
-      return *this;                                                         
+      return *this;
-    }                                                           
+    }
 #ifndef BOOST_FUNCTION_NO_DEPRECATED
    template<typename Functor>
-    void set(const Functor& f)
+    BOOST_FUNCTION_DEPRECATED_PRE 
        void set(Functor BOOST_FUNCTION_TARGET_FIX(const &) f) 
    {
-      this->assign_to(f);
+      BOOST_FUNCTION_DEPRECATED_INNER
      self_type(f).swap(*this);
    }
-#ifdef __BORLANDC__
+    BOOST_FUNCTION_DEPRECATED_PRE
-    template<typename Functor>
+    void set(const base_type& f) 
    void set(Functor* f)
    {
-      this->assign_to(f);
+      BOOST_FUNCTION_DEPRECATED_INNER
-    }
+      self_type(f).swap(*this);
 #endif // __BORLANDC__
    void set(const base_type& f)
    {
      this->assign_to_own(f);
    }
-    void set(const function& f)                             
+    BOOST_FUNCTION_DEPRECATED_PRE
    void set(const self_type& f)                             
    {
-      this->assign_to_own(f);
+      BOOST_FUNCTION_DEPRECATED_INNER
      self_type(f).swap(*this);
    }   
 #endif // ndef BOOST_FUNCTION_NO_DEPRECATED
  };
  template<typename R,
@ -534,6 +893,8 @@ namespace boost {
  {
    f1.swap(f2);
  }
-}
+} // end namespace boost
 #endif // !no deprecated || !no partial specialization
 #endif
--- 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
+#ifndef BOOST_FUNCTION_FUNCTION0_HEADER
-#define BOOST_FUNCTION0_HPP
+#define BOOST_FUNCTION_FUNCTION0_HEADER
 #include <boost/function/function_base.hpp>
 #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_NOT_0_PARMS 
-#define BOOST_FUNCTION_BASE function0_base
+#define BOOST_FUNCTION_NOT_0_ARGS 
 #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
 #include <boost/function/function_template.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#undef BOOST_FUNCTION_NOT_0_ARGS
-#undef BOOST_FUNCTION_COMMA
+#undef BOOST_FUNCTION_NOT_0_PARMS
 #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_ARGS
-#undef BOOST_FUNCTION_FUNCTION
+#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_BASE
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_INVOKER_BASE
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_NUM_ARGS
 #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
-#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
+#ifndef BOOST_FUNCTION_FUNCTION1_HEADER
-#define BOOST_FUNCTION1_HPP
+#define BOOST_FUNCTION_FUNCTION1_HEADER
 #include <boost/function/function_base.hpp>
 #define BOOST_FUNCTION_NUM_ARGS 1
-#define BOOST_FUNCTION_COMMA ,
+#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1
+#define BOOST_FUNCTION_TEMPLATE_ARGS T0
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1
+#define BOOST_FUNCTION_PARMS T0 a0
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1
+#define BOOST_FUNCTION_ARGS a0
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1
+#define BOOST_FUNCTION_NOT_0_PARMS 
-#define BOOST_FUNCTION_PARMS T1 a1
+#define BOOST_FUNCTION_NOT_0_ARGS 
 #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
 #include <boost/function/function_template.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#undef BOOST_FUNCTION_NOT_0_ARGS
-#undef BOOST_FUNCTION_COMMA
+#undef BOOST_FUNCTION_NOT_0_PARMS
 #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_ARGS
-#undef BOOST_FUNCTION_FUNCTION
+#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_BASE
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_INVOKER_BASE
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_NUM_ARGS
 #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
-#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
+#ifndef BOOST_FUNCTION_FUNCTION10_HEADER
-#define BOOST_FUNCTION10_HPP
+#define BOOST_FUNCTION_FUNCTION10_HEADER
 #include <boost/function/function_base.hpp>
 #define BOOST_FUNCTION_NUM_ARGS 10
-#define BOOST_FUNCTION_COMMA ,
+#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_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 T0, T1, T2, T3, T4, T5, T6, T7, T8, T9
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1, T2, T3, T4, T5, T6, T7, T8, T9, T10
+#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_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_ARGS a0, a1, a2, a3, a4, a5, a6, a7, a8, a9
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2, OtherT3, OtherT4, OtherT5, OtherT6, OtherT7, OtherT8, OtherT9, OtherT10
+#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_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7, T8 a8, T9 a9, T10 a10
+#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3, a4, a5, a6, a7, a8, a9
 #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
 #include <boost/function/function_template.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#undef BOOST_FUNCTION_NOT_0_ARGS
-#undef BOOST_FUNCTION_COMMA
+#undef BOOST_FUNCTION_NOT_0_PARMS
 #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_ARGS
-#undef BOOST_FUNCTION_FUNCTION
+#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_BASE
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_INVOKER_BASE
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_NUM_ARGS
 #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
-#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
+#ifndef BOOST_FUNCTION_FUNCTION2_HEADER
-#define BOOST_FUNCTION2_HPP
+#define BOOST_FUNCTION_FUNCTION2_HEADER
 #include <boost/function/function_base.hpp>
 #define BOOST_FUNCTION_NUM_ARGS 2
-#define BOOST_FUNCTION_COMMA ,
+#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1, typename T2
+#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1, T2
+#define BOOST_FUNCTION_PARMS T0 a0, T1 a1
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1, typename OtherT2
+#define BOOST_FUNCTION_ARGS a0, a1
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2
+#define BOOST_FUNCTION_NOT_0_PARMS T1 a1
-#define BOOST_FUNCTION_PARMS T1 a1, T2 a2
+#define BOOST_FUNCTION_NOT_0_ARGS a1
 #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
 #include <boost/function/function_template.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#undef BOOST_FUNCTION_NOT_0_ARGS
-#undef BOOST_FUNCTION_COMMA
+#undef BOOST_FUNCTION_NOT_0_PARMS
 #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_ARGS
-#undef BOOST_FUNCTION_FUNCTION
+#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_BASE
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_INVOKER_BASE
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_NUM_ARGS
 #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
-#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
+#ifndef BOOST_FUNCTION_FUNCTION3_HEADER
-#define BOOST_FUNCTION3_HPP
+#define BOOST_FUNCTION_FUNCTION3_HEADER
 #include <boost/function/function_base.hpp>
 #define BOOST_FUNCTION_NUM_ARGS 3
-#define BOOST_FUNCTION_COMMA ,
+#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1, typename T2, typename T3
+#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1, T2, T3
+#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1, typename OtherT2, typename OtherT3
+#define BOOST_FUNCTION_ARGS a0, a1, a2
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2, OtherT3
+#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2
-#define BOOST_FUNCTION_PARMS T1 a1, T2 a2, T3 a3
+#define BOOST_FUNCTION_NOT_0_ARGS a1, a2
 #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
 #include <boost/function/function_template.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#undef BOOST_FUNCTION_NOT_0_ARGS
-#undef BOOST_FUNCTION_COMMA
+#undef BOOST_FUNCTION_NOT_0_PARMS
 #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_ARGS
-#undef BOOST_FUNCTION_FUNCTION
+#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_BASE
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_INVOKER_BASE
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_NUM_ARGS
 #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
-#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
+#ifndef BOOST_FUNCTION_FUNCTION4_HEADER
-#define BOOST_FUNCTION4_HPP
+#define BOOST_FUNCTION_FUNCTION4_HEADER
 #include <boost/function/function_base.hpp>
 #define BOOST_FUNCTION_NUM_ARGS 4
-#define BOOST_FUNCTION_COMMA ,
+#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1, typename T2, typename T3, typename T4
+#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2, T3
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1, T2, T3, T4
+#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2, T3 a3
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1, typename OtherT2, typename OtherT3, typename OtherT4
+#define BOOST_FUNCTION_ARGS a0, a1, a2, a3
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2, OtherT3, OtherT4
+#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3
-#define BOOST_FUNCTION_PARMS T1 a1, T2 a2, T3 a3, T4 a4
+#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3
 #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
 #include <boost/function/function_template.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#undef BOOST_FUNCTION_NOT_0_ARGS
-#undef BOOST_FUNCTION_COMMA
+#undef BOOST_FUNCTION_NOT_0_PARMS
 #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_ARGS
-#undef BOOST_FUNCTION_FUNCTION
+#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_BASE
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_INVOKER_BASE
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_NUM_ARGS
 #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
-#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
+#ifndef BOOST_FUNCTION_FUNCTION5_HEADER
-#define BOOST_FUNCTION5_HPP
+#define BOOST_FUNCTION_FUNCTION5_HEADER
 #include <boost/function/function_base.hpp>
 #define BOOST_FUNCTION_NUM_ARGS 5
-#define BOOST_FUNCTION_COMMA ,
+#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3, typename T4
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1, typename T2, typename T3, typename T4, typename T5
+#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2, T3, T4
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1, T2, T3, T4, T5
+#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2, T3 a3, T4 a4
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1, typename OtherT2, typename OtherT3, typename OtherT4, typename OtherT5
+#define BOOST_FUNCTION_ARGS a0, a1, a2, a3, a4
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2, OtherT3, OtherT4, OtherT5
+#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3, T4 a4
-#define BOOST_FUNCTION_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5
+#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3, a4
 #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
 #include <boost/function/function_template.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#undef BOOST_FUNCTION_NOT_0_ARGS
-#undef BOOST_FUNCTION_COMMA
+#undef BOOST_FUNCTION_NOT_0_PARMS
 #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_ARGS
-#undef BOOST_FUNCTION_FUNCTION
+#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_BASE
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_INVOKER_BASE
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_NUM_ARGS
 #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
-#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
+#ifndef BOOST_FUNCTION_FUNCTION6_HEADER
-#define BOOST_FUNCTION6_HPP
+#define BOOST_FUNCTION_FUNCTION6_HEADER
 #include <boost/function/function_base.hpp>
 #define BOOST_FUNCTION_NUM_ARGS 6
-#define BOOST_FUNCTION_COMMA ,
+#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3, typename T4, typename T5
-#define BOOST_FUNCTION_TEMPLATE_PARMS typename T1, typename T2, typename T3, typename T4, typename T5, typename T6
+#define BOOST_FUNCTION_TEMPLATE_ARGS T0, T1, T2, T3, T4, T5
-#define BOOST_FUNCTION_TEMPLATE_ARGS T1, T2, T3, T4, T5, T6
+#define BOOST_FUNCTION_PARMS T0 a0, T1 a1, T2 a2, T3 a3, T4 a4, T5 a5
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1, typename OtherT2, typename OtherT3, typename OtherT4, typename OtherT5, typename OtherT6
+#define BOOST_FUNCTION_ARGS a0, a1, a2, a3, a4, a5
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2, OtherT3, OtherT4, OtherT5, OtherT6
+#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5
-#define BOOST_FUNCTION_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6
+#define BOOST_FUNCTION_NOT_0_ARGS a1, a2, a3, a4, a5
 #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
 #include <boost/function/function_template.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#undef BOOST_FUNCTION_NOT_0_ARGS
-#undef BOOST_FUNCTION_COMMA
+#undef BOOST_FUNCTION_NOT_0_PARMS
 #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_ARGS
-#undef BOOST_FUNCTION_FUNCTION
+#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_BASE
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_INVOKER_BASE
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_NUM_ARGS
 #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
-#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
+#ifndef BOOST_FUNCTION_FUNCTION7_HEADER
-#define BOOST_FUNCTION7_HPP
+#define BOOST_FUNCTION_FUNCTION7_HEADER
 #include <boost/function/function_base.hpp>
 #define BOOST_FUNCTION_NUM_ARGS 7
-#define BOOST_FUNCTION_COMMA ,
+#define BOOST_FUNCTION_TEMPLATE_PARMS typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6
-#define BOOST_FUNCTION_TEMPLATE_PARMS 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
-#define BOOST_FUNCTION_TEMPLATE_ARGS 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
-#define BOOST_FUNCTION_OTHER_TEMPLATE_PARMS typename OtherT1, typename OtherT2, typename OtherT3, typename OtherT4, typename OtherT5, typename OtherT6, typename OtherT7
+#define BOOST_FUNCTION_ARGS a0, a1, a2, a3, a4, a5, a6
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2, OtherT3, OtherT4, OtherT5, OtherT6, OtherT7
+#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6
-#define BOOST_FUNCTION_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
 #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
 #include <boost/function/function_template.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#undef BOOST_FUNCTION_NOT_0_ARGS
-#undef BOOST_FUNCTION_COMMA
+#undef BOOST_FUNCTION_NOT_0_PARMS
 #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_ARGS
-#undef BOOST_FUNCTION_FUNCTION
+#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_BASE
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_INVOKER_BASE
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_NUM_ARGS
 #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
-#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
+#ifndef BOOST_FUNCTION_FUNCTION8_HEADER
-#define BOOST_FUNCTION8_HPP
+#define BOOST_FUNCTION_FUNCTION8_HEADER
 #include <boost/function/function_base.hpp>
 #define BOOST_FUNCTION_NUM_ARGS 8
-#define BOOST_FUNCTION_COMMA ,
+#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_PARMS 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
-#define BOOST_FUNCTION_TEMPLATE_ARGS 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
-#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_ARGS a0, a1, a2, a3, a4, a5, a6, a7
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2, OtherT3, OtherT4, OtherT5, OtherT6, OtherT7, OtherT8
+#define BOOST_FUNCTION_NOT_0_PARMS T1 a1, T2 a2, T3 a3, T4 a4, T5 a5, T6 a6, T7 a7
-#define BOOST_FUNCTION_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
 #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
 #include <boost/function/function_template.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#undef BOOST_FUNCTION_NOT_0_ARGS
-#undef BOOST_FUNCTION_COMMA
+#undef BOOST_FUNCTION_NOT_0_PARMS
 #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_ARGS
-#undef BOOST_FUNCTION_FUNCTION
+#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_BASE
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_INVOKER_BASE
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_NUM_ARGS
 #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
-#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
+#ifndef BOOST_FUNCTION_FUNCTION9_HEADER
-#define BOOST_FUNCTION9_HPP
+#define BOOST_FUNCTION_FUNCTION9_HEADER
 #include <boost/function/function_base.hpp>
 #define BOOST_FUNCTION_NUM_ARGS 9
-#define BOOST_FUNCTION_COMMA ,
+#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_PARMS 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
-#define BOOST_FUNCTION_TEMPLATE_ARGS 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
-#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_ARGS a0, a1, a2, a3, a4, a5, a6, a7, a8
-#define BOOST_FUNCTION_OTHER_TEMPLATE_ARGS OtherT1, OtherT2, OtherT3, OtherT4, OtherT5, OtherT6, OtherT7, OtherT8, OtherT9
+#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_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
 #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
 #include <boost/function/function_template.hpp>
-#undef BOOST_FUNCTION_NUM_ARGS
+#undef BOOST_FUNCTION_NOT_0_ARGS
-#undef BOOST_FUNCTION_COMMA
+#undef BOOST_FUNCTION_NOT_0_PARMS
 #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_ARGS
-#undef BOOST_FUNCTION_FUNCTION
+#undef BOOST_FUNCTION_PARMS
-#undef BOOST_FUNCTION_BASE
+#undef BOOST_FUNCTION_TEMPLATE_ARGS
-#undef BOOST_FUNCTION_INVOKER_BASE
+#undef BOOST_FUNCTION_TEMPLATE_PARMS
-#undef BOOST_FUNCTION_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_NUM_ARGS
 #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
-#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,55 +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/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
 #ifdef BOOST_FUNCTION_SILENT_DEPRECATED
 #  define BOOST_FUNCTION_DEPRECATED_PRE
 #  define BOOST_FUNCTION_DEPRECATED_INNER
 #else
 #  if defined (BOOST_MSVC) && (BOOST_MSVC >= 1300)
 #    define BOOST_FUNCTION_DEPRECATED_PRE __declspec(deprecated)
 #    define BOOST_FUNCTION_DEPRECATED_INNER
 #  else
 #    define BOOST_FUNCTION_DEPRECATED_PRE
 #    define BOOST_FUNCTION_DEPRECATED_INNER int deprecated;
 #  endif
 #endif
 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;
      };
      /**
       * A union of a function pointer and a void pointer. This is necessary
       * because 5.2.10/6 allows reinterpret_cast<> to safely cast between 
@ -78,9 +58,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 +91,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 +144,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 +164,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 +212,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),
+          typedef typename get_function_tag<functor_type>::type tag_type;
                              function_ptr_tag,
                              function_obj_tag>::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 +267,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() {};
@ -287,6 +296,7 @@ namespace boost {
    safe_bool operator!() const
      { return (this->empty())? &dummy::nonnull : 0; }
 #endif
  };
  /* Poison comparison between Boost.Function objects (because it is 
@ -300,92 +310,14 @@ namespace boost {
  namespace detail {
    namespace function {
-      /**
+      inline bool has_empty_target(const function_base* f)
-       * Determine if the given target is empty.
+      {
-       */
+        return f->empty();
      // Fallback - assume target is not empty
      inline bool has_empty_target(...) 
      { 
        return false; 
      }
      // If the target is a 'function', query the empty() method
      inline bool has_empty_target(const function_base* af) 
      { 
        return af->empty();
      }
-      // If the target is a 'function', query the empty() method
+      inline bool has_empty_target(...)
      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)())
      {
-        return f == 0;
+        return false;
      }
      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;
      }
    } // end namespace function
  } // end namespace detail
@ -397,8 +329,19 @@ namespace boost {
    inline void postcall(const function_base*) {}
  };
-  // The default function mixin costs nothing
+  // The default function mixin does nothing. The assignment and
-  struct empty_function_mixin {};
+  // 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
--- 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/index.html
+++ b/index.html
@ -13,236 +13,66 @@
 <p> Generally, any place in which a function pointer would be used to defer a call or make a callback, Boost.Function can be used instead to allow the user greater flexibility in the implementation of the target. Targets can be any 'compatible' function object (or function pointer), meaning that the arguments to the interface designated by Boost.Function can be converted to the arguments of the target function object.
 <ul>
-  <li><a href="#usage">Basic usage</a>
+  <li><a href="#compatibility">Compatibility Note</a></li>
-     <ul>
+  <li><a href="doc/tutorial.html">Tutorial</a></li>
-       <li>Free functions</li>
+  <li><a href="doc/reference.html">Reference manual</a></li>
       <li>Member functions</li>
     </ul>
    </li>
  <li><a href="#family">The <code>function</code> family</a></li>
  <li><a href="#operations">Operations on function object wrappers</a></li>
  <li><a href="#advanced">Advanced usage</a>
    <ul>
      <li><a href="#policies">Policies</a></li>
      <li><a href="#mixins">Mixins</a></li>
      <li><a href="#allocators">Allocators</a></li>
      <li><a href="#synchronizing">Example: Synchronized functions</a></li>
   </ul>
  </li>
  <li><a href="#vspointers">Boost.Function vs. Function Pointers</a></li>
  <li><a href="#performance">Performance</a></li>
  <li><a href="#portability">Portability</a></li>
  <li><a href="#design">Design rationale</a></li>
  <li><a href="#acknowledgements">Acknowledgements</a></li>
-  <li><a href="faq.html">Frequently Asked Questions</a></li>
+  <li><a href="doc/faq.html">Frequently Asked Questions</a></li>
 </ul>
-<h2>Basic usage</h2>
+<a name="compatibility"><h2>Compatibility Note</h2></a>
-<a name="usage"></a>
+<p> Boost.Function has been partially redesigned to minimize the interface and make it cleaner. Several seldom- or never-used features of the older Boost.Function have been deprecated and will be removed in the near future. Here is a list of features that have been deprecated, the likely impact of the deprecations, and how to adjust your code:
 <p> A wrapper is defined simply by specializing a <code>function</code> object with the desired return type and argument types. Any number of arguments may be supplied, up to some implementation-defined limit (10 is the default maximum). The following declares a function object wrapper <code>f</code> that takes two <code>int</code> parameters and returns a <code>float</code>:
 <pre>
 boost::function&lt;float, int, int&gt; f;
 </pre>
 <p> By default, function object wrappers are empty, so we can create a 
 function object to assign to <code>f</code>:
 <pre>
 struct int_div { float operator()(int x, int y) const { return ((float)x)/y; }; };
 f = int_div();
 </pre>
 <p> Now we can use <code>f</code> to execute the underlying function object
 <code>int_div</code>:
 <pre>
  std::cout << f(5, 3) << std::endl;
 </pre>
 <p> We are free to assign any compatible function object to <code>f</code>. If <code>int_div</code> had been declared to take two <code>long</code> operands,
 the implicit conversions would have been applied without any user interference.
 <p> Invoking a function object wrapper that does not actually contain a function object is a precondition violation. We can check for an empty function object wrapper by querying its <code>empty()</code> method or, more succinctly, by using it in a boolean context: if it evaluates true, it contains a function object target, i.e.,
 <pre>
  if (f)
    std::cout << f(5, 3) << std::endl;
  else
    std::cout << "f has no target" << std::endl;
 </pre>
 <p> We can clear out a function target using the <code>clear()</code> member functor. 
 <h3>Free functions</h3>
 <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;
 </pre>
 <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
 <ul>
-  <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:
+  <li>The <code>boost::function</code> class template syntax has
-<pre>
+  changed. The old syntax, e.g., <code>boost::function&lt;int, float,
-  struct X {
+  double, std::string&gt;</code>, has been changed to a more natural
-    int foo(int);
+  syntax <code>boost::function&lt;int (float, double,
-  };
+  std::string)&gt;</code>, where all return and argument types are
  encoded in a single function type parameter. Any other template
  parameters (e.g., the <code>Allocator</code>) follow this single
  parameter.  
-  boost::function&lt;int, int&gt; f;
+  <p> The resolution to this change depends on the
-  X x;
+  abilities of your compiler: if your compiler supports template
-  f = std::bind1st(std::mem_fun(&X::foo), &x);
+  partial specialization and can parse function types (most do), modify 
  your code to use the newer
  syntax (preferable) or directly use one of the
  <code>function<em>N</em></code> classes whose syntax has not
  changed. If your compiler does not support template partial
  specialization or function types, you must take the latter option and 
  use the numbered Boost.Function classes. This option merely requires 
  changing types such as <code>boost::function&lt;void, int, int&gt;</code>
  to <code>boost::function2&lt;void, int, int&gt;</code> (adding the number of
  function arguments to the end of the class name).
-  f(5); // Call x.foo(5)</pre></li>
+  <p> Support for the old syntax with the
  <code>boost::function</code> class template will persist for a short
  while, but will eventually be removed so that we can provide better
  error messages and link compatibility. </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>The invocation
-
+  policy template parameter (<code>Policy</code>) has been deprecated
-  <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>
+  and will be removed. There is no direct equivalent to this rarely
  used feature.</li> <li>The mixin template parameter
  (<code>Mixin</code>) has been deprecated and will be removed. There
  is not direct equivalent to this rarely used feature.</li> <li>The
  <code>set</code> methods have been deprecated and will be
  removed. Use the assignment operator instead.</li>
 </ul>
-<h2>The <code>function</code> family</h2>
+<p> To aid in porting to the new syntax and removing the use of deprecated features, define the preprocessor macro <code>BOOST_FUNCTION_NO_DEPRECATED</code>. This macro makes all deprecated features unavailable. A program compiled with <code>BOOST_FUNCTION_NO_DEPRECATED</code> will likely be prepared when the deprecated features are removed.
 <a name="family"></a>
 <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>
-<p> The numbered class templates contain most of the implementation and are each distinct class templates. They may be helpful if used in shared libraries, where the number of arguments supported by Boost.Function may change between revisions. Additionally, some compilers (e.g., Microsoft Visual C++ 6.0) have been known to be incapable of compiling <code>boost::function</code> in some instances but are able to handle the numbered variants.
+<h2><a name="vspointers">Boost.Function vs. Function Pointers</a></h2>
 <h2>Operations on function object wrappers</h2>
 <a name="operations"></a>
 <p>Each function object wrapper type (that has N actual arguments) supports the following operations:
 <table border=1>
  <tr>
    <th>Syntax</th> 
    <th>Semantics</th>
  </tr>
  <tr>
    <td><pre>
 f = func_obj;
 f.set(func_obj);</pre></td>
    <td>Clears out <code>f</code>'s current target and retargets <code>f</code> to a copy of <code>func_obj</code>.</td>
  </tr>
  <tr>
     <td><pre>
 f.clear();</pre></td>
     <td>Removes <code>f</code>'s target, if it has one.</td>
  </tr>
  <tr>
     <td><pre>
 (bool)f
 !f.empty()</pre></td>
     <td>True if <code>f</code> has no target. The conversion to <code>bool</code> evaluates true if a target exists, whereas <code>empty()</code> returns true if no target exists.</td>
   </tr>
   <tr>
     <td><pre>f(a1, a2, ..., aN)</pre></td>
     <td>Invoke <code>f</code>'s current target with the given arguments.
   </tr>
   <tr>
     <td><pre>
 swap(f1, f2);
 f1.swap(f2);</pre></td>
     <td>Swap the targets of <code>f1</code> and <code>f2</code>, which must be of the same type. No exceptions will be thrown.
   </tr>
 </table>
 <p> Additionally, function object wrappers may be default-constructed (as empty) or constructed from any compatible function object. They are copy constructible and copy-assignable.
 <p> All function object wrappers derive from <code>boost::function_base</code>, which implements the <code>empty()</code> member function and the <code>bool</code> conversion. Additionally, no other class may inherit <code>boost::function_base</code>, so user code may rely on the implicit base pointer conversion to determine if a type is a <code>boost::function</code> type or one of its variants.
 <h2>Advanced usage</h2>
 <a name="advanced"></a>
 <p> The <code>boost::function</code> family supports additional customization by means of policies, mixins, and allocators. The specific usage of each of these will be explained in later sections, but they share a common problem: how to replace each default with your own version. 
 <p>For the numbered function object wrappers, one need only specify the new classes as a template parameter in the appropriate position. The following is a general definition for each of the numbered function object wrappers:
 <pre>
  template&lt;typename Return,
           typename Arg1,
           typename Arg2,
           ...
           typename ArgN,
           typename Policy    = empty_function_policy,
    	   typename Mixin     = empty_function_mixin,
    	   typename Allocator = std::allocator&lt;function_base&gt;
           &gt; class functionN { /* ... */ };
 </pre>
 <p> With <code>boost::function</code> it is not so clear, because support for an arbitrary number of parameters means that it is impossible to specify just the last parameter, but not 5 of the parameters in between. Therefore, <code>boost::function</code> doubles as a generative interface for the underlying numbered class templates that uses named template parameters. For instance, to specify both a policy and an allocator for a function object wrapper <code>f</code> taking an <code>int</code> and returning an <code>int</code>, use:
 <pre>
  function&lt;int, int&gt;::policy&lt;MyPolicy&gt;::allocator&lt;MyAllocator&gt;::type f;
 </pre>
 <p> The named template parameters <code>policy</code>, <code>mixin</code> and <code>allocator</code> each take one template parameter (the replacement class) and may be nested as above to generate a function object wrapper. The <code>::type</code> at the end accesses the actual type that fits the given properties.
 <h3>Policies</h3>
 <a name="policies"></a>
 <p> Policies define what happens directly before and directly after an invocation of a function object target is made. A policy must have two member functions, <code>precall</code> and <code>postcall</code>, each of which must be able to accept a <code>const</code> function object wrapper pointer. The following policy will print "before" prior to execution and "after" afterwards:
 <pre>
 struct print_policy {
  void precall(const boost::function_base*) { std::cout << "before"; }
  void postcall(const boost::function_base*) { std::cout << "after"; }
 };
 </pre>
 <p> A new instance of the policy class will be created prior to calling the function object target and will be preserved until after the call has returned. Therefore, for any invocation the <code>precall</code> and <code>postcall</code> will be executed on the same policy class instance; however, policy class instances will not be kept between target invocations.
 <p> Policies are further <a href="http://www.boost.org/more/generic_programming.html#policy">described</a> in the Boost discussion on <a href="http://www.boost.org/more/generic_programming.html">generic programming techniques</a>.
 <h3>Mixins</h3>
 <a name="mixins"></a>
 <p> The function object wrappers allow any class to be "mixed in" as a base class. This allows extra members and/or functionality to be included by the user. This can be used, for instance, to overcome the limitations of policies by storing data between invocations in a base class instead of in a <code>static</code> member of a policy class. 
 <h3>Allocators</h3>
 <a name="allocators"></a>
 <p> The function object wrappers allow the user to specify a new allocator to handle the cloning of function object targets (when the wrappers are copied). The allocators used are the same as the C++ standard library allocators. The wrappers assume the allocators are stateless, and will create a new instance each time they are used (because they are rebound very often). This shares the semantics of most standard library implementations, and is explicitly allowed by the C++ standard.
 <h3>Example: Synchronized callbacks</h3>
 <a name="synchronizing"></a>
 <p> Synchronization of callbacks in a multithreaded environment is extremely important. Using mixins and policies, a Boost.Function object may implement its own synchronization policy that ensures that only one thread can be in the callback function at any given point in time.
 <p> We will use the prototype Boost.Threads library for its <code>recursive_mutex</code>. Since the mutex is on a per-callback basis, we will add a mutex to the <code>boost::function</code> by mixin it in with this mixin class:
 <pre>
 class SynchronizedMixin {
  mutable boost::recursive_mutex mutex;
 };
 </pre>
 <p> Next, we create a policy that obtains a lock before the target is called (via the <code>precall</code> function) and releases the lock after the target has been called (via the <code>postcall</code> function):
 <pre>
 class SynchronizedPolicy {
  std::auto_ptr&lt;boost::recursive_mutex::lock&gt; lock;
  void precall(const SynchronizedMixin* f) 
  {
    lock.reset(new boost::recursive_mutex::lock(f->mutex));
  }
  void postcall(const SynchronizedMixin* f)
  {
    lock.reset();
  }
 };
 </pre>
 <p>The use of <code>std::auto_ptr</code> ensures that the lock will be destroyed (and therefore released) if an exception is thrown by the target function. Now we can use the policy and mixin together to create a synchronized callback:
 <pre>
 boost::function2&lt;float, int, int, SynchronizedPolicy, SynchronizedMixin&gt; f;
 </pre>
 <h2>Boost.Function vs. Function Pointers</h2>
 <a name="vspointers"></a>
 <p>Boost.Function has several advantages over function pointers, namely:
 <ul>
   <li>Boost.Function allows arbitrary compatible function objects to be targets (instead of requiring an exact function signature).</li>
   <li>Boost.Function may be used with argument-binding and other function object construction libraries.</li>
   <li>Boost.Function has predictible debug behavior when an empty function object is called. </li>
   <li>Boost.Function can be adapted to perform operations before and after each call, allowing, for instance, synchronization primitives to be made part of the function type.</li>
 </ul>
@ -258,26 +88,24 @@ And, of course, function pointers have several advantages over Boost.Function:
 <p> The above two lists were adapted from comments made by Darin Adler.
-<h2>Performance</h2>
+<h2><a name="performance">Performance</a></h2>
 <a name="performance"></a>
 <h3>Function object wrapper size</h3>
 <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>Portability</h2>
+<h2><a name="portability">Portability</a></h2>
-<a name="portability"></a>
+<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>.
 <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>.
 <ul>
  <li>GCC 2.95.3</li>
  <li>GCC 3.0</li>
  <li>SGI MIPSpro 7.3.0</li>
  <li>Borland C++ 5.5.1</li>
-  <li>Comeau C++ 4.2.44 (beta 3)</li>
+  <li>Comeau C++ 4.2.45.2</li>
  <li>Metrowerks Codewarrior 6.1</li>
 </ul>
@ -287,49 +115,18 @@ And, of course, function pointers have several advantages over Boost.Function:
  <li>Intel C++ 5.0: allocators not supported</li>
 </ul>
-<p> If your compiler is not listed, there is a small set of tests to stress the capabilities of the <code>boost::function</code> library. A standards-compliant compiler should compile the code without any modifications, but if you find you run into problems the following macros can be defined to adapt the function object wrappers to a broken compiler:
+<p> If your compiler is not listed, there is a small set of tests to stress the capabilities of the <code>boost::function</code> library. A standards-compliant compiler should compile the code without any modifications, but if you find you run into problems please submit a bug report.
 <table border=1>
  <tr>
    <th>Macro name</th>
    <th>Effect and symptoms</th>
  </tr>
  <tr>
    <td>BOOST_FUNCTION_USE_VIRTUAL_FUNCTIONS</td>
    <td>When enabled, this macro uses virtual functions instead of the default function pointers. In most cases, this will generate larger executables. However, if a compiler optimizes virtual function calls well it may result in smaller, faster executables. Enabling this macro also fixes some code generation problems in some compilers...
  </tr>
  <tr>
    <td>BOOST_WEAK_FUNCTION_TEMPLATE_ORDERING</td>
    <td><code>boost::function</code> stresses function template ordering more than most compilers can handle. If your compiler is having trouble with free function pointer assignments, try defining this macro</td>
  </tr>
  <tr>
    <td>BOOST_NO_DEPENDENT_BASE_LOOKUP</td>
    <td>If your compiler cannot seem to find operators defined in a dependent base class (i.e., if you are trying to use <code>boost::function</code> operators and your compiler isn't finding them), try defining this macro</td>
  </tr>
  <tr>
    <td>BOOST_NO_DEPENDENT_NESTED_DERIVATIONS</td>
    <td>If your compiler can't handle the code in the <code>function_traits_builder</code> class, try defining this.</td>
  </tr>
  <tr>
    <td>BOOST_WEAK_CONVERSION_OPERATORS</td>
    <td>If expressions such as <code>!f</code> (for a <code>boost::function</code> object <code>f</code>) fail, try to define this. Note that this may allow some meaningless expressions to compile, such as <code>f+4</code>.</td>
  </tr>
 </table>
 <h2>Design rationale</h2>
 <a name="design"></a>
 <h2><a name="design">Design rationale</a></h2>
 <h3>Combatting virtual function bloat</h3>
 <p> The use of virtual functions tends to cause 'code bloat' on many compilers. When a class contains a virtual function, it is necessary to emit an additional function that classifies the type of the object. It has been our experience that these auxiliary functions increase the size of the executable significantly when many <code>boost::function</code> objects are used. 
 <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>
 <h2>Acknowledgements</h2>
 <a name="acknowledgements"></a>
 <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/deprecated_syntax_test.cpp
+++ b/test/deprecated_syntax_test.cpp
@ -0,0 +1,645 @@
 // 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 boost;
 using std::string;
 using std::negate;
 int global_int;
 struct write_five_obj { void operator()() const { global_int = 5; } };
 struct write_three_obj { int operator()() const { global_int = 3; return 7; }};
 static void write_five() { global_int = 5; }
 static void write_three() { global_int = 3; }
 struct generate_five_obj { int operator()() const { return 5; } };
 struct generate_three_obj { int operator()() const { return 3; } };
 static int generate_five() { return 5; }
 static int generate_three() { return 3; }
 static string identity_str(const string& s) { return s; }
 static string string_cat(const string& s1, const string& s2) { return s1+s2; }
 static int sum_ints(int x, int y) { return x+y; }
 struct write_const_1_nonconst_2
 {
  void operator()() { global_int = 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()
 {
  typedef function<void> func_void_type;
  write_five_obj five;
  write_three_obj three;
  // Default construction
  func_void_type v1;
  BOOST_TEST(v1.empty());
  // Assignment to an empty function 
  v1 = five;
  BOOST_TEST(!v1.empty());
  // Invocation of a function
  global_int = 0;
  v1();
  BOOST_TEST(global_int == 5);
  // clear() method
  v1.clear();
  BOOST_TEST(v1.empty());
  // Assignment to an empty function
  v1 = three;
  BOOST_TEST(!v1.empty());
  // Invocation and self-assignment
  global_int = 0;
  v1 = v1;
  v1();
  BOOST_TEST(global_int == 3);
  // Assignment to a non-empty function
  v1 = five;
  // Invocation and self-assignment
  global_int = 0;
  v1 = (v1);
  v1();
  BOOST_TEST(global_int == 5);
  // clear()
  v1.clear();
  BOOST_TEST(v1.empty());
  // Assignment to an empty function from a free function
  v1 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
  BOOST_TEST(!v1.empty());
  // Invocation
  global_int = 0;
  v1();
  BOOST_TEST(global_int == 5);
  // Assignment to a non-empty function from a free function
  v1 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
  BOOST_TEST(!v1.empty());
  // Invocation
  global_int = 0;
  v1();
  BOOST_TEST(global_int == 3);
  // Assignment
  v1 = five;
  BOOST_TEST(!v1.empty());
  // Invocation
  global_int = 0;
  v1();
  BOOST_TEST(global_int == 5);
  // Assignment to a non-empty function from a free function
  v1 = &write_three;
  BOOST_TEST(!v1.empty());
  // Invocation
  global_int = 0;
  v1();
  BOOST_TEST(global_int == 3);
  // Construction from another function (that is empty)
  v1.clear();
  func_void_type v2(v1);
  BOOST_TEST(!v2);
  // Assignment to an empty function
  v2 = three;
  BOOST_TEST(!v2.empty());
  // Invocation
  global_int = 0;
  v2();
  BOOST_TEST(global_int == 3);
  // Assignment to a non-empty function
  v2 = (five);
  // Invocation
  global_int = 0;
  v2();
  BOOST_TEST(global_int == 5);
  v2.clear();
  BOOST_TEST(v2.empty());
  // Assignment to an empty function from a free function
  v2 = (BOOST_FUNCTION_TARGET_FIX(&) write_five);
  BOOST_TEST(v2);
  // Invocation
  global_int = 0;
  v2();
  BOOST_TEST(global_int == 5);
  // Assignment to a non-empty function from a free function
  v2 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
  BOOST_TEST(!v2.empty());
  // Invocation
  global_int = 0;
  v2();
  BOOST_TEST(global_int == 3);
  // Swapping
  v1 = five;
  swap(v1, v2);
  v2();
  BOOST_TEST(global_int == 5);
  v1();
  BOOST_TEST(global_int == 3);
  swap(v1, v2);
  v1.clear();
  // Assignment
  v2 = five;
  BOOST_TEST(!v2.empty());
  // Invocation
  global_int = 0;
  v2();
  BOOST_TEST(global_int == 5);
  // Assignment to a non-empty function from a free function
  v2 = &write_three;
  BOOST_TEST(!v2.empty());
  // Invocation
  global_int = 0;
  v2();
  BOOST_TEST(global_int == 3);
  // Assignment to a function from an empty function
  v2 = v1;
  BOOST_TEST(v2.empty()); 
  // Assignment to a function from a function with a functor
  v1 = three;
  v2 = v1;
  BOOST_TEST(!v1.empty());
  BOOST_TEST(!v2.empty());
  // Invocation
  global_int = 0;
  v1();
  BOOST_TEST(global_int == 3);
  global_int = 0;
  v2();
  BOOST_TEST(global_int == 3);
  // Assign to a function from a function with a function
  v2 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
  v1 = v2;
  BOOST_TEST(!v1.empty());
  BOOST_TEST(!v2.empty());
  global_int = 0;
  v1();
  BOOST_TEST(global_int == 5);
  global_int = 0;
  v2();
  BOOST_TEST(global_int == 5);
  // Construct a function given another function containing a function
  func_void_type v3(v1);
  // Invocation of a function
  global_int = 0;
  v3();
  BOOST_TEST(global_int == 5);
  // clear() method
  v3.clear();
  BOOST_TEST(!v3);
  // Assignment to an empty function
  v3 = three;
  BOOST_TEST(!v3.empty());
  // Invocation
  global_int = 0;
  v3();
  BOOST_TEST(global_int == 3);
  // Assignment to a non-empty function
  v3 = five;
  // Invocation
  global_int = 0;
  v3();
  BOOST_TEST(global_int == 5);
  // clear()
  v3.clear();
  BOOST_TEST(v3.empty());
  // Assignment to an empty function from a free function
  v3 = &write_five;
  BOOST_TEST(!v3.empty());
  // Invocation
  global_int = 0;
  v3();
  BOOST_TEST(global_int == 5);
  // Assignment to a non-empty function from a free function
  v3 = &write_three;
  BOOST_TEST(!v3.empty());
  // Invocation
  global_int = 0;
  v3();
  BOOST_TEST(global_int == 3);
  // Assignment
  v3 = five;
  BOOST_TEST(!v3.empty());
  // Invocation
  global_int = 0;
  v3();
  BOOST_TEST(global_int == 5);
  // Construction of a function from a function containing a functor
  func_void_type v4(v3);
  // Invocation of a function
  global_int = 0;
  v4();
  BOOST_TEST(global_int == 5);
  // clear() method
  v4.clear();
  BOOST_TEST(v4.empty());
  // Assignment to an empty function
  v4 = three;
  BOOST_TEST(!v4.empty());
  // Invocation
  global_int = 0;
  v4();
  BOOST_TEST(global_int == 3);
  // Assignment to a non-empty function
  v4 = five;
  // Invocation
  global_int = 0;
  v4();
  BOOST_TEST(global_int == 5);
  // clear()
  v4.clear();
  BOOST_TEST(v4.empty());
  // Assignment to an empty function from a free function
  v4 = &write_five;
  BOOST_TEST(!v4.empty());
  // Invocation
  global_int = 0;
  v4();
  BOOST_TEST(global_int == 5);
  // Assignment to a non-empty function from a free function
  v4 = &write_three;
  BOOST_TEST(!v4.empty());
  // Invocation
  global_int = 0;
  v4();
  BOOST_TEST(global_int == 3);
  // Assignment
  v4 = five;
  BOOST_TEST(!v4.empty());
  // Invocation
  global_int = 0;
  v4();
  BOOST_TEST(global_int == 5);
  // Construction of a function from a functor
  func_void_type v5(five);
  // Invocation of a function
  global_int = 0;
  v5();
  BOOST_TEST(global_int == 5);
  // clear() method
  v5.clear();
  BOOST_TEST(v5.empty());
  // Assignment to an empty function
  v5 = three;
  BOOST_TEST(!v5.empty());
  // Invocation
  global_int = 0;
  v5();
  BOOST_TEST(global_int == 3);
  // Assignment to a non-empty function
  v5 = five;
  // Invocation
  global_int = 0;
  v5();
  BOOST_TEST(global_int == 5);
  // clear()
  v5.clear();
  BOOST_TEST(v5.empty());
  // Assignment to an empty function from a free function
  v5 = &write_five;
  BOOST_TEST(!v5.empty());
  // Invocation
  global_int = 0;
  v5();
  BOOST_TEST(global_int == 5);
  // Assignment to a non-empty function from a free function
  v5 = &write_three;
  BOOST_TEST(!v5.empty());
  // Invocation
  global_int = 0;
  v5();
  BOOST_TEST(global_int == 3);
  // Assignment
  v5 = five;
  BOOST_TEST(!v5.empty());
  // Invocation
  global_int = 0;
  v5();
  BOOST_TEST(global_int == 5);  
  // Construction of a function from a function
  func_void_type v6(&write_five);
  // Invocation of a function
  global_int = 0;
  v6();
  BOOST_TEST(global_int == 5);
  // clear() method
  v6.clear();
  BOOST_TEST(v6.empty());
  // Assignment to an empty function
  v6 = three;
  BOOST_TEST(!v6.empty());
  // Invocation
  global_int = 0;
  v6();
  BOOST_TEST(global_int == 3);
  // Assignment to a non-empty function
  v6 = five;
  // Invocation
  global_int = 0;
  v6();
  BOOST_TEST(global_int == 5);
  // clear()
  v6.clear();
  BOOST_TEST(v6.empty());
  // Assignment to an empty function from a free function
  v6 = &write_five;
  BOOST_TEST(!v6.empty());
  // Invocation
  global_int = 0;
  v6();
  BOOST_TEST(global_int == 5);
  // Assignment to a non-empty function from a free function
  v6 = &write_three;
  BOOST_TEST(!v6.empty());
  // Invocation
  global_int = 0;
  v6();
  BOOST_TEST(global_int == 3);
  // Assignment
  v6 = five;
  BOOST_TEST(!v6.empty());
  // Invocation
  global_int = 0;
  v6();
  BOOST_TEST(global_int == 5);  
  // Const vs. non-const
  write_const_1_nonconst_2 one_or_two;
  const function<void> v7(one_or_two);
  function <void> v8(one_or_two);
  global_int = 0;
  v7();
  BOOST_TEST(global_int == 2);
  global_int = 0;
  v8();
  BOOST_TEST(global_int == 2);
  // Test return values
  typedef function<int> func_int_type;
  generate_five_obj gen_five;
  generate_three_obj gen_three;
  func_int_type i0(gen_five);
  BOOST_TEST(i0() == 5);
  i0 = gen_three;
  BOOST_TEST(i0() == 3);
  i0 = &generate_five;
  BOOST_TEST(i0() == 5);
  i0 = &generate_three;
  BOOST_TEST(i0() == 3);
  BOOST_TEST(i0);
  i0.clear();
  BOOST_TEST(!i0);
  // Test return values with compatible types
  typedef function<long> func_long_type;
  func_long_type i1(gen_five);
  BOOST_TEST(i1() == 5);
  i1 = gen_three;
  BOOST_TEST(i1() == 3);
  i1 = &generate_five;
  BOOST_TEST(i1() == 5);
  i1 = &generate_three;
  BOOST_TEST(i1() == 3);
  BOOST_TEST(i1);
  i1.clear();
  BOOST_TEST(!i1);
 }
 static void
 test_one_arg()
 {
  negate<int> neg;
  function<int, int> f1(neg);
  BOOST_TEST(f1(5) == -5);
  function<string, string> id(&identity_str);
  BOOST_TEST(id("str") == "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
 test_two_args()
 {
  function<string, const string&, const string&> cat(&string_cat);
  BOOST_TEST(cat("str", "ing") == "string");  
  function<int, short, short> sum(&sum_ints);
  BOOST_TEST(sum(2, 3) == 5);
 }
 static void
 test_emptiness()
 {
  function<float> f1;
  BOOST_TEST(f1.empty());
  function<float> f2;
  f2 = f1;
  BOOST_TEST(f2.empty());
  function<double> f3;
  f3 = f2;
  BOOST_TEST(f3.empty());
 }
 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/function_n_test.cpp
+++ b/test/function_n_test.cpp
@ -24,7 +24,7 @@ using namespace boost;
 using std::string;
 using std::negate;
-static int global_int;
+int global_int;
 struct write_five_obj { void operator()() const { global_int = 5; } };
 struct write_three_obj { int operator()() const { global_int = 3; return 7; }};
@ -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
@ -476,7 +485,7 @@ test_zero_args()
  global_int = 0;
  v7();
-  BOOST_TEST(global_int == 1);
+  BOOST_TEST(global_int == 2);
  global_int = 0;
  v8();
@ -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
+struct X {
-test_main(int, char* [])
+  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
@ -14,6 +14,7 @@
 // For more information, see http://www.boost.org
 #define BOOST_INCLUDE_MAIN
 #define BOOST_FUNCTION_NO_DEPRECATED
 #include <boost/test/test_tools.hpp>
 #include <boost/function.hpp>
 #include <functional>
@ -21,10 +22,9 @@
 #include <string>
 using namespace boost;
-using std::string;
+using namespace std;
 using std::negate;
-static int global_int;
+int global_int;
 struct write_five_obj { void operator()() const { global_int = 5; } };
 struct write_three_obj { int operator()() const { global_int = 3; return 7; }};
@ -44,10 +44,19 @@ 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()
 {
-  typedef function<void> func_void_type;
+  typedef function<void ()> func_void_type;
  write_five_obj five;
  write_three_obj three;
@ -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());
@ -471,19 +480,19 @@ test_zero_args()
  // Const vs. non-const
  write_const_1_nonconst_2 one_or_two;
-  const function<void> v7(one_or_two);
+  const function<void ()> v7(one_or_two);
-  function <void> v8(one_or_two);
+  function<void ()> v8(one_or_two);
  global_int = 0;
  v7();
-  BOOST_TEST(global_int == 1);
+  BOOST_TEST(global_int == 2);
  global_int = 0;
  v8();
  BOOST_TEST(global_int == 2);
  // Test return values
-  typedef function<int> func_int_type;
+  typedef function<int ()> func_int_type;
  generate_five_obj gen_five;
  generate_three_obj gen_three;
@ -501,7 +510,7 @@ test_zero_args()
  BOOST_TEST(!i0);
  // Test return values with compatible types
-  typedef function<long> func_long_type;
+  typedef function<long ()> func_long_type;
  func_long_type i1(gen_five);
  BOOST_TEST(i1() == 5);
@ -521,47 +530,181 @@ test_one_arg()
 {
  negate<int> neg;
-  function<int, int> f1(neg);
+  function<int (int)> f1(neg);
  BOOST_TEST(f1(5) == -5);
-  function<string, string> id(&identity_str);
+  function<string (string)> id(&identity_str);
  BOOST_TEST(id("str") == "str");
-  function<std::string, char*> id2(&identity_str);
+  function<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
 test_two_args()
 {
-  function<string, const string&, const string&> cat(&string_cat);
+  function<string (const string&, const string&)> cat(&string_cat);
  BOOST_TEST(cat("str", "ing") == "string");  
-  function<int, short, short> sum(&sum_ints);
+  function<int (short, short)> sum(&sum_ints);
  BOOST_TEST(sum(2, 3) == 5);
 }
 static void
 test_emptiness()
 {
-  function<float> f1;
+  function<float ()> f1;
  BOOST_TEST(f1.empty());
-  function<float> f2;
+  function<float ()> f2;
  f2 = f1;
  BOOST_TEST(f2.empty());
-  function<double> f3;
+  function<double ()> f3;
  f3 = f2;
  BOOST_TEST(f3.empty());
 }
-int
+struct X {
-test_main(int, char* [])
+  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 runtime_error("But this CAN'T throw");
  }
  add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
  {
    throw 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(runtime_error e) {
    BOOST_ERROR("Nonthrowing constructor threw an exception");
  }
 }
 static int alloc_count = 0;
 static int dealloc_count = 0;
 template<typename T>
 struct counting_allocator : public allocator<T>
 {
  template<typename U>
  struct rebind
  {
    typedef counting_allocator<U> other;
  };
  T* allocate(size_t n)
  {
    alloc_count++;
    return allocator<T>::allocate(n);
  }
  void deallocate(T* p, size_t n)
  {
    dealloc_count++;
    allocator<T>::deallocate(p, n);
  }
 };
 static int do_minus(int x, int y) { return x-y; }
 struct DoNothing
 {
  void operator()() const {}
 };
 static void do_nothing() {}
 static void test_allocator()
 {
 #ifndef BOOST_NO_STD_ALLOCATOR
  boost::function<int (int, int), counting_allocator<int> > f;
  f = plus<int>();
  f.clear();
  BOOST_TEST(alloc_count == 1);
  BOOST_TEST(dealloc_count == 1);
  alloc_count = 0;
  dealloc_count = 0;
  f = &do_minus;
  f.clear();
  boost::function<void (), counting_allocator<int> > fv;
  alloc_count = 0;
  dealloc_count = 0;
  fv = DoNothing();
  fv.clear();
  BOOST_TEST(alloc_count == 1);
  BOOST_TEST(dealloc_count == 1);
  alloc_count = 0;
  dealloc_count = 0;
  fv = &do_nothing;
  fv.clear();
 #endif // ndef BOOST_NO_STD_ALLOCATOR
 }
 int test_main(int, char* [])
 {
  test_zero_args();
  test_one_arg();
  test_two_args();
  test_emptiness();
  test_member_functions();
  test_ref();
  test_allocator();
  return 0;
 }
--- a/test/mixin_test.cpp
+++ b/test/mixin_test.cpp
@ -19,22 +19,42 @@
 #include <functional>
 #include <boost/function.hpp>
 using namespace std;
 using namespace boost;
 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;
 };
-int
+static int do_plus(int x, int y) { return x+y; }
 test_main(int, char*[])
 {
  function<int, int, int>::mixin<id_mixin>::type f;
  f = plus<int>();
  f.id = 7;
  f.clear();
  BOOST_TEST(f.id == 7);
 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/policy_test.cpp
+++ b/test/policy_test.cpp
@ -27,8 +27,8 @@ struct counting_policy
 {
  static int count;
-  void precall(function_base*) { count++; }
+  void precall(const function_base*) { count++; }
-  void postcall(function_base*) { count+=2; }
+  void postcall(const function_base*) { count+=2; }
 };
 int counting_policy::count = 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
@ -0,0 +1,47 @@
 // 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 <stdexcept>
 struct stateless_integer_add {
  int operator()(int x, int y) const { return x+y; }
  void* operator new(std::size_t, stateless_integer_add*)
  {
    throw std::runtime_error("Cannot allocate a stateless_integer_add");
  }
  void operator delete(void*, stateless_integer_add*)
  {
  }
 };
 namespace boost {
  template<>
  struct is_stateless<stateless_integer_add> {
    BOOST_STATIC_CONSTANT(bool, value = true);
  };
 }
 int test_main(int, char*[])
 {
  boost::function<int, int, int> f;
  f = stateless_integer_add();
  return 0;
 }
Author	SHA1	Message	Date
nobody	659326b45f	This commit was manufactured by cvs2svn to create branch 'python-v2-dev'. [SVN r14785]	2002-08-12 13:35:54 +00:00
Douglas Gregor	893069311a	function_base.hpp: - Use the BOOST_FUNCTION_SILENT_DEPRECATED macro as a signal to turn off all "deprecated" warnings [SVN r14756]	2002-08-09 14:34:23 +00:00
Douglas Gregor	0db4ad9f55	Attempted Borland fix [SVN r14709]	2002-08-06 14:20:08 +00:00
Douglas Gregor	d59b93384b	Report success on Compaq cxx 6.2 [SVN r14697]	2002-08-05 15:07:34 +00:00
Douglas Gregor	e837b20127	Report the sad fate of CodeWarrior [SVN r14696]	2002-08-05 15:05:57 +00:00
Douglas Gregor	39e2be08cb	Don't test allocators if they aren't supported [SVN r14695]	2002-08-05 15:05:34 +00:00
Douglas Gregor	021063eddf	Attempted fix for Compaq CXX 6.2 [SVN r14693]	2002-08-05 13:32:25 +00:00
Douglas Gregor	0ff1daa573	Proper HTML, please [SVN r14690]	2002-08-05 06:29:07 +00:00
Douglas Gregor	8b734dac5a	Added Sun CC to the bad side of the syntax table [SVN r14689]	2002-08-05 06:24:18 +00:00
Douglas Gregor	5010a0beb0	tutorial.html: - Use tables to show both preferred/compatible syntaxes - Include a table describing which syntax is right for each compiler [SVN r14687]	2002-08-05 06:20:30 +00:00
Douglas Gregor	39687e1a05	Describe BOOST_FUNCTION_NO_DEPRECATED [SVN r14686]	2002-08-05 06:19:47 +00:00
Douglas Gregor	688df3d137	function_base.hpp: - Use <boost/pending/ct_if.hpp> all: - Add BOOST_FUNCTION_NO_DEPRECATED macro hackery to get rid of ALL deprecated features [SVN r14685]	2002-08-05 06:19:17 +00:00
Douglas Gregor	232069aa00	allocator_test.cpp: - Remove partial specialization-specific code function_test.cpp: - Uses BOOST_FUNCTION_NO_DEPRECATED - Use only the new syntax - Test the allocator parameter deprecated_syntax_test.cpp: - Test the deprecated syntax [SVN r14684]	2002-08-05 06:13:32 +00:00
Douglas Gregor	694ebbb301	Use built-in deprecation facilities, when available [SVN r14677]	2002-08-05 03:08:08 +00:00
Douglas Gregor	837591456f	Remove the unused is_not_same [SVN r14676]	2002-08-05 02:34:02 +00:00
Douglas Gregor	2d8a4b136a	Use function_traits in type_traits library [SVN r14675]	2002-08-05 02:33:26 +00:00
Douglas Gregor	4f5147f96e	function.hpp: - When determining if a type is a function type, don't blindly add a pointer but instead use add_pointer [SVN r14586]	2002-07-24 13:27:49 +00:00
Douglas Gregor	9db8577d16	Removed all of the deprecated parameters and made them variables [SVN r14578]	2002-07-23 21:57:57 +00:00
Douglas Gregor	2963cb89a8	function_test.cpp: Don't use void() directly because of broken compilers [SVN r14571]	2002-07-23 13:47:01 +00:00
Dave Abrahams	d62193624e	VC6/7 workaround [SVN r14552]	2002-07-21 11:09:23 +00:00
Douglas Gregor	461e51a592	Expand on the compatibility note [SVN r14542]	2002-07-19 21:21:56 +00:00
Douglas Gregor	7ad9e2afee	Tutorial now describes the new syntax (and the old syntax) [SVN r14541]	2002-07-19 21:18:01 +00:00
Douglas Gregor	e9ce99dede	test/function_n_test.cpp: test/function_test.cpp: - Don't use deprecated functions index.html: doc/reference.html: - Describe deprecations [SVN r14540]	2002-07-19 20:45:36 +00:00
Douglas Gregor	3264064074	Removed some cruft Deprecated the 'set' methods [SVN r14538]	2002-07-19 20:09:29 +00:00
Douglas Gregor	84bdb40567	Don't test new syntax if partial specialization is unavailable [SVN r14536]	2002-07-19 19:42:25 +00:00
Douglas Gregor	a0bd17560f	Don't fail on compilers without partial specialization (but don't allow the new syntax either) [SVN r14535]	2002-07-19 19:41:53 +00:00
Douglas Gregor	97f72b7f8b	Don't try to use function types inline for those silly compilers that can't handle it (e.g., Borland C++ 5.5.1) [SVN r14534]	2002-07-19 19:17:14 +00:00
Douglas Gregor	fca8413df6	Support for Borland C++ 5.5.1 [SVN r14533]	2002-07-19 19:16:33 +00:00
Douglas Gregor	fff815d58b	allocator_test.cpp: function_test.cpp: - Test out the new function syntax [SVN r14532]	2002-07-19 18:31:41 +00:00
Douglas Gregor	9e49833a8c	function.hpp: - Support Peter Dimov's rockin' new syntax: function<string (int x, double y, float z)> f; [SVN r14531]	2002-07-19 18:30:48 +00:00
Douglas Gregor	df34714340	Removed 'truth' template, which isn't needed [SVN r14060]	2002-05-29 17:27:59 +00:00
Douglas Gregor	d50e9729ea	Fixed conflicts in 1.28.0 merge [SVN r13946]	2002-05-16 02:18:29 +00:00
Douglas Gregor	e975d1e0c2	Lambda is now a Boost library [SVN r13831]	2002-05-13 12:33:19 +00:00
Douglas Gregor	a3e9eb5db2	Removed tabs [SVN r13812]	2002-05-10 17:54:40 +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
Douglas Gregor	f79765cce1	reference.html: - Remove declaration/documentation of non-const operator(). - Update documentation of operator() const to state that the called object is not cv-qualified. [SVN r10687]	2001-07-22 05:30:15 +00:00
Douglas Gregor	e34716babd	function_n_test.cpp: function_test.cpp: - Updated testcases to reflect semantic change in const calling policy_test.cpp: - precall/postcall in policy should take pointers to const function_base [SVN r10686]	2001-07-22 05:27:20 +00:00
Douglas Gregor	657a63fce4	function_template.hpp: - const function calling semantics changed. Now 'function' has pointer/reference semantics (constness of 'function' object does not affect constness of targetted function object) [SVN r10685]	2001-07-22 05:26:17 +00:00
Douglas Gregor	a9aa465826	function_n_test.cpp: function_test.cpp: - Removed 'static' storage specifier from 'global_int' declaration. Perhaps Sun Workshop 6 will compile Boost.Function now? [SVN r10684]	2001-07-22 05:03:43 +00:00
Douglas Gregor	aa026cd1d8	defarg_test.cpp: - Test zero and one arguments [SVN r10640]	2001-07-17 01:27:42 +00:00
Douglas Gregor	931737f72b	reference.html: - Boldified C++ keywords to make summary more readable. [SVN r10634]	2001-07-16 18:17:00 +00:00
Douglas Gregor	ce08e55a63	referemce.html: - Document swapping of mixins in swap() [SVN r10622]	2001-07-14 20:02:39 +00:00
Douglas Gregor	8121f4ebb6	reference.html: - Assignment operator and set() function both meet the strong exception guarantee. [SVN r10621]	2001-07-14 19:58:43 +00:00
Douglas Gregor	d37903b2e7	index.html: - Removed reference and tutorial: now just link to them faq.html: - Moved to doc/faq.html doc/faq.html: - Relative directory fixups doc/reference.html: - Reference manual for Boost.Function doc/tutorial.html: - Tutorial for Boost.Function (the old "Usage" sections) - Additional example showing the use of references and arrays example/bind1st.cpp: example/int_div.cpp: example/sum_avg.cpp: - Examples from tutorial [SVN r10620]	2001-07-14 19:57:09 +00:00
Douglas Gregor	3ba640809b	function.hpp: - Use "self_type" instead of "function" for constructing swapping temporary (Borland C++ needs it) function_base.hpp: - Give empty copy constructor, default constructor, and assignment operator to empty_function_mixin (MSVC generates incorrect ones) function_template.hpp: - Make Borland C++ and MSVC agree on the code (involves an extra constructor definition and careful use of self_type vs. BOOST_FUNCTION_FUNCTION) [SVN r10619]	2001-07-14 19:34:14 +00:00
Douglas Gregor	131ed15e59	mixin_test.cpp: - Check assignment from function pointer [SVN r10618]	2001-07-14 18:58:16 +00:00
Douglas Gregor	aad9b5f5e0	function_template.cpp: - Correctly copy mixin when assigning from any function/function object [SVN r10617]	2001-07-14 18:51:00 +00:00
Douglas Gregor	40b70509cc	mixin_test.cpp: - Test persistence of mixins when assigning to a function object [SVN r10616]	2001-07-14 18:46:42 +00:00
Douglas Gregor	b5f3694938	mixin_test.cpp: - Test copying of mixins [SVN r10615]	2001-07-14 18:41:47 +00:00
Douglas Gregor	5754d88110	function.hpp: - Use swap() for exception safe assignment operators function_template.hpp: - Use swap() for exception safe assignment operators - Remove BOOST_FUNCTION_BASE class. - Support copying of mixins. (Richard Crossley) [SVN r10614]	2001-07-14 18:41:19 +00:00
Douglas Gregor	b51aa315da	index.html: - Use relative pathnames for links to generic programming techniques page (Gustavo Guerra). - Terminology in Basic Usage intro (Jeremy Siek). [SVN r10592]	2001-07-11 19:49:26 +00:00
Douglas Gregor	deabdc22c6	faq.html: - Fixed HTML typo near the end index.html: - Added declarations of all members for all classes. - Added detailed description of interface according to Boost guidelines. [SVN r10591]	2001-07-11 18:55:44 +00:00
Douglas Gregor	e28a833db5	Ron Garcia suggested removal of the duplicate explanation of (bool)f/f.empty() [SVN r10586]	2001-07-10 21:56:02 +00:00