Cleanup release tags.

[SVN r44324]

bind.html

@@ -833,7 +833,7 @@ namespace
 					STL</a> by Petter Urkedal.</li></ul>
 		<p>Doug Gregor suggested that a visitor mechanism would allow <b>bind</b> to 
 			interoperate with a signal/slot library.</p>
-		<p>John Maddock fixed a MSVC-specific conflict between <b>bind</b> and the <A href="../type_traits/index.htm">
+		<p>John Maddock fixed a MSVC-specific conflict between <b>bind</b> and the <A href="../type_traits/index.html">
 				type traits library</A>.</p>
 		<p>Numerous improvements were suggested during the formal review period by Ross 
 			Smith, Richard Crossley, Jens Maurer, Ed Brey, and others. Review manager was 

bind_as_compose.cpp

@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion

bind_visitor.cpp

@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion

doc/ref.xml

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

include/boost/bind.hpp

@@ -1,8 +1,10 @@
 #ifndef BOOST_BIND_HPP_INCLUDED
 #define BOOST_BIND_HPP_INCLUDED
 
-#if _MSC_VER >= 1020
-#pragma once
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif
 
 //
@@ -141,6 +143,11 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
+    template<class R, class F, class A> R operator()(type<R>, F f, A &)
+    {
+        return unwrap(f, 0)();
+    }
+
     template<class R, class F, class A> R operator()(type<R>, F f, A &) const
     {
         return unwrap(f, 0)();
@@ -181,6 +188,11 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
+    template<class R, class F, class A> R operator()(type<R>, F f, A & a)
+    {
+        return unwrap(f, 0)(a[a1_]);
+    }
+
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
         return unwrap(f, 0)(a[a1_]);
@@ -229,6 +241,11 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
+    template<class R, class F, class A> R operator()(type<R>, F f, A & a)
+    {
+        return unwrap(f, 0)(a[a1_], a[a2_]);
+    }
+
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
         return unwrap(f, 0)(a[a1_], a[a2_]);
@@ -281,6 +298,11 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
+    template<class R, class F, class A> R operator()(type<R>, F f, A & a)
+    {
+        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_]);
+    }
+
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
         return unwrap(f, 0)(a[a1_], a[a2_], a[a3_]);
@@ -337,6 +359,11 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
+    template<class R, class F, class A> R operator()(type<R>, F f, A & a)
+    {
+        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
+    }
+
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
         return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_]);
@@ -397,6 +424,11 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
+    template<class R, class F, class A> R operator()(type<R>, F f, A & a)
+    {
+        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
+    }
+
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
         return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_]);
@@ -461,6 +493,11 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
+    template<class R, class F, class A> R operator()(type<R>, F f, A & a)
+    {
+        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
+    }
+
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
         return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_]);
@@ -529,6 +566,11 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
+    template<class R, class F, class A> R operator()(type<R>, F f, A & a)
+    {
+        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
+    }
+
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
         return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_]);
@@ -601,6 +643,11 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
+    template<class R, class F, class A> R operator()(type<R>, F f, A & a)
+    {
+        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
+    }
+
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
         return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_]);
@@ -677,6 +724,11 @@ public:
 
     template<class R, class F, class L> typename result_traits<R, F>::type operator[] (bind_t<R, F, L> const & b) const { return b.eval(*this); }
 
