Release 1.37.0

[SVN r51178]

CMakeLists.txt

@@ -0,0 +1,22 @@
+#----------------------------------------------------------------------------
+# This file was automatically generated from the original CMakeLists.txt file
+# Add a variable to hold the headers for the library
+set (lib_headers
+    bind.hpp
+    bind
+)
+
+# Add a library target to the build system
+boost_library_project(
+  bind
+  #  SRCDIRS 
+  TESTDIRS  test
+  HEADERS ${lib_headers}
+  #  DOCDIRS 
+  DESCRIPTION  "A generalization of the standard functions std::bind1st and std::bind2nd. It supports arbitrary function objects, functions, function pointers, and member function pointers, and is able to bind any argument to a specific value or route input arguments into arbitrary positions."
+  MODULARIZED 
+  AUTHORS  "Peter Dimov <pdimov -at- mmltd.net>"
+  #  MAINTAINERS 
+)
+
+

bind.html

@@ -61,7 +61,6 @@
 				bind&lt;R&gt;(f, ...)</A></h4>
 		<h4 style="MARGIN-LEFT: 40pt"><A href="#err_nonstd">Binding a nonstandard function</A></h4>
 		<h4 style="MARGIN-LEFT: 40pt"><A href="#err_overloaded">Binding an overloaded function</A></h4>
-		<h4 style="MARGIN-LEFT: 40pt"><A href="#err_modeling_stl_function_object_concepts">Modeling STL function object concepts</A></h4>
 		<h4 style="MARGIN-LEFT: 40pt"><A href="#err_const_arg"><b>const</b> in signatures</A></h4>
 		<h4 style="MARGIN-LEFT: 40pt"><A href="#err_msvc_using">MSVC specific: using 
 				boost::bind;</A></h4>
@@ -147,8 +146,8 @@ bind(g, _1, _1, _1)(x, y, z);          // g(x, x, x)
 
 bind(f, i, _1);
 </pre>
-		<p>a copy of the value of <b>i</b> is stored into the function object. <A href="../core/doc/html/core/ref.html">
-				boost::ref</A> and <A href="../core/doc/html/core/ref.html">boost::cref</A> can be used to make 
+		<p>a copy of the value of <b>i</b> is stored into the function object. <A href="ref.html">
+				boost::ref</A> and <A href="ref.html">boost::cref</A> can be used to make 
 			the function object store a reference to an object, rather than a copy:
 		</p>
 		<pre>int i = 5;
@@ -272,7 +271,7 @@ bind(&amp;X::f, p, _1)(i);			// (<i>internal copy of p</i>)-&gt;f(i)
 		</p>
 		<P>This feature of <b>bind</b> can be used to perform function composition. See <A href="bind_as_compose.cpp">
 				bind_as_compose.cpp</A> for an example that demonstrates how to use <b>bind</b>
-			to achieve similar functionality to <A href="http://www.boost.org/doc/libs/1_31_0/libs/compose/index.htm">Boost.Compose</A>.
+			to achieve similar functionality to <A href="../compose/index.htm">Boost.Compose</A>.
 		</P>
 		<p>Note that the first argument - the bound function object - is not evaluated, 
 			even when it's a function object that is produced by <STRONG>bind</STRONG> or a 
@@ -390,7 +389,7 @@ void connect()
 		<p>As a general rule, the function objects generated by <b>bind</b> take their 
 			arguments by reference and cannot, therefore, accept non-const temporaries or 
 			literal constants. This is an inherent limitation of the C++ language in its 
-			current (2003) incarnation, known as <A href="http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2002/n1385.htm">
+			current (2003) incarnation, known as <A href="http://std.dkuug.dk/jtc1/sc22/wg21/docs/papers/2002/n1385.htm">
 				the forwarding problem</A>. (It will be fixed in the next standard, usually 
 			called C++0x.)</p>
 		<p>The library uses signatures of the form
@@ -586,48 +585,6 @@ int main()
     boost::bind( get, _1 );
 }
 </pre>
-		<h3><a name="err_modeling_stl_function_object_concepts">Modeling STL function object concepts</a></h3>
-		<p>The function objects that are produced by <b>boost::bind</b> do not model the
-		STL <a href="http://www.sgi.com/tech/stl/UnaryFunction.html">Unary Function</a> or
-		<a href="http://www.sgi.com/tech/stl/BinaryFunction.html">Binary Function</a> concepts,
-		even when the function objects are unary or binary operations, because the function object
-		types are missing public typedefs <tt>result_type</tt> and <tt>argument_type</tt> or
-		<tt>first_argument_type</tt> and <tt>second_argument_type</tt>. In cases where these
-		typedefs are desirable, however, the utility function <tt>make_adaptable</tt>
-		can be used to adapt unary and binary function objects to these concepts. This allows
-		unary and binary function objects resulting from <b>boost::bind</b> to be combined with
-		STL templates such as <a href="http://msdn.microsoft.com/en-us/library/se0409db%28v=VS.90%29.aspx"><tt>std::unary_negate</tt></a>
-		and <a href="http://msdn.microsoft.com/en-us/library/833073z4%28v=VS.90%29.aspx"><tt>std::binary_negate</tt></a>.</p>
-		
-		<p>The <tt>make_adaptable</tt> function is defined in &lt;<a href="../../boost/bind/make_adaptable.hpp">boost/bind/make_adaptable.hpp</a>&gt;,
-		which must be included explicitly in addition to &lt;boost/bind.hpp&gt;:</p>
-		<pre>
-#include &lt;boost/bind/make_adaptable.hpp&gt;
-
-template &lt;class R, class F&gt; <i>unspecified-type</i> make_adaptable(F f);
-
-template&lt;class R, class A1, class F&gt; <i>unspecified-unary-functional-type</i> make_adaptable(F f);
-
-template&lt;class R, class A1, class A2, class F&gt; <i>unspecified-binary-functional-type</i> make_adaptable(F f);
-
-template&lt;class R, class A1, class A2, class A3, class F&gt; <i>unspecified-ternary-functional-type</i> make_adaptable(F f);
-
-template&lt;class R, class A1, class A2, class A3, class A4, class F&gt; <i>unspecified-4-ary-functional-type</i> make_adaptable(F f);
-		</pre>
-		
-		<p>This example shows how to use <tt>make_adaptable</tt> to make a predicate for "is not a space":</p>
-		<pre>typedef char char_t;
-std::locale loc("");
-const std::ctype&lt;char_t&gt;&amp; ct = std::use_facet&lt;std::ctype&lt;char_t&gt; &gt;(loc);
-
-auto isntspace = std::not1( boost::make_adaptable&lt;bool, char_t&gt;( boost::bind(&amp;std::ctype&lt;char_t&gt;::is, &amp;ct, std::ctype_base::space, _1) ) );
-</pre>
-
-		<p>In this example, <b>boost::bind</b> creates the "is a space" (unary) predicate.
-		It is then passed to <tt>make_adaptable</tt> so that a function object modeling
-		the Unary Function concept can be created, serving as the argument to
-		<a href="http://msdn.microsoft.com/en-us/library/syyszzf8%28v=VS.90%29.aspx"><tt>std::not1</tt></a>.</p>
-		
 		<h3><a name="err_const_arg"><b>const</b> in signatures</a></h3>
 		<p>Some compilers, including MSVC 6.0 and Borland C++ 5.5.1, have problems with the 
 			top-level <b>const</b> in function signatures:
@@ -737,7 +694,7 @@ namespace
 			a nonnegative integer, is defined as:</p>
 		<ul>
 			<li>
-				<tt>x.get()</tt>, when <tt>x</tt> is of type <tt><A href="../core/doc/html/core/ref.html">boost::reference_wrapper</A>&lt;T&gt;</tt>
+				<tt>x.get()</tt>, when <tt>x</tt> is of type <tt><A href="ref.html">boost::reference_wrapper</A>&lt;T&gt;</tt>
 				for some type <tt>T</tt>;
 			<li>
 				v<sub>k</sub>, when <tt>x</tt>
@@ -912,7 +869,7 @@ namespace
 			<li>
 				<A href="../config/config.htm">Boost.Config</A>
 			<li>
-				<A href="../core/doc/html/core/ref.html">boost/ref.hpp</A>
+				<A href="ref.html">boost/ref.hpp</A>
 			<li>
 				<A href="mem_fn.html">boost/mem_fn.hpp</A>
 			<li>

doc/ref.xml

@@ -0,0 +1,240 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!DOCTYPE library PUBLIC "-//Boost//DTD BoostBook XML V1.0//EN"
+  "http://www.boost.org/tools/boostbook/dtd/boostbook.dtd">
+<library name="Ref" dirname="ref" id="ref" last-revision="$Date$">
+  <libraryinfo>
+    <author>
+      <firstname>Jaakko</firstname>
+      <surname>J&auml;rvi</surname>
+    </author>
+    <author>
+      <firstname>Peter</firstname>
+      <surname>Dimov</surname>
+    </author>
+    <author>
+      <firstname>Douglas</firstname>
+      <surname>Gregor</surname>
+    </author>
+    <author>
+      <firstname>Dave</firstname>
+      <surname>Abrahams</surname>
+    </author>
+
+    <copyright>
+      <year>1999</year>
+      <year>2000</year>
+      <holder>Jaakko J&auml;rvi</holder>
+    </copyright>
+
+    <copyright>
+      <year>2001</year>
+      <year>2002</year>
+      <holder>Peter Dimov</holder>
+    </copyright>
+    
+    <copyright>
+      <year>2002</year>
+      <holder>David Abrahams</holder>
+    </copyright>
+
+    <legalnotice>
+      <para>Subject to the Boost Software License, Version 1.0. See 
+      accompanying file <filename>LICENSE_1_0.txt</filename> or copy at
+      <ulink url="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</ulink>.
+      </para>
+    </legalnotice>
+
+    <librarypurpose>A utility library for passing references to generic functions</librarypurpose>
+    <librarycategory name="category:higher-order"/>
+  </libraryinfo>
+
+<title>Boost.Ref</title>
+
+<section id="ref.intro">
+  <title>Introduction</title> 
+
+  <using-namespace name="boost"/>
+
+  <para>The Ref library is a small library that is useful for passing
+  references to function templates (algorithms) that would usually
+  take copies of their arguments. It defines the class template
+  <code><classname>boost::reference_wrapper&lt;T&gt;</classname></code>,
+  the two functions
+  <code><functionname>boost::ref</functionname></code> and
+  <code><functionname>boost::cref</functionname></code> that return
+  instances of <code>boost::reference_wrapper&lt;T&gt;</code>, and the
+  two traits classes
+  <code><classname>boost::is_reference_wrapper&lt;T&gt;</classname></code>
+  and
+  <code><classname>boost::unwrap_reference&lt;T&gt;</classname></code>.</para>
+
+  <para>The purpose of
+  <code>boost::reference_wrapper&lt;T&gt;</code> is to
+  contain a reference to an object of type T. It is primarily used to
+  "feed" references to function templates (algorithms) that take their
+  parameter by value.</para>
+
+  <para>To support this usage,
+  <code>boost::reference_wrapper&lt;T&gt;</code> provides an implicit
+  conversion to <code>T&amp;</code>. This usually allows the function
+  templates to work on references unmodified.</para>
+
+  <para><code>boost::reference_wrapper&lt;T&gt;</code> is
+  both CopyConstructible and Assignable (ordinary references are not
+  Assignable).</para>
+
+  <para>The expression <code>boost::ref(x)</code>
+  returns a
+  <code>boost::reference_wrapper&lt;X&gt;(x)</code> where X
+  is the type of x. Similarly,
+  <code>boost::cref(x)</code> returns a
+  <code>boost::reference_wrapper&lt;X const&gt;(x)</code>.</para>
+
+  <para>The expression
+  <code>boost::is_reference_wrapper&lt;T&gt;::value</code>
+  is true if T is a <code>reference_wrapper</code>, and
+  false otherwise.</para>
+
+  <para>The type-expression
+  <code>boost::unwrap_reference&lt;T&gt;::type</code> is T::type if T
+  is a <code>reference_wrapper</code>, T otherwise.</para>
+</section>
+
+<library-reference>
+<header name="boost/ref.hpp">
+  <namespace name="boost">
+    <class name="reference_wrapper">
+      <template>
+        <template-type-parameter name="T"/>
+      </template>
+      <purpose>
+        Contains a reference to an object of type
+        <computeroutput>T</computeroutput>. 
+      </purpose>
+
+      <description>
+        <para><computeroutput><classname>reference_wrapper</classname></computeroutput>
+        is primarily used to "feed" references to function templates
+        (algorithms) that take their parameter by value.  It provides
+        an implicit conversion to
+        <computeroutput>T&amp;</computeroutput>, which usually allows
+        the function templates to work on references
+        unmodified.</para>
+      </description>
+
+      <typedef name="type"><type>T</type></typedef>
+
+      <constructor specifiers="explicit">
+        <parameter name="t">
+          <paramtype>T&amp;</paramtype>
+        </parameter>
+
+        <effects><simpara>Constructs a
+        <computeroutput><classname>reference_wrapper</classname></computeroutput>
+        object that stores a reference to
+        <computeroutput>t</computeroutput>.</simpara></effects>
+
+        <throws><simpara>Does not throw.</simpara></throws>
+      </constructor>    
+
+      <method-group name="access">
+        <method name="conversion-operator" cv="const">
+          <type>T&amp;</type>
+          <returns><simpara>The stored reference.</simpara></returns>
+          <throws><simpara>Does not throw.</simpara></throws>
+        </method>
+
+        <method name="get" cv="const">
+          <type>T&amp;</type>
+          <returns><simpara>The stored reference.</simpara></returns>
+          <throws><simpara>Does not throw.</simpara></throws>
+        </method>
+
+        <method name="get_pointer" cv="const">
+          <type>T*</type>
+          <returns><simpara>A pointer to the object referenced by the stored reference.</simpara></returns>
+          <throws><simpara>Does not throw.</simpara></throws>
+        </method>
+      </method-group>
+
+      <free-function-group name="constructors">
+        <function name="ref">
+          <type>reference_wrapper&lt;T&gt;</type>
+          <parameter name="t">
+            <paramtype>T&amp;</paramtype>
+          </parameter>
+
+          <returns><simpara><computeroutput><classname>reference_wrapper</classname>&lt;T&gt;(t)</computeroutput></simpara></returns>
+
+          <throws><simpara>Does not throw.</simpara></throws>
+        </function>
+
+        <function name="cref">
+          <type>reference_wrapper&lt;T const&gt;</type>
+          <parameter name="t">
+            <paramtype>T const&amp;</paramtype>
+          </parameter>
+
+          <returns><simpara><computeroutput><classname>reference_wrapper</classname>&lt;T const&gt;(t)</computeroutput></simpara></returns>
+
+          <throws><simpara>Does not throw.</simpara></throws>
+        </function>
+      </free-function-group>
+    </class>
+
+    <class name="is_reference_wrapper">
+      <template>
+        <template-type-parameter name="T"/>
+      </template>
+
+      <purpose>Determine if a type <computeroutput>T</computeroutput> is an instantiation of <computeroutput><classname>reference_wrapper</classname></computeroutput>.</purpose>
+
+      <description>
+        <para>The <computeroutput>value</computeroutput> static
+        constant will be <computeroutput>true</computeroutput> iff the
+        type <computeroutput>T</computeroutput> is a specialization of
+        <computeroutput><classname>reference_wrapper</classname></computeroutput>.</para>
+      </description>
+
+      <static-constant name="value">
+        <type>bool</type>
+        <default><emphasis>unspecified</emphasis></default>
+      </static-constant>
+    </class>
+
+    <class name="unwrap_reference">
+      <template>
+        <template-type-parameter name="T"/>
+      </template>
+  
+      <purpose>Find the type in a <computeroutput><classname>reference_wrapper</classname></computeroutput>.</purpose>
+
+      <description>
+        <para>The typedef <computeroutput>type</computeroutput> is
+        <computeroutput>T::type</computeroutput> if
+        <computeroutput>T</computeroutput> is a
+        <computeroutput><classname>reference_wrapper</classname></computeroutput>,
+        <computeroutput>T</computeroutput> otherwise.</para>
+      </description>
+
+      <typedef name="type"><type><emphasis>unspecified</emphasis></type></typedef>
+    </class>
+  </namespace>
+</header>
+</library-reference>
+
+<section id="ref.ack">
+  <title>Acknowledgements</title>
+
+  <using-namespace name="boost"/> 
+
+  <para><functionname>ref</functionname> and <functionname>cref</functionname>
+  were originally part of the <libraryname>Tuple</libraryname> library
+  by Jaakko J&auml;rvi. They were "promoted to boost:: status" by
+  Peter Dimov because they are generally useful.  Douglas Gregor and
+  Dave Abrahams contributed
+  <classname>is_reference_wrapper</classname> and
+  <classname>unwrap_reference</classname>.</para>
+</section>
+
+</library>

