Release 1.53.0

[SVN r82734]

doc/Jamfile.v2

@@ -3,7 +3,7 @@
 #   Distributed under the Boost Software License, Version 1.0.
 #   (See accompanying file LICENSE_1_0.txt or copy at
 #   http://www.boost.org/LICENSE_1_0.txt)
-project function/doc ;
+project boost/doc ;
 import boostbook : boostbook ;
 
 boostbook function-doc 

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

@@ -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)              \
@@ -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

@@ -935,11 +935,10 @@ namespace boost {
 
       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;
@@ -970,7 +969,6 @@ namespace boost {
 
       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)

test/mem_fun_cxx98.cpp

@@ -14,32 +14,24 @@
 #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;
+  std::ostream& foo2(std::ostream&) const;
 };
 int X::foo(int x) { return -x; }
-Y& X::foo2(Y& x) const { return x; }
+std::ostream& X::foo2(std::ostream& x) const { return x; }
 
 int main()
 {
     boost::function<int (X*, int)> f;
-    boost::function<Y& (X*, Y&)> f2;
-	Y y1;
-	
+    boost::function<std::ostream& (X*, std::ostream&)> f2;
+
     f = &X::foo;
     f2 = &X::foo2;
 
     X x;
     BOOST_TEST(f(&x, 5) == -5);
-    BOOST_TEST(f2(&x, boost::ref(y1)) == y1);
+    BOOST_TEST(f2(&x, boost::ref(std::cout)) == std::cout);
 
     return ::boost::report_errors();
 }

test/mem_fun_portable.cpp

@@ -14,32 +14,24 @@
 #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;
+  std::ostream& foo2(std::ostream&) const;
 };
 int X::foo(int x) { return -x; }
-Y& X::foo2(Y& x) const { return x; }
+std::ostream& X::foo2(std::ostream& x) const { return x; }
 
 int main()
 {
     boost::function2<int, X*, int> f;
-    boost::function2<Y&, X*, Y&> f2;
-    Y y1;
-    
+    boost::function2<std::ostream&, X*, std::ostream&> f2;
+
     f = &X::foo;
     f2 = &X::foo2;
 
     X x;
     BOOST_TEST(f(&x, 5) == -5);
-    BOOST_TEST(f2(&x, boost::ref(y1)) == y1);
+    BOOST_TEST(f2(&x, boost::ref(std::cout)) == std::cout);
 
     return ::boost::report_errors();
 }