+    template<class R, class F, class A> R operator()(type<R>, F f, A & a)
+    {
+        return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
+    }
+
     template<class R, class F, class A> R operator()(type<R>, F f, A & a) const
     {
         return unwrap(f, 0)(a[a1_], a[a2_], a[a3_], a[a4_], a[a5_], a[a6_], a[a7_], a[a8_], a[a9_]);
@@ -724,7 +776,7 @@ private:
 template <class R> struct evaluator0
 {
     template<class L, class F, class A>
-    static R eval(L const&, F f, A &)
+    static R eval(L &, F f, A &)
     {
         return unwrap(f, 0)();
     }
@@ -733,7 +785,7 @@ template <class R> struct evaluator0
 template <> struct evaluator0<void>
 {
     template<class L, class F, class A>
-    static void eval(L const&, F f, A &)
+    static void eval(L &, F f, A &)
     {
         unwrap(f, 0)();
     }
@@ -742,7 +794,7 @@ template <> struct evaluator0<void>
 template <class R> struct evaluator1
 {
     template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
+    static R eval(L & l, F f, A & a)
     {
         return unwrap(f, 0)(a[l.a1_]);
     }
@@ -751,7 +803,7 @@ template <class R> struct evaluator1
 template <> struct evaluator1<void>
 {
     template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
+    static void eval(L & l, F f, A & a)
     {
         unwrap(f, 0)(a[l.a1_]);
     }
@@ -760,7 +812,7 @@ template <> struct evaluator1<void>
 template <class R> struct evaluator2
 {
     template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
+    static R eval(L & l, F f, A & a)
     {
         return unwrap(f, 0)(a[l.a1_], a[l.a2_]);
     }
@@ -769,7 +821,7 @@ template <class R> struct evaluator2
 template <> struct evaluator2<void>
 {
     template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
+    static void eval(L & l, F f, A & a)
     {
         unwrap(f, 0)(a[l.a1_], a[l.a2_]);
     }
@@ -778,7 +830,7 @@ template <> struct evaluator2<void>
 template <class R> struct evaluator3
 {
     template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
+    static R eval(L & l, F f, A & a)
     {
         return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_]);
     }
@@ -787,7 +839,7 @@ template <class R> struct evaluator3
 template <> struct evaluator3<void>
 {
     template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
+    static void eval(L & l, F f, A & a)
     {
         unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_]);
     }
@@ -796,7 +848,7 @@ template <> struct evaluator3<void>
 template <class R> struct evaluator4
 {
     template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
+    static R eval(L & l, F f, A & a)
     {
         return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_]);
     }
@@ -805,7 +857,7 @@ template <class R> struct evaluator4
 template <> struct evaluator4<void>
 {
     template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
+    static void eval(L & l, F f, A & a)
     {
         unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_]);
     }
@@ -814,7 +866,7 @@ template <> struct evaluator4<void>
 template <class R> struct evaluator5
 {
     template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
+    static R eval(L & l, F f, A & a)
     {
         return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_]);
     }
@@ -823,7 +875,7 @@ template <class R> struct evaluator5
 template <> struct evaluator5<void>
 {
     template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
+    static void eval(L & l, F f, A & a)
     {
         unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_]);
     }
@@ -832,7 +884,7 @@ template <> struct evaluator5<void>
 template <class R> struct evaluator6
 {
     template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
+    static R eval(L & l, F f, A & a)
     {
         return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_]);
     }
@@ -841,7 +893,7 @@ template <class R> struct evaluator6
 template <> struct evaluator6<void>
 {
     template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
+    static void eval(L & l, F f, A & a)
     {
         unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_]);
     }
@@ -850,7 +902,7 @@ template <> struct evaluator6<void>
 template <class R> struct evaluator7
 {
     template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
+    static R eval(L & l, F f, A & a)
     {
         return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_]);
     }
@@ -859,7 +911,7 @@ template <class R> struct evaluator7
 template <> struct evaluator7<void>
 {
     template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
+    static void eval(L & l, F f, A & a)
     {
         unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_]);
     }
@@ -868,7 +920,7 @@ template <> struct evaluator7<void>
 template <class R> struct evaluator8
 {
     template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
+    static R eval(L & l, F f, A & a)
     {
         return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_]);
     }
@@ -877,7 +929,7 @@ template <class R> struct evaluator8
 template <> struct evaluator8<void>
 {
     template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
+    static void eval(L & l, F f, A & a)
     {
         unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_]);
     }