include/boost/bind/arg.hpp

@@ -21,7 +21,6 @@
 
 #include <boost/config.hpp>
 #include <boost/is_placeholder.hpp>
-#include <boost/static_assert.hpp>
 
 namespace boost
 {
@@ -34,7 +33,8 @@ template< int I > struct arg
 
     template< class T > arg( T const & /* t */ )
     {
-        BOOST_STATIC_ASSERT( I == is_placeholder<T>::value );
+        // static assert I == is_placeholder<T>::value
+        typedef char T_must_be_placeholder[ I == is_placeholder<T>::value? 1: -1 ];
     }
 };
 

include/boost/bind/mem_fn.hpp

@@ -1,389 +0,0 @@
-#ifndef BOOST_BIND_MEM_FN_HPP_INCLUDED
-#define BOOST_BIND_MEM_FN_HPP_INCLUDED
-
-// MS compatible compilers support #pragma once
-
-#if defined(_MSC_VER) && (_MSC_VER >= 1020)
-# pragma once
-#endif
-
-//
-//  mem_fn.hpp - a generalization of std::mem_fun[_ref]
-//
-//  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
-//  Copyright (c) 2001 David Abrahams
-//  Copyright (c) 2003-2005 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-//  See http://www.boost.org/libs/bind/mem_fn.html for documentation.
-//
-
-#include <boost/config.hpp>
-#include <boost/get_pointer.hpp>
-#include <boost/detail/workaround.hpp>
-
-namespace boost
-{
-
-#if defined(BOOST_NO_VOID_RETURNS)
-
-#define BOOST_MEM_FN_CLASS_F , class F
-#define BOOST_MEM_FN_TYPEDEF(X)
-
-namespace _mfi // mem_fun_impl
-{
-
-template<class V> struct mf
-{
-
-#define BOOST_MEM_FN_RETURN return
-
-#define BOOST_MEM_FN_NAME(X) inner_##X
-#define BOOST_MEM_FN_CC
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#ifdef BOOST_MEM_FN_ENABLE_CDECL
-
-#define BOOST_MEM_FN_NAME(X) inner_##X##_cdecl
-#define BOOST_MEM_FN_CC __cdecl
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
-
-#define BOOST_MEM_FN_NAME(X) inner_##X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
-
-#define BOOST_MEM_FN_NAME(X) inner_##X##_fastcall
-#define BOOST_MEM_FN_CC __fastcall
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#undef BOOST_MEM_FN_RETURN
-
-}; // struct mf<V>
-
-template<> struct mf<void>
-{
-
-#define BOOST_MEM_FN_RETURN
-
-#define BOOST_MEM_FN_NAME(X) inner_##X
-#define BOOST_MEM_FN_CC
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#ifdef BOOST_MEM_FN_ENABLE_CDECL
-
-#define BOOST_MEM_FN_NAME(X) inner_##X##_cdecl
-#define BOOST_MEM_FN_CC __cdecl
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
-
-#define BOOST_MEM_FN_NAME(X) inner_##X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
-
-#define BOOST_MEM_FN_NAME(X) inner_##X##_fastcall
-#define BOOST_MEM_FN_CC __fastcall
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#undef BOOST_MEM_FN_RETURN
-
-}; // struct mf<void>
-
-#undef BOOST_MEM_FN_CLASS_F
-#undef BOOST_MEM_FN_TYPEDEF_F
-
-#define BOOST_MEM_FN_NAME(X) X
-#define BOOST_MEM_FN_NAME2(X) inner_##X
-#define BOOST_MEM_FN_CC
-
-#include <boost/bind/mem_fn_vw.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_NAME2
-#undef BOOST_MEM_FN_CC
-
-#ifdef BOOST_MEM_FN_ENABLE_CDECL
-
-#define BOOST_MEM_FN_NAME(X) X##_cdecl
-#define BOOST_MEM_FN_NAME2(X) inner_##X##_cdecl
-#define BOOST_MEM_FN_CC __cdecl
-
-#include <boost/bind/mem_fn_vw.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_NAME2
-#undef BOOST_MEM_FN_CC
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
-
-#define BOOST_MEM_FN_NAME(X) X##_stdcall
-#define BOOST_MEM_FN_NAME2(X) inner_##X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
-
-#include <boost/bind/mem_fn_vw.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_NAME2
-#undef BOOST_MEM_FN_CC
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
-
-#define BOOST_MEM_FN_NAME(X) X##_fastcall
-#define BOOST_MEM_FN_NAME2(X) inner_##X##_fastcall
-#define BOOST_MEM_FN_CC __fastcall
-
-#include <boost/bind/mem_fn_vw.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_NAME2
-#undef BOOST_MEM_FN_CC
-
-#endif
-
-} // namespace _mfi
-
-#else // #ifdef BOOST_NO_VOID_RETURNS
-
-#define BOOST_MEM_FN_CLASS_F
-#define BOOST_MEM_FN_TYPEDEF(X) typedef X;
-
-namespace _mfi
-{
-
-#define BOOST_MEM_FN_RETURN return
-
-#define BOOST_MEM_FN_NAME(X) X
-#define BOOST_MEM_FN_CC
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#ifdef BOOST_MEM_FN_ENABLE_CDECL
-
-#define BOOST_MEM_FN_NAME(X) X##_cdecl
-#define BOOST_MEM_FN_CC __cdecl
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
-
-#define BOOST_MEM_FN_NAME(X) X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
-
-#define BOOST_MEM_FN_NAME(X) X##_fastcall
-#define BOOST_MEM_FN_CC __fastcall
-
-#include <boost/bind/mem_fn_template.hpp>
-
-#undef BOOST_MEM_FN_CC
-#undef BOOST_MEM_FN_NAME
-
-#endif
-
-#undef BOOST_MEM_FN_RETURN
-
-} // namespace _mfi
-
-#undef BOOST_MEM_FN_CLASS_F
-#undef BOOST_MEM_FN_TYPEDEF
-
-#endif // #ifdef BOOST_NO_VOID_RETURNS
-
-#define BOOST_MEM_FN_NAME(X) X
-#define BOOST_MEM_FN_CC
-
-#include <boost/bind/mem_fn_cc.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_CC
-
-#ifdef BOOST_MEM_FN_ENABLE_CDECL
-
-#define BOOST_MEM_FN_NAME(X) X##_cdecl
-#define BOOST_MEM_FN_CC __cdecl
-
-#include <boost/bind/mem_fn_cc.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_CC
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_STDCALL
-
-#define BOOST_MEM_FN_NAME(X) X##_stdcall
-#define BOOST_MEM_FN_CC __stdcall
-
-#include <boost/bind/mem_fn_cc.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_CC
-
-#endif
-
-#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
-
-#define BOOST_MEM_FN_NAME(X) X##_fastcall
-#define BOOST_MEM_FN_CC __fastcall
-
-#include <boost/bind/mem_fn_cc.hpp>
-
-#undef BOOST_MEM_FN_NAME
-#undef BOOST_MEM_FN_CC
-
-#endif
-
-// data member support
-
-namespace _mfi
-{
-
-template<class R, class T> class dm
-{
-public:
-
-    typedef R const & result_type;
-    typedef T const * argument_type;
-
-private:
-    
-    typedef R (T::*F);
-    F f_;
-
-    template<class U> R const & call(U & u, T const *) const
-    {
-        return (u.*f_);
-    }
-
-    template<class U> R const & call(U & u, void const *) const
-    {
-        return (get_pointer(u)->*f_);
-    }
-
-public:
-    
-    explicit dm(F f): f_(f) {}
-
-    R & operator()(T * p) const
-    {
-        return (p->*f_);
-    }
-
-    R const & operator()(T const * p) const
-    {
-        return (p->*f_);
-    }
-
-    template<class U> R const & operator()(U const & u) const
-    {
-        return call(u, &u);
-    }
-
-#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) && !BOOST_WORKAROUND(__MWERKS__, < 0x3200)
-
-    R & operator()(T & t) const
-    {
-        return (t.*f_);
-    }
-
-    R const & operator()(T const & t) const
-    {
-        return (t.*f_);
-    }
-
-#endif
-
-    bool operator==(dm const & rhs) const
-    {
-        return f_ == rhs.f_;
-    }
-
-    bool operator!=(dm const & rhs) const
-    {
-        return f_ != rhs.f_;
-    }
-};
-
-} // namespace _mfi
-
-template<class R, class T> _mfi::dm<R, T> mem_fn(R T::*f)
-{
-    return _mfi::dm<R, T>(f);
-}
-
-} // namespace boost
-
-#endif // #ifndef BOOST_BIND_MEM_FN_HPP_INCLUDED

include/boost/bind/mem_fn_template.hpp

@@ -51,16 +51,14 @@ public:
 
     template<class U> R operator()(U & u) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p);
+        BOOST_MEM_FN_RETURN call(u, &u);
     }
 
 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 
     template<class U> R operator()(U const & u) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p);
+        BOOST_MEM_FN_RETURN call(u, &u);
     }
 
 #endif
@@ -111,8 +109,7 @@ public:
 
     template<class U> R operator()(U const & u) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p);
+        BOOST_MEM_FN_RETURN call(u, &u);
     }
 
     R operator()(T const & t) const
@@ -167,16 +164,14 @@ public:
 
     template<class U> R operator()(U & u, A1 a1) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1);
+        BOOST_MEM_FN_RETURN call(u, &u, a1);
     }
 
 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 
     template<class U> R operator()(U const & u, A1 a1) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1);
+        BOOST_MEM_FN_RETURN call(u, &u, a1);
     }
 
 #endif
