v2, v3, integration branch

[SVN r62649]

doc/Jamfile.v2

@@ -7,10 +7,9 @@ project boost/doc ;
 import boostbook : boostbook ;
 
 boostbook function-doc 
-    : 
+	: 
-    function.xml 
+	function.xml 
-    :
+	:
-        <xsl:param>boost.root=../../../..
         <format>pdf:<xsl:param>boost.url.prefix=http://www.boost.org/doc/libs/release/doc/html
-    ;
+	;
 

doc/history.xml

@@ -13,15 +13,6 @@
 
 <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

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;F&gt;</code>
+      <code><classname>boost::is_stateless</classname>&lt;T&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,15 +203,6 @@
       <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"/>
@@ -245,15 +236,6 @@
       </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">
@@ -625,16 +607,7 @@
       <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>
@@ -643,15 +616,6 @@
       <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"/>
@@ -681,19 +645,10 @@
 
     <copy-assignment>
       <parameter name="f">
-        <paramtype>const <classname>functionN</classname>&amp;</paramtype>
+        <paramtype>const <classname>function</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">
@@ -702,15 +657,6 @@
       <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">

include/boost/function/function_base.hpp

@@ -56,7 +56,7 @@
 // need to use std::type_info::name to compare instead of operator==.
 #if defined( BOOST_NO_TYPEID )
 #  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
-#elif defined(__GNUC__) \
+#elif (defined(__GNUC__) && __GNUC__ >= 3) \
  || defined(_AIX) \
  || (   defined(__sgi) && defined(__host_mips))
 #  include <cstring>
@@ -66,11 +66,11 @@
 #  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) ((X)==(Y))
 #endif
 
-#if defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406 && !defined(BOOST_STRICT_CONFIG)
+#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || 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 // __ICL etc
+#endif // not MSVC
 
 #if !BOOST_WORKAROUND(__BORLANDC__, < 0x5A0)
 #  define BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor,Type)              \