@@ -886,7 +938,7 @@ template <> struct evaluator8<void>
 template <class R> struct evaluator9
 {
     template<class L, class F, class A>
-    static R eval(L const& l, F f, A & a)
+    static R eval(L & l, F f, A & a)
     {
         return unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_], a[l.a9_]);
     }
@@ -895,7 +947,7 @@ template <class R> struct evaluator9
 template <> struct evaluator9<void>
 {
     template<class L, class F, class A>
-    static void eval(L const& l, F f, A & a)
+    static void eval(L & l, F f, A & a)
     {
         unwrap(f, 0)(a[l.a1_], a[l.a2_], a[l.a3_], a[l.a4_], a[l.a5_], a[l.a6_], a[l.a7_], a[l.a8_], a[l.a9_]);
     }

include/boost/bind/apply.hpp

@@ -4,7 +4,7 @@
 //
 //  apply.hpp
 //
-//  Copyright (c) 2002 Peter Dimov and Multi Media Ltd.
+//  Copyright (c) 2002, 2003 Peter Dimov and Multi Media Ltd.
 //
 //  Permission to copy, use, modify, sell and distribute this software
 //  is granted provided this copyright notice appears in all copies.
@@ -19,52 +19,52 @@ template<class R> struct apply
 {
     typedef R result_type;
 
-    template<class F> result_type operator()(F f) const
+    template<class F> result_type operator()(F & f) const
     {
         return f();
     }
 
-    template<class F, class A1> result_type operator()(F f, A1 & a1) const
+    template<class F, class A1> result_type operator()(F & f, A1 & a1) const
     {
         return f(a1);
     }
 
-    template<class F, class A1, class A2> result_type operator()(F f, A1 & a1, A2 & a2) const
+    template<class F, class A1, class A2> result_type operator()(F & f, A1 & a1, A2 & a2) const
     {
         return f(a1, a2);
     }
 
-    template<class F, class A1, class A2, class A3> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3) const
+    template<class F, class A1, class A2, class A3> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3) const
     {
         return f(a1, a2, a3);
     }
 
-    template<class F, class A1, class A2, class A3, class A4> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
+    template<class F, class A1, class A2, class A3, class A4> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4) const
     {
         return f(a1, a2, a3, a4);
     }
 
-    template<class F, class A1, class A2, class A3, class A4, class A5> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
+    template<class F, class A1, class A2, class A3, class A4, class A5> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5) const
     {
         return f(a1, a2, a3, a4, a5);
     }
 
-    template<class F, class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
+    template<class F, class A1, class A2, class A3, class A4, class A5, class A6> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6) const
     {
         return f(a1, a2, a3, a4, a5, a6);
     }
 
-    template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
+    template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7) const
     {
         return f(a1, a2, a3, a4, a5, a6, a7);
     }
 
-    template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
+    template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8) const
     {
         return f(a1, a2, a3, a4, a5, a6, a7, a8);
     }
 