@@ -228,8 +223,7 @@ public:
 
     template<class U> R operator()(U const & u, A1 a1) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1);
+        BOOST_MEM_FN_RETURN call(u, &u, a1);
     }
 
     R operator()(T const & t, A1 a1) const
@@ -282,16 +276,14 @@ public:
 
     template<class U> R operator()(U & u, A1 a1, A2 a2) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2);
+        BOOST_MEM_FN_RETURN call(u, &u, a1, a2);
     }
 
 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2);
+        BOOST_MEM_FN_RETURN call(u, &u, a1, a2);
     }
 
 #endif
@@ -341,8 +333,7 @@ public:
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2);
+        BOOST_MEM_FN_RETURN call(u, &u, a1, a2);
     }
 
     R operator()(T const & t, A1 a1, A2 a2) const
@@ -395,16 +386,14 @@ public:
 
     template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3);
+        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3);
     }
 
 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3);
+        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3);
     }
 
 #endif
@@ -454,8 +443,7 @@ public:
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3);
+        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3);
     }
 
     R operator()(T const & t, A1 a1, A2 a2, A3 a3) const
@@ -508,16 +496,14 @@ public:
 
     template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4);
+        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4);
     }
 
 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4);
+        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4);
     }
 
 #endif
@@ -567,8 +553,7 @@ public:
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4);
+        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4);
     }
 
     R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4) const
@@ -621,16 +606,14 @@ public:
 
     template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5);
+        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5);
     }
 
 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5);
+        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5);
     }
 
 #endif
@@ -680,8 +663,7 @@ public:
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5);
+        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5);
     }
 
     R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5) const
@@ -734,16 +716,14 @@ public:
 
     template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6);
+        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6);
     }
 
 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6);
+        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6);
     }
 
 #endif
@@ -793,8 +773,7 @@ public:
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6);
+        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6);
     }
 
     R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6) const
@@ -847,16 +826,14 @@ public:
 
     template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7);
+        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6, a7);
     }
 
 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7);
+        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6, a7);
     }
 
 #endif
@@ -906,8 +883,7 @@ public:
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7);
+        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6, a7);
     }
 
     R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7) const
@@ -960,16 +936,14 @@ public:
 
     template<class U> R operator()(U & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
+        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6, a7, a8);
     }
 
 #ifdef BOOST_MEM_FN_ENABLE_CONST_OVERLOADS
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
+        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6, a7, a8);
     }
 
 #endif
@@ -1024,8 +998,7 @@ public:
 
     template<class U> R operator()(U const & u, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const
     {
-        U const * p = 0;
-        BOOST_MEM_FN_RETURN call(u, p, a1, a2, a3, a4, a5, a6, a7, a8);
+        BOOST_MEM_FN_RETURN call(u, &u, a1, a2, a3, a4, a5, a6, a7, a8);
     }
 
     R operator()(T const & t, A1 a1, A2 a2, A3 a3, A4 a4, A5 a5, A6 a6, A7 a7, A8 a8) const

include/boost/bind/placeholders.hpp

@@ -25,7 +25,7 @@
 namespace
 {
 
-#if defined(__BORLANDC__) || defined(__GNUC__) && (__GNUC__ < 4)
+#if defined(__BORLANDC__) || defined(__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ <= 400)
 
 static inline boost::arg<1> _1() { return boost::arg<1>(); }
 static inline boost::arg<2> _2() { return boost::arg<2>(); }
@@ -37,8 +37,7 @@ static inline boost::arg<7> _7() { return boost::arg<7>(); }
 static inline boost::arg<8> _8() { return boost::arg<8>(); }
 static inline boost::arg<9> _9() { return boost::arg<9>(); }
 
-#elif defined(BOOST_MSVC) || (defined(__DECCXX_VER) && __DECCXX_VER <= 60590031) || defined(__MWERKS__) || \
-    defined(__GNUC__) && (__GNUC__ == 4 && __GNUC_MINOR__ < 2)  
+#elif defined(BOOST_MSVC) || (defined(__DECCXX_VER) && __DECCXX_VER <= 60590031) || defined(__MWERKS__)
 
 static boost::arg<1> _1;
 static boost::arg<2> _2;

include/boost/bind/protect.hpp

@@ -5,16 +5,12 @@
 //  protect.hpp
 //
 //  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
-//  Copyright (c) 2009 Steven Watanabe
 //
 // Distributed under the Boost Software License, Version 1.0. (See
 // accompanying file LICENSE_1_0.txt or copy at
 // http://www.boost.org/LICENSE_1_0.txt)
 //
 
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
 namespace boost
 {
 
@@ -51,22 +47,6 @@ public:
         return f_(a1);
     }
 
-
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
-
-    template<class A1> result_type operator()(const A1 & a1)
-    {
-        return f_(a1);
-    }
-
-    template<class A1> result_type operator()(const A1 & a1) const
-    {
-        return f_(a1);
-    }
-
-#endif
-
     template<class A1, class A2> result_type operator()(A1 & a1, A2 & a2)
     {
         return f_(a1, a2);
@@ -77,41 +57,6 @@ public:
         return f_(a1, a2);
     }
 
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
-
-    template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2)
-    {
-        return f_(a1, a2);
-    }
-
-    template<class A1, class A2> result_type operator()(A1 const & a1, A2 & a2) const
-    {
-        return f_(a1, a2);
-    }
-
-    template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2)
-    {
-        return f_(a1, a2);
-    }
-
-    template<class A1, class A2> result_type operator()(A1 & a1, A2 const & a2) const
-    {
-        return f_(a1, a2);
-    }
-
-    template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2)
-    {
-        return f_(a1, a2);
-    }
-
-    template<class A1, class A2> result_type operator()(A1 const & a1, A2 const & a2) const
-    {
-        return f_(a1, a2);
-    }
-
-#endif
-
     template<class A1, class A2, class A3> result_type operator()(A1 & a1, A2 & a2, A3 & a3)
     {
         return f_(a1, a2, a3);
@@ -121,21 +66,6 @@ public:
     {
         return f_(a1, a2, a3);
     }
-    
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
-
-    template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3)
-    {
-        return f_(a1, a2, a3);
-    }
-
-    template<class A1, class A2, class A3> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3) const
-    {
-        return f_(a1, a2, a3);
-    }
-    
-#endif
 
     template<class A1, class A2, class A3, class A4> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4)
     {
@@ -146,21 +76,6 @@ public:
     {
         return f_(a1, a2, a3, a4);
     }
-    
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
-
-    template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4)
-    {
-        return f_(a1, a2, a3, a4);
-    }
-
-    template<class A1, class A2, class A3, class A4> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4) const
-    {
-        return f_(a1, a2, a3, a4);
-    }
-
-#endif
 
     template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5)
     {
@@ -171,21 +86,6 @@ public:
     {
         return f_(a1, a2, a3, a4, a5);
     }
-    
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
-
-    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5)
-    {
-        return f_(a1, a2, a3, a4, a5);
-    }
-
-    template<class A1, class A2, class A3, class A4, class A5> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5) const
-    {
-        return f_(a1, a2, a3, a4, a5);
-    }
-
-#endif
 
     template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6)
     {
@@ -196,21 +96,6 @@ public:
     {
         return f_(a1, a2, a3, a4, a5, a6);
     }
-    
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
-
-    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6)
-    {
-        return f_(a1, a2, a3, a4, a5, a6);
-    }
-
-    template<class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6) const
-    {
-        return f_(a1, a2, a3, a4, a5, a6);
-    }
-
-#endif
 
     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7)
     {
@@ -221,21 +106,6 @@ public:
     {
         return f_(a1, a2, a3, a4, a5, a6, a7);
     }
-    
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
-
-    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7)
-    {
-        return f_(a1, a2, a3, a4, a5, a6, a7);
-    }
-
-    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7) const
-    {
-        return f_(a1, a2, a3, a4, a5, a6, a7);
-    }
-
-#endif
 
     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8)
     {
@@ -246,21 +116,6 @@ public:
     {
         return f_(a1, a2, a3, a4, a5, a6, a7, a8);
     }
-    
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
-
-    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8)
-    {
-        return f_(a1, a2, a3, a4, a5, a6, a7, a8);
-    }
-
-    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8) const
-    {
-        return f_(a1, a2, a3, a4, a5, a6, a7, a8);
-    }
-
-#endif
 
     template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9)
     {
@@ -271,21 +126,6 @@ public:
     {
         return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
     }
-    
-#if !defined(BOOST_NO_FUNCTION_TEMPLATE_ORDERING) \
- && !BOOST_WORKAROUND(__EDG_VERSION__, <= 238)
-
-    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9)
-    {
-        return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-    }
-
-    template<class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(A1 const & a1, A2 const & a2, A3 const & a3, A4 const & a4, A5 const & a5, A6 const & a6, A7 const & a7, A8 const & a8, A9 const & a9) const
-    {
-        return f_(a1, a2, a3, a4, a5, a6, a7, a8, a9);
-    }
-
-#endif
 
 private:
 

include/boost/mem_fn.hpp

@@ -10,15 +10,380 @@
 //
 //  mem_fn.hpp - a generalization of std::mem_fun[_ref]
 //
-//  Copyright (c) 2009 Peter Dimov
+//  Copyright (c) 2001, 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2001 David Abrahams
+//  Copyright (c) 2003-2005 Peter Dimov
 //
-//  Distributed under the Boost Software License, Version 1.0.
-//  See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt
+// Distributed under the Boost Software License, Version 1.0. (See
+// accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
 //
 //  See http://www.boost.org/libs/bind/mem_fn.html for documentation.
 //
 