@@ -203,11 +203,11 @@ namespace boost {
         {
           switch (op) {
           case clone_functor_tag: 
-            out_buffer.obj_ref = in_buffer.obj_ref;
+            out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr;
             return;
 
           case move_functor_tag:
-            out_buffer.obj_ref = in_buffer.obj_ref;
+            out_buffer.obj_ref.obj_ptr = in_buffer.obj_ref.obj_ptr;
             in_buffer.obj_ref.obj_ptr = 0;
             return;
 
@@ -661,7 +661,11 @@ public:
     }
 
   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;
 
@@ -679,7 +683,11 @@ public:
   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 {

include/boost/function/function_fwd.hpp

@@ -19,7 +19,8 @@ namespace boost { namespace python { namespace objects {
 }}}
 #endif
 
-#if defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                         \
+#if defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                    \
+ || defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                         \
  || !(defined(BOOST_STRICT_CONFIG) || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
 #  define BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX
 #endif

include/boost/function/function_template.hpp

@@ -486,19 +486,19 @@ namespace boost {
                                             BOOST_FUNCTION_TEMPLATE_ARGS);
 
         template<typename F>
-        bool assign_to(F f, function_buffer& functor) const
+        bool assign_to(F f, function_buffer& functor)
         {
           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) const
+        bool assign_to_a(F f, function_buffer& functor, Allocator a)
         {
           typedef typename get_function_tag<F>::type tag;
           return assign_to_a(f, functor, a, tag());
         }
 
-        void clear(function_buffer& functor) const
+        void clear(function_buffer& functor)
         {
           if (base.manager)
             base.manager(functor, functor, destroy_functor_tag);
@@ -508,7 +508,7 @@ namespace boost {
         // Function pointers
         template<typename FunctionPtr>
         bool 
-        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag) const
+        assign_to(FunctionPtr f, function_buffer& functor, function_ptr_tag)
         {
           this->clear(functor);
           if (f) {
@@ -522,7 +522,7 @@ namespace boost {
         }
         template<typename FunctionPtr,typename Allocator>
         bool 
-        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag) const
+        assign_to_a(FunctionPtr f, function_buffer& functor, Allocator, function_ptr_tag)
         {
           return assign_to(f,functor,function_ptr_tag());
         }
@@ -530,7 +530,7 @@ namespace boost {
         // Member pointers
 #if BOOST_FUNCTION_NUM_ARGS > 0
         template<typename MemberPtr>
-        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag) const
+        bool assign_to(MemberPtr f, function_buffer& functor, member_ptr_tag)
         {
           // DPG TBD: Add explicit support for member function
           // objects, so we invoke through mem_fn() but we retain the
@@ -543,7 +543,7 @@ namespace boost {
           }
         }
         template<typename MemberPtr,typename Allocator>
-        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag) const
+        bool assign_to_a(MemberPtr f, function_buffer& functor, Allocator a, member_ptr_tag)
         {
           // DPG TBD: Add explicit support for member function
           // objects, so we invoke through mem_fn() but we retain the
@@ -561,13 +561,13 @@ namespace boost {
         // Assign to a function object using the small object optimization
         template<typename FunctionObj>
         void 
-        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_) const
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::true_)
         {
           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_) const
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator, mpl::true_)
         {
           assign_functor(f,functor,mpl::true_());
         }
@@ -575,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_) const
+        assign_functor(FunctionObj f, function_buffer& functor, mpl::false_)
         {
           functor.obj_ptr = new FunctionObj(f);
         }
         template<typename FunctionObj,typename Allocator>
         void 
-        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_) const
+        assign_functor_a(FunctionObj f, function_buffer& functor, Allocator a, mpl::false_)
         {
           typedef functor_wrapper<FunctionObj,Allocator> functor_wrapper_type;
           typedef typename Allocator::template rebind<functor_wrapper_type>::other
@@ -596,7 +596,7 @@ namespace boost {
 
         template<typename FunctionObj>
         bool 
-        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag) const
+        assign_to(FunctionObj f, function_buffer& functor, function_obj_tag)
         {
           if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
             assign_functor(f, functor, 
@@ -608,7 +608,7 @@ namespace boost {
         }
         template<typename FunctionObj,typename Allocator>
         bool 
-        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag) const
+        assign_to_a(FunctionObj f, function_buffer& functor, Allocator a, function_obj_tag)
         {
           if (!boost::detail::function::has_empty_target(boost::addressof(f))) {
             assign_functor_a(f, functor, a,
@@ -623,7 +623,7 @@ namespace boost {
         template<typename FunctionObj>
         bool 
         assign_to(const reference_wrapper<FunctionObj>& f, 
-                  function_buffer& functor, function_obj_ref_tag) const
+                  function_buffer& functor, function_obj_ref_tag)
         {
           functor.obj_ref.obj_ptr = (void *)(f.get_pointer());
           functor.obj_ref.is_const_qualified = is_const<FunctionObj>::value;
@@ -633,7 +633,7 @@ namespace boost {
         template<typename FunctionObj,typename Allocator>
         bool 
         assign_to_a(const reference_wrapper<FunctionObj>& f, 
-                  function_buffer& functor, Allocator, function_obj_ref_tag) const
+                  function_buffer& functor, Allocator, function_obj_ref_tag)
         {
           return assign_to(f,functor,function_obj_ref_tag());
         }
@@ -677,7 +677,7 @@ namespace boost {
 
     vtable_type* get_vtable() const {
       return reinterpret_cast<vtable_type*>(
-               reinterpret_cast<std::size_t>(vtable) & ~static_cast<std::size_t>(0x01));
+               reinterpret_cast<std::size_t>(vtable) & ~static_cast<size_t>(0x01));
     }
 
     struct clear_type {};
@@ -748,16 +748,12 @@ 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())
@@ -766,6 +762,9 @@ namespace boost {
       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
@@ -837,26 +836,6 @@ namespace boost {
       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)
     {
@@ -885,7 +864,7 @@ namespace boost {
 #else
   private:
     struct dummy {
-      void nonnull() {}
+      void nonnull() {};
     };
 
     typedef void (dummy::*safe_bool)();
@@ -930,16 +909,15 @@ namespace boost {
       // 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 = 
+      static 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);
+          value |= static_cast<size_t>(0x01);
         vtable = reinterpret_cast<detail::function::vtable_base *>(value);
       } else 
         vtable = 0;
@@ -965,12 +943,11 @@ namespace boost {
       // 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 =
+      static 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)
@@ -1021,6 +998,22 @@ 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
+  inline 
+  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 get_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<
@@ -1092,26 +1085,12 @@ 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<
@@ -1140,14 +1119,6 @@ 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

test/function_test.cpp

@@ -690,95 +690,6 @@ 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();
@@ -791,8 +702,6 @@ int test_main(int, char* [])
   test_exception();
   test_implicit();
   test_call();
-  test_move_semantics<function<void()> >();
-  test_move_semantics<boost::function0<void> >();
 
   return 0;
 }

test/mem_fun_cxx98.cpp

@@ -10,36 +10,22 @@
 
     
 #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;
 
-    X x;
+f = &X::foo;
-    BOOST_TEST(f(&x, 5) == -5);
+  
-    BOOST_TEST(f2(&x, boost::ref(y1)) == y1);
+X x;
+f(&x, 5);
 
-    return ::boost::report_errors();
+    return 0;
 }

test/mem_fun_portable.cpp

@@ -10,36 +10,22 @@
 
     
 #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;
 
-    X x;
+f = &X::foo;
-    BOOST_TEST(f(&x, 5) == -5);
+  
-    BOOST_TEST(f2(&x, boost::ref(y1)) == y1);
+X x;
+f(&x, 5);
 
-    return ::boost::report_errors();
+    return 0;
 }