-    template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(F f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
+    template<class F, class A1, class A2, class A3, class A4, class A5, class A6, class A7, class A8, class A9> result_type operator()(F & f, A1 & a1, A2 & a2, A3 & a3, A4 & a4, A5 & a5, A6 & a6, A7 & a7, A8 & a8, A9 & a9) const
     {
         return f(a1, a2, a3, a4, a5, a6, a7, a8, a9);
     }

include/boost/bind/arg.hpp

@@ -1,8 +1,10 @@
 #ifndef BOOST_BIND_ARG_HPP_INCLUDED
 #define BOOST_BIND_ARG_HPP_INCLUDED
 
-#if _MSC_VER >= 1020
-#pragma once
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif
 
 //

include/boost/bind/placeholders.hpp

@@ -1,8 +1,10 @@
 #ifndef BOOST_BIND_PLACEHOLDERS_HPP_INCLUDED
 #define BOOST_BIND_PLACEHOLDERS_HPP_INCLUDED
 
-#if _MSC_VER >= 1020
-#pragma once
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif
 
 //

include/boost/mem_fn.hpp

@@ -1,8 +1,10 @@
 #ifndef BOOST_MEM_FN_HPP_INCLUDED
 #define BOOST_MEM_FN_HPP_INCLUDED
 
-#if _MSC_VER+0 >= 1020
-#pragma once
+// MS compatible compilers support #pragma once
+
+#if defined(_MSC_VER) && (_MSC_VER >= 1020)
+# pragma once
 #endif
 
 //
@@ -21,6 +23,7 @@
 
 #include <boost/config.hpp>
 #include <boost/get_pointer.hpp>
+#include <boost/detail/workaround.hpp>
 
 namespace boost
 {
@@ -292,7 +295,7 @@ public:
         return call(u, &u);
     }
 
-#if !defined(BOOST_MSVC) || (BOOST_MSVC > 1300)
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1300) && !BOOST_WORKAROUND(__MWERKS__, BOOST_TESTED_AT(0x3003))
 
     R & operator()(T & t) const
     {

ref.html

@@ -1,195 +1,9 @@
-<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
 <html>
-	<head>
-		<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
-		<title>Boost: ref.hpp documentation</title>
-	</head>
-	<body bgcolor="White">
-		<table border="0" width="100%">
-			<tr>
-				<td width="277">
-					<img src="../../c++boost.gif" alt="c++boost.gif (8819 bytes)" width="277" height="86">
-				</td>
-				<td align="center">
-					<table border="0">
-						<tr>
-							<td nowrap><h1>ref.hpp</h1>
-							</td>
-						</tr>
-						<tr>
-							<td align="right" nowrap><small>&nbsp;1.00.0004 (2002-01-27)</small></td>
-						</tr>
-					</table>
-				</td>
-			</tr>
-			<tr>
-				<td colspan="2" height="64">&nbsp;</td>
-			</tr>
-		</table>
-		<h2>Files</h2>
-		<ul>
-			<li>
-				<a href="../../boost/ref.hpp">ref.hpp</a>
-		</ul>
-		<h2>Purpose</h2>
-		<p>
-			The header <a href="../../boost/ref.hpp">boost/ref.hpp</a> defines the class 
-			template <b>boost::reference_wrapper&lt;T&gt;</b>, the two functions <b>boost::ref</b>
-			and <b>boost::cref</b> that return instances of <b>boost::reference_wrapper&lt;T&gt;</b>, 
-			and the two traits classes <b>boost::is_reference_wrapper&lt;T&gt;</b> and <b>boost::unwrap_reference&lt;T&gt;</b>.
-		</p>
-		<p>
-			The purpose of <b>boost::reference_wrapper&lt;T&gt;</b> is to contain a 
-			reference to an object of type <b>T</b>. It is primarily used to "feed" 
-			references to function templates (algorithms) that take their parameter by 
-			value.
-		</p>
-		<p>
-			To support this usage, <b>boost::reference_wrapper&lt;T&gt;</b> provides an 
-			implicit conversion to <b>T &amp;</b>. This usually allows the function 
-			templates to work on references unmodified.
-		</p>
-		<p>
-			<b>boost::reference_wrapper&lt;T&gt;</b> is both <b>CopyConstructible</b> and <b>Assignable</b>
-			(ordinary references are not <b>Assignable</b>).
-		</p>
-		<p>
-			The expression <b>boost::ref(x)</b> returns a <b>boost::reference_wrapper&lt;X&gt;(x)</b>
-			where <b>X</b> is the type of <b>x</b>. Similarly, <b>boost::cref(x)</b> returns 
-			a <b>boost::reference_wrapper&lt;X const&gt;(x)</b>.
-		</p>
-		<p>
-			The expression <b>boost::is_reference_wrapper&lt;T&gt;::value</b> is <b>true</b> 
-			if <b>T</b> is a <b>reference_wrapper</b>, and <b>false</b>
-			otherwise.
-		</p>
-		<p>
-			The type-expression <b>boost::unwrap_reference&lt;T&gt;::type</b> is <b>T::type</b>
-			if <b>T</b> is a <b>reference_wrapper</b>, <b>T</b> otherwise.
-		</p>
-			<h2>Interface</h2>
-			<h3>Synopsis</h3>
-			<pre>
-namespace boost
-{
-    template&lt;class T&gt; class <a href="#reference_wrapper">reference_wrapper</a>;
-    template&lt;class T&gt; reference_wrapper&lt;T&gt; <a href="#ref">ref</a>(T &amp; t);
-    template&lt;class T&gt; reference_wrapper&lt;T const&gt; <a href="#cref">cref</a>(T const &amp; t);
-    template&lt;class T&gt; class is_reference_wrapper&lt;T const&gt;;
-    template&lt;class T&gt; class unwrap_reference&lt;T const&gt;;
-}
-</pre>
-			<h3><a name="reference_wrapper">reference_wrapper</a></h3>
-			<pre>
-template&lt;class T&gt; class reference_wrapper
-{
-public:
-    typedef T type;
-
-    explicit <a href="#rt_construct">reference_wrapper</a>(T &amp; t);
-
-    <a href="#rt_operator">operator T &amp;</a> () const;
-
-    T &amp; <a href="#rt_get">get</a>() const;
-    T* <a href="#rt_get_pointer">get_pointer</a>() const;
-};
-</pre>
-			<h4><a name="rt_construct">explicit reference_wrapper(T &amp; t)</a></h4>
-			<blockquote>
-				<p>
-					<b>Effects:</b> Constructs a <b>reference_wrapper</b> object that stores a 
-					reference to <b>t</b>.
-				</p>
-				<p>
-					<b>Throws:</b> Nothing.
-				</p>
-			</blockquote>
-			<h4><a name="rt_operator">operator T &amp; () const</a></h4>
-			<blockquote>
-				<p>
-					<b>Returns:</b> the stored reference.
-				</p>
-				<p>
-					<b>Throws:</b> Nothing.
-				</p>
-			</blockquote>
-			<h4><a name="rt_get">T &amp; get() const</a></h4>
-			<blockquote>
-				<p>
-					<b>Returns:</b> the stored reference.
-				</p>
-				<p>
-					<b>Throws:</b> Nothing.
-				</p>
-			</blockquote>
-<h4><a name="rt_get_pointer">T* get_pointer() const</a></h4>
-			<blockquote>
-				<p>
-					<b>Returns:</b> a pointer to the stored object.
-				</p>
-				<p>
-					<b>Throws:</b> Nothing.
-				</p>
-			</blockquote>
-			<h3><a name="ref">ref</a></h3>
-			<pre>
-template&lt;class T&gt; reference_wrapper&lt;T&gt; ref(T &amp; t);
-</pre>
-			<blockquote>
-				<p>
-					<b>Returns:</b> <tt>reference_wrapper&lt;T&gt;(t)</tt>.
-				</p>
-				<p>
-					<b>Throws:</b> Nothing.
-				</p>
-			</blockquote>
-			<h3><a name="cref">cref</a></h3>
-			<pre>
-template&lt;class T&gt; reference_wrapper&lt;T const&gt; cref(T const &amp; t);
-</pre>
-			<blockquote>
-				<p>
-					<b>Returns:</b> <tt>reference_wrapper&lt;T const&gt;(t)</tt>.
-				</p>
-				<p>
-					<b>Throws:</b> Nothing.
-				</p>
-			</blockquote>
-			<h3><a name="is_reference_wrapper">is_reference_wrapper</a></h3>
-			<pre>
-template&lt;class T&gt; class is_reference_wrapper&lt;T const&gt;
-{
- public:
-    static bool value = <i>unspecified</i>;
-};
-</pre>
-			Value is <b>true</b> iff <tt>T</tt> is a specialization of <tt>reference_wrapper</tt>.
-			<h3><a name="unwrap_reference">unwrap_reference</a></h3>
-			<pre>
-template&lt;class T&gt; class unwrap_reference&lt;T const&gt;
-{
- public:
-    typedef <i>unspecified</i> type;
-};
-</pre>
-			<tt>type</tt> is equivalent to <tt>T::type</tt> if <tt>T</tt> is a 
-			specialization of <tt>reference_wrapper</tt>. Otherwise <tt>type</tt> is 
-			equivalent to <tt>T</tt>.
-			<h2>Acknowledgements</h2>
-		<p>
-			<b>ref</b> and <b>cref</b> were originally part of the Boost.Tuple library by <a href="../../people/jaakko_jarvi.htm">
-				Jaakko J&auml;rvi</a>. They were "promoted to <b>boost::</b> status" by <a href="../../people/peter_dimov.htm">
-				Peter Dimov</a> because they are generally useful. <a href="../../people/doug_gregor.html">
-				Douglas Gregor</a> and <a href="../../people/dave_abrahams.htm">Dave Abrahams</a>
-			contributed <tt>is_reference_wrapper</tt> and <tt>unwrap_reference</tt>.
-		</p>
-		<p><br>
-			<br>
-			<br>
-			<small>Copyright &copy; 2001 by Peter Dimov and Multi Media Ltd. Permission to 
-				copy, use, modify, sell and distribute this document is granted provided this 
-				copyright notice appears in all copies. This document is provided &quot;as 
-				is&quot; without express or implied warranty, and with no claim as to its 
-				suitability for any purpose.</small></p>
-	</body>
+<head>
+<meta http-equiv="refresh" content="0; URL=../../doc/html/ref.html">
+</head>
+<body>
+Automatic redirection failed, please go to
+<a href="../../doc/html/ref.html">../../doc/html/ref.html</a>
+</body>
 </html>

test/Jamfile

@@ -10,8 +10,7 @@
 subproject libs/bind/test ;
 
 # bring in rules for testing
-SEARCH on testing.jam = $(BOOST_BUILD_PATH) ;
-include testing.jam ;
+import testing ;
 
 # Make tests run by default.
 DEPENDS all : bind ;

test/Jamfile.v2

@@ -0,0 +1,19 @@
+#  Boost.Bind Library test Jamfile
+#
+#  Copyright (c) 2003 Peter Dimov
+#
+#  Permission to copy, use, modify, sell and distribute this software
+#  is granted provided this copyright notice appears in all copies.
+#  This software is provided "as is" without express or implied
+#  warranty, and with no claim as to its suitability for any purpose.
+
+# bring in rules for testing
+import testing ;
+
+test-suite "bind"
+    : [ run bind_test.cpp ]
+      [ run mem_fn_test.cpp ]
+      [ run mem_fn_void_test.cpp ]
+      [ run mem_fn_derived_test.cpp ]
+    ;
+

test/bind_fastcall_mf_test.cpp

@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion

test/bind_fastcall_test.cpp

@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion

test/bind_stdcall_mf_test.cpp

@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion

test/bind_stdcall_test.cpp

@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion

test/bind_test.cpp

@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL) && !defined(__COMO__)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion

test/mem_fn_derived_test.cpp

@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion

test/mem_fn_fastcall_test.cpp

@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion

test/mem_fn_stdcall_test.cpp

@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion

test/mem_fn_test.cpp

@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion

test/mem_fn_void_test.cpp

@@ -1,4 +1,6 @@
-#if defined(_MSC_VER) && !defined(__ICL)
+#include <boost/config.hpp>
+
+#if defined(BOOST_MSVC)
 #pragma warning(disable: 4786)  // identifier truncated in debug info
 #pragma warning(disable: 4710)  // function not inlined
 #pragma warning(disable: 4711)  // function selected for automatic inline expansion