-#include <boost/bind/mem_fn.hpp>
+#include <boost/config.hpp>
+#include <boost/get_pointer.hpp>
+#include <boost/detail/workaround.hpp>
+
+namespace boost
+{
+
+#if defined(BOOST_NO_VOID_RETURNS)
+
+#define BOOST_MEM_FN_CLASS_F , class F
+#define BOOST_MEM_FN_TYPEDEF(X)
+
+namespace _mfi // mem_fun_impl
+{
+
+template<class V> struct mf
+{
+
+#define BOOST_MEM_FN_RETURN return
+
+#define BOOST_MEM_FN_NAME(X) inner_##X
+#define BOOST_MEM_FN_CC
+
+#include <boost/bind/mem_fn_template.hpp>
+
+#undef BOOST_MEM_FN_CC
+#undef BOOST_MEM_FN_NAME
+
+#ifdef BOOST_MEM_FN_ENABLE_CDECL
+
+#define BOOST_MEM_FN_NAME(X) inner_##X##_cdecl
+#define BOOST_MEM_FN_CC __cdecl
+
+#include <boost/bind/mem_fn_template.hpp>
+
+#undef BOOST_MEM_FN_CC
+#undef BOOST_MEM_FN_NAME
+
+#endif
+
+#ifdef BOOST_MEM_FN_ENABLE_STDCALL
+
+#define BOOST_MEM_FN_NAME(X) inner_##X##_stdcall
+#define BOOST_MEM_FN_CC __stdcall
+
+#include <boost/bind/mem_fn_template.hpp>
+
+#undef BOOST_MEM_FN_CC
+#undef BOOST_MEM_FN_NAME
+
+#endif
+
+#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
+
+#define BOOST_MEM_FN_NAME(X) inner_##X##_fastcall
+#define BOOST_MEM_FN_CC __fastcall
+
+#include <boost/bind/mem_fn_template.hpp>
+
+#undef BOOST_MEM_FN_CC
+#undef BOOST_MEM_FN_NAME
+
+#endif
+
+#undef BOOST_MEM_FN_RETURN
+
+}; // struct mf<V>
+
+template<> struct mf<void>
+{
+
+#define BOOST_MEM_FN_RETURN
+
+#define BOOST_MEM_FN_NAME(X) inner_##X
+#define BOOST_MEM_FN_CC
+
+#include <boost/bind/mem_fn_template.hpp>
+
+#undef BOOST_MEM_FN_CC
+#undef BOOST_MEM_FN_NAME
+
+#ifdef BOOST_MEM_FN_ENABLE_CDECL
+
+#define BOOST_MEM_FN_NAME(X) inner_##X##_cdecl
+#define BOOST_MEM_FN_CC __cdecl
+
+#include <boost/bind/mem_fn_template.hpp>
+
+#undef BOOST_MEM_FN_CC
+#undef BOOST_MEM_FN_NAME
+
+#endif
+
+#ifdef BOOST_MEM_FN_ENABLE_STDCALL
+
+#define BOOST_MEM_FN_NAME(X) inner_##X##_stdcall
+#define BOOST_MEM_FN_CC __stdcall
+
+#include <boost/bind/mem_fn_template.hpp>
+
+#undef BOOST_MEM_FN_CC
+#undef BOOST_MEM_FN_NAME
+
+#endif
+
+#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
+
+#define BOOST_MEM_FN_NAME(X) inner_##X##_fastcall
+#define BOOST_MEM_FN_CC __fastcall
+
+#include <boost/bind/mem_fn_template.hpp>
+
+#undef BOOST_MEM_FN_CC
+#undef BOOST_MEM_FN_NAME
+
+#endif
+
+#undef BOOST_MEM_FN_RETURN
+
+}; // struct mf<void>
+
+#undef BOOST_MEM_FN_CLASS_F
+#undef BOOST_MEM_FN_TYPEDEF_F
+
+#define BOOST_MEM_FN_NAME(X) X
+#define BOOST_MEM_FN_NAME2(X) inner_##X
+#define BOOST_MEM_FN_CC
+
+#include <boost/bind/mem_fn_vw.hpp>
+
+#undef BOOST_MEM_FN_NAME
+#undef BOOST_MEM_FN_NAME2
+#undef BOOST_MEM_FN_CC
+
+#ifdef BOOST_MEM_FN_ENABLE_CDECL
+
+#define BOOST_MEM_FN_NAME(X) X##_cdecl
+#define BOOST_MEM_FN_NAME2(X) inner_##X##_cdecl
+#define BOOST_MEM_FN_CC __cdecl
+
+#include <boost/bind/mem_fn_vw.hpp>
+
+#undef BOOST_MEM_FN_NAME
+#undef BOOST_MEM_FN_NAME2
+#undef BOOST_MEM_FN_CC
+
+#endif
+
+#ifdef BOOST_MEM_FN_ENABLE_STDCALL
+
+#define BOOST_MEM_FN_NAME(X) X##_stdcall
+#define BOOST_MEM_FN_NAME2(X) inner_##X##_stdcall
+#define BOOST_MEM_FN_CC __stdcall
+
+#include <boost/bind/mem_fn_vw.hpp>
+
+#undef BOOST_MEM_FN_NAME
+#undef BOOST_MEM_FN_NAME2
+#undef BOOST_MEM_FN_CC
+
+#endif
+
+#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
+
+#define BOOST_MEM_FN_NAME(X) X##_fastcall
+#define BOOST_MEM_FN_NAME2(X) inner_##X##_fastcall
+#define BOOST_MEM_FN_CC __fastcall
+
+#include <boost/bind/mem_fn_vw.hpp>
+
+#undef BOOST_MEM_FN_NAME
+#undef BOOST_MEM_FN_NAME2
+#undef BOOST_MEM_FN_CC
+
+#endif
+
+} // namespace _mfi
+
+#else // #ifdef BOOST_NO_VOID_RETURNS
+
+#define BOOST_MEM_FN_CLASS_F
+#define BOOST_MEM_FN_TYPEDEF(X) typedef X;
+
+namespace _mfi
+{
+
+#define BOOST_MEM_FN_RETURN return
+
+#define BOOST_MEM_FN_NAME(X) X
+#define BOOST_MEM_FN_CC
+
+#include <boost/bind/mem_fn_template.hpp>
+
+#undef BOOST_MEM_FN_CC
+#undef BOOST_MEM_FN_NAME
+
+#ifdef BOOST_MEM_FN_ENABLE_CDECL
+
+#define BOOST_MEM_FN_NAME(X) X##_cdecl
+#define BOOST_MEM_FN_CC __cdecl
+
+#include <boost/bind/mem_fn_template.hpp>
+
+#undef BOOST_MEM_FN_CC
+#undef BOOST_MEM_FN_NAME
+
+#endif
+
+#ifdef BOOST_MEM_FN_ENABLE_STDCALL
+
+#define BOOST_MEM_FN_NAME(X) X##_stdcall
+#define BOOST_MEM_FN_CC __stdcall
+
+#include <boost/bind/mem_fn_template.hpp>
+
+#undef BOOST_MEM_FN_CC
+#undef BOOST_MEM_FN_NAME
+
+#endif
+
+#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
+
+#define BOOST_MEM_FN_NAME(X) X##_fastcall
+#define BOOST_MEM_FN_CC __fastcall
+
+#include <boost/bind/mem_fn_template.hpp>
+
+#undef BOOST_MEM_FN_CC
+#undef BOOST_MEM_FN_NAME
+
+#endif
+
+#undef BOOST_MEM_FN_RETURN
+
+} // namespace _mfi
+
+#undef BOOST_MEM_FN_CLASS_F
+#undef BOOST_MEM_FN_TYPEDEF
+
+#endif // #ifdef BOOST_NO_VOID_RETURNS
+
+#define BOOST_MEM_FN_NAME(X) X
+#define BOOST_MEM_FN_CC
+
+#include <boost/bind/mem_fn_cc.hpp>
+
+#undef BOOST_MEM_FN_NAME
+#undef BOOST_MEM_FN_CC
+
+#ifdef BOOST_MEM_FN_ENABLE_CDECL
+
+#define BOOST_MEM_FN_NAME(X) X##_cdecl
+#define BOOST_MEM_FN_CC __cdecl
+
+#include <boost/bind/mem_fn_cc.hpp>
+
+#undef BOOST_MEM_FN_NAME
+#undef BOOST_MEM_FN_CC
+
+#endif
+
+#ifdef BOOST_MEM_FN_ENABLE_STDCALL
+
+#define BOOST_MEM_FN_NAME(X) X##_stdcall
+#define BOOST_MEM_FN_CC __stdcall
+
+#include <boost/bind/mem_fn_cc.hpp>
+
+#undef BOOST_MEM_FN_NAME
+#undef BOOST_MEM_FN_CC
+
+#endif
+
+#ifdef BOOST_MEM_FN_ENABLE_FASTCALL
+
+#define BOOST_MEM_FN_NAME(X) X##_fastcall
+#define BOOST_MEM_FN_CC __fastcall
+
+#include <boost/bind/mem_fn_cc.hpp>
+
+#undef BOOST_MEM_FN_NAME
+#undef BOOST_MEM_FN_CC
+
+#endif
+
+// data member support
+
+namespace _mfi
+{
+
+template<class R, class T> class dm
+{
+public:
+
+    typedef R const & result_type;
+    typedef T const * argument_type;
+
+private:
+    
+    typedef R (T::*F);
+    F f_;
+
+    template<class U> R const & call(U & u, T const *) const
+    {
+        return (u.*f_);
+    }
+
+    template<class U> R const & call(U & u, void const *) const
+    {
+        return (get_pointer(u)->*f_);
+    }
+
+public:
+    
+    explicit dm(F f): f_(f) {}
+
+    R & operator()(T * p) const
+    {
+        return (p->*f_);
+    }
+
+    R const & operator()(T const * p) const
+    {
+        return (p->*f_);
+    }
+
+    template<class U> R const & operator()(U const & u) const
+    {
+        return call(u, &u);
+    }
+
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) && !BOOST_WORKAROUND(__MWERKS__, < 0x3200)
+
+    R & operator()(T & t) const
+    {
+        return (t.*f_);
+    }
+
+    R const & operator()(T const & t) const
+    {
+        return (t.*f_);
+    }
+
+#endif
+
+    bool operator==(dm const & rhs) const
+    {
+        return f_ == rhs.f_;
+    }
+
+    bool operator!=(dm const & rhs) const
+    {
+        return f_ != rhs.f_;
+    }
+};
+
+} // namespace _mfi
+
+template<class R, class T> _mfi::dm<R, T> mem_fn(R T::*f)
+{
+    return _mfi::dm<R, T>(f);
+}
+
+} // namespace boost
 
 #endif // #ifndef BOOST_MEM_FN_HPP_INCLUDED

mem_fn.html

@@ -1,405 +1,14 @@
 <html>
