Fixed two tests to work with C++11/libc++. The tests attempted to compare two ostream&, but didn't really. In c++03, both decayed to void *, which wre then compared. In c++11, the ostreams are comvertible to bool, but only explicitly, and this failed to compile. Use a custom struct with operator== instead of ostream in these tests instead.

Merge branch 'develop'
Created first merge point for git
2014-02-03 11:46:05 -08:00 · 2014-02-03 11:29:22 -08:00 · 2014-02-03 11:27:41 -08:00 · 2014-01-31 19:50:02 -08:00 · 2014-01-31 19:42:29 -08:00 · 2013-10-11 23:22:36 +00:00
19 changed files with 1107 additions and 320 deletions
--- a/doc/Jamfile.v2
+++ b/doc/Jamfile.v2
@ -6,5 +6,11 @@
 project boost/doc ;
 import boostbook : boostbook ;

-boostbook function-doc : function.xml ;
+boostbook function-doc 
+    : 
+    function.xml 
+    :
+        <xsl:param>boost.root=../../../..
+        <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
+    ;

--- a/doc/history.xml
+++ b/doc/history.xml
@ -13,6 +13,35 @@

 <itemizedlist spacing="compact">

+  <listitem><para><bold>Version 1.52.0</bold>: </para>
+    <itemizedlist spacing="compact">
+      <listitem><para>Move constructors and move assignment 
+      operators added (only for compilers with C++11 rvalue 
+      references support). Original patch
+      contributed by Antony Polukhin.</para></listitem>
+    </itemizedlist>
+  </listitem>
+
+  <listitem><para><bold>Version 1.37.0</bold>: </para>
+    <itemizedlist spacing="compact">
+      <listitem><para>Improved the performance of Boost.Function's
+      swap() operation for large function objects. Original patch
+      contributed by Niels Dekker.</para></listitem>
+
+      <listitem><para>Added a new header &lt;boost/function/function_typeof.hpp&gt; that provides support for using the Boost.Typeof library on Boost.Function objects.</para></listitem>
+
+      <listitem><para>Added a new header &lt;boost/function/function_fwd.hpp&gt; that provides support for using the Boost.Typeof library on Boost.Function objects.</para></listitem>
+
+      <listitem><para>The <methodname alt="boost::function::target">target</methodname>()
+      function now respects the cv-qualifiers of function objects
+      stored by reference
+      (using <classname>boost::reference_wrapper</classname>), such
+      that a reference to a <code>const</code> function object cannot
+      be accessed as a reference to a non-<code>const</code> function
+      object.</para></listitem>
+    </itemizedlist>
+  </listitem>
+
  <listitem><para><bold>Version 1.36.0</bold>: </para>
    <itemizedlist spacing="compact">
      <listitem><para>Boost.Function now implements allocator support
--- a/doc/reference.xml
+++ b/doc/reference.xml
@ -58,7 +58,7 @@
      <para>A function object <code>f</code> of
      type <code>F</code> is
      <emphasis>stateless</emphasis> if it is a function pointer or if
-      <code><classname>boost::is_stateless</classname>&lt;T&gt;</code>
+      <code><classname>boost::is_stateless</classname>&lt;F&gt;</code>
      is true. The construction of or copy to a Boost.Function object
      from a stateless function object will not cause exceptions to be
      thrown and will not allocate any storage.
@ -203,6 +203,15 @@
      <throws><simpara>Will not throw unless copying the target of <code>f</code> throws.</simpara></throws>
    </constructor>

+    <constructor>
+      <parameter name="f">
+        <paramtype><classname>functionN</classname>&amp;&amp;</paramtype>
+      </parameter>
+      <requires><simpara>C++11 compatible compiler.</simpara></requires>
+      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
+      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
+    </constructor>
+    
    <constructor>
      <template>
        <template-type-parameter name="F"/>
@ -236,6 +245,15 @@
      </parameter>
      <postconditions><simpara>If copy construction does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></postconditions>
    </copy-assignment>
+    
+    <copy-assignment>
+      <parameter name="f">
+        <paramtype><classname>functionN</classname>&amp;&amp;</paramtype>
+      </parameter>
+      <requires><simpara>C++11 compatible compiler.</simpara></requires>
+      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
+      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
+    </copy-assignment>

    <method-group name="modifiers">
      <method name="swap">
@ -607,7 +625,16 @@
      <postconditions><simpara>Contains a copy of the <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>.</simpara></postconditions>
      <throws><simpara>Will not throw unless copying the target of <code>f</code> throws.</simpara></throws>
    </constructor>
-
+        
+    <constructor>
+      <parameter name="f">
+        <paramtype><classname>functionN</classname>&amp;&amp;</paramtype>
+      </parameter>
+      <requires><simpara>C++11 compatible compiler.</simpara></requires>
+      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
+      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
+    </constructor>
+    
    <constructor>
      <parameter name="f">
        <paramtype>const <classname>function</classname>&amp;</paramtype>
@ -616,6 +643,15 @@
      <throws><simpara>Will not throw unless copying the target of <code>f</code> throws.</simpara></throws>
    </constructor>

+    <constructor>
+      <parameter name="f">
+        <paramtype><classname>function</classname>&amp;&amp;</paramtype>
+      </parameter>
+      <requires><simpara>C++11 compatible compiler.</simpara></requires>
+      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
+      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
+    </constructor>
+    
    <constructor>
      <template>
        <template-type-parameter name="F"/>
@ -645,10 +681,19 @@

    <copy-assignment>
      <parameter name="f">
-        <paramtype>const <classname>function</classname>&amp;</paramtype>
+        <paramtype>const <classname>functionN</classname>&amp;</paramtype>
      </parameter>
      <postconditions><simpara>If copy construction does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></postconditions>
    </copy-assignment>
+    
+    <copy-assignment>
+      <parameter name="f">
+        <paramtype><classname>functionN</classname>&amp;&amp;</paramtype>
+      </parameter>
+      <requires><simpara>C++11 compatible compiler.</simpara></requires>
+      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
+      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
+    </copy-assignment>

    <copy-assignment>
      <parameter name="f">
@ -657,6 +702,15 @@
      <postconditions><simpara>If copy construction of the target of <code>f</code> does not throw, <code>*this</code> targets a copy of <code>f</code>'s target, if it has one, or is empty if <code>f.<methodname>empty</methodname>()</code>. </simpara></postconditions>
      <throws><simpara>Will not throw when the target of <code>f</code> is a stateless function object or a reference to the function object. If copy construction does throw, <code>this-&gt;<methodname>empty</methodname>()</code>.</simpara></throws>
    </copy-assignment>
+    
+    <copy-assignment>
+      <parameter name="f">
+        <paramtype><classname>function</classname>&amp;&amp;</paramtype>
+      </parameter>
+      <requires><simpara>C++11 compatible compiler.</simpara></requires>
+      <postconditions><simpara>Moves the value from <code>f</code> to <code>*this</code>. If the argument has its function object allocated on the heap, its buffer will be assigned to <code>*this</code> leaving argument empty.</simpara></postconditions>
+      <throws><simpara>Will not throw unless argument has its function object allocated not on the heap and copying the target of <code>f</code> throws.</simpara></throws>
+    </copy-assignment>

    <method-group name="modifiers">
      <method name="swap">
--- a/doc/tutorial.xml
+++ b/doc/tutorial.xml
@ -35,12 +35,12 @@ form to use for your compiler.
        <row>
          <entry>
            <itemizedlist spacing="compact">
-              <listitem><simpara>GNU C++ 2.95.x, 3.0.x, 3.1.x</simpara></listitem>
+              <listitem><simpara>GNU C++ 2.95.x, 3.0.x and later versions</simpara></listitem>
              <listitem><simpara>Comeau C++ 4.2.45.2</simpara></listitem>
              <listitem><simpara>SGI MIPSpro 7.3.0</simpara></listitem>
              <listitem><simpara>Intel C++ 5.0, 6.0</simpara></listitem>
              <listitem><simpara>Compaq's cxx 6.2</simpara></listitem>
-	      <listitem><simpara>Microsoft Visual C++ 7.1</simpara></listitem>
+	      <listitem><simpara>Microsoft Visual C++ 7.1 and later versions</simpara></listitem>
            </itemizedlist>
          </entry>
          <entry>
--- a/include/boost/function.hpp
+++ b/include/boost/function.hpp
@ -23,8 +23,8 @@
 // in anything that may be included by function_template.hpp doesn't break
 #include <boost/function/detail/prologue.hpp>

-// Visual Age C++ doesn't handle the file iteration well
-#if BOOST_WORKAROUND(__IBMCPP__, >= 500)
+// Older Visual Age C++ version do not handle the file iteration well
+#if BOOST_WORKAROUND(__IBMCPP__, >= 500) && BOOST_WORKAROUND(__IBMCPP__, < 800)
 #  if BOOST_FUNCTION_MAX_ARGS >= 0
 #    include <boost/function/function0.hpp>
 #  endif
--- a/include/boost/function/function_base.hpp
+++ b/include/boost/function/function_base.hpp
@ -15,11 +15,17 @@
 #include <string>
 #include <memory>
 #include <new>
-#include <typeinfo>
 #include <boost/config.hpp>
+#include <boost/detail/sp_typeinfo.hpp>
 #include <boost/assert.hpp>
+#include <boost/integer.hpp>
+#include <boost/type_traits/has_trivial_copy.hpp>
+#include <boost/type_traits/has_trivial_destructor.hpp>
+#include <boost/type_traits/is_const.hpp>
 #include <boost/type_traits/is_integral.hpp>
+#include <boost/type_traits/is_volatile.hpp>
 #include <boost/type_traits/composite_traits.hpp>
+#include <boost/type_traits/ice.hpp>
 #include <boost/ref.hpp>
 #include <boost/mpl/if.hpp>
 #include <boost/detail/workaround.hpp>
@ -30,6 +36,7 @@
 #  include "boost/mpl/bool.hpp"
 #endif
 #include <boost/function_equal.hpp>
+#include <boost/function/function_fwd.hpp>

 #if defined(BOOST_MSVC)
 #   pragma warning( push )
@ -38,7 +45,7 @@
 #endif       

 // Define BOOST_FUNCTION_STD_NS to the namespace that contains type_info.
-#ifdef BOOST_NO_EXCEPTION_STD_NAMESPACE
+#ifdef BOOST_NO_STD_TYPEINFO
 // Embedded VC++ does not have type_info in namespace std
 #  define BOOST_FUNCTION_STD_NS
 #else
@ -47,7 +54,9 @@

 // Borrowed from Boost.Python library: determines the cases where we
 // need to use std::type_info::name to compare instead of operator==.
-# if (defined(__GNUC__) && __GNUC__ >= 3) \
+#if defined( BOOST_NO_TYPEID )
+#  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
+#elif defined(__GNUC__) \
 || defined(_AIX) \
 || (   defined(__sgi) && defined(__host_mips))
 #  include <cstring>
@ -57,28 +66,13 @@
 #  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
 #endif

-#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG)
+#if defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG)
 #  define BOOST_FUNCTION_TARGET_FIX(x) x
 #else
 #  define BOOST_FUNCTION_TARGET_FIX(x)
-#endif // not MSVC
+#endif // __ICL etc

-#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
-// Work around a compiler bug.
-// boost::python::objects::function has to be seen by the compiler before the
-// boost::function class template.
-namespace boost { namespace python { namespace objects {
-  class function;
-}}}
-#endif
-
-#if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                    \
- || defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                         \
- || !(BOOST_STRICT_CONFIG || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
-#  define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
-#endif
-
-#if !BOOST_WORKAROUND(__BORLANDC__, < 0x600)
+#if !BOOST_WORKAROUND(__BORLANDC__, < 0x5A0)
 #  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)              \
      typename ::boost::enable_if_c<(::boost::type_traits::ice_not<          \
                            (::boost::is_integral<Functor>::value)>::value), \
@ -92,22 +86,6 @@ namespace boost { namespace python { namespace objects {
                       Type>::type
 #endif

-#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
-namespace boost {
-
-template<typename Signature>
-class function;
-
-template<typename Signature>
-inline void swap(function<Signature>& f1,
-                 function<Signature>& f2)
-{
-  f1.swap(f2);
-}
-
-} // end namespace boost
-#endif // have partial specialization
-
 namespace boost {
  namespace detail {
    namespace function {
@ -122,11 +100,18 @@ namespace boost {
      union function_buffer
      {
        // For pointers to function objects
-        void* obj_ptr;
+        mutable void* obj_ptr;

        // For pointers to std::type_info objects
-        // (get_functor_type_tag, check_functor_type_tag).
-        const void* const_obj_ptr;
+        struct type_t {
+          // (get_functor_type_tag, check_functor_type_tag).
+          const detail::sp_typeinfo* type;
+
+          // Whether the type is const-qualified.
+          bool const_qualified;
+          // Whether the type is volatile-qualified.
+          bool volatile_qualified;
+        } type;

        // For function pointers of all kinds
        mutable void (*func_ptr)();
@ -137,6 +122,14 @@ namespace boost {
          void* obj_ptr;
        } bound_memfunc_ptr;

+        // For references to function objects. We explicitly keep
+        // track of the cv-qualifiers on the object referenced.
+        struct obj_ref_t {
+          mutable void* obj_ptr;
+          bool is_const_qualified;
+          bool is_volatile_qualified;
+        } obj_ref;
+
        // To relax aliasing constraints
        mutable char data;
      };
@ -168,6 +161,7 @@ namespace boost {
      // The operation type to perform on the given functor/function pointer
      enum functor_manager_operation_type {
        clone_functor_tag,
+        move_functor_tag,
        destroy_functor_tag,
        check_functor_type_tag,
        get_functor_type_tag
@ -204,34 +198,45 @@ namespace boost {
      struct reference_manager
      {
        static inline void
-        get(const function_buffer& in_buffer, function_buffer& out_buffer, 
-            functor_manager_operation_type op)
+        manage(const function_buffer& in_buffer, function_buffer& out_buffer, 
+               functor_manager_operation_type op)
        {
          switch (op) {
          case clone_functor_tag: 
-            out_buffer.obj_ptr = in_buffer.obj_ptr;
+            out_buffer.obj_ref = in_buffer.obj_ref;
+            return;
+
+          case move_functor_tag:
+            out_buffer.obj_ref = in_buffer.obj_ref;
+            in_buffer.obj_ref.obj_ptr = 0;
            return;

          case destroy_functor_tag:
-            out_buffer.obj_ptr = 0;
+            out_buffer.obj_ref.obj_ptr = 0;
            return;

          case check_functor_type_tag:
            {
-              // DPG TBD: Since we're only storing a pointer, it's
-              // possible that the user could ask for a base class or
-              // derived class. Is that okay?
-              const BOOST_FUNCTION_STD_NS::type_info& check_type = 
-                *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
-              if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(F)))
-                out_buffer.obj_ptr = in_buffer.obj_ptr;
+              const detail::sp_typeinfo& check_type 
+                = *out_buffer.type.type;
+
+              // Check whether we have the same type. We can add
+              // cv-qualifiers, but we can't take them away.
+              if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(F))
+                  && (!in_buffer.obj_ref.is_const_qualified 
+                      || out_buffer.type.const_qualified)
+                  && (!in_buffer.obj_ref.is_volatile_qualified
+                      || out_buffer.type.volatile_qualified))
+                out_buffer.obj_ptr = in_buffer.obj_ref.obj_ptr;
              else
                out_buffer.obj_ptr = 0;
            }
            return;

          case get_functor_type_tag:
-            out_buffer.const_obj_ptr = &typeid(F);
+            out_buffer.type.type = &BOOST_SP_TYPEID(F);
+            out_buffer.type.const_qualified = in_buffer.obj_ref.is_const_qualified;
+            out_buffer.type.volatile_qualified = in_buffer.obj_ref.is_volatile_qualified;
            return;
          }
        }
@ -259,6 +264,12 @@ namespace boost {
          A(a)
        {
        }
+        
+        functor_wrapper(const functor_wrapper& f) :
+          F(static_cast<const F&>(f)),
+          A(static_cast<const A&>(f))
+        {
+        }
      };

      /**
@ -277,15 +288,22 @@ namespace boost {
        {
          if (op == clone_functor_tag)
            out_buffer.func_ptr = in_buffer.func_ptr;
-          else if (op == destroy_functor_tag)
+          else if (op == move_functor_tag) {
+            out_buffer.func_ptr = in_buffer.func_ptr;
+            in_buffer.func_ptr = 0;
+          } else if (op == destroy_functor_tag)
            out_buffer.func_ptr = 0;
-          else /* op == check_functor_type_tag */ {
-            const BOOST_FUNCTION_STD_NS::type_info& check_type = 
-              *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
-            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+          else if (op == check_functor_type_tag) {
+            const detail::sp_typeinfo& check_type 
+              = *out_buffer.type.type;
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
              out_buffer.obj_ptr = &in_buffer.func_ptr;
            else
              out_buffer.obj_ptr = 0;
+          } else /* op == get_functor_type_tag */ {
+            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
          }
        }

@ -294,20 +312,32 @@ namespace boost {
        manage_small(const function_buffer& in_buffer, function_buffer& out_buffer, 
                functor_manager_operation_type op)
        {
-          if (op == clone_functor_tag) {
+          if (op == clone_functor_tag || op == move_functor_tag) {
            const functor_type* in_functor = 
              reinterpret_cast<const functor_type*>(&in_buffer.data);
-            new ((void*)&out_buffer.data) functor_type(*in_functor);
+            new (reinterpret_cast<void*>(&out_buffer.data)) functor_type(*in_functor);
+
+            if (op == move_functor_tag) {
+              functor_type* f = reinterpret_cast<functor_type*>(&in_buffer.data);
+              (void)f; // suppress warning about the value of f not being used (MSVC)
+              f->~Functor();
+            }
          } else if (op == destroy_functor_tag) {
            // Some compilers (Borland, vc6, ...) are unhappy with ~functor_type.
-            reinterpret_cast<functor_type*>(&out_buffer.data)->~Functor();
-          } else /* op == check_functor_type_tag */ {
-            const BOOST_FUNCTION_STD_NS::type_info& check_type = 
-              *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
-            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+             functor_type* f = reinterpret_cast<functor_type*>(&out_buffer.data);
+             (void)f; // suppress warning about the value of f not being used (MSVC)
+             f->~Functor();
+          } else if (op == check_functor_type_tag) {
+            const detail::sp_typeinfo& check_type 
+              = *out_buffer.type.type;
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
              out_buffer.obj_ptr = &in_buffer.data;
            else
              out_buffer.obj_ptr = 0;
+          } else /* op == get_functor_type_tag */ {
+            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;            
          }
        }
      };
@ -343,23 +373,32 @@ namespace boost {
            // Clone the functor
            // GCC 2.95.3 gets the CV qualifiers wrong here, so we
            // can't do the static_cast that we should do.
+            // jewillco: Changing this to static_cast because GCC 2.95.3 is
+            // obsolete.
            const functor_type* f =
-              (const functor_type*)(in_buffer.obj_ptr);
+              static_cast<const functor_type*>(in_buffer.obj_ptr);
            functor_type* new_f = new functor_type(*f);
            out_buffer.obj_ptr = new_f;
+          } else if (op == move_functor_tag) {
+            out_buffer.obj_ptr = in_buffer.obj_ptr;
+            in_buffer.obj_ptr = 0;
          } else if (op == destroy_functor_tag) {
            /* Cast from the void pointer to the functor pointer type */
            functor_type* f =
              static_cast<functor_type*>(out_buffer.obj_ptr);
            delete f;
            out_buffer.obj_ptr = 0;
-          } else /* op == check_functor_type_tag */ {
-            const BOOST_FUNCTION_STD_NS::type_info& check_type = 
-              *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
-            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+          } else if (op == check_functor_type_tag) {
+            const detail::sp_typeinfo& check_type
+              = *out_buffer.type.type;
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
              out_buffer.obj_ptr = in_buffer.obj_ptr;
            else
              out_buffer.obj_ptr = 0;
+          } else /* op == get_functor_type_tag */ {
+            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
          }
        }

@ -374,6 +413,14 @@ namespace boost {
                  mpl::bool_<(function_allows_small_object_optimization<functor_type>::value)>());
        }

+        // For member pointers, we use the small-object optimization buffer.
+        static inline void
+        manager(const function_buffer& in_buffer, function_buffer& out_buffer, 
+                functor_manager_operation_type op, member_ptr_tag)
+        {
+          manager(in_buffer, out_buffer, op, mpl::true_());
+        }
+
      public:
        /* Dispatch to an appropriate manager based on whether we have a
           function pointer or a function object pointer. */
@ -384,7 +431,9 @@ namespace boost {
          typedef typename get_function_tag<functor_type>::type tag_type;
          switch (op) {
          case get_functor_type_tag:
-            out_buffer.const_obj_ptr = &typeid(functor_type);
+            out_buffer.type.type = &BOOST_SP_TYPEID(functor_type);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
            return;

          default:
@ -431,7 +480,7 @@ namespace boost {
            // GCC 2.95.3 gets the CV qualifiers wrong here, so we
            // can't do the static_cast that we should do.
            const functor_wrapper_type* f =
-              (const functor_wrapper_type*)(in_buffer.obj_ptr);
+              static_cast<const functor_wrapper_type*>(in_buffer.obj_ptr);
            wrapper_allocator_type wrapper_allocator(static_cast<Allocator const &>(*f));
            wrapper_allocator_pointer_type copy = wrapper_allocator.allocate(1);
            wrapper_allocator.construct(copy, *f);
@ -439,6 +488,9 @@ namespace boost {
            // Get back to the original pointer type
            functor_wrapper_type* new_f = static_cast<functor_wrapper_type*>(copy);
            out_buffer.obj_ptr = new_f;
+          } else if (op == move_functor_tag) {
+            out_buffer.obj_ptr = in_buffer.obj_ptr;
+            in_buffer.obj_ptr = 0;
          } else if (op == destroy_functor_tag) {
            /* Cast from the void pointer to the functor_wrapper_type */
            functor_wrapper_type* victim =
@ -447,13 +499,17 @@ namespace boost {
            wrapper_allocator.destroy(victim);
            wrapper_allocator.deallocate(victim,1);
            out_buffer.obj_ptr = 0;
-          } else /* op == check_functor_type_tag */ {
-            const BOOST_FUNCTION_STD_NS::type_info& check_type = 
-              *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(out_buffer.const_obj_ptr);
-            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, typeid(Functor)))
+          } else if (op == check_functor_type_tag) {
+            const detail::sp_typeinfo& check_type 
+              = *out_buffer.type.type;
+            if (BOOST_FUNCTION_COMPARE_TYPE_ID(check_type, BOOST_SP_TYPEID(Functor)))
              out_buffer.obj_ptr = in_buffer.obj_ptr;
            else
              out_buffer.obj_ptr = 0;
+          } else /* op == get_functor_type_tag */ {
+            out_buffer.type.type = &BOOST_SP_TYPEID(Functor);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
          }
        }

@ -478,7 +534,9 @@ namespace boost {
          typedef typename get_function_tag<functor_type>::type tag_type;
          switch (op) {
          case get_functor_type_tag:
-            out_buffer.const_obj_ptr = &typeid(functor_type);
+            out_buffer.type.type = &BOOST_SP_TYPEID(functor_type);
+            out_buffer.type.const_qualified = false;
+            out_buffer.type.volatile_qualified = false;
            return;

          default:
@ -556,7 +614,6 @@ namespace boost {
       */
      struct vtable_base
      {
-        vtable_base() : manager(0) { }
        void (*manager)(const function_buffer& in_buffer, 
                        function_buffer& out_buffer, 
                        functor_manager_operation_type op);
@ -578,15 +635,15 @@ public:
  /** Determine if the function is empty (i.e., has no target). */
  bool empty() const { return !vtable; }

-  /** Retrieve the type of the stored function object, or typeid(void)
+  /** Retrieve the type of the stored function object, or BOOST_SP_TYPEID(void)
      if this is empty. */
-  const BOOST_FUNCTION_STD_NS::type_info& target_type() const
+  const detail::sp_typeinfo& target_type() const
  {
-    if (!vtable) return typeid(void);
+    if (!vtable) return BOOST_SP_TYPEID(void);

    detail::function::function_buffer type;
-    vtable->manager(functor, type, detail::function::get_functor_type_tag);
-    return *static_cast<const BOOST_FUNCTION_STD_NS::type_info*>(type.const_obj_ptr);
+    get_vtable()->manager(functor, type, detail::function::get_functor_type_tag);
+    return *type.type.type;
  }

  template<typename Functor>
@ -595,38 +652,34 @@ public:
      if (!vtable) return 0;

      detail::function::function_buffer type_result;
-      type_result.const_obj_ptr = &typeid(Functor);
-      vtable->manager(functor, type_result, 
+      type_result.type.type = &BOOST_SP_TYPEID(Functor);
+      type_result.type.const_qualified = is_const<Functor>::value;
+      type_result.type.volatile_qualified = is_volatile<Functor>::value;
+      get_vtable()->manager(functor, type_result, 
                      detail::function::check_functor_type_tag);
      return static_cast<Functor*>(type_result.obj_ptr);
    }

  template<typename Functor>
-#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-    const Functor* target( Functor * = 0 ) const
-#else
    const Functor* target() const
-#endif
    {
      if (!vtable) return 0;

      detail::function::function_buffer type_result;
-      type_result.const_obj_ptr = &typeid(Functor);
-      vtable->manager(functor, type_result, 
+      type_result.type.type = &BOOST_SP_TYPEID(Functor);
+      type_result.type.const_qualified = true;
+      type_result.type.volatile_qualified = is_volatile<Functor>::value;
+      get_vtable()->manager(functor, type_result, 
                      detail::function::check_functor_type_tag);
      // GCC 2.95.3 gets the CV qualifiers wrong here, so we
      // can't do the static_cast that we should do.
-      return (const Functor*)(type_result.obj_ptr);
+      return static_cast<const Functor*>(type_result.obj_ptr);
    }

  template<typename F>
    bool contains(const F& f) const
    {
-#if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-      if (const F* fp = this->target( (F*)0 ))
-#else
      if (const F* fp = this->template target<F>())
-#endif
      {
        return function_equal(*fp, f);
      } else {
@ -658,6 +711,15 @@ public:
 #endif

 public: // should be protected, but GCC 2.95.3 will fail to allow access
+  detail::function::vtable_base* get_vtable() const {
+    return reinterpret_cast<detail::function::vtable_base*>(
+             reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
+  }
+
+  bool has_trivial_copy_and_destroy() const {
+    return reinterpret_cast<std::size_t>(vtable) & 0x01;
+  }
+
  detail::function::vtable_base* vtable;
  mutable detail::function::function_buffer functor;
 };
@ -833,4 +895,8 @@ namespace detail {
 #undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL
 #undef BOOST_FUNCTION_COMPARE_TYPE_ID

+#if defined(BOOST_MSVC)
+#   pragma warning( pop )
+#endif       
+
 #endif // BOOST_FUNCTION_BASE_HEADER
--- a/include/boost/function/function_fwd.hpp
+++ b/include/boost/function/function_fwd.hpp
@ -0,0 +1,69 @@
+// Boost.Function library
+//  Copyright (C) Douglas Gregor 2008
+//
+//  Use, modification and distribution is subject to 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)
+//
+// For more information, see http://www.boost.org
+#ifndef BOOST_FUNCTION_FWD_HPP
+#define BOOST_FUNCTION_FWD_HPP
+#include <boost/config.hpp>
+
+#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
+// Work around a compiler bug.
+// boost::python::objects::function has to be seen by the compiler before the
+// boost::function class template.
+namespace boost { namespace python { namespace objects {
+  class function;
+}}}
+#endif
+
+#if defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                         \
+ || !(defined(BOOST_STRICT_CONFIG) || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
+#  define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
+#endif
+
+namespace boost {
+  class bad_function_call;
+
+#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
+  // Preferred syntax
+  template<typename Signature> class function;
+
+  template<typename Signature>
+  inline void swap(function<Signature>& f1, function<Signature>& f2)
+  {
+    f1.swap(f2);
+  }
+#endif // have partial specialization
+
+  // Portable syntax
+  template<typename R> class function0;
+  template<typename R, typename T1> class function1;
+  template<typename R, typename T1, typename T2> class function2;
+  template<typename R, typename T1, typename T2, typename T3> class function3;
+  template<typename R, typename T1, typename T2, typename T3, typename T4> 
+    class function4;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5> 
+    class function5;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6> 
+    class function6;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6, typename T7> 
+    class function7;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6, typename T7, typename T8> 
+    class function8;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6, typename T7, typename T8, typename T9> 
+    class function9;
+  template<typename R, typename T1, typename T2, typename T3, typename T4,
+           typename T5, typename T6, typename T7, typename T8, typename T9,
+           typename T10> 
+    class function10;
+}
+
+#endif
--- a/include/boost/function/function_template.hpp
+++ b/include/boost/function/function_template.hpp
@ -11,6 +11,7 @@
 // Note: this header is a header template and must NOT have multiple-inclusion
 // protection.
 #include <boost/function/detail/prologue.hpp>
+#include <boost/detail/no_exceptions_support.hpp>

 #if defined(BOOST_MSVC)
 #   pragma warning( push )
@ -53,12 +54,20 @@
  BOOST_JOIN(function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
 #define BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER \
  BOOST_JOIN(void_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_MEMBER_INVOKER \
+  BOOST_JOIN(function_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_VOID_MEMBER_INVOKER \
+  BOOST_JOIN(function_void_mem_invoker,BOOST_FUNCTION_NUM_ARGS)
 #define BOOST_FUNCTION_GET_FUNCTION_INVOKER \
  BOOST_JOIN(get_function_invoker,BOOST_FUNCTION_NUM_ARGS)
 #define BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER \
  BOOST_JOIN(get_function_obj_invoker,BOOST_FUNCTION_NUM_ARGS)
 #define BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER \
  BOOST_JOIN(get_function_ref_invoker,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_GET_MEMBER_INVOKER \
+  BOOST_JOIN(get_member_invoker,BOOST_FUNCTION_NUM_ARGS)
+#define BOOST_FUNCTION_GET_INVOKER \
+  BOOST_JOIN(get_invoker,BOOST_FUNCTION_NUM_ARGS)
 #define BOOST_FUNCTION_VTABLE BOOST_JOIN(basic_vtable,BOOST_FUNCTION_NUM_ARGS)

 #ifndef BOOST_NO_VOID_RETURNS
@ -180,6 +189,44 @@ namespace boost {
        }
      };

+#if BOOST_FUNCTION_NUM_ARGS > 0
+      /* Handle invocation of member pointers. */
+      template<
+        typename MemberPtr,
+        typename R BOOST_FUNCTION_COMMA
+        BOOST_FUNCTION_TEMPLATE_PARMS
+      >
+      struct BOOST_FUNCTION_MEMBER_INVOKER
+      {
+        static R invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
+                        BOOST_FUNCTION_PARMS)
+
+        {
+          MemberPtr* f = 
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+          return boost::mem_fn(*f)(BOOST_FUNCTION_ARGS);
+        }
+      };
+
+      template<
+        typename MemberPtr,
+        typename R BOOST_FUNCTION_COMMA
+        BOOST_FUNCTION_TEMPLATE_PARMS
+      >
+      struct BOOST_FUNCTION_VOID_MEMBER_INVOKER
+      {
+        static BOOST_FUNCTION_VOID_RETURN_TYPE
+        invoke(function_buffer& function_obj_ptr BOOST_FUNCTION_COMMA
+               BOOST_FUNCTION_PARMS)
+
+        {
+          MemberPtr* f = 
+            reinterpret_cast<MemberPtr*>(&function_obj_ptr.data);
+          BOOST_FUNCTION_RETURN(boost::mem_fn(*f)(BOOST_FUNCTION_ARGS));
+        }
+      };
+#endif
+
      template<
        typename FunctionPtr,
        typename R BOOST_FUNCTION_COMMA
@ -243,11 +290,190 @@ namespace boost {
                       >::type type;
      };

+#if BOOST_FUNCTION_NUM_ARGS > 0
+      /* Retrieve the appropriate invoker for a member pointer.  */
+      template<
+        typename MemberPtr,
+        typename R BOOST_FUNCTION_COMMA
+        BOOST_FUNCTION_TEMPLATE_PARMS
+       >
+      struct BOOST_FUNCTION_GET_MEMBER_INVOKER
+      {
+        typedef typename mpl::if_c<(is_void<R>::value),
+                            BOOST_FUNCTION_VOID_MEMBER_INVOKER<
+                            MemberPtr,
+                            R BOOST_FUNCTION_COMMA
+                            BOOST_FUNCTION_TEMPLATE_ARGS
+                          >,
+                          BOOST_FUNCTION_MEMBER_INVOKER<
+                            MemberPtr,
+                            R BOOST_FUNCTION_COMMA
+                            BOOST_FUNCTION_TEMPLATE_ARGS
+                          >
+                       >::type type;
+      };
+#endif
+
+      /* Given the tag returned by get_function_tag, retrieve the
+         actual invoker that will be used for the given function
+         object. 
+
+         Each specialization contains an "apply" nested class template
+         that accepts the function object, return type, function
+         argument types, and allocator. The resulting "apply" class
+         contains two typedefs, "invoker_type" and "manager_type",
+         which correspond to the invoker and manager types. */
+      template<typename Tag>
+      struct BOOST_FUNCTION_GET_INVOKER { };
+
+      /* Retrieve the invoker for a function pointer. */
+      template<>
+      struct BOOST_FUNCTION_GET_INVOKER<function_ptr_tag>
+      {
+        template<typename FunctionPtr,
+                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
+        struct apply
+        {
+          typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
+                             FunctionPtr,
+                             R BOOST_FUNCTION_COMMA
+                             BOOST_FUNCTION_TEMPLATE_ARGS
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+
+        template<typename FunctionPtr,
+                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
+                             FunctionPtr,
+                             R BOOST_FUNCTION_COMMA
+                             BOOST_FUNCTION_TEMPLATE_ARGS
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionPtr> manager_type;
+        };
+      };
+
+#if BOOST_FUNCTION_NUM_ARGS > 0
+      /* Retrieve the invoker for a member pointer. */
+      template<>
+      struct BOOST_FUNCTION_GET_INVOKER<member_ptr_tag>
+      {
+        template<typename MemberPtr,
+                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
+        struct apply
+        {
+          typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<
+                             MemberPtr,
+                             R BOOST_FUNCTION_COMMA
+                             BOOST_FUNCTION_TEMPLATE_ARGS
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+
+        template<typename MemberPtr,
+                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename BOOST_FUNCTION_GET_MEMBER_INVOKER<
+                             MemberPtr,
+                             R BOOST_FUNCTION_COMMA
+                             BOOST_FUNCTION_TEMPLATE_ARGS
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<MemberPtr> manager_type;
+        };
+      };
+#endif
+
+      /* Retrieve the invoker for a function object. */
+      template<>
+      struct BOOST_FUNCTION_GET_INVOKER<function_obj_tag>
+      {
+        template<typename FunctionObj,
+                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
+        struct apply
+        {
+          typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
+                             FunctionObj,
+                             R BOOST_FUNCTION_COMMA
+                             BOOST_FUNCTION_TEMPLATE_ARGS
+                           >::type
+            invoker_type;
+
+          typedef functor_manager<FunctionObj> manager_type;
+        };
+
+        template<typename FunctionObj,
+                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
+                             FunctionObj,
+                             R BOOST_FUNCTION_COMMA
+                             BOOST_FUNCTION_TEMPLATE_ARGS
+                           >::type
+            invoker_type;
+
+          typedef functor_manager_a<FunctionObj, Allocator> manager_type;
+        };
+      };
+
+      /* Retrieve the invoker for a reference to a function object. */
+      template<>
+      struct BOOST_FUNCTION_GET_INVOKER<function_obj_ref_tag>
+      {
+        template<typename RefWrapper,
+                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
+        struct apply
+        {
+          typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
+                             typename RefWrapper::type,
+                             R BOOST_FUNCTION_COMMA
+                             BOOST_FUNCTION_TEMPLATE_ARGS
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+
+        template<typename RefWrapper,
+                 typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
+                 typename Allocator>
+        struct apply_a
+        {
+          typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
+                             typename RefWrapper::type,
+                             R BOOST_FUNCTION_COMMA
+                             BOOST_FUNCTION_TEMPLATE_ARGS
+                           >::type
+            invoker_type;
+
+          typedef reference_manager<typename RefWrapper::type> manager_type;
+        };
+      };
+
+
      /**
-       * vtable for a specific boost::function instance.
+       * vtable for a specific boost::function instance. This
+       * structure must be an aggregate so that we can use static
+       * initialization in boost::function's assign_to and assign_to_a
+       * members. It therefore cannot have any constructors,
+       * destructors, base classes, etc.
       */
      template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
-      struct BOOST_FUNCTION_VTABLE : vtable_base
+      struct BOOST_FUNCTION_VTABLE
      {
 #ifndef BOOST_NO_VOID_RETURNS
        typedef R         result_type;
@ -260,86 +486,35 @@ namespace boost {
                                            BOOST_FUNCTION_TEMPLATE_ARGS);

        template<typename F>
-        BOOST_FUNCTION_VTABLE(F f) : vtable_base(), invoker(0)
-        {
-          init(f);
-        }
-        template<typename F,typename Allocator>
-        BOOST_FUNCTION_VTABLE(F f, Allocator) : vtable_base(), invoker(0)
-        {
-          init_a<Allocator>(f);
-        }
-
-        template<typename F>
-        bool assign_to(F f, function_buffer& functor)
+        bool assign_to(F f, function_buffer& functor) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to(f, functor, tag());
        }
        template<typename F,typename Allocator>
-        bool assign_to_a(F f, function_buffer& functor, Allocator a)
+        bool assign_to_a(F f, function_buffer& functor, Allocator a) const
        {
          typedef typename get_function_tag<F>::type tag;
          return assign_to_a(f, functor, a, tag());
        }

-        void clear(function_buffer& functor)
+        void clear(function_buffer& functor) const
        {
-          if (manager)
-            manager(functor, functor, destroy_functor_tag);
+          if (base.manager)
+            base.manager(functor, functor, destroy_functor_tag);
        }

      private:
-        template<typename F>
-        void init(F f)
-        {
-          typedef typename get_function_tag<F>::type tag;
-          init(f, tag());
-        }
-        template<typename Allocator,typename F>
-        void init_a(F f)
-        {
-          typedef typename get_function_tag<F>::type tag;
-          init_a<Allocator>(f, tag());
-        }
-
        // Function pointers
-        template<typename FunctionPtr>
-        void init(FunctionPtr /*f*/, function_ptr_tag)
-        {
-          typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
-                             FunctionPtr,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
-                           >::type
-            actual_invoker_type;
-
-          invoker = &actual_invoker_type::invoke;
-          manager = &functor_manager<FunctionPtr>::manage;
-        }
-        template<typename Allocator,typename FunctionPtr>
-        void init_a(FunctionPtr f, function_ptr_tag)
-        {
-          typedef typename BOOST_FUNCTION_GET_FUNCTION_INVOKER<
-                             FunctionPtr,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
-                           >::type
-            actual_invoker_type;
-
-          invoker = &actual_invoker_type::invoke;
-          manager = &functor_manager_a<FunctionPtr, Allocator>::manage;
-        }
-
        template<typename FunctionPtr>
        bool 
-        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
        {
          this->clear(functor);
          if (f) {
            // should be a reinterpret cast, but some compilers insist
            // on giving cv-qualifiers to free functions
-            functor.func_ptr = (void (*)())(f);
+            functor.func_ptr = reinterpret_cast<void (*)()>(f);
            return true;
          } else {
            return false;
@ -347,7 +522,7 @@ namespace boost {
        }
        template<typename FunctionPtr,typename Allocator>
        bool 
-        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag)
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
        {
          return assign_to(f,functor,function_ptr_tag());
        }
@ -355,43 +530,26 @@ namespace boost {
        // Member pointers
 #if BOOST_FUNCTION_NUM_ARGS > 0
        template<typename MemberPtr>
-        void init(MemberPtr f, member_ptr_tag)
-        {
-          // DPG TBD: Add explicit support for member function
-          // objects, so we invoke through mem_fn() but we retain the
-          // right target_type() values.
-          this->init(mem_fn(f));
-        }
-        template<typename Allocator,typename MemberPtr>
-        void init_a(MemberPtr f, member_ptr_tag)
-        {
-          // DPG TBD: Add explicit support for member function
-          // objects, so we invoke through mem_fn() but we retain the
-          // right target_type() values.
-          this->init_a<Allocator>(mem_fn(f));
-        }
-
-        template<typename MemberPtr>
-        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
        {
          // DPG TBD: Add explicit support for member function
          // objects, so we invoke through mem_fn() but we retain the
          // right target_type() values.
          if (f) {
-            this->assign_to(mem_fn(f), functor);
+            this->assign_to(boost::mem_fn(f), functor);
            return true;
          } else {
            return false;
          }
        }
        template<typename MemberPtr,typename Allocator>
-        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag)
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
        {
          // DPG TBD: Add explicit support for member function
          // objects, so we invoke through mem_fn() but we retain the
          // right target_type() values.
          if (f) {
-            this->assign_to_a(mem_fn(f), functor, a);
+            this->assign_to_a(boost::mem_fn(f), functor, a);
            return true;
          } else {
            return false;
@ -400,43 +558,16 @@ namespace boost {
 #endif // BOOST_FUNCTION_NUM_ARGS > 0

        // Function objects
-        template<typename FunctionObj>
-        void init(FunctionObj /*f*/, function_obj_tag)
-        {
-          typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
-                             FunctionObj,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
-                           >::type
-            actual_invoker_type;
-
-          invoker = &actual_invoker_type::invoke;
-          manager = &functor_manager<FunctionObj>::manage;
-        }
-        template<typename Allocator,typename FunctionObj>
-        void init_a(FunctionObj /*f*/, function_obj_tag)
-        {
-          typedef typename BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
-                             FunctionObj,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
-                           >::type
-            actual_invoker_type;
-
-          invoker = &actual_invoker_type::invoke;
-          manager = &functor_manager_a<FunctionObj, Allocator>::manage;
-        }
-
        // Assign to a function object using the small object optimization
        template<typename FunctionObj>
        void 
-        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
        {
-          new ((void*)&functor.data) FunctionObj(f);
+          new (reinterpret_cast<void*>(&functor.data)) FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void 
-        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_)
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_) const
        {
          assign_functor(f,functor,mpl::true_());
        }
@ -444,13 +575,13 @@ namespace boost {
        // Assign to a function object allocated on the heap.
        template<typename FunctionObj>
        void 
-        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_) const
        {
          functor.obj_ptr = new FunctionObj(f);
        }
        template<typename FunctionObj,typename Allocator>
        void 
-        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_)
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
        {
          typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
          typedef typename Allocator::template rebind<functor_wrapper_type>::other
@ -465,7 +596,7 @@ namespace boost {

        template<typename FunctionObj>
        bool 
-        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor(f, functor, 
@ -477,7 +608,7 @@ namespace boost {
        }
        template<typename FunctionObj,typename Allocator>
        bool 
-        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag)
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
        {
          if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
            assign_functor_a(f, functor, a,
@ -489,52 +620,26 @@ namespace boost {
        }

        // Reference to a function object
-        template<typename FunctionObj>
-        void 
-        init(const reference_wrapper<FunctionObj>& /*f*/, function_obj_ref_tag)
-        {
-          typedef typename BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER<
-                             FunctionObj,
-                             R BOOST_FUNCTION_COMMA
-                             BOOST_FUNCTION_TEMPLATE_ARGS
-                           >::type
-            actual_invoker_type;
-
-          invoker = &actual_invoker_type::invoke;
-          manager = &reference_manager<FunctionObj>::get;
-        }
-        template<typename Allocator,typename FunctionObj>
-        void 
-        init_a(const reference_wrapper<FunctionObj>& f, function_obj_ref_tag)
-        {
-          init(f,function_obj_ref_tag());
-        }
-
        template<typename FunctionObj>
        bool 
        assign_to(const reference_wrapper<FunctionObj>& f, 
-                  function_buffer& functor, function_obj_ref_tag)
+                  function_buffer& functor, function_obj_ref_tag) const
        {
-          if (!boost::detail::function::has_empty_target(f.get_pointer())) {
-            // DPG TBD: We might need to detect constness of
-            // FunctionObj to assign into obj_ptr or const_obj_ptr to
-            // be truly legit, but no platform in existence makes
-            // const void* different from void*.
-            functor.const_obj_ptr = f.get_pointer();
-            return true;
-          } else {
-            return false;
-          }
+          functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
+          functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
+          functor.obj_ref.is_volatile_qualified = is_volatile<FunctionObj>::value;
+          return true;
        }
        template<typename FunctionObj,typename Allocator>
        bool 
        assign_to_a(const reference_wrapper<FunctionObj>& f, 
-                  function_buffer& functor, Allocator, function_obj_ref_tag)
+                  function_buffer& functor, Allocator, function_obj_ref_tag) const
        {
          return assign_to(f,functor,function_obj_ref_tag());
        }

      public:
+        vtable_base base;
        invoker_type invoker;
      };
    } // end namespace function
@ -570,6 +675,11 @@ namespace boost {
              R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>
      vtable_type;

+    vtable_type* get_vtable() const {
+      return reinterpret_cast<vtable_type*>(
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
+    }
+
    struct clear_type {};

  public:
@ -638,23 +748,24 @@ namespace boost {
    {
      this->assign_to_own(f);
    }
-
+    
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    BOOST_FUNCTION_FUNCTION(BOOST_FUNCTION_FUNCTION&& f) : function_base()
+    {
+      this->move_assign(f);
+    }
+#endif
+    
    ~BOOST_FUNCTION_FUNCTION() { clear(); }

-#if BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-    // MSVC 6.0 and prior require all definitions to be inline, but
-    // these definitions can become very costly.
    result_type operator()(BOOST_FUNCTION_PARMS) const
    {
      if (this->empty())
        boost::throw_exception(bad_function_call());

-      return static_cast<vtable_type*>(vtable)->invoker
+      return get_vtable()->invoker
               (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
    }
-#else
-    result_type operator()(BOOST_FUNCTION_PARMS) const;
-#endif

    // The distinction between when to use BOOST_FUNCTION_FUNCTION and
    // when to use self_type is obnoxious. MSVC cannot handle self_type as
@ -673,24 +784,26 @@ namespace boost {
    operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
    {
      this->clear();
-      try {
+      BOOST_TRY  {
        this->assign_to(f);
-      } catch (...) {
+      } BOOST_CATCH (...) {
        vtable = 0;
-        throw;
+        BOOST_RETHROW;
      }
+      BOOST_CATCH_END
      return *this;
    }
    template<typename Functor,typename Allocator>
    void assign(Functor BOOST_FUNCTION_TARGET_FIX(const &) f, Allocator a)
    {
      this->clear();
-      try {
+      BOOST_TRY{
        this->assign_to_a(f,a);
-      } catch (...) {
+      } BOOST_CATCH (...) {
        vtable = 0;
-        throw;
+        BOOST_RETHROW;
      }
+      BOOST_CATCH_END
    }

 #ifndef BOOST_NO_SFINAE
@ -715,30 +828,53 @@ namespace boost {
        return *this;

      this->clear();
-      try {
+      BOOST_TRY {
        this->assign_to_own(f);
-      } catch (...) {
+      } BOOST_CATCH (...) {
        vtable = 0;
-        throw;
+        BOOST_RETHROW;
      }
+      BOOST_CATCH_END
      return *this;
    }
+    
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+    // Move assignment from another BOOST_FUNCTION_FUNCTION
+    BOOST_FUNCTION_FUNCTION& operator=(BOOST_FUNCTION_FUNCTION&& f)
+    {
+      
+      if (&f == this)
+        return *this;
+
+      this->clear();
+      BOOST_TRY {
+        this->move_assign(f);
+      } BOOST_CATCH (...) {
+        vtable = 0;
+        BOOST_RETHROW;
+      }
+      BOOST_CATCH_END
+      return *this;
+    }
+#endif

    void swap(BOOST_FUNCTION_FUNCTION& other)
    {
      if (&other == this)
        return;

-      BOOST_FUNCTION_FUNCTION tmp = *this;
-      *this = other;
-      other = tmp;
+      BOOST_FUNCTION_FUNCTION tmp;
+      tmp.move_assign(*this);
+      this->move_assign(other);
+      other.move_assign(tmp);
    }

    // Clear out a target, if there is one
    void clear()
    {
      if (vtable) {
-        static_cast<vtable_type*>(vtable)->clear(this->functor);
+        if (!this->has_trivial_copy_and_destroy())
+          get_vtable()->clear(this->functor);
        vtable = 0;
      }
    }
@ -749,7 +885,7 @@ namespace boost {
 #else
  private:
    struct dummy {
-      void nonnull() {};
+      void nonnull() {}
    };

    typedef void (dummy::*safe_bool)();
@ -767,24 +903,108 @@ namespace boost {
    {
      if (!f.empty()) {
        this->vtable = f.vtable;
-        f.vtable->manager(f.functor, this->functor,
-                          boost::detail::function::clone_functor_tag);
+        if (this->has_trivial_copy_and_destroy())
+          this->functor = f.functor;
+        else
+          get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::clone_functor_tag);
      }
    }

    template<typename Functor>
    void assign_to(Functor f)
    {
-      static vtable_type stored_vtable(f);
-      if (stored_vtable.assign_to(f, functor)) vtable = &stored_vtable;
-      else vtable = 0;
+      using detail::function::vtable_base;
+
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply<Functor, R BOOST_FUNCTION_COMMA 
+                        BOOST_FUNCTION_TEMPLATE_ARGS>
+        handler_type;
+      
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+      // Note: it is extremely important that this initialization use
+      // static initialization. Otherwise, we will have a race
+      // condition here in multi-threaded code. See
+      // http://thread.gmane.org/gmane.comp.lib.boost.devel/164902/.
+      static const vtable_type stored_vtable = 
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to(f, functor)) {
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        // coverity[pointless_expression]: suppress coverity warnings on apparant if(const).
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else 
+        vtable = 0;
    }
+
    template<typename Functor,typename Allocator>
    void assign_to_a(Functor f,Allocator a)
    {
-      static vtable_type stored_vtable(f,a);
-      if (stored_vtable.assign_to_a(f, functor, a)) vtable = &stored_vtable;
-      else vtable = 0;
+      using detail::function::vtable_base;
+
+      typedef typename detail::function::get_function_tag<Functor>::type tag;
+      typedef detail::function::BOOST_FUNCTION_GET_INVOKER<tag> get_invoker;
+      typedef typename get_invoker::
+                         template apply_a<Functor, R BOOST_FUNCTION_COMMA 
+                         BOOST_FUNCTION_TEMPLATE_ARGS,
+                         Allocator>
+        handler_type;
+      
+      typedef typename handler_type::invoker_type invoker_type;
+      typedef typename handler_type::manager_type manager_type;
+
+      // Note: it is extremely important that this initialization use
+      // static initialization. Otherwise, we will have a race
+      // condition here in multi-threaded code. See
+      // http://thread.gmane.org/gmane.comp.lib.boost.devel/164902/.
+      static const vtable_type stored_vtable =
+        { { &manager_type::manage }, &invoker_type::invoke };
+
+      if (stored_vtable.assign_to_a(f, functor, a)) { 
+        std::size_t value = reinterpret_cast<std::size_t>(&stored_vtable.base);
+        // coverity[pointless_expression]: suppress coverity warnings on apparant if(const).
+        if (boost::has_trivial_copy_constructor<Functor>::value &&
+            boost::has_trivial_destructor<Functor>::value &&
+            detail::function::function_allows_small_object_optimization<Functor>::value)
+          value |= static_cast<std::size_t>(0x01);
+        vtable = reinterpret_cast<detail::function::vtable_base *>(value);
+      } else 
+        vtable = 0;
+    }
+
+    // Moves the value from the specified argument to *this. If the argument 
+    // has its function object allocated on the heap, move_assign will pass 
+    // its buffer to *this, and set the argument's buffer pointer to NULL. 
+    void move_assign(BOOST_FUNCTION_FUNCTION& f) 
+    { 
+      if (&f == this)
+        return;
+
+      BOOST_TRY {
+        if (!f.empty()) {
+          this->vtable = f.vtable;
+          if (this->has_trivial_copy_and_destroy())
+            this->functor = f.functor;
+          else
+            get_vtable()->base.manager(f.functor, this->functor,
+                                     boost::detail::function::move_functor_tag);
+          f.vtable = 0;
+        } else {
+          clear();
+        }
+      } BOOST_CATCH (...) {
+        vtable = 0;
+        BOOST_RETHROW;
+      }
+      BOOST_CATCH_END
    }
  };

@ -801,21 +1021,6 @@ namespace boost {
    f1.swap(f2);
  }

-#if !BOOST_WORKAROUND(BOOST_MSVC, < 1300)
-  template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
-  typename BOOST_FUNCTION_FUNCTION<
-      R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>::result_type
-   BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS>
-  ::operator()(BOOST_FUNCTION_PARMS) const
-  {
-    if (this->empty())
-      boost::throw_exception(bad_function_call());
-
-    return static_cast<vtable_type*>(vtable)->invoker
-             (this->functor BOOST_FUNCTION_COMMA BOOST_FUNCTION_ARGS);
-  }
-#endif
-
 // Poison comparisons between boost::function objects of the same type.
 template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS>
  void operator==(const BOOST_FUNCTION_FUNCTION<
@ -887,12 +1092,26 @@ public:

  function(const base_type& f) : base_type(static_cast<const base_type&>(f)){}

+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+  // Move constructors
+  function(self_type&& f): base_type(static_cast<base_type&&>(f)){}
+  function(base_type&& f): base_type(static_cast<base_type&&>(f)){}
+#endif
+  
  self_type& operator=(const self_type& f)
  {
    self_type(f).swap(*this);
    return *this;
  }

+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+  self_type& operator=(self_type&& f)
+  {
+    self_type(static_cast<self_type&&>(f)).swap(*this);
+    return *this;
+  }
+#endif  
+
  template<typename Functor>
 #ifndef BOOST_NO_SFINAE
  typename enable_if_c<
@ -921,6 +1140,14 @@ public:
    self_type(f).swap(*this);
    return *this;
  }
+  
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+  self_type& operator=(base_type&& f)
+  {
+    self_type(static_cast<base_type&&>(f)).swap(*this);
+    return *this;
+  }
+#endif 
 };

 #undef BOOST_FUNCTION_PARTIAL_SPEC
@ -938,10 +1165,13 @@ public:
 #undef BOOST_FUNCTION_VOID_FUNCTION_OBJ_INVOKER
 #undef BOOST_FUNCTION_FUNCTION_REF_INVOKER
 #undef BOOST_FUNCTION_VOID_FUNCTION_REF_INVOKER
+#undef BOOST_FUNCTION_MEMBER_INVOKER
+#undef BOOST_FUNCTION_VOID_MEMBER_INVOKER
 #undef BOOST_FUNCTION_GET_FUNCTION_INVOKER
 #undef BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER
 #undef BOOST_FUNCTION_GET_FUNCTION_REF_INVOKER
 #undef BOOST_FUNCTION_GET_MEM_FUNCTION_INVOKER
+#undef BOOST_FUNCTION_GET_INVOKER
 #undef BOOST_FUNCTION_TEMPLATE_PARMS
 #undef BOOST_FUNCTION_TEMPLATE_ARGS
 #undef BOOST_FUNCTION_PARMS
--- a/include/boost/function/function_typeof.hpp
+++ b/include/boost/function/function_typeof.hpp
@ -0,0 +1,45 @@
+// Boost.Function library - Typeof support
+//  Copyright (C) Douglas Gregor 2008
+//
+//  Use, modification and distribution is subject to 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)
+//
+// For more information, see http://www.boost.org
+#ifndef BOOST_FUNCTION_TYPEOF_HPP
+#define BOOST_FUNCTION_TYPEOF_HPP
+#include <boost/function/function_fwd.hpp>
+#include <boost/typeof/typeof.hpp>
+
+#include BOOST_TYPEOF_INCREMENT_REGISTRATION_GROUP()
+
+BOOST_TYPEOF_REGISTER_TYPE(boost::bad_function_call)
+
+#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function, (typename))
+#endif
+
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function0, (typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function1, (typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function2, (typename)(typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function3, 
+  (typename)(typename)(typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function4, 
+  (typename)(typename)(typename)(typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function5, 
+  (typename)(typename)(typename)(typename)(typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function6, 
+  (typename)(typename)(typename)(typename)(typename)(typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function7, 
+  (typename)(typename)(typename)(typename)(typename)(typename)(typename)
+  (typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function8, 
+  (typename)(typename)(typename)(typename)(typename)(typename)(typename)
+  (typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function9, 
+  (typename)(typename)(typename)(typename)(typename)(typename)(typename)
+  (typename)(typename)(typename))
+BOOST_TYPEOF_REGISTER_TEMPLATE(boost::function10, 
+  (typename)(typename)(typename)(typename)(typename)(typename)(typename)
+  (typename)(typename)(typename)(typename))
+#endif
--- a/test/Jamfile.v2
+++ b/test/Jamfile.v2
@ -8,6 +8,7 @@
 # For more information, see http://www.boost.org/

 project
+    : requirements <toolset>msvc:<asynch-exceptions>on
    : source-location $(BOOST_ROOT)
    ;

@ -58,6 +59,9 @@ import testing ;
   
  [ run libs/function/test/contains2_test.cpp : : : : ]
   
+  [ run libs/function/test/nothrow_swap.cpp :  :  :  :  ]
+
+  [ compile libs/function/test/function_typeof_test.cpp ]
 ;
 }
      
--- a/test/allocator_test.cpp
+++ b/test/allocator_test.cpp
@ -128,6 +128,10 @@ test_main(int, char*[])
  BOOST_CHECK(dealloc_count == 0);
  fv.assign( &do_nothing, std::allocator<int>() );
  fv.clear();
+  
+  function0<void> fv2;
+  fv.assign(&do_nothing, std::allocator<int>() );
+  fv2.assign(fv, std::allocator<int>() );

  return 0;
 }
--- a/test/contains_test.cpp
+++ b/test/contains_test.cpp
@ -88,6 +88,15 @@ static void target_test()
  BOOST_CHECK(!f.target<int (*)()>());
  BOOST_CHECK(f.target<Seventeen>());
  BOOST_CHECK(f.target<Seventeen>() == &this_seventeen);
+
+  const Seventeen const_seventeen = this_seventeen;
+  f = boost::ref(const_seventeen);
+  BOOST_CHECK(!f.target<int (*)()>());
+  BOOST_CHECK(f.target<const Seventeen>());
+  BOOST_CHECK(f.target<const Seventeen>() == &const_seventeen);
+  BOOST_CHECK(f.target<const volatile Seventeen>());
+  BOOST_CHECK(!f.target<Seventeen>());
+  BOOST_CHECK(!f.target<volatile Seventeen>());
 }

 static void equal_test()
--- a/test/function_n_test.cpp
+++ b/test/function_n_test.cpp
@ -636,6 +636,54 @@ test_ref()
  }
 }

+static unsigned construction_count = 0;
+static unsigned destruction_count = 0;
+
+struct MySmallFunctor {
+  MySmallFunctor() { ++construction_count; }
+  MySmallFunctor(const MySmallFunctor &) { ++construction_count; }
+  ~MySmallFunctor() { ++destruction_count; }
+  int operator()() { return 0; }
+ };
+
+struct MyLargeFunctor {
+  MyLargeFunctor() { ++construction_count; }
+  MyLargeFunctor(const MyLargeFunctor &) { ++construction_count; }
+  ~MyLargeFunctor() { ++destruction_count; }
+  int operator()() { return 0; }
+
+  float data[128];
+ };
+
+void test_construct_destroy_count()
+{
+  {
+    boost::function0<int> f;
+    boost::function0<int> g;
+    f = MySmallFunctor();
+    g = MySmallFunctor();
+    f.swap(g);
+  }
+
+  // MySmallFunctor objects should be constructed as many times as
+  // they are destroyed.
+  BOOST_CHECK(construction_count == destruction_count);
+ 
+  construction_count = 0;
+  destruction_count = 0;
+  {
+    boost::function0<int> f;
+    boost::function0<int> g;
+    f = MyLargeFunctor();
+    g = MyLargeFunctor();
+    f.swap(g);
+   }
+
+   // MyLargeFunctor objects should be constructed as many times as
+   // they are destroyed.
+   BOOST_CHECK(construction_count == destruction_count);
+}
+
 int test_main(int, char* [])
 {
  test_zero_args();
@ -644,5 +692,6 @@ int test_main(int, char* [])
  test_emptiness();
  test_member_functions();
  test_ref();
+  test_construct_destroy_count();
  return 0;
 }
--- a/test/function_test.cpp
+++ b/test/function_test.cpp
@ -13,8 +13,8 @@
 #include <string>
 #include <utility>

-using namespace boost;
-using namespace std;
+using boost::function;
+using std::string;

 int global_int;

@ -525,7 +525,7 @@ test_zero_args()
 static void
 test_one_arg()
 {
-  negate<int> neg;
+  std::negate<int> neg;

  function<int (int)> f1(neg);
  BOOST_CHECK(f1(5) == -5);
@ -607,12 +607,12 @@ struct add_with_throw_on_copy {

  add_with_throw_on_copy(const add_with_throw_on_copy&)
  {
-    throw runtime_error("But this CAN'T throw");
+    throw std::runtime_error("But this CAN'T throw");
  }

  add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
  {
-    throw runtime_error("But this CAN'T throw");
+    throw std::runtime_error("But this CAN'T throw");
  }
 };

@ -621,14 +621,38 @@ test_ref()
 {
  add_with_throw_on_copy atc;
  try {
-    boost::function<int (int, int)> f(ref(atc));
+    boost::function<int (int, int)> f(boost::ref(atc));
    BOOST_CHECK(f(1, 3) == 4);
  }
-  catch(runtime_error e) {
+  catch(std::runtime_error e) {
    BOOST_ERROR("Nonthrowing constructor threw an exception");
  }
 }

+static void dummy() {}
+
+static void test_empty_ref()
+{
+  boost::function<void()> f1;
+  boost::function<void()> f2(boost::ref(f1));
+
+  try {
+    f2();
+    BOOST_ERROR("Exception didn't throw for reference to empty function.");
+  }
+  catch(std::runtime_error e) {}
+
+  f1 = dummy;
+
+  try {
+    f2();
+  }
+  catch(std::runtime_error e) {
+    BOOST_ERROR("Error calling referenced function.");
+  }
+}
+
+
 static void test_exception()
 {
  boost::function<int (int, int)> f;
@ -666,6 +690,95 @@ static void test_call()
  test_call_cref(std::plus<int>());
 }

+struct big_aggregating_structure {
+  int disable_small_objects_optimizations[32];
+    
+  big_aggregating_structure()
+  {
+    ++ global_int;
+  }
+    
+  big_aggregating_structure(const big_aggregating_structure&)
+  {
+    ++ global_int;
+  }
+
+  ~big_aggregating_structure()
+  {
+    -- global_int;
+  }
+    
+  void operator()() 
+  {
+    ++ global_int;
+  }
+
+  void operator()(int) 
+  {
+    ++ global_int;
+  }
+};
+
+template <class FunctionT>
+static void test_move_semantics() 
+{
+  typedef FunctionT f1_type;
+
+  big_aggregating_structure obj;
+  
+  f1_type f1 = obj;
+  global_int = 0;
+  f1();
+  
+  BOOST_CHECK(!f1.empty());
+  BOOST_CHECK(global_int == 1);
+  
+#ifndef BOOST_NO_CXX11_RVALUE_REFERENCES
+  // Testing rvalue constructors
+  f1_type f2(static_cast<f1_type&&>(f1));
+  BOOST_CHECK(f1.empty());
+  BOOST_CHECK(!f2.empty());
+  BOOST_CHECK(global_int == 1);
+  f2();
+  BOOST_CHECK(global_int == 2);
+  
+  f1_type f3(static_cast<f1_type&&>(f2));
+  BOOST_CHECK(f1.empty());
+  BOOST_CHECK(f2.empty());
+  BOOST_CHECK(!f3.empty());
+  BOOST_CHECK(global_int == 2);
+  f3();
+  BOOST_CHECK(global_int == 3);
+    
+  // Testing move assignment
+  f1_type f4;
+  BOOST_CHECK(f4.empty());
+  f4 = static_cast<f1_type&&>(f3);
+  BOOST_CHECK(f1.empty());
+  BOOST_CHECK(f2.empty());
+  BOOST_CHECK(f3.empty());
+  BOOST_CHECK(!f4.empty());
+  BOOST_CHECK(global_int == 3);
+  f4();
+  BOOST_CHECK(global_int == 4);
+  
+  // Testing self move assignment
+  f4 = static_cast<f1_type&&>(f4);
+  BOOST_CHECK(!f4.empty());
+  BOOST_CHECK(global_int == 4);
+
+  // Testing, that no memory leaked when assigning to nonempty function
+  f4 = obj;
+  BOOST_CHECK(!f4.empty());
+  BOOST_CHECK(global_int == 4);
+  f1_type f5 = obj;
+  BOOST_CHECK(global_int == 5);
+  f4 = static_cast<f1_type&&>(f5);
+  BOOST_CHECK(global_int == 4);
+  
+#endif  
+}
+
 int test_main(int, char* [])
 {
  test_zero_args();
@ -674,9 +787,12 @@ int test_main(int, char* [])
  test_emptiness();
  test_member_functions();
  test_ref();
+  test_empty_ref();
  test_exception();
  test_implicit();
  test_call();
+  test_move_semantics<function<void()> >();
+  test_move_semantics<boost::function0<void> >();

  return 0;
 }
--- a/test/function_typeof_test.cpp
+++ b/test/function_typeof_test.cpp
@ -0,0 +1,18 @@
+// Boost.Function library
+
+//  Copyright Douglas Gregor 2008. Use, modification and
+//  distribution is subject to 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)
+
+// For more information, see http://www.boost.org
+#include <boost/function/function_typeof.hpp>
+#include <boost/function.hpp>
+#include <boost/typeof/typeof.hpp>
+#include <boost/type_traits/is_same.hpp>
+#include <boost/static_assert.hpp>
+
+void f(boost::function0<void> f, boost::function0<void> g)
+{
+  BOOST_STATIC_ASSERT((boost::is_same<boost::function0<void>, BOOST_TYPEOF(f = g)>::value));
+}
--- a/test/lambda_test.cpp
+++ b/test/lambda_test.cpp
@ -15,21 +15,21 @@
 #include <boost/lambda/bind.hpp>
 #include <boost/function.hpp>

-using namespace std;
-using namespace boost;
-using namespace boost::lambda;
-
 static unsigned
 func_impl(int arg1, bool arg2, double arg3)
 {
+  using namespace std;
  return abs (static_cast<int>((arg2 ? arg1 : 2 * arg1) * arg3));
 }

 int test_main(int, char*[])
 {
+  using boost::function;
+  using namespace boost::lambda;
+
  function <unsigned(bool, double)> f1 = bind(func_impl, 15, _1, _2);
-  function <unsigned(double)>       f2 = bind(f1, false, _1);
-  function <unsigned()>             f3 = bind(f2, 4.0);
+  function <unsigned(double)>       f2 = boost::lambda::bind(f1, false, _1);
+  function <unsigned()>             f3 = boost::lambda::bind(f2, 4.0);

  f3();

--- a/test/mem_fun_cxx98.cpp
+++ b/test/mem_fun_cxx98.cpp
@ -10,22 +10,36 @@

    
 #include <boost/function.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <iostream>
 #include <functional>

+struct Y {
+    Y(int y = 0) : y_(y) {}
+    bool operator==(const Y& rhs) { return y_ == rhs.y_; }
+private:
+    int y_;
+    };
+
 struct X {
  int foo(int);
+  Y& foo2(Y&) const;
 };
 int X::foo(int x) { return -x; }
+Y& X::foo2(Y& x) const { return x; }

 int main()
 {
    boost::function<int (X*, int)> f;
+    boost::function<Y& (X*, Y&)> f2;
+	Y y1;
+	
+    f = &X::foo;
+    f2 = &X::foo2;

-f = &X::foo;
-  
-X x;
-f(&x, 5);
+    X x;
+    BOOST_TEST(f(&x, 5) == -5);
+    BOOST_TEST(f2(&x, boost::ref(y1)) == y1);

-    return 0;
+    return ::boost::report_errors();
 }
--- a/test/mem_fun_portable.cpp
+++ b/test/mem_fun_portable.cpp
@ -10,22 +10,36 @@

    
 #include <boost/function.hpp>
+#include <boost/detail/lightweight_test.hpp>
 #include <iostream>
 #include <functional>

+struct Y {
+    Y(int y = 0) : y_(y) {}
+    bool operator==(const Y& rhs) { return y_ == rhs.y_; }
+private:
+    int y_;
+    };
+
 struct X {
  int foo(int);
+  Y& foo2(Y&) const;
 };
 int X::foo(int x) { return -x; }
+Y& X::foo2(Y& x) const { return x; }

 int main()
 {
    boost::function2<int, X*, int> f;
+    boost::function2<Y&, X*, Y&> f2;
+    Y y1;
+    
+    f = &X::foo;
+    f2 = &X::foo2;

-f = &X::foo;
-  
-X x;
-f(&x, 5);
+    X x;
+    BOOST_TEST(f(&x, 5) == -5);
+    BOOST_TEST(f2(&x, boost::ref(y1)) == y1);

-    return 0;
+    return ::boost::report_errors();
 }
--- a/test/nothrow_swap.cpp
+++ b/test/nothrow_swap.cpp
@ -0,0 +1,60 @@
+// Boost.Function library
+
+//  Copyright Douglas Gregor 2008. Use, modification and
+//  distribution is subject to 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)
+
+// For more information, see http://www.boost.org
+
+#include <boost/test/minimal.hpp>
+#include <boost/function.hpp>
+
+struct tried_to_copy { };
+
+struct MaybeThrowOnCopy {
+  MaybeThrowOnCopy(int value = 0) : value(value) { }
+
+  MaybeThrowOnCopy(const MaybeThrowOnCopy& other) : value(other.value) {
+    if (throwOnCopy)
+      throw tried_to_copy();
+  }
+
+  MaybeThrowOnCopy& operator=(const MaybeThrowOnCopy& other) {
+    if (throwOnCopy)
+      throw tried_to_copy();
+    value = other.value;
+    return *this;
+  }
+
+  int operator()() { return value; }
+
+  int value;
+
+  // Make sure that this function object doesn't trigger the
+  // small-object optimization in Function.
+  float padding[100];
+
+  static bool throwOnCopy;
+};
+
+bool MaybeThrowOnCopy::throwOnCopy = false;
+
+int test_main(int, char* [])
+{
+  boost::function0<int> f;
+  boost::function0<int> g;
+
+  MaybeThrowOnCopy::throwOnCopy = false;
+  f = MaybeThrowOnCopy(1);
+  g = MaybeThrowOnCopy(2);
+  BOOST_CHECK(f() == 1);
+  BOOST_CHECK(g() == 2);
+
+  MaybeThrowOnCopy::throwOnCopy = true;
+  f.swap(g);
+  BOOST_CHECK(f() == 2);
+  BOOST_CHECK(g() == 1);
+  
+  return 0;
+}
Author	SHA1	Message	Date
Marshall Clow	78eb6b1c8c	Fixed two tests to work with C++11/libc++. The tests attempted to compare two ostream&, but didn't really. In c++03, both decayed to void *, which wre then compared. In c++11, the ostreams are comvertible to bool, but only explicitly, and this failed to compile. Use a custom struct with operator== instead of ostream in these tests instead.	2014-02-03 11:46:05 -08:00
Marshall Clow	a80ac7f5c5	Merge branch 'develop'	2014-02-03 11:29:22 -08:00
Marshall Clow	e9fe0b6db3	Created first merge point for git	2014-02-03 11:27:41 -08:00
Marshall Clow	9f06e35e8d	Add coverity comments to silence Coverity warnings	2014-01-31 19:50:02 -08:00
Marshall Clow	250655ad6d	Add 'std:' qualification to size_t. Fixes Bug #6184	2014-01-31 19:42:29 -08:00
Stephen Kelly	ea19e9e745	Remove remaining occurances of BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION These evaded scripting. [SVN r86249]	2013-10-11 23:22:36 +00:00
Stephen Kelly	8d5a27fb85	Function: Remove obsolete GCC version check. [SVN r86111]	2013-10-01 08:46:26 +00:00
Stephen Kelly	8760088d44	Function: Remove obsolete MSVC version checks. [SVN r86018]	2013-09-30 00:16:55 +00:00
Antony Polukhin	9245ac2a8f	Merge from trunk: * Update documentation of Boost.Function and add info about rvalues (fixes #8505) [SVN r84788]	2013-06-15 07:06:26 +00:00
Antony Polukhin	26d278733f	Update documentation of Boost.Function and add info about rvalues (refs #8505 ) [SVN r84787]	2013-06-15 06:59:30 +00:00
Marshall Clow	62cce2aaaf	Merge fix from trunk; Fixes #7819 [SVN r82280]	2012-12-30 01:07:13 +00:00
Marshall Clow	95a1956397	Added missing 'std::'; Refs #7819 [SVN r82273]	2012-12-29 16:36:12 +00:00
Marshall Clow	352cb183fe	Merge macro changes for Boost.Function to release branch [SVN r82054]	2012-12-17 17:50:38 +00:00
Marshall Clow	74a61f0252	Removed usage of deprecated macros in Boost.Function [SVN r81570]	2012-11-26 18:47:49 +00:00
Marshall Clow	9e30736439	Updated to use new macro names [SVN r81450]	2012-11-21 01:49:52 +00:00
Antony Polukhin	3ac49dc978	Merge from trunk: added move assignment and move constructors to Boost.Function (fixes #7330 ) [SVN r80738]	2012-09-28 18:14:00 +00:00
Marshall Clow	1ebe83a832	Merge doc fixes to release; Fixes #7244 [SVN r80694]	2012-09-24 16:36:41 +00:00
Antony Polukhin	419f424959	Add move assignment and move constructors to Boost.Function (refs #7330 ) [SVN r80552]	2012-09-17 04:08:18 +00:00
Marshall Clow	bfde71273b	Fix typo; Refs #7244 [SVN r80077]	2012-08-18 14:26:41 +00:00
Marshall Clow	0dc186d891	Merge Change 74916 (extra semicolon) to release [SVN r74939]	2011-10-13 18:34:19 +00:00
Marshall Clow	775213a9e6	Remove extraneous semicolon [SVN r74916]	2011-10-11 15:23:29 +00:00
Marshall Clow	b31584cfb5	Merge fixes to release; Fixes #4717 [SVN r72347]	2011-06-02 15:34:54 +00:00
Marshall Clow	cbb9e7c4da	Applied patch from #4717 [SVN r72316]	2011-05-31 21:12:35 +00:00
Daniel James	3193df71b9	Function: Merge from trunk. - Remove extra definition of operator(), since it's inline anyway. Fixes #4765. - Make sure that the cv flags are copied when we copy a reference to a function object. Fixes #4325 - Fully qualified function calls to avoid ambiguity with new additions to standard. Thanks to Conrad Poelman. Fixes #4073 - Remove iterator workaround for newer versions of Visual Age C++. Thanks to 'ccambly'. Fixes #3912 - Fix unused variable warning for Visual C++. Fixes #3618 - Testing flag for Visual C++. - Removed all but one old-style cast, prevents GCC warnings, but breaks GCC 2.95.3. Fixes #3410 - Fixed tab and newline issues from inspection report. [SVN r70361]	2011-03-21 21:32:38 +00:00
Daniel James	7ee94c6975	Function: Extra member tests, to catch #4073 . [SVN r70301]	2011-03-21 09:01:18 +00:00
Steven Watanabe	8cde82a568	Remove extra definition of operator(), since it's inline anyway. Fixes #4765 . [SVN r67560]	2011-01-02 05:13:03 +00:00
Hartmut Kaiser	f85a3db133	Spirit: merging from trunk upto rev. 61489 [SVN r63640]	2010-07-04 22:38:38 +00:00
Daniel James	a0286a58c7	Merge documentation fixes. * Use `doc/src/.css` instead of `doc/html/.css`. * Remove wiki and people directories. * Some documentation fixes. * Left out `minimal.css` changes and boostbook changes because of clashes. [SVN r63347]	2010-06-26 12:30:09 +00:00
Daniel James	9ea95b071b	Detab some jamfiles. [SVN r63343]	2010-06-26 12:10:47 +00:00
Daniel James	09fc8792fa	Update various libraries' documentation build. Mostly to use the images and css files under doc/src instead of doc/html, usually be deleting the settings in order to use the defaults. Also add 'boost.root' to some builds in order to fix links which rely on it. [SVN r63146]	2010-06-20 18:00:48 +00:00
Steven Watanabe	c0d4005441	Make sure that the cv flags are copied when we copy a reference to a function object. Fixes #4325 [SVN r62665]	2010-06-09 15:40:48 +00:00
Jeremiah Willcock	6902f6f943	Applied patch from #4073 ; fixes #4073 [SVN r62623]	2010-06-09 00:51:41 +00:00
Jeremiah Willcock	c4f1ce7cb1	Applied patch from #3912 ; fixes #3912 [SVN r62622]	2010-06-09 00:49:45 +00:00
Jeremiah Willcock	820ad024fe	Applied patch from #3618 ; fixes #3618 [SVN r62621]	2010-06-09 00:47:51 +00:00
Jeremiah Willcock	2e19728cdb	Removed all but one old-style cast, breaking GCC 2.95.3; fixes #3410 [SVN r62614]	2010-06-08 23:55:25 +00:00
Jeremiah Willcock	de3b8e7451	Fixed tab and no-newline-at-end-of-file issues from inspection report [SVN r61435]	2010-04-20 17:54:16 +00:00
Peter Dimov	1b6a5673cb	Merge [58123], [58127], [58128] to release. Fixes #3666 . [SVN r58195]	2009-12-06 17:50:28 +00:00
Peter Dimov	22c6592a40	Fix function_base.hpp to not require typeid. Refs #3666 . Requires [58127]. [SVN r58128]	2009-12-03 20:59:32 +00:00
Troy D. Straszheim	a1f62de420	rm cmake from trunk. I'm not entirely sure this is necessary to satisfy the inspect script, but I'm not taking any chances, and it is easy to put back [SVN r56942]	2009-10-17 02:07:38 +00:00
Troy D. Straszheim	24a7ce00a8	rm cmake from the release branch before it goes out broken. Policy dictates that you never commit to release, you commit to trunk and merge to release. [SVN r56941]	2009-10-17 01:10:45 +00:00
Troy D. Straszheim	81c7876588	Copyrights on CMakeLists.txt to keep them from clogging up the inspect reports. This is essentially the same commit as r55095 on the release branch. [SVN r55159]	2009-07-26 00:49:56 +00:00
Troy D. Straszheim	c398dfceb3	Add basic copyright/license to keep cmake out of the inspection report [SVN r55095]	2009-07-22 21:51:01 +00:00
Daniel James	a108a1cf26	Fix a typo. Merged revisions 54909 via svnmerge from https://svn.boost.org/svn/boost/trunk [SVN r54912]	2009-07-12 16:13:35 +00:00
Daniel James	2020d39e2c	Fix a typo. [SVN r54909]	2009-07-12 15:53:54 +00:00
Daniel James	d68cc8a51c	Merge various function changes from trunk. Merged revisions 49571,50064,51743,51745,53722,54616-54619 via svnmerge from https://svn.boost.org/svn/boost/trunk ........ r49571 \| noel_belcourt \| 2008-11-03 18:37:49 +0000 (Mon, 03 Nov 2008) \| 9 lines Both Sun and Pgi on Linux correctly put typeinfo into the std namespace, but function_base keys off the BOOST_NO_EXCEPTION_STD_NAMESPACE macro instead of the BOOST_NO_STD_TYPEINFO macro. The attached patch changes function_base to use the typeinfo macro. Because eVC 4.2 doesn't put typeinfo into the std namespace, I need to define BOOST_NO_STD_TYPEINFO only for this eVC version. ........ r50064 \| johnmaddock \| 2008-12-02 10:10:46 +0000 (Tue, 02 Dec 2008) \| 1 line Fix -Wundef warning and suspect usage of BOOST_STRICT_CONFIG. ........ r51743 \| dgregor \| 2009-03-13 05:23:53 +0000 (Fri, 13 Mar 2009) \| 11 lines Implement an optimization that David Abrahams and myself came up with, where Boost.Function uses a bit in the vtable pointer to indicate when the target function object has a trivial copy constructor, trivial destructor, and fits within the small object buffer. In this case, we just copy the bits of the function object rather than performing an indirect call to the manager. This results in a 60% speedup on a micro-benchmark that copies and calls such function objects repeatedly. ........ r51745 \| dgregor \| 2009-03-13 05:49:02 +0000 (Fri, 13 Mar 2009) \| 7 lines Make Boost.Function compile under BOOST_NO_EXCEPTIONS. Fixes #2499 Fixes #2494 Fixes #2469 Fixes #2466 ........ r53722 \| vladimir_prus \| 2009-06-07 16:44:50 +0100 (Sun, 07 Jun 2009) \| 4 lines Make Boost.Function compile with disabled exceptions. Closes #2900. Patch from Gabi Davar. ........ r54616 \| danieljames \| 2009-07-03 23:20:26 +0100 (Fri, 03 Jul 2009) \| 3 lines When copying boost::ref, copy even when the referenced function is empty. Fixes #2642 Patch by Steven Watanabe ........ r54617 \| danieljames \| 2009-07-03 23:20:52 +0100 (Fri, 03 Jul 2009) \| 6 lines Add 'and later versions' to support info for GCC and Visual C++. Fixes #2847. I didn't explicitly specify the versions since no one's updating this list and it's highly unlikely that a future version will break this. The same could probably be done for the other compilers but I don't know them very well so I'm leaving them alone. ........ r54618 \| danieljames \| 2009-07-03 23:21:40 +0100 (Fri, 03 Jul 2009) \| 4 lines Fix Boost.Function unit tests for C++0x. Fixes #3012 Based on a patch from Richard Webb. Changed a bit so that it also works for the Visual C++ 10 beta. ........ r54619 \| danieljames \| 2009-07-03 23:22:03 +0100 (Fri, 03 Jul 2009) \| 3 lines Work around Visual C++ copy constructor bug. Fixes #2929. Based on the patch by Steven Watanabe. ........ [SVN r54824]	2009-07-08 23:23:52 +00:00
Daniel James	8b63c146ea	Work around Visual C++ copy constructor bug. Fixes #2929 . Based on the patch by Steven Watanabe. [SVN r54619]	2009-07-03 22:22:03 +00:00
Daniel James	ae534d7342	Fix Boost.Function unit tests for C++0x. Fixes #3012 Based on a patch from Richard Webb. Changed a bit so that it also works for the Visual C++ 10 beta. [SVN r54618]	2009-07-03 22:21:40 +00:00
Daniel James	e8247198fa	Add 'and later versions' to support info for GCC and Visual C++. Fixes #2847 . I didn't explicitly specify the versions since no one's updating this list and it's highly unlikely that a future version will break this. The same could probably be done for the other compilers but I don't know them very well so I'm leaving them alone. [SVN r54617]	2009-07-03 22:20:52 +00:00
Daniel James	ff3244d562	When copying boost::ref, copy even when the referenced function is empty. Fixes #2642 Patch by Steven Watanabe [SVN r54616]	2009-07-03 22:20:26 +00:00
Daniel James	cca7b35712	Add missing #pragma warning(pop) in Boost.Function. Merged revisions 53694 via svnmerge from https://svn.boost.org/svn/boost/trunk ........ r53694 \| danieljames \| 2009-06-06 16:31:47 +0100 (Sat, 06 Jun 2009) \| 1 line Add missing #pragma warning(pop). Fixes #2767. ........ [SVN r54410]	2009-06-27 10:46:20 +00:00
Vladimir Prus	68128bfffa	Make Boost.Function compile with disabled exceptions. Closes #2900. Patch from Gabi Davar. [SVN r53722]	2009-06-07 15:44:50 +00:00
Daniel James	e10f4eaef9	Add missing #pragma warning(pop). Fixes #2767 . [SVN r53694]	2009-06-06 15:31:47 +00:00
Jeremiah Willcock	9bb12ce87a	Fixed almost all tab and min/max issues found by inspect tool [SVN r53142]	2009-05-20 19:41:20 +00:00
Douglas Gregor	a74e72cce9	Make Boost.Function compile under BOOST_NO_EXCEPTIONS. Fixes #2499 Fixes #2494 Fixes #2469 Fixes #2466 [SVN r51745]	2009-03-13 05:49:02 +00:00
Douglas Gregor	6f8ec5c8c5	Implement an optimization that David Abrahams and myself came up with, where Boost.Function uses a bit in the vtable pointer to indicate when the target function object has a trivial copy constructor, trivial destructor, and fits within the small object buffer. In this case, we just copy the bits of the function object rather than performing an indirect call to the manager. This results in a 60% speedup on a micro-benchmark that copies and calls such function objects repeatedly. [SVN r51743]	2009-03-13 05:23:53 +00:00
John Maddock	467ae9613f	Merge PDF build changes from Trunk. [SVN r51417]	2009-02-23 18:39:32 +00:00
John Maddock	678fb133f0	Add PDF generation options to fix external links to point to the web site. Added a few more Boostbook based libs that were missed first time around. Fixed PDF naming issues. [SVN r51284]	2009-02-17 10:05:58 +00:00
Troy D. Straszheim	2fd383cd2e	merge of cmake build files from trunk per beman [SVN r50756]	2009-01-24 18:57:20 +00:00
John Maddock	821e6d34dd	Fix -Wundef warning and suspect usage of BOOST_STRICT_CONFIG. [SVN r50064]	2008-12-02 10:10:46 +00:00
Michael A. Jackson	529dc74954	Updating dependency information for modularized libraries. [SVN r49628]	2008-11-07 17:05:27 +00:00
Michael A. Jackson	e8504c1777	Updating CMake files to latest trunk. Added dependency information for regression tests and a few new macros for internal use. [SVN r49627]	2008-11-07 17:02:56 +00:00
K. Noel Belcourt	07800455a8	Both Sun and Pgi on Linux correctly put typeinfo into the std namespace, but function_base keys off the BOOST_NO_EXCEPTION_STD_NAMESPACE macro instead of the BOOST_NO_STD_TYPEINFO macro. The attached patch changes function_base to use the typeinfo macro. Because eVC 4.2 doesn't put typeinfo into the std namespace, I need to define BOOST_NO_STD_TYPEINFO only for this eVC version. [SVN r49571]	2008-11-03 18:37:49 +00:00
Michael A. Jackson	f559986ae8	Continuing merge of CMake build system files into trunk with the encouragement of Doug Gregor [SVN r49510]	2008-11-01 13:15:41 +00:00
Douglas Gregor	587658b047	Merge Boost.Function fixes from trunk [SVN r49361]	2008-10-16 13:21:50 +00:00
Douglas Gregor	8ca7384121	Fix Boost.Function thread safety issue again [SVN r49326]	2008-10-14 15:31:57 +00:00
Douglas Gregor	75890fea53	CodeGear C++ fix, from Nicola Musatti. Fixes #2325 [SVN r48922]	2008-09-23 00:26:21 +00:00
Douglas Gregor	da259e8dce	Make MyLargeFunctor large. [SVN r48633]	2008-09-06 16:30:58 +00:00
Douglas Gregor	2fe4cc253f	Fix double-destruction problem with small function objects and swap(), and try to work around a GCC 4.2 issue. See #1910 for comments about the former problem from Niels Dekker. [SVN r48627]	2008-09-06 03:16:25 +00:00
Douglas Gregor	f379ef8532	Make Boost.Function's target() operation respect the cv-qualifiers of referenced function objects. Fixes #736 [SVN r48618]	2008-09-05 17:52:12 +00:00
Douglas Gregor	ea18f5777b	Add Boost.Typeof support to Boost.Function. Fixes #1621 [SVN r48616]	2008-09-05 16:13:49 +00:00
Douglas Gregor	d5a86a2d52	Improve the performance of Boost.Function's swap. Thanks to Niels Dekker for the original patch. Fixes #1910 [SVN r48615]	2008-09-05 15:43:22 +00:00
Douglas Gregor	e3dfa7268a	Add forward-declaration header for Boost.Function. Fixes #1668 [SVN r48613]	2008-09-05 14:55:34 +00:00
Douglas Gregor	83309a36c7	Merge Boost.Function from the trunk [SVN r47422]	2008-07-14 18:32:29 +00:00
Douglas Gregor	bfdb5b161d	Merged fixes for Function, Signals, and MPI from trunk. See #1499 , see #1416 , see #1486 [SVN r42031]	2007-12-14 14:48:14 +00:00
Beman Dawes	c4539395fe	Full merge from trunk at revision 41356 of entire boost-root tree. [SVN r41369]	2007-11-25 18:07:19 +00:00
Beman Dawes	6147e7ddcc	Starting point for releases [SVN r39706]	2007-10-05 14:25:06 +00:00
nobody	1b60e82b2f	This commit was manufactured by cvs2svn to create tag 'Version_1_34_1'. [SVN r38286]	2007-07-24 19:28:14 +00:00
Thomas Witt	7581949360	Patches from Trac #583 . [SVN r37846]	2007-06-01 16:12:08 +00:00
Beman Dawes	0b2aeda226	Merged copyright and license addition [SVN r35907]	2006-11-07 19:27:00 +00:00
Rene Rivera	2ecd62c612	Remove obsolete Boost.Build v1 files. [SVN r35880]	2006-11-06 17:10:46 +00:00
Douglas Gregor	47033bd162	Fix inspection problems [SVN r35827]	2006-11-03 19:41:10 +00:00
Douglas Gregor	c7d5016022	Eliminate MSVC 8.0 warning [SVN r35588]	2006-10-13 14:29:56 +00:00
Douglas Gregor	d92355cca2	Suppress annoying MSVC warnings [SVN r35424]	2006-09-29 17:23:28 +00:00
Douglas Gregor	0123f84bff	Suppress annoying MSVC warnings [SVN r35423]	2006-09-29 17:23:17 +00:00
nobody	0207da8008	This commit was manufactured by cvs2svn to create branch 'RC_1_34_0'. [SVN r33417]	2006-03-21 02:26:31 +00:00