-	<head>
-		<title>Boost: mem_fn.hpp documentation</title>
-		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-	</head>
-	<body bgcolor="white" style="MARGIN-LEFT: 5%; MARGIN-RIGHT: 5%">
-		<table border="0" width="100%">
-			<tr>
-				<td width="277"><A href="../../index.htm"> <img src="../../boost.png" alt="boost.png (6897 bytes)" width="277" height="86" border="0"></A>
-				</td>
-				<td align="center">
-					<h1>mem_fn.hpp</h1>
-				</td>
-			</tr>
-			<tr>
-				<td colspan="2" height="64">&nbsp;</td>
-			</tr>
-		</table>
-		<h2>Contents</h2>
-		<h3 style="MARGIN-LEFT: 20pt"><a href="#Purpose">Purpose</a></h3>
-		<h3 style="MARGIN-LEFT: 20pt"><a href="#FAQ">Frequently Asked Questions</a></h3>
-		<h4 style="MARGIN-LEFT: 40pt"><a href="#Q1">Can <b>mem_fn</b> be used instead of the 
-				standard <b>std::mem_fun[_ref]</b> adaptors?</a></h4>
-		<h4 style="MARGIN-LEFT: 40pt"><a href="#Q2">Should I replace every occurence of <b>std::mem_fun[_ref]</b>
-				with <b>mem_fn</b> in my existing code?</a></h4>
-		<h4 style="MARGIN-LEFT: 40pt"><a href="#Q3">Does <b>mem_fn</b> work with COM methods?</a></h4>
-		<h4 style="MARGIN-LEFT: 40pt"><a href="#Q4">Why isn't BOOST_MEM_FN_ENABLE_STDCALL 
-				defined automatically?</a></h4>
-		<h3 style="MARGIN-LEFT: 20pt"><a href="#Interface">Interface</a></h3>
-		<h4 style="MARGIN-LEFT: 40pt"><a href="#Synopsis">Synopsis</a></h4>
-		<h4 style="MARGIN-LEFT: 40pt"><a href="#CommonRequirements">Common requirements</a></h4>
-		<h4 style="MARGIN-LEFT: 40pt"><a href="#get_pointer">get_pointer</a></h4>
-		<h4 style="MARGIN-LEFT: 40pt"><a href="#mem_fn">mem_fn</a></h4>
-		<h3 style="MARGIN-LEFT: 20pt"><a href="#Implementation">Implementation</a></h3>
-		<h4 style="MARGIN-LEFT: 40pt"><a href="#Files">Files</a></h4>
-		<h4 style="MARGIN-LEFT: 40pt"><a href="#Dependencies">Dependencies</a></h4>
-		<h4 style="MARGIN-LEFT: 40pt"><a href="#NumberOfArguments">Number of Arguments</a></h4>
-		<h4 style="MARGIN-LEFT: 40pt"><a href="#stdcall">"__stdcall", "__cdecl" and 
-				"__fastcall" Support</a></h4>
-		<h3 style="MARGIN-LEFT: 20pt"><a href="#Acknowledgements">Acknowledgements</a></h3>
-		<h2><a name="Purpose">Purpose</a></h2>
-		<p>
-			<b>boost::mem_fn</b> is a generalization of the standard functions <b>std::mem_fun</b>
-			and <b>std::mem_fun_ref</b>. It supports member function pointers with more 
-			than one argument, and the returned function object can take a pointer, a 
-			reference, or a smart pointer to an object instance as its first argument. <STRONG>mem_fn</STRONG>
-			also supports pointers to data members by treating them as functions taking no 
-			arguments and returning a (const) reference to the member.
-		</p>
-		<p>
-			The purpose of <b>mem_fn</b> is twofold. First, it allows users to invoke a 
-			member function on a container with the familiar
-		</p>
-		<pre>
-    std::for_each(v.begin(), v.end(), boost::mem_fn(&amp;Shape::draw));
-</pre>
-		<p>
-			syntax, even when the container stores smart pointers.
-		</p>
-		<p>
-			Second, it can be used as a building block by library developers that want to 
-			treat a pointer to member function as a function object. A library might define 
-			an enhanced <b>for_each</b> algorithm with an overload of the form:
-		</p>
-		<pre>
-template&lt;class It, class R, class T&gt; void for_each(It first, It last, R (T::*pmf) ())
-{
-    std::for_each(first, last, boost::mem_fn(pmf));
-}
-</pre>
-		<p>
-			that will allow the convenient syntax:
-		</p>
-		<pre>
-    for_each(v.begin(), v.end(), &amp;Shape::draw);
-</pre>
-		<p>
-			When documenting the feature, the library author will simply state:
-		</p>
-		<h4 style="MARGIN-LEFT: 20pt">template&lt;class It, class R, class T&gt; void 
-			for_each(It first, It last, R (T::*pmf) ());</h4>
-		<p style="MARGIN-LEFT: 20pt">
-			<b>Effects:</b> equivalent to std::for_each(first, last, boost::mem_fn(pmf));
-		</p>
-		<p>
-			where <b>boost::mem_fn</b> can be a link to this page. See <a href="bind.html">the 
-				documentation of <b>bind</b></a> for an example.
-		</p>
-		<p>
-			<b>mem_fn</b> takes one argument, a pointer to a member, and returns a function 
-			object suitable for use with standard or user-defined algorithms:
-		</p>
-		<pre>
-struct X
-{
-    void f();
-};
-
-void g(std::vector&lt;X&gt; &amp; v)
-{
-    std::for_each(v.begin(), v.end(), boost::mem_fn(&amp;X::f));
-};
-
-void h(std::vector&lt;X *&gt; const &amp; v)
-{
-    std::for_each(v.begin(), v.end(), boost::mem_fn(&amp;X::f));
-};
-
-void k(std::vector&lt;boost::shared_ptr&lt;X&gt; &gt; const &amp; v)
-{
-    std::for_each(v.begin(), v.end(), boost::mem_fn(&amp;X::f));
-};
-</pre>
-		<p>
-			The returned function object takes the same arguments as the input member 
-			function plus a "flexible" first argument that represents the object instance.
-		</p>
-		<p>
-			When the function object is invoked with a first argument <b>x</b> that is 
-			neither a pointer nor a reference to the appropriate class (<b>X</b> in the 
-			example above), it uses <tt>get_pointer(x)</tt> to obtain a pointer from <b>x</b>. 
-			Library authors can "register" their smart pointer classes by supplying an 
-			appropriate <b>get_pointer</b> overload, allowing <b>mem_fn</b> to recognize 
-			and support them.
-		</p>
-		<p>
-			[Note: <b>get_pointer</b> is not restricted to return a pointer. Any object 
-			that can be used in a member function call expression <tt>(x-&gt;*pmf)(...)</tt>
-			will work.]
-		</p>
-		<p>
-			[Note: the library uses an unqualified call to <b>get_pointer</b>. Therefore, 
-			it will find, through argument-dependent lookup, <b>get_pointer</b> overloads 
-			that are defined in the same namespace as the corresponding smart pointer 
-			class, in addition to any <b>boost::get_pointer</b> overloads.]
-		</p>
-		<p>
-			All function objects returned by <b>mem_fn</b> expose a <b>result_type</b> typedef 
-			that represents the return type of the member function. For data members, <STRONG>result_type</STRONG>
-			is defined as the type of the member.
-		</p>
-		<h2><a name="FAQ">Frequently Asked Questions</a></h2>
-		<h3><a name="Q1">Can <b>mem_fn</b> be used instead of the standard <b>std::mem_fun[_ref]</b>
-				adaptors?</a></h3>
-		<p>
-			Yes. For simple uses, <b>mem_fn</b> provides additional functionality that the 
-			standard adaptors do not. Complicated expressions that use <b>std::bind1st</b>, <b>std::bind2nd</b>
-			or <a href="http://www.boost.org/doc/libs/1_31_0/libs/compose/index.htm"><b>Boost.Compose</b></a> along with the 
-			standard adaptors can be rewritten using <a href="bind.html"><b>boost::bind</b></a>
-			that automatically takes advantage of <b>mem_fn</b>.
-		</p>
-		<h3><a name="Q2">Should I replace every occurence of <b>std::mem_fun[_ref]</b> with <b>mem_fn</b>
-				in my existing code?</a></h3>
-		<p>
-			No, unless you have good reasons to do so. <b>mem_fn</b> is not 100% compatible 
-			with the standard adaptors, although it comes pretty close. In particular, <b>mem_fn</b>
-			does not return objects of type <b>std::[const_]mem_fun[1][_ref]_t</b>, as the 
-			standard adaptors do, and it is not possible to fully describe the type of the 
-			first argument using the standard <b>argument_type</b> and <b>first_argument_type</b>
-			nested typedefs. Libraries that need adaptable function objects in order to 
-			function might not like <b>mem_fn</b>.
-		</p>
-		<h3><a name="Q3">Does <b>mem_fn</b> work with COM methods?</a></h3>
-		<p>
-			Yes, if you <a href="#stdcall">#define BOOST_MEM_FN_ENABLE_STDCALL</a>.
-		</p>
-		<h3><a name="Q4">Why isn't BOOST_MEM_FN_ENABLE_STDCALL defined automatically?</a></h3>
-		<p>
-			Non-portable extensions, in general, should default to off to prevent vendor 
-			lock-in. Had BOOST_MEM_FN_ENABLE_STDCALL been defined automatically, you could 
-			have accidentally taken advantage of it without realizing that your code is, 
-			perhaps, no longer portable. In addition, it is possible for the default 
-			calling convention to be __stdcall, in which case enabling __stdcall support 
-			will result in duplicate definitions.
-		</p>
-		<h2><a name="Interface">Interface</a></h2>
-		<h3><a name="Synopsis">Synopsis</a></h3>
-		<pre>
-namespace boost
-{
-
-template&lt;class T&gt; T * <a href="#get_pointer_1">get_pointer</a>(T * p);
-
-template&lt;class R, class T&gt; <i>unspecified-1</i> <a href="#mem_fn_1">mem_fn</a>(R (T::*pmf) ());
-
-template&lt;class R, class T&gt; <i>unspecified-2</i> <a href="#mem_fn_2">mem_fn</a>(R (T::*pmf) () const);
-
-template&lt;class R, class T&gt; <i>unspecified-2-1</i> <a href="#mem_fn_2_1">mem_fn</a>(R T::*pm);
-
-template&lt;class R, class T, class A1&gt; <i>unspecified-3</i> <a href="#mem_fn_3">mem_fn</a>(R (T::*pmf) (A1));
-
-template&lt;class R, class T, class A1&gt; <i>unspecified-4</i> <a href="#mem_fn_4">mem_fn</a>(R (T::*pmf) (A1) const);
-
-template&lt;class R, class T, class A1, class A2&gt; <i>unspecified-5</i> <a href="#mem_fn_5">mem_fn</a>(R (T::*pmf) (A1, A2));
-
-template&lt;class R, class T, class A1, class A2&gt; <i>unspecified-6</i> <a href="#mem_fn_6">mem_fn</a>(R (T::*pmf) (A1, A2) const);
-
-// implementation defined number of additional overloads for more arguments
-
-}
-</pre>
-		<h3><a name="CommonRequirements">Common requirements</a></h3>
-		<p>
-			All <tt><i>unspecified-N</i></tt> types mentioned in the Synopsis are <b>CopyConstructible</b>
-			and <b>Assignable</b>. Their copy constructors and assignment operators do not 
-			throw exceptions. <tt><i>unspecified-N</i>::result_type</tt> is defined as the 
-			return type of the member function pointer passed as an argument to <b>mem_fn</b>
-			(<b>R</b> in the Synopsis.) <tt><i>unspecified-2-1</i>::result_type</tt> is 
-			defined as <tt>R</tt>.
-		</p>
-		<h3><a name="get_pointer">get_pointer</a></h3>
-		<h4><a name="get_pointer_1">template&lt;class T&gt; T * get_pointer(T * p)</a></h4>
-		<blockquote>
-			<p>
-				<b>Returns:</b> <tt>p</tt>.
-			</p>
-			<p>
-				<b>Throws:</b> Nothing.
-			</p>
-		</blockquote>
-		<h3><a name="mem_fn">mem_fn</a></h3>
-		<h4><a name="mem_fn_1">template&lt;class R, class T&gt; <i>unspecified-1</i> mem_fn(R 
-				(T::*pmf) ())</a></h4>
-		<blockquote>
-			<p>
-				<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t)</i></tt>
-				is equivalent to <tt>(t.*pmf)()</tt> when <i>t</i> is an l-value of type <STRONG>T </STRONG>
-				or derived, <tt>(get_pointer(t)-&gt;*pmf)()</tt> otherwise.
-			</p>
-			<p>
-				<b>Throws:</b> Nothing.
-			</p>
-		</blockquote>
-		<h4><a name="mem_fn_2">template&lt;class R, class T&gt; <i>unspecified-2</i> mem_fn(R 
-				(T::*pmf) () const)</a></h4>
-		<blockquote>
-			<p>
-				<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t)</i></tt>
-				is equivalent to <tt>(t.*pmf)()</tt> when <i>t</i> is of type <STRONG>T</STRONG>
-				<EM>[const]<STRONG> </STRONG></EM>or derived, <tt>(get_pointer(t)-&gt;*pmf)()</tt>
-				otherwise.
-			</p>
-			<p>
-				<b>Throws:</b> Nothing.
-			</p>
-		</blockquote>
-		<h4><a name="mem_fn_2_1">template&lt;class R, class T&gt; <i>unspecified-2-1</i> mem_fn(R 
-				T::*pm)</a></h4>
-		<blockquote>
-			<p>
-				<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t)</i></tt>
-				is equivalent to <tt>t.*pm</tt> when <i>t</i> is of type <STRONG>T</STRONG> <EM>[const]<STRONG>
-					</STRONG></EM>or derived, <tt>get_pointer(t)-&gt;*pm</tt> otherwise.
-			</p>
-			<p>
-				<b>Throws:</b> Nothing.
-			</p>
-		</blockquote>
-		<h4><a name="mem_fn_3">template&lt;class R, class T, class A1&gt; <i>unspecified-3</i> mem_fn(R 
-				(T::*pmf) (A1))</a></h4>
-		<blockquote>
-			<p>
-				<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t, a1)</i></tt>
-				is equivalent to <tt>(t.*pmf)(a1)</tt> when <i>t</i> is an l-value of type <STRONG>T
-				</STRONG>or derived, <tt>(get_pointer(t)-&gt;*pmf)(a1)</tt> otherwise.
-			</p>
-			<p>
-				<b>Throws:</b> Nothing.
-			</p>
-		</blockquote>
-		<h4><a name="mem_fn_4">template&lt;class R, class T, class A1&gt; <i>unspecified-4</i> mem_fn(R 
-				(T::*pmf) (A1) const)</a></h4>
-		<blockquote>
-			<p>
-				<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t, a1)</i></tt>
-				is equivalent to <tt>(t.*pmf)(a1)</tt> when <i>t</i> is of type <STRONG>T</STRONG>
-				<EM>[const]<STRONG> </STRONG></EM>or derived, <tt>(get_pointer(t)-&gt;*pmf)(a1)</tt>
-				otherwise.
-			</p>
-			<p>
-				<b>Throws:</b> Nothing.
-			</p>
-		</blockquote>
-		<h4><a name="mem_fn_5">template&lt;class R, class T, class A1, class A2&gt; <i>unspecified-5</i>
-				mem_fn(R (T::*pmf) (A1, A2))</a></h4>
-		<blockquote>
-			<p>
-				<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t, a1, a2)</i></tt>
-				is equivalent to <tt>(t.*pmf)(a1, a2)</tt> when <i>t</i> is an l-value of type <STRONG>
-					T</STRONG> or derived, <tt>(get_pointer(t)-&gt;*pmf)(a1, a2)</tt> otherwise.
-			</p>
-			<p>
-				<b>Throws:</b> Nothing.
-			</p>
-		</blockquote>
-		<h4><a name="mem_fn_6">template&lt;class R, class T, class A1, class A2&gt; <i>unspecified-6</i>
-				mem_fn(R (T::*pmf) (A1, A2) const)</a></h4>
-		<blockquote>
-			<p>
-				<b>Returns:</b> a function object <i>f</i> such that the expression <tt><i>f(t, a1, a2)</i></tt>
-				is equivalent to <tt>(t.*pmf)(a1, a2)</tt> when <i>t</i> is of type <STRONG>T</STRONG>
-				<EM>[const]</EM> or derived, <tt>(get_pointer(t)-&gt;*pmf)(a1, a2)</tt> otherwise.
-			</p>
-			<p>
-				<b>Throws:</b> Nothing.
-			</p>
-		</blockquote>
-		<h2><a name="Implementation">Implementation</a></h2>
-		<h3><a name="Files">Files</a></h3>
-		<ul>
-			<li>
-				<a href="../../boost/mem_fn.hpp">boost/mem_fn.hpp</a>
-			(main header)
-			<li>
-				<a href="../../boost/bind/mem_fn_cc.hpp">boost/bind/mem_fn_cc.hpp</a>
-			(used by mem_fn.hpp, do not include directly)
-			<li>
-				<a href="../../boost/bind/mem_fn_vw.hpp">boost/bind/mem_fn_vw.hpp</a>
-			(used by mem_fn.hpp, do not include directly)
-			<li>
-				<a href="../../boost/bind/mem_fn_template.hpp">boost/bind/mem_fn_template.hpp</a>
-			(used by mem_fn.hpp, do not include directly)
-			<li>
-				<a href="test/mem_fn_test.cpp">libs/bind/test/mem_fn_test.cpp</a>
-			(test)
-			<li>
-				<a href="test/mem_fn_derived_test.cpp">libs/bind/test/mem_fn_derived_test.cpp</a>
-			(test with derived objects)
-			<li>
-				<a href="test/mem_fn_fastcall_test.cpp">libs/bind/test/mem_fn_fastcall_test.cpp</a>
-			(test for __fastcall)
-			<li>
-				<a href="test/mem_fn_stdcall_test.cpp">libs/bind/test/mem_fn_stdcall_test.cpp</a>
-			(test for __stdcall)
-			<li>
-				<a href="test/mem_fn_void_test.cpp">libs/bind/test/mem_fn_void_test.cpp</a> (test 
-				for void returns)</li>
-		</ul>
-		<h3><a name="Dependencies">Dependencies</a></h3>
-		<ul>
-			<li>
-				<a href="../config/config.htm">Boost.Config</a></li>
-		</ul>
-		<h3><a name="NumberOfArguments">Number of Arguments</a></h3>
-		<p>
-			This implementation supports member functions with up to eight arguments. This 
-			is not an inherent limitation of the design, but an implementation detail.
-		</p>
-		<h3><a name="stdcall">"__stdcall", "__cdecl" and "__fastcall" Support</a></h3>
-		<p>
-			Some platforms allow several types of member functions that differ by their <b>calling 
-				convention</b> (the rules by which the function is invoked: how are 
-			arguments passed, how is the return value handled, and who cleans up the stack 
-			- if any.)
-		</p>
-		<p>
-			For example, Windows API functions and COM interface member functions use a 
-			calling convention known as <b>__stdcall</b>. Borland VCL components use <STRONG>__fastcall</STRONG>. 
-			UDK, the component model of OpenOffice.org, uses <STRONG>__cdecl</STRONG>.
-		</p>
-		<p>
-			To use <b>mem_fn</b> with <b>__stdcall</b> member functions, <b>#define</b> the 
-			macro <b>BOOST_MEM_FN_ENABLE_STDCALL</b> before including, directly or 
-			indirectly, <b>&lt;boost/mem_fn.hpp&gt;</b>.
-		</p>
-		<P>To use <B>mem_fn</B> with <B>__fastcall</B> member functions, <B>#define</B> the 
-			macro <B>BOOST_MEM_FN_ENABLE_FASTCALL</B> before including <B>&lt;boost/mem_fn.hpp&gt;</B>.
-		</P>
-		<P>To use <B>mem_fn</B> with <B>__cdecl</B> member functions, <B>#define</B> the 
-			macro <B>BOOST_MEM_FN_ENABLE_CDECL</B> before including <B>&lt;boost/mem_fn.hpp&gt;</B>.
-		</P>
-		<P><STRONG>It is best to define these macros in the project options, via -D on the 
-				command line, or as the first line in the translation unit (.cpp file) where 
-				mem_fn is used.</STRONG> Not following this rule can lead to obscure errors 
-			when a header includes mem_fn.hpp before the macro has been defined.</P>
-		<P>[Note: this is a non-portable extension. It is not part of the interface.]
-		</P>
-		<p>
-			[Note: Some compilers provide only minimal support for the <b>__stdcall</b> keyword.]
-		</p>
-		<h2><a name="Acknowledgements">Acknowledgements</a></h2>
-		<p>
-			Rene Jager's initial suggestion of using traits classes to make <b>mem_fn</b> adapt 
-			to user-defined smart pointers inspired the <b>get_pointer</b>-based design.
-		</p>
-		<p>
-			Numerous improvements were suggested during the formal review period by Richard 
-			Crossley, Jens Maurer, Ed Brey, and others. Review manager was Darin Adler.
-		</p>
-		<p>
-			Steve Anichini pointed out that COM interfaces use <b>__stdcall</b>.
-		</p>
-		<p>
-			Dave Abrahams modified <b>bind</b> and <b>mem_fn</b> to support void returns on 
-			deficient compilers.
-		</p>
-		<p>Daniel Boelzle pointed out that UDK uses <STRONG>__cdecl</STRONG>.<br>
-			<br>
-			<br>
-			<small>Copyright © 2001, 2002 by Peter Dimov and Multi Media Ltd. Copyright 
-				2003-2005 Peter Dimov. Distributed under the Boost Software License, Version 
-				1.0. See accompanying file <A href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</A> or 
-				copy at <A href="http://www.boost.org/LICENSE_1_0.txt">http://www.boost.org/LICENSE_1_0.txt</A>.</small></p>
-	</body>
-</html>
+<head>
+<meta http-equiv="refresh" content="0; URL=../bind/mem_fn.html">
+</head>
+<body>
+Automatic redirection failed, please go to
+<a href="../bind/mem_fn.html">../bind/mem_fn.html</a>.&nbsp;<hr>
+<p>© Copyright Beman Dawes, 2001</p>
+<p>Distributed under the Boost Software License, Version 1.0. (See accompanying 
+file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy 
+at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
+<p>&nbsp;</p>
+</body>
+</html>

meta/libraries.json

@@ -1,34 +0,0 @@
-[
-    {
-        "key": "bind",
-        "name": "Bind",
-        "authors": [
-            "Peter Dimov"
-        ],
-        "description": "boost::bind is a generalization of the standard functions std::bind1st and std::bind2nd. It supports arbitrary function objects, functions, function pointers, and member function pointers, and is able to bind any argument to a specific value or route input arguments into arbitrary positions.",
-        "std": [
-            "tr1"
-        ],
-        "category": [
-            "Function-objects"
-        ],
-        "maintainers": [
-            "Peter Dimov <pdimov -at- pdimov.com>"
-        ]
-    },
-    {
-        "key": "bind/mem_fn",
-        "name": "Member Function",
-        "authors": [
-            "Peter Dimov"
-        ],
-        "description": "Generalized binders for function/object/pointers and member functions.",
-        "documentation": "mem_fn.html",
-        "std": [
-            "tr1"
-        ],
-        "category": [
-            "Function-objects"
-        ]
-    }
-]

module.cmake

@@ -0,0 +1 @@
+boost_module(bind DEPENDS utility mpl detail config)

ref.html

@@ -0,0 +1,15 @@
+<html>
+<head>
+<meta http-equiv="refresh" content="0; URL=../../doc/html/ref.html">
+</head>
+<body>
+Automatic redirection failed, please go to
+<a href="../../doc/html/ref.html">../../doc/html/ref.html</a>
+</body>
+</html>
+<!--
+	© Copyright Beman Dawes, 2001
+	Distributed under the Boost Software License, Version 1.0.
+	See accompanying file LICENSE_1_0.txt or copy at
+	http://www.boost.org/LICENSE_1_0.txt
+-->

test/CMakeLists.txt

@@ -0,0 +1,30 @@
+boost_additional_test_dependencies(bind BOOST_DEPENDS test)
+
+SET(tests 
+    bind_test
+    bind_dm_test
+    bind_eq_test
+    bind_const_test
+    bind_cv_test
+    bind_stateful_test
+    bind_dm2_test
+    bind_not_test
+    bind_rel_test
+    bind_function_test
+    bind_lookup_problem_test
+    bind_rv_sp_test
+    bind_dm3_test
+    bind_visit_test 
+    mem_fn_test 
+    mem_fn_void_test 
+    mem_fn_derived_test 
+    mem_fn_eq_test 
+    mem_fn_dm_test 
+    mem_fn_rv_test 
+    )
+FOREACH(test ${tests})
+  boost_test_run(${test})
+ENDFOREACH(test ${tests})
+
+boost_test_compile(bind_unary_addr)
+

test/Jamfile.v2

@@ -38,10 +38,4 @@ test-suite "bind"
       [ run bind_fnobj2_test.cpp ]
       [ run bind_fn2_test.cpp ]
       [ run bind_mf2_test.cpp ]
-      [ run bind_eq2_test.cpp ]
-      [ run mem_fn_ref_test.cpp ]
-      [ run bind_ref_test.cpp ]
-      [ run bind_eq3_test.cpp ]
-      [ run protect_test.cpp ]
-      [ run mem_fn_unary_addr_test.cpp ]
     ;

test/bind_cv_test.cpp

@@ -33,12 +33,6 @@
 
 struct X
 {
-    // SGI-related compilers have odd compiler-synthesized ctors dtors
-    #ifdef __PATHSCALE__
-    X() {}
-    ~X() {}
-    #endif
-
     int operator()()
     {
         return 17041;

test/bind_eq2_test.cpp

@@ -1,49 +0,0 @@
-#include <boost/config.hpp>
-
-#if defined(BOOST_MSVC)
-#pragma warning(disable: 4786)  // identifier truncated in debug info
-#pragma warning(disable: 4710)  // function not inlined
-#pragma warning(disable: 4711)  // function selected for automatic inline expansion
-#pragma warning(disable: 4514)  // unreferenced inline removed
-#endif
-
-//
-//  bind_eq2_test.cpp - boost::bind equality operator
-//
-//  Copyright (c) 2004, 2005, 2009 Peter Dimov
-//
-// Distributed under the Boost Software License, Version 1.0. (See
-// accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-//
-
-#include <boost/bind.hpp>
-#include <boost/function_equal.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-void f( int )
-{
-}
-
-int g( int i )
-{
-    return i + 5;
-}
-
-template< class F > void test_self_equal( F f )
-{
-#ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
-    using boost::function_equal;
-#endif
-
-    BOOST_TEST( function_equal( f, f ) );
-}
- 
-int main()
-{
-    test_self_equal( boost::bind( f, _1 ) );
-    test_self_equal( boost::bind( g, _1 ) );
-    test_self_equal( boost::bind( f, boost::bind( g, _1 ) ) );
-
-    return boost::report_errors();
-}

test/bind_eq3_test.cpp

@@ -1,45 +0,0 @@
-#include <boost/config.hpp>
-
-#if defined(BOOST_MSVC)
-#pragma warning(disable: 4786)  // identifier truncated in debug info
-#pragma warning(disable: 4710)  // function not inlined
-#pragma warning(disable: 4711)  // function selected for automatic inline expansion
-#pragma warning(disable: 4514)  // unreferenced inline removed
-#endif
-
-//
-//  bind_eq3_test.cpp - function_equal with bind and weak_ptr
-//
-//  Copyright (c) 2004, 2005, 2009 Peter Dimov
-//
-//  Distributed under the Boost Software License, Version 1.0.
-//  See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt
-//
-
-#include <boost/bind.hpp>
-#include <boost/function_equal.hpp>
-#include <boost/weak_ptr.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-int f( boost::weak_ptr<void> wp )
-{
-    return wp.use_count();
-}
-
-template< class F > void test_self_equal( F f )
-{
-#ifdef BOOST_NO_ARGUMENT_DEPENDENT_LOOKUP
-    using boost::function_equal;
-#endif
-
-    BOOST_TEST( function_equal( f, f ) );
-}
-
-int main()
-{
-    test_self_equal( boost::bind( f, _1 ) );
-    test_self_equal( boost::bind( f, boost::weak_ptr<void>() ) );
-
-    return boost::report_errors();
-}

test/bind_ref_test.cpp

@@ -1,36 +0,0 @@
-//
-//  bind_ref_test.cpp - reference_wrapper
-//
-//  Copyright (c) 2009 Peter Dimov
-//
-//  Distributed under the Boost Software License, Version 1.0.
-//  See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt
-//
-
-#include <boost/bind.hpp>
-#include <boost/ref.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-struct X
-{
-    int f( int x )
-    {
-        return x;
-    }
-
-    int g( int x ) const
-    {
-        return -x;
-    }
-};
-
-int main()
-{
-    X x;
-
-    BOOST_TEST( boost::bind( &X::f, _1, 1 )( boost::ref( x ) ) == 1 );
-    BOOST_TEST( boost::bind( &X::g, _1, 2 )( boost::cref( x ) ) == -2 );
-
-    return boost::report_errors();
-}

test/bind_stateful_test.cpp

@@ -43,11 +43,6 @@ public:
     {
     }
 
-    // SGI-related compilers have odd compiler-synthesized ctors and dtors
-    #ifdef __PATHSCALE__
-    ~X() {}
-    #endif
-
     int state() const
     {
         return state_;

test/bind_visit_test.cpp

@@ -5,7 +5,6 @@
 # pragma warning(disable: 4710)  // function not inlined
 # pragma warning(disable: 4711)  // function selected for automatic inline expansion
 # pragma warning(disable: 4514)  // unreferenced inline removed
-# pragma warning(disable: 4100)  // unreferenced formal parameter (it is referenced!)
 #endif
 
 // Copyright (c) 2006 Douglas Gregor <doug.gregor@gmail.com>

test/mem_fn_eq_test.cpp

@@ -39,128 +39,128 @@ struct X
     // 0
 
     int mf0_1() { return 0; }
-    int mf0_2() { return 1; }
+    int mf0_2() { return 0; }
 
     int cmf0_1() const { return 0; }
-    int cmf0_2() const { return 1; }
+    int cmf0_2() const { return 0; }
 
     void mf0v_1() {}
-    void mf0v_2() { static int x; ++x; }
+    void mf0v_2() {}
 
     void cmf0v_1() const {}
-    void cmf0v_2() const { static int x; ++x; }
+    void cmf0v_2() const {}
 
     // 1
 
     int mf1_1(int) { return 0; }
-    int mf1_2(int) { return 1; }
+    int mf1_2(int) { return 0; }
 
     int cmf1_1(int) const { return 0; }
-    int cmf1_2(int) const { return 1; }
+    int cmf1_2(int) const { return 0; }
 
     void mf1v_1(int) {}
-    void mf1v_2(int) { static int x; ++x; }
+    void mf1v_2(int) {}
 
     void cmf1v_1(int) const {}
-    void cmf1v_2(int) const { static int x; ++x; }
+    void cmf1v_2(int) const {}
 
     // 2
 
     int mf2_1(int, int) { return 0; }
-    int mf2_2(int, int) { return 1; }
+    int mf2_2(int, int) { return 0; }
 
     int cmf2_1(int, int) const { return 0; }
-    int cmf2_2(int, int) const { return 1; }
+    int cmf2_2(int, int) const { return 0; }
 
     void mf2v_1(int, int) {}
-    void mf2v_2(int, int) { static int x; ++x; }
+    void mf2v_2(int, int) {}
 
     void cmf2v_1(int, int) const {}
-    void cmf2v_2(int, int) const { static int x; ++x; }
+    void cmf2v_2(int, int) const {}
 
     // 3
 
     int mf3_1(int, int, int) { return 0; }
-    int mf3_2(int, int, int) { return 1; }
+    int mf3_2(int, int, int) { return 0; }
 
     int cmf3_1(int, int, int) const { return 0; }
-    int cmf3_2(int, int, int) const { return 1; }
+    int cmf3_2(int, int, int) const { return 0; }
 
     void mf3v_1(int, int, int) {}
-    void mf3v_2(int, int, int) { static int x; ++x; }
+    void mf3v_2(int, int, int) {}
 
     void cmf3v_1(int, int, int) const {}
-    void cmf3v_2(int, int, int) const { static int x; ++x; }
+    void cmf3v_2(int, int, int) const {}
 
     // 4
 
     int mf4_1(int, int, int, int) { return 0; }
-    int mf4_2(int, int, int, int) { return 1; }
+    int mf4_2(int, int, int, int) { return 0; }
 
     int cmf4_1(int, int, int, int) const { return 0; }
-    int cmf4_2(int, int, int, int) const { return 1; }
+    int cmf4_2(int, int, int, int) const { return 0; }
 
     void mf4v_1(int, int, int, int) {}
-    void mf4v_2(int, int, int, int) { static int x; ++x; }
+    void mf4v_2(int, int, int, int) {}
 
     void cmf4v_1(int, int, int, int) const {}
-    void cmf4v_2(int, int, int, int) const { static int x; ++x; }
+    void cmf4v_2(int, int, int, int) const {}
 
     // 5
 
     int mf5_1(int, int, int, int, int) { return 0; }
-    int mf5_2(int, int, int, int, int) { return 1; }
+    int mf5_2(int, int, int, int, int) { return 0; }
 
     int cmf5_1(int, int, int, int, int) const { return 0; }
-    int cmf5_2(int, int, int, int, int) const { return 1; }
+    int cmf5_2(int, int, int, int, int) const { return 0; }
 
     void mf5v_1(int, int, int, int, int) {}
-    void mf5v_2(int, int, int, int, int) { static int x; ++x; }
+    void mf5v_2(int, int, int, int, int) {}
 
     void cmf5v_1(int, int, int, int, int) const {}
-    void cmf5v_2(int, int, int, int, int) const { static int x; ++x; }
+    void cmf5v_2(int, int, int, int, int) const {}
 
     // 6
 
     int mf6_1(int, int, int, int, int, int) { return 0; }
-    int mf6_2(int, int, int, int, int, int) { return 1; }
+    int mf6_2(int, int, int, int, int, int) { return 0; }
 
     int cmf6_1(int, int, int, int, int, int) const { return 0; }
-    int cmf6_2(int, int, int, int, int, int) const { return 1; }
+    int cmf6_2(int, int, int, int, int, int) const { return 0; }
 
     void mf6v_1(int, int, int, int, int, int) {}
-    void mf6v_2(int, int, int, int, int, int) { static int x; ++x; }
+    void mf6v_2(int, int, int, int, int, int) {}
 
     void cmf6v_1(int, int, int, int, int, int) const {}
-    void cmf6v_2(int, int, int, int, int, int) const { static int x; ++x; }
+    void cmf6v_2(int, int, int, int, int, int) const {}
 
     // 7
 
     int mf7_1(int, int, int, int, int, int, int) { return 0; }
-    int mf7_2(int, int, int, int, int, int, int) { return 1; }
+    int mf7_2(int, int, int, int, int, int, int) { return 0; }
 
     int cmf7_1(int, int, int, int, int, int, int) const { return 0; }
-    int cmf7_2(int, int, int, int, int, int, int) const { return 1; }
+    int cmf7_2(int, int, int, int, int, int, int) const { return 0; }
 
     void mf7v_1(int, int, int, int, int, int, int) {}
-    void mf7v_2(int, int, int, int, int, int, int) { static int x; ++x; }
+    void mf7v_2(int, int, int, int, int, int, int) {}
 
     void cmf7v_1(int, int, int, int, int, int, int) const {}
-    void cmf7v_2(int, int, int, int, int, int, int) const { static int x; ++x; }
+    void cmf7v_2(int, int, int, int, int, int, int) const {}
 
     // 8
 
     int mf8_1(int, int, int, int, int, int, int, int) { return 0; }
-    int mf8_2(int, int, int, int, int, int, int, int) { return 1; }
+    int mf8_2(int, int, int, int, int, int, int, int) { return 0; }
 
     int cmf8_1(int, int, int, int, int, int, int, int) const { return 0; }
-    int cmf8_2(int, int, int, int, int, int, int, int) const { return 1; }
+    int cmf8_2(int, int, int, int, int, int, int, int) const { return 0; }
 
     void mf8v_1(int, int, int, int, int, int, int, int) {}
-    void mf8v_2(int, int, int, int, int, int, int, int) { static int x; ++x; }
+    void mf8v_2(int, int, int, int, int, int, int, int) {}
 
     void cmf8v_1(int, int, int, int, int, int, int, int) const {}
-    void cmf8v_2(int, int, int, int, int, int, int, int) const { static int x; ++x; }
+    void cmf8v_2(int, int, int, int, int, int, int, int) const {}
 
 };
 

test/mem_fn_ref_test.cpp

@@ -1,36 +0,0 @@
-//
-//  mem_fn_ref_test.cpp - reference_wrapper
-//
-//  Copyright (c) 2009 Peter Dimov
-//
-//  Distributed under the Boost Software License, Version 1.0.
-//  See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt
-//
-
-#include <boost/mem_fn.hpp>
-#include <boost/ref.hpp>
-#include <boost/detail/lightweight_test.hpp>
-
-struct X
-{
-    int f()
-    {
-        return 1;
-    }
-
-    int g() const
-    {
-        return 2;
-    }
-};
-
-int main()
-{
-    X x;
-
-    BOOST_TEST( boost::mem_fn( &X::f )( boost::ref( x ) ) == 1 );
-    BOOST_TEST( boost::mem_fn( &X::g )( boost::cref( x ) ) == 2 );
-
-    return boost::report_errors();
-}

test/mem_fn_unary_addr_test.cpp

@@ -1,151 +0,0 @@
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#if defined(BOOST_MSVC)
-#pragma warning(disable: 4786)  // identifier truncated in debug info
-#pragma warning(disable: 4710)  // function not inlined
-#pragma warning(disable: 4711)  // function selected for automatic inline expansion
-#pragma warning(disable: 4514)  // unreferenced inline removed
-#endif
-
-//
-//  mem_fn_unary_addr_test.cpp - poisoned operator& test
-//
-//  Copyright (c) 2009 Peter Dimov
-//
-//  Distributed under the Boost Software License, Version 1.0.
-//  See accompanying file LICENSE_1_0.txt or copy at
-//  http://www.boost.org/LICENSE_1_0.txt
-//
-
-#include <boost/mem_fn.hpp>
-
-#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
-#pragma warning(push, 3)
-#endif
-
-#include <iostream>
-
-#if defined(BOOST_MSVC) && (BOOST_MSVC < 1300)
-#pragma warning(pop)
-#endif
-
-unsigned int hash = 0;
-
-struct X
-{
-    int f0() { f1(17); return 0; }
-    int g0() const { g1(17); return 0; }
-
-    int f1(int a1) { hash = (hash * 17041 + a1) % 32768; return 0; }
-    int g1(int a1) const { hash = (hash * 17041 + a1 * 2) % 32768; return 0; }
-
-    int f2(int a1, int a2) { f1(a1); f1(a2); return 0; }
-    int g2(int a1, int a2) const { g1(a1); g1(a2); return 0; }
-
-    int f3(int a1, int a2, int a3) { f2(a1, a2); f1(a3); return 0; }
-    int g3(int a1, int a2, int a3) const { g2(a1, a2); g1(a3); return 0; }
-
-    int f4(int a1, int a2, int a3, int a4) { f3(a1, a2, a3); f1(a4); return 0; }
-    int g4(int a1, int a2, int a3, int a4) const { g3(a1, a2, a3); g1(a4); return 0; }
-
-    int f5(int a1, int a2, int a3, int a4, int a5) { f4(a1, a2, a3, a4); f1(a5); return 0; }
-    int g5(int a1, int a2, int a3, int a4, int a5) const { g4(a1, a2, a3, a4); g1(a5); return 0; }
-
-    int f6(int a1, int a2, int a3, int a4, int a5, int a6) { f5(a1, a2, a3, a4, a5); f1(a6); return 0; }
-    int g6(int a1, int a2, int a3, int a4, int a5, int a6) const { g5(a1, a2, a3, a4, a5); g1(a6); return 0; }
-
-    int f7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) { f6(a1, a2, a3, a4, a5, a6); f1(a7); return 0; }
-    int g7(int a1, int a2, int a3, int a4, int a5, int a6, int a7) const { g6(a1, a2, a3, a4, a5, a6); g1(a7); return 0; }
-
-    int f8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) { f7(a1, a2, a3, a4, a5, a6, a7); f1(a8); return 0; }
-    int g8(int a1, int a2, int a3, int a4, int a5, int a6, int a7, int a8) const { g7(a1, a2, a3, a4, a5, a6, a7); g1(a8); return 0; }
-};
-
-template<class T> class Y
-{
-private:
-
-    T * pt_;
-
-    void operator& ();
-    void operator& () const;
-
-public:
-
-    explicit Y( T * pt ): pt_( pt )
-    {
-    }
-
-    T * get() const
-    {
-        return pt_;
-    }
-};
-
-#if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x620 ) )
-namespace boost
-{
-#endif
-
-template<class T> T * get_pointer( Y< T > const & y )
-{
-    return y.get();
-}
-
-#if defined( __BORLANDC__ ) && BOOST_WORKAROUND( __BORLANDC__, BOOST_TESTED_AT( 0x620 ) )
-} // namespace boost
-#endif
-
-int detect_errors(bool x)
-{
-    if( x )
-    {
-        std::cerr << "no errors detected.\n";
-        return 0;
-    }
-    else
-    {
-        std::cerr << "test failed.\n";
-        return 1;
-    }
-}
-
-int main()
-{
-    using boost::mem_fn;
-
-    X x;
-
-    Y<X> px( &x );
-    Y<X const> pcx( &x );
-
-    mem_fn(&X::f0)( px );
-    mem_fn(&X::g0)( pcx );
-
-    mem_fn(&X::f1)( px, 1 );
-    mem_fn(&X::g1)( pcx, 1 );
-
-    mem_fn(&X::f2)( px, 1, 2 );
-    mem_fn(&X::g2)( pcx, 1, 2 );
-
-    mem_fn(&X::f3)( px, 1, 2, 3 );
-    mem_fn(&X::g3)( pcx, 1, 2, 3 );
-
-    mem_fn(&X::f4)( px, 1, 2, 3, 4 );
-    mem_fn(&X::g4)( pcx, 1, 2, 3, 4 );
-
-    mem_fn(&X::f5)( px, 1, 2, 3, 4, 5 );
-    mem_fn(&X::g5)( pcx, 1, 2, 3, 4, 5 );
-
-    mem_fn(&X::f6)( px, 1, 2, 3, 4, 5, 6 );
-    mem_fn(&X::g6)( pcx, 1, 2, 3, 4, 5, 6 );
-
-    mem_fn(&X::f7)( px, 1, 2, 3, 4, 5, 6, 7 );
-    mem_fn(&X::g7)( pcx, 1, 2, 3, 4, 5, 6, 7 );
-
-    mem_fn(&X::f8)( px, 1, 2, 3, 4, 5, 6, 7, 8 );
-    mem_fn(&X::g8)( pcx, 1, 2, 3, 4, 5, 6, 7, 8 );
-
-    return detect_errors( hash == 2155 );
-}

test/protect_test.cpp

@@ -1,281 +0,0 @@
-//  protect_test.cpp
-//
-//  Copyright (c) 2009 Steven Watanabe
-//
-// Distributed under the Boost Software License, Version 1.0.
-//
-// See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-#include <boost/bind/protect.hpp>
-#include <boost/bind/bind.hpp>
-
-#include <boost/detail/lightweight_test.hpp>
-
-int f(int x)
-{
-    return x;
-}
-
-int& g(int& x)
-{
-    return x;
-}
-
-template<class T>
-const T& constify(const T& arg)
-{
-    return arg;
-}
-
-int main()
-{
-    int i[9] = {0,1,2,3,4,5,6,7,8};
-
-    // non-const
-
-    // test nullary
-    BOOST_TEST(boost::protect(boost::bind(f, 1))() == 1);
-
-    // test lvalues
-
-    BOOST_TEST(&boost::protect(boost::bind(g, _1))(i[0]) == &i[0]);
-
-    BOOST_TEST(&boost::protect(boost::bind(g, _1))(i[0], i[1]) == &i[0]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _2))(i[0], i[1]) == &i[1]);
-
-    BOOST_TEST(&boost::protect(boost::bind(g, _1))(i[0], i[1], i[2]) == &i[0]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _2))(i[0], i[1], i[2]) == &i[1]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _3))(i[0], i[1], i[2]) == &i[2]);
-
-    BOOST_TEST(&boost::protect(boost::bind(g, _1))(i[0], i[1], i[2], i[3]) == &i[0]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _2))(i[0], i[1], i[2], i[3]) == &i[1]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _3))(i[0], i[1], i[2], i[3]) == &i[2]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _4))(i[0], i[1], i[2], i[3]) == &i[3]);
-
-    BOOST_TEST(&boost::protect(boost::bind(g, _1))(i[0], i[1], i[2], i[3], i[4]) == &i[0]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _2))(i[0], i[1], i[2], i[3], i[4]) == &i[1]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _3))(i[0], i[1], i[2], i[3], i[4]) == &i[2]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _4))(i[0], i[1], i[2], i[3], i[4]) == &i[3]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _5))(i[0], i[1], i[2], i[3], i[4]) == &i[4]);
-
-    BOOST_TEST(&boost::protect(boost::bind(g, _1))(i[0], i[1], i[2], i[3], i[4], i[5]) == &i[0]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _2))(i[0], i[1], i[2], i[3], i[4], i[5]) == &i[1]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _3))(i[0], i[1], i[2], i[3], i[4], i[5]) == &i[2]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _4))(i[0], i[1], i[2], i[3], i[4], i[5]) == &i[3]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _5))(i[0], i[1], i[2], i[3], i[4], i[5]) == &i[4]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _6))(i[0], i[1], i[2], i[3], i[4], i[5]) == &i[5]);
-
-    BOOST_TEST(&boost::protect(boost::bind(g, _1))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[0]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _2))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[1]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _3))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[2]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _4))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[3]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _5))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[4]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _6))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[5]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _7))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[6]);
-
-    BOOST_TEST(&boost::protect(boost::bind(g, _1))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[0]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _2))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[1]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _3))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[2]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _4))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[3]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _5))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[4]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _6))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[5]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _7))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[6]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _8))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[7]);
-
-    BOOST_TEST(&boost::protect(boost::bind(g, _1))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[0]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _2))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[1]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _3))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[2]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _4))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[3]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _5))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[4]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _6))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[5]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _7))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[6]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _8))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[7]);
-    BOOST_TEST(&boost::protect(boost::bind(g, _9))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[8]);
-
-    // test rvalues
-
-    BOOST_TEST(boost::protect(boost::bind(f, _1))(0) == 0);
-
-    BOOST_TEST(boost::protect(boost::bind(f, _1))(0, 1) == 0);
-    BOOST_TEST(boost::protect(boost::bind(f, _2))(0, 1) == 1);
-
-    BOOST_TEST(boost::protect(boost::bind(f, _1))(0, 1, 2) == 0);
-    BOOST_TEST(boost::protect(boost::bind(f, _2))(0, 1, 2) == 1);
-    BOOST_TEST(boost::protect(boost::bind(f, _3))(0, 1, 2) == 2);
-
-    BOOST_TEST(boost::protect(boost::bind(f, _1))(0, 1, 2, 3) == 0);
-    BOOST_TEST(boost::protect(boost::bind(f, _2))(0, 1, 2, 3) == 1);
-    BOOST_TEST(boost::protect(boost::bind(f, _3))(0, 1, 2, 3) == 2);
-    BOOST_TEST(boost::protect(boost::bind(f, _4))(0, 1, 2, 3) == 3);
-
-    BOOST_TEST(boost::protect(boost::bind(f, _1))(0, 1, 2, 3, 4) == 0);
-    BOOST_TEST(boost::protect(boost::bind(f, _2))(0, 1, 2, 3, 4) == 1);
-    BOOST_TEST(boost::protect(boost::bind(f, _3))(0, 1, 2, 3, 4) == 2);
-    BOOST_TEST(boost::protect(boost::bind(f, _4))(0, 1, 2, 3, 4) == 3);
-    BOOST_TEST(boost::protect(boost::bind(f, _5))(0, 1, 2, 3, 4) == 4);
-
-    BOOST_TEST(boost::protect(boost::bind(f, _1))(0, 1, 2, 3, 4, 5) == 0);
-    BOOST_TEST(boost::protect(boost::bind(f, _2))(0, 1, 2, 3, 4, 5) == 1);
-    BOOST_TEST(boost::protect(boost::bind(f, _3))(0, 1, 2, 3, 4, 5) == 2);
-    BOOST_TEST(boost::protect(boost::bind(f, _4))(0, 1, 2, 3, 4, 5) == 3);
-    BOOST_TEST(boost::protect(boost::bind(f, _5))(0, 1, 2, 3, 4, 5) == 4);
-    BOOST_TEST(boost::protect(boost::bind(f, _6))(0, 1, 2, 3, 4, 5) == 5);
-
-    BOOST_TEST(boost::protect(boost::bind(f, _1))(0, 1, 2, 3, 4, 5, 6) == 0);
-    BOOST_TEST(boost::protect(boost::bind(f, _2))(0, 1, 2, 3, 4, 5, 6) == 1);
-    BOOST_TEST(boost::protect(boost::bind(f, _3))(0, 1, 2, 3, 4, 5, 6) == 2);
-    BOOST_TEST(boost::protect(boost::bind(f, _4))(0, 1, 2, 3, 4, 5, 6) == 3);
-    BOOST_TEST(boost::protect(boost::bind(f, _5))(0, 1, 2, 3, 4, 5, 6) == 4);
-    BOOST_TEST(boost::protect(boost::bind(f, _6))(0, 1, 2, 3, 4, 5, 6) == 5);
-    BOOST_TEST(boost::protect(boost::bind(f, _7))(0, 1, 2, 3, 4, 5, 6) == 6);
-
-    BOOST_TEST(boost::protect(boost::bind(f, _1))(0, 1, 2, 3, 4, 5, 6, 7) == 0);
-    BOOST_TEST(boost::protect(boost::bind(f, _2))(0, 1, 2, 3, 4, 5, 6, 7) == 1);
-    BOOST_TEST(boost::protect(boost::bind(f, _3))(0, 1, 2, 3, 4, 5, 6, 7) == 2);
-    BOOST_TEST(boost::protect(boost::bind(f, _4))(0, 1, 2, 3, 4, 5, 6, 7) == 3);
-    BOOST_TEST(boost::protect(boost::bind(f, _5))(0, 1, 2, 3, 4, 5, 6, 7) == 4);
-    BOOST_TEST(boost::protect(boost::bind(f, _6))(0, 1, 2, 3, 4, 5, 6, 7) == 5);
-    BOOST_TEST(boost::protect(boost::bind(f, _7))(0, 1, 2, 3, 4, 5, 6, 7) == 6);
-    BOOST_TEST(boost::protect(boost::bind(f, _8))(0, 1, 2, 3, 4, 5, 6, 7) == 7);
-
-    BOOST_TEST(boost::protect(boost::bind(f, _1))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 0);
-    BOOST_TEST(boost::protect(boost::bind(f, _2))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 1);
-    BOOST_TEST(boost::protect(boost::bind(f, _3))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 2);
-    BOOST_TEST(boost::protect(boost::bind(f, _4))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 3);
-    BOOST_TEST(boost::protect(boost::bind(f, _5))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 4);
-    BOOST_TEST(boost::protect(boost::bind(f, _6))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 5);
-    BOOST_TEST(boost::protect(boost::bind(f, _7))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 6);
-    BOOST_TEST(boost::protect(boost::bind(f, _8))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 7);
-    BOOST_TEST(boost::protect(boost::bind(f, _9))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 8);
-
-    // test mixed perfect forwarding
-    BOOST_TEST(boost::protect(boost::bind(f, _1))(i[0], 1) == 0);
-    BOOST_TEST(boost::protect(boost::bind(f, _2))(i[0], 1) == 1);
-    BOOST_TEST(boost::protect(boost::bind(f, _1))(0, i[1]) == 0);
-    BOOST_TEST(boost::protect(boost::bind(f, _2))(0, i[1]) == 1);
-
-    // const
-
-    // test nullary
-    BOOST_TEST(constify(constify(boost::protect(boost::bind(f, 1))))() == 1);
-
-    // test lvalues
-    BOOST_TEST(&constify(constify(boost::protect(boost::bind(g, _1))))(i[0]) == &i[0]);
-
-    BOOST_TEST(&constify(constify(boost::protect(boost::bind(g, _1))))(i[0], i[1]) == &i[0]);
-    BOOST_TEST(&constify(constify(boost::protect(boost::bind(g, _2))))(i[0], i[1]) == &i[1]);
-
-    BOOST_TEST(&constify(constify(boost::protect(boost::bind(g, _1))))(i[0], i[1], i[2]) == &i[0]);
-    BOOST_TEST(&constify(constify(boost::protect(boost::bind(g, _2))))(i[0], i[1], i[2]) == &i[1]);
-    BOOST_TEST(&constify(constify(boost::protect(boost::bind(g, _3))))(i[0], i[1], i[2]) == &i[2]);
-
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _1)))(i[0], i[1], i[2], i[3]) == &i[0]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _2)))(i[0], i[1], i[2], i[3]) == &i[1]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _3)))(i[0], i[1], i[2], i[3]) == &i[2]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _4)))(i[0], i[1], i[2], i[3]) == &i[3]);
-
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _1)))(i[0], i[1], i[2], i[3], i[4]) == &i[0]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _2)))(i[0], i[1], i[2], i[3], i[4]) == &i[1]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _3)))(i[0], i[1], i[2], i[3], i[4]) == &i[2]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _4)))(i[0], i[1], i[2], i[3], i[4]) == &i[3]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _5)))(i[0], i[1], i[2], i[3], i[4]) == &i[4]);
-
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _1)))(i[0], i[1], i[2], i[3], i[4], i[5]) == &i[0]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _2)))(i[0], i[1], i[2], i[3], i[4], i[5]) == &i[1]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _3)))(i[0], i[1], i[2], i[3], i[4], i[5]) == &i[2]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _4)))(i[0], i[1], i[2], i[3], i[4], i[5]) == &i[3]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _5)))(i[0], i[1], i[2], i[3], i[4], i[5]) == &i[4]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _6)))(i[0], i[1], i[2], i[3], i[4], i[5]) == &i[5]);
-
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _1)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[0]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _2)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[1]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _3)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[2]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _4)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[3]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _5)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[4]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _6)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[5]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _7)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6]) == &i[6]);
-
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _1)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[0]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _2)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[1]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _3)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[2]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _4)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[3]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _5)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[4]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _6)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[5]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _7)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[6]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _8)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7]) == &i[7]);
-
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _1)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[0]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _2)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[1]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _3)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[2]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _4)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[3]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _5)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[4]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _6)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[5]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _7)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[6]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _8)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[7]);
-    BOOST_TEST(&constify(boost::protect(boost::bind(g, _9)))(i[0], i[1], i[2], i[3], i[4], i[5], i[6], i[7], i[8]) == &i[8]);
-
-    // test rvalues
-
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _1)))(0) == 0);
-
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _1)))(0, 1) == 0);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _2)))(0, 1) == 1);
-
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _1)))(0, 1, 2) == 0);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _2)))(0, 1, 2) == 1);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _3)))(0, 1, 2) == 2);
-
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _1)))(0, 1, 2, 3) == 0);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _2)))(0, 1, 2, 3) == 1);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _3)))(0, 1, 2, 3) == 2);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _4)))(0, 1, 2, 3) == 3);
-
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _1)))(0, 1, 2, 3, 4) == 0);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _2)))(0, 1, 2, 3, 4) == 1);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _3)))(0, 1, 2, 3, 4) == 2);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _4)))(0, 1, 2, 3, 4) == 3);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _5)))(0, 1, 2, 3, 4) == 4);
-
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _1)))(0, 1, 2, 3, 4, 5) == 0);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _2)))(0, 1, 2, 3, 4, 5) == 1);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _3)))(0, 1, 2, 3, 4, 5) == 2);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _4)))(0, 1, 2, 3, 4, 5) == 3);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _5)))(0, 1, 2, 3, 4, 5) == 4);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _6)))(0, 1, 2, 3, 4, 5) == 5);
-
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _1)))(0, 1, 2, 3, 4, 5, 6) == 0);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _2)))(0, 1, 2, 3, 4, 5, 6) == 1);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _3)))(0, 1, 2, 3, 4, 5, 6) == 2);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _4)))(0, 1, 2, 3, 4, 5, 6) == 3);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _5)))(0, 1, 2, 3, 4, 5, 6) == 4);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _6)))(0, 1, 2, 3, 4, 5, 6) == 5);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _7)))(0, 1, 2, 3, 4, 5, 6) == 6);
-
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _1)))(0, 1, 2, 3, 4, 5, 6, 7) == 0);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _2)))(0, 1, 2, 3, 4, 5, 6, 7) == 1);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _3)))(0, 1, 2, 3, 4, 5, 6, 7) == 2);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _4)))(0, 1, 2, 3, 4, 5, 6, 7) == 3);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _5)))(0, 1, 2, 3, 4, 5, 6, 7) == 4);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _6)))(0, 1, 2, 3, 4, 5, 6, 7) == 5);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _7)))(0, 1, 2, 3, 4, 5, 6, 7) == 6);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _8)))(0, 1, 2, 3, 4, 5, 6, 7) == 7);
-
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _1)))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 0);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _2)))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 1);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _3)))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 2);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _4)))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 3);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _5)))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 4);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _6)))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 5);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _7)))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 6);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _8)))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 7);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _9)))(0, 1, 2, 3, 4, 5, 6, 7, 8) == 8);
-
-    // test mixed perfect forwarding
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _1)))(i[0], 1) == 0);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _2)))(i[0], 1) == 1);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _1)))(0, i[1]) == 0);
-    BOOST_TEST(constify(boost::protect(boost::bind(f, _2)))(0, i[1]) == 1);
-
-    return boost::report_errors();
-}