This commit was manufactured by cvs2svn to create branch 'SPIRIT_1_6'.

[SVN r23968]
function_template.hpp: Move definition of operator() out-of-line for
2004-07-23 02:16:28 +00:00 · 2004-07-11 03:09:35 +00:00 · 2004-06-23 16:00:01 +00:00 · 2004-06-20 05:32:28 +00:00 · 2004-06-10 12:37:31 +00:00 · 2004-05-12 00:39:00 +00:00
43 changed files with 526 additions and 2538 deletions
--- a/example/bind1st.cpp
+++ b/example/bind1st.cpp
@ -1,38 +0,0 @@
-// Boost.Function library examples
-
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-#include <iostream>
-#include <boost/function.hpp>
-#include <functional>
-
-struct X {
-  X(int val) : value(val) {}
-
-  int foo(int x) { return x * value; }
-
-  int value;
-};
-
-
-int
-main()
-{
-  boost::function<int, int> f;
-  X x(7);
-  f = std::bind1st(std::mem_fun(&X::foo), &x);
-
-  std::cout << f(5) << std::endl; // Call x.foo(5)
-  return 0;
-}
--- a/example/int_div.cpp
+++ b/example/int_div.cpp
@ -1,32 +0,0 @@
-// Boost.Function library examples
-
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-#include <iostream>
-#include <boost/function.hpp>
-
-struct int_div { 
-  float operator()(int x, int y) const { return ((float)x)/y; }; 
-};
-
-int
-main()
-{
-  boost::function<float, int, int> f;
-  f = int_div();
-
-  std::cout << f(5, 3) << std::endl; // 1.66667
-
-  return 0;
-}
--- a/example/sum_avg.cpp
+++ b/example/sum_avg.cpp
@ -1,44 +0,0 @@
-// Boost.Function library examples
-
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-#include <iostream>
-#include <boost/function.hpp>
-
-void do_sum_avg(int values[], int n, int& sum, float& avg)
-{
-  sum = 0;
-  for (int i = 0; i < n; i++)
-    sum += values[i];
-  avg = (float)sum / n;
-}
-
-int
-main()
-{
-  // The second parameter should be int[], but some compilers (e.g., GCC)
-  // complain about this 
-  boost::function<void, int*, int, int&, float&> sum_avg;
-
-  sum_avg = &do_sum_avg;
-
-  int values[5] = { 1, 1, 2, 3, 5 };
-  int sum;
-  float avg;
-  sum_avg(values, 5, sum, avg);
-
-  std::cout << "sum = " << sum << std::endl;
-  std::cout << "avg = " << avg << std::endl;
-  return 0;
-}
--- a/include/boost/function.hpp
+++ b/include/boost/function.hpp
@ -1,15 +1,9 @@
 // Boost.Function library

-// Copyright (C) 2001, 2002 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
+//  Copyright Doug Gregor 2001-2003. 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/libs/function

--- a/include/boost/function/detail/function_iterate.hpp
+++ b/include/boost/function/detail/function_iterate.hpp
@ -1,15 +1,9 @@
 // Boost.Function library

-// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
+//  Copyright Doug Gregor 2003. 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
 #if !defined(BOOST_PP_IS_ITERATING)
--- a/include/boost/function/detail/maybe_include.hpp
+++ b/include/boost/function/detail/maybe_include.hpp
@ -1,15 +1,9 @@
 // Boost.Function library

-// Copyright (C) 2003 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
+//  Copyright Doug Gregor 2003. 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

--- a/include/boost/function/detail/prologue.hpp
+++ b/include/boost/function/detail/prologue.hpp
@ -1,15 +1,9 @@
 // Boost.Function library

-// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
+//  Copyright Doug Gregor 2002-2003. 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

@ -21,7 +15,7 @@
 #  include <boost/config.hpp>
 #  include <boost/function/function_base.hpp>
 #  include <boost/mem_fn.hpp>
-#  include <boost/type_traits/is_same.hpp>
+#  include <boost/type_traits/is_integral.hpp>
 #  include <boost/preprocessor/enum.hpp>
 #  include <boost/preprocessor/enum_params.hpp>
 #  include <boost/preprocessor/cat.hpp>
--- a/include/boost/function/function0.hpp
+++ b/include/boost/function/function0.hpp
@ -1,15 +1,9 @@
 // Boost.Function library

-// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
+//  Copyright Doug Gregor 2002-2003. 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

--- a/include/boost/function/function1.hpp
+++ b/include/boost/function/function1.hpp
@ -1,15 +1,9 @@
 // Boost.Function library

-// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
+//  Copyright Doug Gregor 2002-2003. 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

--- a/include/boost/function/function10.hpp
+++ b/include/boost/function/function10.hpp
@ -1,15 +1,9 @@
 // Boost.Function library

-// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
+//  Copyright Doug Gregor 2002-2003. 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

--- a/include/boost/function/function2.hpp
+++ b/include/boost/function/function2.hpp
@ -1,15 +1,9 @@
 // Boost.Function library

-// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
+//  Copyright Doug Gregor 2002-2003. 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

--- a/include/boost/function/function3.hpp
+++ b/include/boost/function/function3.hpp
@ -1,15 +1,9 @@
 // Boost.Function library

-// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
+//  Copyright Doug Gregor 2002-2003. 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

--- a/include/boost/function/function4.hpp
+++ b/include/boost/function/function4.hpp
@ -1,15 +1,9 @@
 // Boost.Function library

-// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
+//  Copyright Doug Gregor 2002-2003. 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

--- a/include/boost/function/function5.hpp
+++ b/include/boost/function/function5.hpp
@ -1,15 +1,9 @@
 // Boost.Function library

-// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
+//  Copyright Doug Gregor 2002-2003. 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

--- a/include/boost/function/function6.hpp
+++ b/include/boost/function/function6.hpp
@ -1,15 +1,9 @@
 // Boost.Function library

-// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
+//  Copyright Doug Gregor 2002-2003. 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

--- a/include/boost/function/function7.hpp
+++ b/include/boost/function/function7.hpp
@ -1,15 +1,9 @@
 // Boost.Function library

-// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
+//  Copyright Doug Gregor 2002-2003. 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

--- a/include/boost/function/function8.hpp
+++ b/include/boost/function/function8.hpp
@ -1,15 +1,9 @@
 // Boost.Function library

-// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
+//  Copyright Doug Gregor 2002-2003. 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

--- a/include/boost/function/function9.hpp
+++ b/include/boost/function/function9.hpp
@ -1,15 +1,9 @@
 // Boost.Function library

-// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
+//  Copyright Doug Gregor 2002-2003. 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

--- a/include/boost/function/function_base.hpp
+++ b/include/boost/function/function_base.hpp
@ -1,15 +1,9 @@
 // Boost.Function library

-// Copyright (C) 2001-2003 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
+//  Copyright Doug Gregor 2001-2004. 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

@ -20,14 +14,33 @@
 #include <string>
 #include <memory>
 #include <new>
+#include <typeinfo>
 #include <boost/config.hpp>
 #include <boost/assert.hpp>
-#include <boost/type_traits/arithmetic_traits.hpp>
+#include <boost/type_traits/is_integral.hpp>
 #include <boost/type_traits/composite_traits.hpp>
 #include <boost/type_traits/is_stateless.hpp>
 #include <boost/ref.hpp>
 #include <boost/pending/ct_if.hpp>
 #include <boost/detail/workaround.hpp>
+#ifndef BOOST_NO_SFINAE
+#  include "boost/utility/enable_if.hpp"
+#else
+#  include "boost/mpl/bool.hpp"
+#endif
+#include <boost/function_equal.hpp>
+
+// 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) \
+ || defined(_AIX) \
+ || (   defined(__sgi) && defined(__host_mips))
+#  include <cstring>
+#  define BOOST_FUNCTION_COMPARE_TYPE_ID(X,Y) \
+     (std::strcmp((X).name(),(Y).name()) == 0)
+# else
+#  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)
 #  define BOOST_FUNCTION_TARGET_FIX(x) x
@ -44,36 +57,19 @@ namespace boost { namespace python { namespace objects {
 }}}
 #endif

-// GCC 2.95.3 (or earlier) doesn't support enable_if
-#if BOOST_WORKAROUND(__GNUC__, < 3)
-#  define BOOST_FUNCTION_NO_ENABLE_IF
+#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

-// MIPSpro 7.3.1.3m doesn't support enable_if
-#if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
-#  define BOOST_FUNCTION_NO_ENABLE_IF
-#endif
+#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), \
+                       Type>::type

-// MSVC 7.0 doesn't support enable_if
-#if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 && !defined(BOOST_STRICT_CONFIG)
-#  define BOOST_FUNCTION_NO_ENABLE_IF
-#endif

-// Borland C++ 5.6.0 doesn't support enable_if
-#if BOOST_WORKAROUND(__BORLANDC__, <= 0x562)
-#  define BOOST_FUNCTION_NO_ENABLE_IF
-#endif
-
-// Metrowerks 7.2 doesn't support enable_if
-#if BOOST_WORKAROUND(__MWERKS__, <= 0x2407)
-#  define BOOST_FUNCTION_NO_ENABLE_IF
-#endif
-
-#if BOOST_WORKAROUND(__SUNPRO_CC, <= 0x540)
-#  define BOOST_FUNCTION_NO_ENABLE_IF
-#endif
-
-#if !defined(BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)
+#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)
 namespace boost {

 #if defined(__sgi) && defined(_COMPILER_VERSION) && _COMPILER_VERSION <= 730 && !defined(BOOST_STRICT_CONFIG)
@ -164,7 +160,8 @@ namespace boost {
      // The operation type to perform on the given functor/function pointer
      enum functor_manager_operation_type {
        clone_functor_tag,
-        destroy_functor_tag
+        destroy_functor_tag,
+        check_functor_type_tag
      };

      // Tags used to decide between different types of functions
@ -197,14 +194,31 @@ namespace boost {

      // The trivial manager does nothing but return the same pointer (if we
      // are cloning) or return the null pointer (if we are deleting).
-      inline any_pointer trivial_manager(any_pointer f,
-                                         functor_manager_operation_type op)
+      template<typename F>
+      struct trivial_manager
      {
-        if (op == clone_functor_tag)
-          return f;
-        else
+        static inline any_pointer
+        get(any_pointer f, functor_manager_operation_type op)
+        {
+          switch (op) {
+          case clone_functor_tag: return f;
+
+          case destroy_functor_tag:
+            return make_any_pointer(reinterpret_cast<void*>(0));
+
+          case check_functor_type_tag:
+            {
+              std::type_info* t = static_cast<std::type_info*>(f.obj_ptr);
+              return BOOST_FUNCTION_COMPARE_TYPE_ID(typeid(F), *t)?
+                f
+                : make_any_pointer(reinterpret_cast<void*>(0));
+            }
+          }
+
+          // Clears up a warning with GCC 3.2.3
          return make_any_pointer(reinterpret_cast<void*>(0));
-      }
+        }
+      };

      /**
       * The functor_manager class contains a static function "manage" which
@ -289,43 +303,81 @@ namespace boost {
        static any_pointer
        manage(any_pointer functor_ptr, functor_manager_operation_type op)
        {
-          typedef typename get_function_tag<functor_type>::type tag_type;
-          return manager(functor_ptr, op, tag_type());
+          if (op == check_functor_type_tag) {
+            std::type_info* type =
+              static_cast<std::type_info*>(functor_ptr.obj_ptr);
+            return (BOOST_FUNCTION_COMPARE_TYPE_ID(typeid(Functor), *type)?
+                    functor_ptr
+                    : make_any_pointer(reinterpret_cast<void*>(0)));
+          }
+          else {
+            typedef typename get_function_tag<functor_type>::type tag_type;
+            return manager(functor_ptr, op, tag_type());
+          }
        }
      };

-#ifndef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION
-    template<bool cond, typename T> struct enable_if;
-    template<typename T> struct enable_if<true, T>  { typedef T type; };
-    template<typename T> struct enable_if<false, T> {};
-
-    template<bool x>
-    struct enabled
-    {
-      template<typename T>
-      struct base
-      {
-        typedef T type;
-      };
-    };
-
-    template<>
-    struct enabled<false>
-    {
-      template<typename T>
-      struct base
-      {
-      };
-    };
-
-    template<bool Enabled, typename T>
-    struct enable_if : public enabled<Enabled>::template base<T>
-    {
-    };
-#endif
-
      // A type that is only used for comparisons against zero
      struct useless_clear_type {};
+
+#ifdef BOOST_NO_SFINAE
+      // These routines perform comparisons between a Boost.Function
+      // object and an arbitrary function object (when the last
+      // parameter is mpl::bool_<false>) or against zero (when the
+      // last parameter is mpl::bool_<true>). They are only necessary
+      // for compilers that don't support SFINAE.
+      template<typename Function, typename Functor>
+        bool
+        compare_equal(const Function& f, const Functor&, int, mpl::bool_<true>)
+        { return f.empty(); }
+
+      template<typename Function, typename Functor>
+        bool
+        compare_not_equal(const Function& f, const Functor&, int,
+                          mpl::bool_<true>)
+        { return !f.empty(); }
+
+      template<typename Function, typename Functor>
+        bool
+        compare_equal(const Function& f, const Functor& g, long,
+                      mpl::bool_<false>)
+        {
+          if (const Functor* fp = f.template target<Functor>())
+            return function_equal(*fp, g);
+          else return false;
+        }
+
+      template<typename Function, typename Functor>
+        bool
+        compare_equal(const Function& f, const reference_wrapper<Functor>& g,
+                      int, mpl::bool_<false>)
+        {
+          if (const Functor* fp = f.template target<Functor>())
+            return fp == g.get_pointer();
+          else return false;
+        }
+
+      template<typename Function, typename Functor>
+        bool
+        compare_not_equal(const Function& f, const Functor& g, long,
+                          mpl::bool_<false>)
+        {
+          if (const Functor* fp = f.template target<Functor>())
+            return !function_equal(*fp, g);
+          else return true;
+        }
+
+      template<typename Function, typename Functor>
+        bool
+        compare_not_equal(const Function& f,
+                          const reference_wrapper<Functor>& g, int,
+                          mpl::bool_<false>)
+        {
+          if (const Functor* fp = f.template target<Functor>())
+            return fp != g.get_pointer();
+          else return true;
+        }
+#endif // BOOST_NO_SFINAE
    } // end namespace function
  } // end namespace detail

@ -346,11 +398,92 @@ public:
  // Is this function empty?
  bool empty() const { return !manager; }

+  template<typename Functor>
+    Functor* target()
+    {
+      if (!manager) return 0;
+
+      detail::function::any_pointer result =
+        manager(detail::function::make_any_pointer(&typeid(Functor)),
+                detail::function::check_functor_type_tag);
+      if (!result.obj_ptr) return 0;
+      else {
+        typedef typename detail::function::get_function_tag<Functor>::type tag;
+        return get_functor_pointer<Functor>(tag(), 0);
+      }
+    }
+
+  template<typename Functor>
+    const Functor* target() const
+    {
+      if (!manager) return 0;
+
+      detail::function::any_pointer result =
+        manager(detail::function::make_any_pointer(&typeid(Functor)),
+                detail::function::check_functor_type_tag);
+      if (!result.obj_ptr) return 0;
+      else {
+        typedef typename detail::function::get_function_tag<Functor>::type tag;
+        return get_functor_pointer<Functor>(tag(), 0);
+      }
+    }
+
+  template<typename F>
+    bool contains(const F& f) const
+    {
+      if (const F* fp = this->template target<F>()) {
+        return function_equal(*fp, f);
+      } else {
+        return false;
+      }
+    }
+
+#if defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3
+  // GCC 3.3 and newer cannot copy with the global operator==, due to
+  // problems with instantiation of function return types before it
+  // has been verified that the argument types match up.
+  template<typename Functor>
+    BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+    operator==(Functor g) const
+    {
+      if (const Functor* fp = target<Functor>())
+	return function_equal(*fp, g);
+      else return false;
+    }
+
+  template<typename Functor>
+    BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+    operator!=(Functor g) const
+    {
+      if (const Functor* fp = target<Functor>())
+	return !function_equal(*fp, g);
+      else return true;
+    }
+#endif
+
 public: // should be protected, but GCC 2.95.3 will fail to allow access
  detail::function::any_pointer (*manager)(
    detail::function::any_pointer,
    detail::function::functor_manager_operation_type);
  detail::function::any_pointer functor;
+
+private:
+  template<typename Functor>
+    Functor* get_functor_pointer(detail::function::function_ptr_tag, int)
+    { return reinterpret_cast<Functor*>(&functor.func_ptr); }
+
+  template<typename Functor, typename Tag>
+    Functor* get_functor_pointer(Tag, long)
+    { return static_cast<Functor*>(functor.obj_ptr); }
+
+  template<typename Functor>
+    const Functor*
+    get_functor_pointer(detail::function::function_ptr_tag, int) const
+    { return reinterpret_cast<const Functor*>(&functor.func_ptr); }
+
+  template<typename Functor, typename Tag>
+    const Functor* get_functor_pointer(Tag, long) const
+    { return static_cast<const Functor*>(functor.const_obj_ptr); }
 };

 /**
@ -363,16 +496,7 @@ public:
  bad_function_call() : std::runtime_error("call to empty boost::function") {}
 };

-/* Poison comparison between Boost.Function objects (because it is
- * meaningless). The comparisons would otherwise be allowed because of the
- * conversion required to allow syntax such as:
- *   boost::function<int, int> f;
- *   if (f) { f(5); }
- */
-void operator==(const function_base&, const function_base&);
-void operator!=(const function_base&, const function_base&);
-
-#if BOOST_WORKAROUND(BOOST_MSVC, <= 1300)
+#ifndef BOOST_NO_SFINAE
 inline bool operator==(const function_base& f,
                       detail::function::useless_clear_type*)
 {
@ -398,6 +522,116 @@ inline bool operator!=(detail::function::useless_clear_type*,
 }
 #endif

+#ifdef BOOST_NO_SFINAE
+// Comparisons between boost::function objects and arbitrary function objects
+template<typename Functor>
+  inline bool operator==(const function_base& f, Functor g)
+  {
+    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    return detail::function::compare_equal(f, g, 0, integral());
+  }
+
+template<typename Functor>
+  inline bool operator==(Functor g, const function_base& f)
+  {
+    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    return detail::function::compare_equal(f, g, 0, integral());
+  }
+
+template<typename Functor>
+  inline bool operator!=(const function_base& f, Functor g)
+  {
+    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    return detail::function::compare_not_equal(f, g, 0, integral());
+  }
+
+template<typename Functor>
+  inline bool operator!=(Functor g, const function_base& f)
+  {
+    typedef mpl::bool_<(is_integral<Functor>::value)> integral;
+    return detail::function::compare_not_equal(f, g, 0, integral());
+  }
+#else
+
+#  if !(defined(__GNUC__) && __GNUC__ == 3 && __GNUC_MINOR__ <= 3)
+// Comparisons between boost::function objects and arbitrary function
+// objects. GCC 3.3 and before has an obnoxious bug that prevents this
+// from working.
+template<typename Functor>
+  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  operator==(const function_base& f, Functor g)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return function_equal(*fp, g);
+    else return false;
+  }
+
+template<typename Functor>
+  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  operator==(Functor g, const function_base& f)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return function_equal(g, *fp);
+    else return false;
+  }
+
+template<typename Functor>
+  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  operator!=(const function_base& f, Functor g)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return !function_equal(*fp, g);
+    else return true;
+  }
+
+template<typename Functor>
+  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  operator!=(Functor g, const function_base& f)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return !function_equal(g, *fp);
+    else return true;
+  }
+#  endif
+
+template<typename Functor>
+  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  operator==(const function_base& f, reference_wrapper<Functor> g)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return fp == g.get_pointer();
+    else return false;
+  }
+
+template<typename Functor>
+  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  operator==(reference_wrapper<Functor> g, const function_base& f)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return g.get_pointer() == fp;
+    else return false;
+  }
+
+template<typename Functor>
+  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  operator!=(const function_base& f, reference_wrapper<Functor> g)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return fp != g.get_pointer();
+    else return true;
+  }
+
+template<typename Functor>
+  BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL(Functor, bool)
+  operator!=(reference_wrapper<Functor> g, const function_base& f)
+  {
+    if (const Functor* fp = f.template target<Functor>())
+      return g.get_pointer() != fp;
+    else return true;
+  }
+
+#endif // Compiler supporting SFINAE
+
 namespace detail {
  namespace function {
    inline bool has_empty_target(const function_base* f)
@ -405,12 +639,22 @@ namespace detail {
      return f->empty();
    }

+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1310)
+    inline bool has_empty_target(const void*)
+    {
+      return false;
+    }
+#else
    inline bool has_empty_target(...)
    {
      return false;
    }
+#endif
  } // end namespace function
 } // end namespace detail
 } // end namespace boost

+#undef BOOST_FUNCTION_ENABLE_IF_NOT_INTEGRAL
+#undef BOOST_FUNCTION_COMPARE_TYPE_ID
+
 #endif // BOOST_FUNCTION_BASE_HEADER
--- a/include/boost/function/function_template.hpp
+++ b/include/boost/function/function_template.hpp
@ -1,15 +1,9 @@
 // Boost.Function library

-// Copyright (C) 2001-2003 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
+//  Copyright Doug Gregor 2001-2003. 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

@ -240,9 +234,11 @@ namespace boost {
  >
  class BOOST_FUNCTION_FUNCTION : public function_base
  {
+  public:
    typedef typename detail::function::function_return_type<R>::type
      internal_result_type;

+  private:
    struct clear_type {};

  public:
@ -280,12 +276,12 @@ namespace boost {
    // one with a default parameter.
    template<typename Functor>
    BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f
-#ifndef BOOST_FUNCTION_NO_ENABLE_IF
-                            ,typename detail::function::enable_if<
+#ifndef BOOST_NO_SFINAE
+                            ,typename enable_if_c<
                            (::boost::type_traits::ice_not<
-                             (is_same<Functor, int>::value)>::value),
+                             (is_integral<Functor>::value)>::value),
                                        int>::type = 0
-#endif // BOOST_FUNCTION_NO_ENABLE_IF
+#endif // BOOST_NO_SFINAE
                            ) :
      function_base(),
      invoker(0)
@ -293,7 +289,7 @@ namespace boost {
      this->assign_to(f);
    }

-#ifndef BOOST_FUNCTION_NO_ENABLE_IF
+#ifndef BOOST_NO_SFINAE
    BOOST_FUNCTION_FUNCTION(clear_type*) : function_base(), invoker(0) {}
 #else
    BOOST_FUNCTION_FUNCTION(int zero) : function_base(), invoker(0)
@ -311,12 +307,15 @@ namespace boost {

    ~BOOST_FUNCTION_FUNCTION() { clear(); }

+#if BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
+    // 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());

-      internal_result_type result = invoker(function_base::functor
+      internal_result_type result = invoker(this->functor
                                            BOOST_FUNCTION_COMMA
                                            BOOST_FUNCTION_ARGS);

@ -326,6 +325,9 @@ namespace boost {
      return result;
 #endif // BOOST_NO_VOID_RETURNS
    }
+#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
@ -333,10 +335,10 @@ namespace boost {
    // handle BOOST_FUNCTION_FUNCTION as the type of the temporary to
    // construct.
    template<typename Functor>
-#ifndef BOOST_FUNCTION_NO_ENABLE_IF
-    typename detail::function::enable_if<
+#ifndef BOOST_NO_SFINAE
+    typename enable_if_c<
               (::boost::type_traits::ice_not<
-                 (is_same<Functor, int>::value)>::value),
+                 (is_integral<Functor>::value)>::value),
               BOOST_FUNCTION_FUNCTION&>::type
 #else
    BOOST_FUNCTION_FUNCTION&
@ -347,7 +349,7 @@ namespace boost {
      return *this;
    }

-#ifndef BOOST_FUNCTION_NO_ENABLE_IF
+#ifndef BOOST_NO_SFINAE
    BOOST_FUNCTION_FUNCTION& operator=(clear_type*)
    {
      this->clear();
@ -377,21 +379,20 @@ namespace boost {
      if (&other == this)
        return;

-      std::swap(function_base::manager, other.manager);
-      std::swap(function_base::functor, other.functor);
+      std::swap(this->manager, other.manager);
+      std::swap(this->functor, other.functor);
      std::swap(invoker, other.invoker);
    }

    // Clear out a target, if there is one
    void clear()
    {
-      if (function_base::manager) {
+      if (this->manager) {
        function_base::functor =
-          function_base::manager(function_base::functor,
-                                 detail::function::destroy_functor_tag);
+          this->manager(this->functor, detail::function::destroy_functor_tag);
      }

-      function_base::manager = 0;
+      this->manager = 0;
      invoker = 0;
    }

@ -419,8 +420,8 @@ namespace boost {
    {
      if (!f.empty()) {
        invoker = f.invoker;
-        function_base::manager = f.manager;
-        function_base::functor =
+        this->manager = f.manager;
+        this->functor =
          f.manager(f.functor, detail::function::clone_functor_tag);
      }
    }
@ -443,13 +444,13 @@ namespace boost {
                           R BOOST_FUNCTION_COMMA
                           BOOST_FUNCTION_TEMPLATE_ARGS
                         >::type
-          invoker_type;
+          actual_invoker_type;

-        invoker = &invoker_type::invoke;
-        function_base::manager =
+        invoker = &actual_invoker_type::invoke;
+        this->manager =
          &detail::function::functor_manager<FunctionPtr, Allocator>::manage;
-        function_base::functor =
-          function_base::manager(detail::function::make_any_pointer(
+        this->functor =
+          this->manager(detail::function::make_any_pointer(
                            // should be a reinterpret cast, but some compilers
                            // insist on giving cv-qualifiers to free functions
                            (void (*)())(f)
@ -476,16 +477,16 @@ namespace boost {
                                       R BOOST_FUNCTION_COMMA
                                       BOOST_FUNCTION_TEMPLATE_ARGS
                                     >::type
-          invoker_type;
+          actual_invoker_type;

-        invoker = &invoker_type::invoke;
-        function_base::manager = &detail::function::functor_manager<
+        invoker = &actual_invoker_type::invoke;
+        this->manager = &detail::function::functor_manager<
                                    FunctionObj, Allocator>::manage;
 #ifndef BOOST_NO_STD_ALLOCATOR
        typedef typename Allocator::template rebind<FunctionObj>::other
-          allocator_type;
-        typedef typename allocator_type::pointer pointer_type;
-        allocator_type allocator;
+          rebound_allocator_type;
+        typedef typename rebound_allocator_type::pointer pointer_type;
+        rebound_allocator_type allocator;
        pointer_type copy = allocator.allocate(1);
        allocator.construct(copy, f);

@ -494,7 +495,7 @@ namespace boost {
 #else
        FunctionObj* new_f = new FunctionObj(f);
 #endif // BOOST_NO_STD_ALLOCATOR
-        function_base::functor =
+        this->functor =
          detail::function::make_any_pointer(static_cast<void*>(new_f));
      }
    }
@ -510,12 +511,12 @@ namespace boost {
                                       R BOOST_FUNCTION_COMMA
                                       BOOST_FUNCTION_TEMPLATE_ARGS
                                     >::type
-          invoker_type;
+          actual_invoker_type;

-        invoker = &invoker_type::invoke;
-        function_base::manager = &detail::function::trivial_manager;
-        function_base::functor =
-          function_base::manager(
+        invoker = &actual_invoker_type::invoke;
+        this->manager = &detail::function::trivial_manager<FunctionObj>::get;
+        this->functor =
+          this->manager(
            detail::function::make_any_pointer(
              const_cast<FunctionObj*>(f.get_pointer())),
            detail::function::clone_functor_tag);
@ -532,10 +533,10 @@ namespace boost {
                       R BOOST_FUNCTION_COMMA
                       BOOST_FUNCTION_TEMPLATE_ARGS
                     >::type
-          invoker_type;
-      invoker = &invoker_type::invoke;
-      function_base::manager = &detail::function::trivial_manager;
-      function_base::functor = detail::function::make_any_pointer(this);
+          actual_invoker_type;
+      invoker = &actual_invoker_type::invoke;
+      this->manager = &detail::function::trivial_manager<FunctionObj>::get;
+      this->functor = detail::function::make_any_pointer(this);
    }

    typedef internal_result_type (*invoker_type)(detail::function::any_pointer
@ -561,9 +562,55 @@ namespace boost {
    f1.swap(f2);
  }

-#if !defined (BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION)                         \
- && !defined(BOOST_BCB_PARTIAL_SPECIALIZATION_BUG)                              \
- && (BOOST_STRICT_CONFIG || !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540)
+#if !BOOST_WORKAROUND(BOOST_MSVC, <= 1200)
+  template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS,
+           typename Allocator>
+  typename BOOST_FUNCTION_FUNCTION<
+      R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS, 
+      Allocator>::result_type
+   BOOST_FUNCTION_FUNCTION<R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_ARGS,
+
+                           Allocator>
+  ::operator()(BOOST_FUNCTION_PARMS) const
+  {
+      if (this->empty())
+        boost::throw_exception(bad_function_call());
+
+      internal_result_type result = invoker(this->functor
+                                            BOOST_FUNCTION_COMMA
+                                            BOOST_FUNCTION_ARGS);
+
+#  ifndef BOOST_NO_VOID_RETURNS
+      return static_cast<result_type>(result);
+#  else
+      return result;
+#  endif // BOOST_NO_VOID_RETURNS
+    }
+#endif
+
+// Poison comparisons between boost::function objects of the same type.
+template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
+         typename Allocator>
+  void operator==(const BOOST_FUNCTION_FUNCTION<
+                          R BOOST_FUNCTION_COMMA
+                          BOOST_FUNCTION_TEMPLATE_ARGS ,
+                          Allocator>&,
+                  const BOOST_FUNCTION_FUNCTION<
+                          R BOOST_FUNCTION_COMMA
+                          BOOST_FUNCTION_TEMPLATE_ARGS ,
+                  Allocator>&);
+template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
+         typename Allocator>
+  void operator!=(const BOOST_FUNCTION_FUNCTION<
+                          R BOOST_FUNCTION_COMMA
+                          BOOST_FUNCTION_TEMPLATE_ARGS ,
+                          Allocator>&,
+                  const BOOST_FUNCTION_FUNCTION<
+                          R BOOST_FUNCTION_COMMA
+                          BOOST_FUNCTION_TEMPLATE_ARGS ,
+                  Allocator>&);
+
+#if !defined(BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX)

 #if BOOST_FUNCTION_NUM_ARGS == 0
 #define BOOST_FUNCTION_PARTIAL_SPEC R (void)
@ -591,10 +638,10 @@ public:

  template<typename Functor>
  function(Functor f
-#ifndef BOOST_FUNCTION_NO_ENABLE_IF
-           ,typename detail::function::enable_if<
+#ifndef BOOST_NO_SFINAE
+           ,typename enable_if_c<
                            (::boost::type_traits::ice_not<
-                          (is_same<Functor, int>::value)>::value),
+                          (is_integral<Functor>::value)>::value),
                       int>::type = 0
 #endif
           ) :
@ -602,7 +649,7 @@ public:
  {
  }

-#ifndef BOOST_FUNCTION_NO_ENABLE_IF
+#ifndef BOOST_NO_SFINAE
  function(clear_type*) : base_type() {}
 #endif

@ -617,10 +664,10 @@ public:
  }

  template<typename Functor>
-#ifndef BOOST_FUNCTION_NO_ENABLE_IF
-  typename detail::function::enable_if<
+#ifndef BOOST_NO_SFINAE
+  typename enable_if_c<
                            (::boost::type_traits::ice_not<
-                         (is_same<Functor, int>::value)>::value),
+                         (is_integral<Functor>::value)>::value),
                      self_type&>::type
 #else
  self_type&
@ -631,7 +678,7 @@ public:
    return *this;
  }

-#ifndef BOOST_FUNCTION_NO_ENABLE_IF
+#ifndef BOOST_NO_SFINAE
  self_type& operator=(clear_type*)
  {
    this->clear();
--- a/include/boost/function/gen_function_N.pl
+++ b/include/boost/function/gen_function_N.pl
@ -2,16 +2,10 @@
 #
 # Boost.Function library
 #
-# Copyright (C) 2001-2003 Doug Gregor (gregod@cs.rpi.edu)
-#
-# Permission to copy, use, sell and distribute this software is granted
-# provided this copyright notice appears in all copies.
-# Permission to modify the code and to distribute modified code is granted
-# provided this copyright notice appears in all copies, and a notice
-# that the code was modified is included with the copyright notice.
-#
-# This software is provided "as is" without express or implied warranty,
-# and with no claim as to its suitability for any purpose.
+# Copyright Doug Gregor 2001-2003. 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
 use English;
--- a/include/boost/function_equal.hpp
+++ b/include/boost/function_equal.hpp
@ -0,0 +1,24 @@
+//  Copyright Doug Gregor 2004. 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_EQUAL_HPP
+#define BOOST_FUNCTION_EQUAL_HPP
+
+namespace boost {
+
+namespace detail {
+  template<typename F, typename G>
+    bool function_equal_impl(const F& f, const G& g, long)
+    { return f == g; }
+} // end namespace boost::function
+
+template<typename F, typename G>
+  bool function_equal(const F& f, const G& g)
+  { return ::boost::detail::function_equal_impl(f, g, 0); }
+
+} // end namespace boost
+
+#endif // BOOST_FUNCTION_EQUAL_HPP
--- a/index.html
+++ b/index.html
@ -1,9 +0,0 @@
-<html>
-<head>
-<meta http-equiv="refresh" content="0; URL=../../doc/html/function.html">
-</head>
-<body>
-Automatic redirection failed, please go to
-<a href="../../doc/html/function.html">../../doc/html/function.html</a>
-</body>
-</html>
--- a/test/Jamfile
+++ b/test/Jamfile
@ -1,69 +0,0 @@
-# Function library
-
-# Copyright (C) 2001-2003 Douglas Gregor
-
-# Permission to copy, use, sell and distribute this software is granted 
-# provided this copyright notice appears in all copies. Permission to modify 
-# the code and to distribute modified code is granted provided this copyright 
-# notice appears in all copies, and a notice that the code was modified is 
-# included with the copyright notice. This software is provided "as is" 
-# without express or implied warranty, and with no claim as to its suitability 
-# for any purpose. 
-
-# For more information, see http://www.boost.org/
-
-
-# Testing Jamfile autogenerated from XML source
-subproject libs/function/test ;
-
-# bring in rules for testing
-SEARCH on testing.jam = $(BOOST_BUILD_PATH) ;
-include testing.jam ;
-
-# Make tests run by default.
-DEPENDS all : test ;
-
-{
-  # look in BOOST_ROOT for sources first, just in this Jamfile
-  local SEARCH_SOURCE = $(BOOST_ROOT) $(SEARCH_SOURCE) ;
-
-  test-suite function
-    : 
-  [ run libs/function/test/function_test.cpp :  :  :  : lib_function_test ]
-
-  [ run libs/function/test/function_n_test.cpp :  :  :  :  ]
-
-  [ run libs/function/test/allocator_test.cpp <lib>../../../libs/test/build/boost_test_exec_monitor :  :  :  :  ]
-
-  [ run libs/function/test/stateless_test.cpp <lib>../../../libs/test/build/boost_test_exec_monitor :  :  :  :  ]
-
-  [ run libs/function/test/lambda_test.cpp <lib>../../../libs/test/build/boost_test_exec_monitor :  :  :  :  ]
-
-  [ compile-fail libs/function/test/function_test_fail1.cpp :  :  :  :  ]
-
-  [ compile-fail libs/function/test/function_test_fail2.cpp :  :  :  :  ]
-
-  [ compile libs/function/test/function_30.cpp :  :  :  :  ] 
-
-  [ run libs/function/test/function_arith_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/function_arith_portable.cpp :  :  :  :  ]
-
-  [ run libs/function/test/sum_avg_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/sum_avg_portable.cpp :  :  :  :  ]
-
-  [ run libs/function/test/mem_fun_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/mem_fun_portable.cpp :  :  :  :  ]
-
-  [ run libs/function/test/std_bind_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/std_bind_portable.cpp :  :  :  :  ]
-
-  [ run libs/function/test/function_ref_cxx98.cpp :  :  :  :  ]
-
-  [ run libs/function/test/function_ref_portable.cpp :  :  :  :  ]
- ;
-}
-      
--- a/test/allocator_test.cpp
+++ b/test/allocator_test.cpp
@ -1,88 +0,0 @@
-// Boost.Function library
-
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-#include <cassert>
-#include <functional>
-#include <boost/function.hpp>
-
-using namespace std;
-using namespace boost;
-
-static int alloc_count = 0;
-static int dealloc_count = 0;
-
-template<typename T>
-struct counting_allocator : public std::allocator<T>
-{
-  template<typename U>
-  struct rebind
-  {
-    typedef counting_allocator<U> other;
-  };
-
-  
-  T* allocate(std::size_t n)
-  {
-    alloc_count++;
-    return std::allocator<T>::allocate(n);
-  }
-
-  void deallocate(T* p, std::size_t n)
-  {
-    dealloc_count++;
-    std::allocator<T>::deallocate(p, n);
-  }
-};
-
-static int do_minus(int x, int y) { return x-y; }
-
-struct DoNothing
-{
-  void operator()() const {}
-};
-
-static void do_nothing() {}
-
-int
-test_main(int, char*[])
-{
-  function2<int, int, int, counting_allocator<int> > f; 
-  f = plus<int>();
-  f.clear();
-  BOOST_TEST(alloc_count == 1);
-  BOOST_TEST(dealloc_count == 1);
-
-  alloc_count = 0;
-  dealloc_count = 0;
-  f = &do_minus;
-  f.clear();
-
-  function0<void, counting_allocator<int> > fv;
-  alloc_count = 0;
-  dealloc_count = 0;
-  fv = DoNothing();
-  fv.clear();
-  BOOST_TEST(alloc_count == 1);
-  BOOST_TEST(dealloc_count == 1);
-  
-  alloc_count = 0;
-  dealloc_count = 0;
-  fv = &do_nothing;
-  fv.clear();
-
-  return 0;
-}
--- a/test/function_30.cpp
+++ b/test/function_30.cpp
@ -1,31 +0,0 @@
-// Boost.Function library
-
-// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-// Make sure we don't try to redefine function2
-#include <boost/function/function2.hpp>
-
-// Define all Boost.Function class templates up to 30 arguments
-#define BOOST_FUNCTION_MAX_ARGS 30
-#include <boost/function.hpp>
-
-int main()
-{
-  boost::function0<float> f0;
-
-  boost::function30<float, int, int, int, int, int, int, int, int, int, int,
-                    int, int, int, int, int, int, int, int, int, int,
-                    int, int, int, int, int, int, int, int, int, int> f30;
-  return 0;
-}
--- a/test/function_arith_cxx98.cpp
+++ b/test/function_arith_cxx98.cpp
@ -1,38 +0,0 @@
-// Function library
-
-// Copyright (C) 2001-2003 Douglas Gregor
-
-// Permission to copy, use, sell and distribute this software is granted 
-// provided this copyright notice appears in all copies. Permission to modify 
-// the code and to distribute modified code is granted provided this copyright 
-// notice appears in all copies, and a notice that the code was modified is 
-// included with the copyright notice. This software is provided "as is" 
-// without express or implied warranty, and with no claim as to its 
-// suitability for any purpose. 
-
-// For more information, see http://www.boost.org/
-
-    
-#include <boost/function.hpp>
-#include <iostream>
-
-
-float mul_ints(int x, int y) { return ((float)x) * y; }
-struct int_div { 
-  float operator()(int x, int y) const { return ((float)x)/y; }; 
-};
-
-int main()
-{
-    boost::function<float (int x, int y)> f;
-    f = int_div();
-    std::cout << f(5, 3) << std::endl;
-    if (f)
-  std::cout << f(5, 3) << std::endl;
-else
-  std::cout << "f has no target, so it is unsafe to call" << std::endl;
-    f = 0;
-    f = &mul_ints;
-  
-    return 0;
-}
--- a/test/function_arith_portable.cpp
+++ b/test/function_arith_portable.cpp
@ -1,36 +0,0 @@
-// Function library
-
-// Copyright (C) 2001-2003 Douglas Gregor
-
-// Permission to copy, use, sell and distribute this software is granted 
-// provided this copyright notice appears in all copies. Permission to modify 
-// the code and to distribute modified code is granted provided this copyright 
-// notice appears in all copies, and a notice that the code was modified is 
-// included with the copyright notice. This software is provided "as is" 
-// without express or implied warranty, and with no claim as to its 
-// suitability for any purpose. 
-
-// For more information, see http://www.boost.org/
-
-    
-#include <boost/function.hpp>
-#include <iostream>
-
-float mul_ints(int x, int y) { return ((float)x) * y; }
-struct int_div { 
-  float operator()(int x, int y) const { return ((float)x)/y; }; 
-};
-int main()
-{
-    boost::function2<float, int, int> f;
-    f = int_div();
-    std::cout << f(5, 3) << std::endl;
-    if (f)
-  std::cout << f(5, 3) << std::endl;
-else
-  std::cout << "f has no target, so it is unsafe to call" << std::endl;
-    f = 0;
-    f = &mul_ints;
-
-    return 0;
-}
--- a/test/function_n_test.cpp
+++ b/test/function_n_test.cpp
@ -1,653 +0,0 @@
-// Boost.Function library
-
-// Copyright (C) 2001, 2002 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-#include <boost/test/minimal.hpp>
-#include <boost/function.hpp>
-#include <functional>
-#include <cassert>
-#include <string>
-
-using namespace boost;
-using std::string;
-using std::negate;
-
-int global_int;
-
-struct write_five_obj { void operator()() const { global_int = 5; } };
-struct write_three_obj { int operator()() const { global_int = 3; return 7; }};
-static void write_five() { global_int = 5; }
-static void write_three() { global_int = 3; }
-struct generate_five_obj { int operator()() const { return 5; } };
-struct generate_three_obj { int operator()() const { return 3; } };
-static int generate_five() { return 5; }
-static int generate_three() { return 3; }
-static string identity_str(const string& s) { return s; }
-static string string_cat(const string& s1, const string& s2) { return s1+s2; }
-static int sum_ints(int x, int y) { return x+y; }
-
-struct write_const_1_nonconst_2
-{
-  void operator()() { global_int = 2; }
-  void operator()() const { global_int = 1; }
-};
-
-struct add_to_obj
-{
-  add_to_obj(int v) : value(v) {}
-
-  int operator()(int x) const { return value + x; }
-
-  int value;
-};
-
-static void
-test_zero_args()
-{
-  typedef function0<void> func_void_type;
-
-  write_five_obj five;
-  write_three_obj three;
-
-  // Default construction
-  func_void_type v1;
-  BOOST_TEST(v1.empty());
-
-  // Assignment to an empty function
-  v1 = five;
-  BOOST_TEST(!v1.empty());
-
-  // Invocation of a function
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 5);
-
-  // clear() method
-  v1.clear();
-  BOOST_TEST(!v1);
-
-  // Assignment to an empty function
-  v1 = three;
-  BOOST_TEST(!v1.empty());
-
-  // Invocation and self-assignment
-  global_int = 0;
-  v1 = v1;
-  v1();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a non-empty function
-  v1 = five;
-
-  // Invocation and self-assignment
-  global_int = 0;
-  v1 = (v1);
-  v1();
-  BOOST_TEST(global_int == 5);
-
-  // clear
-  v1 = 0;
-  BOOST_TEST(v1.empty());
-
-  // Assignment to an empty function from a free function
-  v1 = &write_five;
-  BOOST_TEST(!v1.empty());
-
-  // Invocation
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v1 = &write_three;
-  BOOST_TEST(!v1.empty());
-
-  // Invocation
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment
-  v1 = five;
-  BOOST_TEST(!v1.empty());
-
-  // Invocation
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v1 = write_three;
-  BOOST_TEST(!v1.empty());
-
-  // Invocation
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 3);
-
-  // Construction from another function (that is empty)
-  v1.clear();
-  func_void_type v2(v1);
-  BOOST_TEST(!v2? true : false);
-
-  // Assignment to an empty function
-  v2 = three;
-  BOOST_TEST(!v2.empty());
-
-  // Invocation
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a non-empty function
-  v2 = (five);
-
-  // Invocation
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 5);
-
-  v2.clear();
-  BOOST_TEST(v2.empty());
-
-  // Assignment to an empty function from a free function
-  v2 = (&write_five);
-  BOOST_TEST(v2? true : false);
-
-  // Invocation
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v2 = &write_three;
-  BOOST_TEST(!v2.empty());
-
-  // Invocation
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 3);
-
-  // Swapping
-  v1 = five;
-  swap(v1, v2);
-  v2();
-  BOOST_TEST(global_int == 5);
-  v1();
-  BOOST_TEST(global_int == 3);
-  swap(v1, v2);
-  v1.clear();
-
-  // Assignment
-  v2 = five;
-  BOOST_TEST(!v2.empty());
-
-  // Invocation
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v2 = &write_three;
-  BOOST_TEST(!v2.empty());
-
-  // Invocation
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a function from an empty function
-  v2 = v1;
-  BOOST_TEST(v2.empty());
-
-  // Assignment to a function from a function with a functor
-  v1 = three;
-  v2 = v1;
-  BOOST_TEST(!v1.empty());
-  BOOST_TEST(!v2.empty());
-
-  // Invocation
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 3);
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 3);
-
-  // Assign to a function from a function with a function
-  v2 = &write_five;
-  v1 = v2;
-  BOOST_TEST(!v1.empty());
-  BOOST_TEST(!v2.empty());
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 5);
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 5);
-
-  // Construct a function given another function containing a function
-  func_void_type v3(v1);
-
-  // Invocation of a function
-  global_int = 0;
-  v3();
-  BOOST_TEST(global_int == 5);
-
-  // clear() method
-  v3.clear();
-  BOOST_TEST(!v3? true : false);
-
-  // Assignment to an empty function
-  v3 = three;
-  BOOST_TEST(!v3.empty());
-
-  // Invocation
-  global_int = 0;
-  v3();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a non-empty function
-  v3 = five;
-
-  // Invocation
-  global_int = 0;
-  v3();
-  BOOST_TEST(global_int == 5);
-
-  // clear()
-  v3.clear();
-  BOOST_TEST(v3.empty());
-
-  // Assignment to an empty function from a free function
-  v3 = &write_five;
-  BOOST_TEST(!v3.empty());
-
-  // Invocation
-  global_int = 0;
-  v3();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v3 = &write_three;
-  BOOST_TEST(!v3.empty());
-
-  // Invocation
-  global_int = 0;
-  v3();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment
-  v3 = five;
-  BOOST_TEST(!v3.empty());
-
-  // Invocation
-  global_int = 0;
-  v3();
-  BOOST_TEST(global_int == 5);
-
-  // Construction of a function from a function containing a functor
-  func_void_type v4(v3);
-
-  // Invocation of a function
-  global_int = 0;
-  v4();
-  BOOST_TEST(global_int == 5);
-
-  // clear() method
-  v4.clear();
-  BOOST_TEST(v4.empty());
-
-  // Assignment to an empty function
-  v4 = three;
-  BOOST_TEST(!v4.empty());
-
-  // Invocation
-  global_int = 0;
-  v4();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a non-empty function
-  v4 = five;
-
-  // Invocation
-  global_int = 0;
-  v4();
-  BOOST_TEST(global_int == 5);
-
-  // clear()
-  v4.clear();
-  BOOST_TEST(v4.empty());
-
-  // Assignment to an empty function from a free function
-  v4 = &write_five;
-  BOOST_TEST(!v4.empty());
-
-  // Invocation
-  global_int = 0;
-  v4();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v4 = &write_three;
-  BOOST_TEST(!v4.empty());
-
-  // Invocation
-  global_int = 0;
-  v4();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment
-  v4 = five;
-  BOOST_TEST(!v4.empty());
-
-  // Invocation
-  global_int = 0;
-  v4();
-  BOOST_TEST(global_int == 5);
-
-  // Construction of a function from a functor
-  func_void_type v5(five);
-
-  // Invocation of a function
-  global_int = 0;
-  v5();
-  BOOST_TEST(global_int == 5);
-
-  // clear() method
-  v5.clear();
-  BOOST_TEST(v5.empty());
-
-  // Assignment to an empty function
-  v5 = three;
-  BOOST_TEST(!v5.empty());
-
-  // Invocation
-  global_int = 0;
-  v5();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a non-empty function
-  v5 = five;
-
-  // Invocation
-  global_int = 0;
-  v5();
-  BOOST_TEST(global_int == 5);
-
-  // clear()
-  v5.clear();
-  BOOST_TEST(v5.empty());
-
-  // Assignment to an empty function from a free function
-  v5 = &write_five;
-  BOOST_TEST(!v5.empty());
-
-  // Invocation
-  global_int = 0;
-  v5();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v5 = &write_three;
-  BOOST_TEST(!v5.empty());
-
-  // Invocation
-  global_int = 0;
-  v5();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment
-  v5 = five;
-  BOOST_TEST(!v5.empty());
-
-  // Invocation
-  global_int = 0;
-  v5();
-  BOOST_TEST(global_int == 5);
-
-  // Construction of a function from a function
-  func_void_type v6(&write_five);
-
-  // Invocation of a function
-  global_int = 0;
-  v6();
-  BOOST_TEST(global_int == 5);
-
-  // clear() method
-  v6.clear();
-  BOOST_TEST(v6.empty());
-
-  // Assignment to an empty function
-  v6 = three;
-  BOOST_TEST(!v6.empty());
-
-  // Invocation
-  global_int = 0;
-  v6();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a non-empty function
-  v6 = five;
-
-  // Invocation
-  global_int = 0;
-  v6();
-  BOOST_TEST(global_int == 5);
-
-  // clear()
-  v6.clear();
-  BOOST_TEST(v6.empty());
-
-  // Assignment to an empty function from a free function
-  v6 = &write_five;
-  BOOST_TEST(!v6.empty());
-
-  // Invocation
-  global_int = 0;
-  v6();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v6 = &write_three;
-  BOOST_TEST(!v6.empty());
-
-  // Invocation
-  global_int = 0;
-  v6();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment
-  v6 = five;
-  BOOST_TEST(!v6.empty());
-
-  // Invocation
-  global_int = 0;
-  v6();
-  BOOST_TEST(global_int == 5);
-
-  // Const vs. non-const
-  write_const_1_nonconst_2 one_or_two;
-  const function0<void> v7(one_or_two);
-  function0<void> v8(one_or_two);
-
-  global_int = 0;
-  v7();
-  BOOST_TEST(global_int == 2);
-
-  global_int = 0;
-  v8();
-  BOOST_TEST(global_int == 2);
-
-  // Test construction from 0 and comparison to 0
-  func_void_type v9(0);
-  BOOST_TEST(v9 == 0);
-# if !defined(__SUNPRO_CC) || __SUNPRO_CC > 0x540 || defined(BOOST_STRICT_CONFIG)
-  BOOST_TEST(0 == v9);
-#else
-  BOOST_TEST(v9.empty());
-#endif
-
-  // Test return values
-  typedef function0<int> func_int_type;
-  generate_five_obj gen_five;
-  generate_three_obj gen_three;
-
-  func_int_type i0(gen_five);
-
-  BOOST_TEST(i0() == 5);
-  i0 = gen_three;
-  BOOST_TEST(i0() == 3);
-  i0 = &generate_five;
-  BOOST_TEST(i0() == 5);
-  i0 = &generate_three;
-  BOOST_TEST(i0() == 3);
-  BOOST_TEST(i0? true : false);
-  i0.clear();
-  BOOST_TEST(!i0? true : false);
-
-  // Test return values with compatible types
-  typedef function0<long> func_long_type;
-  func_long_type i1(gen_five);
-
-  BOOST_TEST(i1() == 5);
-  i1 = gen_three;
-  BOOST_TEST(i1() == 3);
-  i1 = &generate_five;
-  BOOST_TEST(i1() == 5);
-  i1 = &generate_three;
-  BOOST_TEST(i1() == 3);
-  BOOST_TEST(i1? true : false);
-  i1.clear();
-  BOOST_TEST(!i1? true : false);
-}
-
-static void
-test_one_arg()
-{
-  negate<int> neg;
-
-  function1<int, int> f1(neg);
-  BOOST_TEST(f1(5) == -5);
-
-  function1<string, string> id(&identity_str);
-  BOOST_TEST(id("str") == "str");
-
-  function1<std::string, const char*> id2(&identity_str);
-  BOOST_TEST(id2("foo") == "foo");
-
-  add_to_obj add_to(5);
-  function1<int, int> f2(add_to);
-  BOOST_TEST(f2(3) == 8);
-
-  const function1<int, int> cf2(add_to);
-  BOOST_TEST(cf2(3) == 8);
-}
-
-static void
-test_two_args()
-{
-  function2<string, const string&, const string&> cat(&string_cat);
-  BOOST_TEST(cat("str", "ing") == "string");
-
-  function2<int, short, short> sum(&sum_ints);
-  BOOST_TEST(sum(2, 3) == 5);
-}
-
-static void
-test_emptiness()
-{
-  function0<float> f1;
-  BOOST_TEST(f1.empty());
-
-  function0<float> f2;
-  f2 = f1;
-  BOOST_TEST(f2.empty());
-
-  function0<double> f3;
-  f3 = f2;
-  BOOST_TEST(f3.empty());
-}
-
-struct X {
-  X(int v) : value(v) {}
-
-  int twice() const { return 2*value; }
-  int plus(int v) { return value + v; }
-
-  int value;
-};
-
-static void
-test_member_functions()
-{
-
-  boost::function1<int, X*> f1(&X::twice);
-
-  X one(1);
-  X five(5);
-
-  BOOST_TEST(f1(&one) == 2);
-  BOOST_TEST(f1(&five) == 10);
-
-  boost::function1<int, X*> f1_2;
-  f1_2 = &X::twice;
-
-  BOOST_TEST(f1_2(&one) == 2);
-  BOOST_TEST(f1_2(&five) == 10);
-
-  boost::function2<int, X&, int> f2(&X::plus);
-  BOOST_TEST(f2(one, 3) == 4);
-  BOOST_TEST(f2(five, 4) == 9);
-}
-
-struct add_with_throw_on_copy {
-  int operator()(int x, int y) const { return x+y; }
-
-  add_with_throw_on_copy() {}
-
-  add_with_throw_on_copy(const add_with_throw_on_copy&)
-  {
-    throw std::runtime_error("But this CAN'T throw");
-  }
-
-  add_with_throw_on_copy& operator=(const add_with_throw_on_copy&)
-  {
-    throw std::runtime_error("But this CAN'T throw");
-  }
-};
-
-static void
-test_ref()
-{
-  add_with_throw_on_copy atc;
-  try {
-    boost::function2<int, int, int> f(ref(atc));
-    BOOST_TEST(f(1, 3) == 4);
-  }
-  catch(std::runtime_error e) {
-    BOOST_ERROR("Nonthrowing constructor threw an exception");
-  }
-}
-
-int test_main(int, char* [])
-{
-  test_zero_args();
-  test_one_arg();
-  test_two_args();
-  test_emptiness();
-  test_member_functions();
-  test_ref();
-  return 0;
-}
--- a/test/function_ref_cxx98.cpp
+++ b/test/function_ref_cxx98.cpp
@ -1,31 +0,0 @@
-// Function library
-
-// Copyright (C) 2001-2003 Douglas Gregor
-
-// Permission to copy, use, sell and distribute this software is granted 
-// provided this copyright notice appears in all copies. Permission to modify 
-// the code and to distribute modified code is granted provided this copyright 
-// notice appears in all copies, and a notice that the code was modified is 
-// included with the copyright notice. This software is provided "as is" 
-// without express or implied warranty, and with no claim as to its 
-// suitability for any purpose. 
-
-// For more information, see http://www.boost.org/
-
-
-#include <boost/function.hpp>
-#include <iostream>
-
-
-struct stateful_type { int operator()(int) const { return 0; } };
-
-int main()
-{
-    stateful_type a_function_object;
-  boost::function<int (int)> f;
-  f = boost::ref(a_function_object);
-
-  boost::function<int (int)> f2(f);
-
-    return 0;
-}
--- a/test/function_ref_portable.cpp
+++ b/test/function_ref_portable.cpp
@ -1,31 +0,0 @@
-// Function library
-
-// Copyright (C) 2001-2003 Douglas Gregor
-
-// Permission to copy, use, sell and distribute this software is granted 
-// provided this copyright notice appears in all copies. Permission to modify 
-// the code and to distribute modified code is granted provided this copyright 
-// notice appears in all copies, and a notice that the code was modified is 
-// included with the copyright notice. This software is provided "as is" 
-// without express or implied warranty, and with no claim as to its 
-// suitability for any purpose. 
-
-// For more information, see http://www.boost.org/
-
-
-#include <boost/function.hpp>
-#include <iostream>
-
-
-struct stateful_type { int operator()(int) const { return 0; } };
-
-int main()
-{
-    stateful_type a_function_object;
-  boost::function1<int, int> f;
-  f = boost::ref(a_function_object);
-
-  boost::function1<int, int> f2(f);
-
-    return 0;
-}
--- a/test/function_test.cpp
+++ b/test/function_test.cpp
@ -1,754 +0,0 @@
-// Boost.Function library
-
-// Copyright (C) 2001, 2002 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-#include <boost/test/minimal.hpp>
-#include <boost/function.hpp>
-#include <functional>
-#include <cassert>
-#include <string>
-#include <utility>
-
-using namespace boost;
-using namespace std;
-
-int global_int;
-
-struct write_five_obj { void operator()() const { global_int = 5; } };
-struct write_three_obj { int operator()() const { global_int = 3; return 7; }};
-static void write_five() { global_int = 5; }
-static void write_three() { global_int = 3; }
-struct generate_five_obj { int operator()() const { return 5; } };
-struct generate_three_obj { int operator()() const { return 3; } };
-static int generate_five() { return 5; }
-static int generate_three() { return 3; }
-static string identity_str(const string& s) { return s; }
-static string string_cat(const string& s1, const string& s2) { return s1+s2; }
-static int sum_ints(int x, int y) { return x+y; }
-
-struct write_const_1_nonconst_2
-{
-  void operator()() { global_int = 2; }
-  void operator()() const { global_int = 1; }
-};
-
-struct add_to_obj
-{
-  add_to_obj(int v) : value(v) {}
-
-  int operator()(int x) const { return value + x; }
-
-  int value;
-};
-
-static void
-test_zero_args()
-{
-  typedef function<void ()> func_void_type;
-
-  write_five_obj five;
-  write_three_obj three;
-
-  // Default construction
-  func_void_type v1;
-  BOOST_TEST(v1.empty());
-
-  // Assignment to an empty function
-  v1 = five;
-  BOOST_TEST(v1 != 0);
-
-  // Invocation of a function
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 5);
-
-  // clear() method
-  v1.clear();
-  BOOST_TEST(v1 == 0);
-
-  // Assignment to an empty function
-  v1 = three;
-  BOOST_TEST(!v1.empty());
-
-  // Invocation and self-assignment
-  global_int = 0;
-  v1 = v1;
-  v1();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a non-empty function
-  v1 = five;
-
-  // Invocation and self-assignment
-  global_int = 0;
-  v1 = (v1);
-  v1();
-  BOOST_TEST(global_int == 5);
-
-  // clear
-  v1 = 0;
-  BOOST_TEST(0 == v1);
-
-  // Assignment to an empty function from a free function
-  v1 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
-  BOOST_TEST(0 != v1);
-
-  // Invocation
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v1 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
-  BOOST_TEST(!v1.empty());
-
-  // Invocation
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment
-  v1 = five;
-  BOOST_TEST(!v1.empty());
-
-  // Invocation
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v1 = &write_three;
-  BOOST_TEST(!v1.empty());
-
-  // Invocation
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 3);
-
-  // Construction from another function (that is empty)
-  v1.clear();
-  func_void_type v2(v1);
-  BOOST_TEST(!v2? true : false);
-
-  // Assignment to an empty function
-  v2 = three;
-  BOOST_TEST(!v2.empty());
-
-  // Invocation
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a non-empty function
-  v2 = (five);
-
-  // Invocation
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 5);
-
-  v2.clear();
-  BOOST_TEST(v2.empty());
-
-  // Assignment to an empty function from a free function
-  v2 = (BOOST_FUNCTION_TARGET_FIX(&) write_five);
-  BOOST_TEST(v2? true : false);
-
-  // Invocation
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v2 = BOOST_FUNCTION_TARGET_FIX(&) write_three;
-  BOOST_TEST(!v2.empty());
-
-  // Invocation
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 3);
-
-  // Swapping
-  v1 = five;
-  swap(v1, v2);
-  v2();
-  BOOST_TEST(global_int == 5);
-  v1();
-  BOOST_TEST(global_int == 3);
-  swap(v1, v2);
-  v1.clear();
-
-  // Assignment
-  v2 = five;
-  BOOST_TEST(!v2.empty());
-
-  // Invocation
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v2 = &write_three;
-  BOOST_TEST(!v2.empty());
-
-  // Invocation
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a function from an empty function
-  v2 = v1;
-  BOOST_TEST(v2.empty());
-
-  // Assignment to a function from a function with a functor
-  v1 = three;
-  v2 = v1;
-  BOOST_TEST(!v1.empty());
-  BOOST_TEST(!v2.empty());
-
-  // Invocation
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 3);
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 3);
-
-  // Assign to a function from a function with a function
-  v2 = BOOST_FUNCTION_TARGET_FIX(&) write_five;
-  v1 = v2;
-  BOOST_TEST(!v1.empty());
-  BOOST_TEST(!v2.empty());
-  global_int = 0;
-  v1();
-  BOOST_TEST(global_int == 5);
-  global_int = 0;
-  v2();
-  BOOST_TEST(global_int == 5);
-
-  // Construct a function given another function containing a function
-  func_void_type v3(v1);
-
-  // Invocation of a function
-  global_int = 0;
-  v3();
-  BOOST_TEST(global_int == 5);
-
-  // clear() method
-  v3.clear();
-  BOOST_TEST(!v3? true : false);
-
-  // Assignment to an empty function
-  v3 = three;
-  BOOST_TEST(!v3.empty());
-
-  // Invocation
-  global_int = 0;
-  v3();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a non-empty function
-  v3 = five;
-
-  // Invocation
-  global_int = 0;
-  v3();
-  BOOST_TEST(global_int == 5);
-
-  // clear()
-  v3.clear();
-  BOOST_TEST(v3.empty());
-
-  // Assignment to an empty function from a free function
-  v3 = &write_five;
-  BOOST_TEST(!v3.empty());
-
-  // Invocation
-  global_int = 0;
-  v3();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v3 = &write_three;
-  BOOST_TEST(!v3.empty());
-
-  // Invocation
-  global_int = 0;
-  v3();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment
-  v3 = five;
-  BOOST_TEST(!v3.empty());
-
-  // Invocation
-  global_int = 0;
-  v3();
-  BOOST_TEST(global_int == 5);
-
-  // Construction of a function from a function containing a functor
-  func_void_type v4(v3);
-
-  // Invocation of a function
-  global_int = 0;
-  v4();
-  BOOST_TEST(global_int == 5);
-
-  // clear() method
-  v4.clear();
-  BOOST_TEST(v4.empty());
-
-  // Assignment to an empty function
-  v4 = three;
-  BOOST_TEST(!v4.empty());
-
-  // Invocation
-  global_int = 0;
-  v4();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a non-empty function
-  v4 = five;
-
-  // Invocation
-  global_int = 0;
-  v4();
-  BOOST_TEST(global_int == 5);
-
-  // clear()
-  v4.clear();
-  BOOST_TEST(v4.empty());
-
-  // Assignment to an empty function from a free function
-  v4 = &write_five;
-  BOOST_TEST(!v4.empty());
-
-  // Invocation
-  global_int = 0;
-  v4();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v4 = &write_three;
-  BOOST_TEST(!v4.empty());
-
-  // Invocation
-  global_int = 0;
-  v4();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment
-  v4 = five;
-  BOOST_TEST(!v4.empty());
-
-  // Invocation
-  global_int = 0;
-  v4();
-  BOOST_TEST(global_int == 5);
-
-  // Construction of a function from a functor
-  func_void_type v5(five);
-
-  // Invocation of a function
-  global_int = 0;
-  v5();
-  BOOST_TEST(global_int == 5);
-
-  // clear() method
-  v5.clear();
-  BOOST_TEST(v5.empty());
-
-  // Assignment to an empty function
-  v5 = three;
-  BOOST_TEST(!v5.empty());
-
-  // Invocation
-  global_int = 0;
-  v5();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a non-empty function
-  v5 = five;
-
-  // Invocation
-  global_int = 0;
-  v5();
-  BOOST_TEST(global_int == 5);
-
-  // clear()
-  v5.clear();
-  BOOST_TEST(v5.empty());
-
-  // Assignment to an empty function from a free function
-  v5 = &write_five;
-  BOOST_TEST(!v5.empty());
-
-  // Invocation
-  global_int = 0;
-  v5();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v5 = &write_three;
-  BOOST_TEST(!v5.empty());
-
-  // Invocation
-  global_int = 0;
-  v5();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment
-  v5 = five;
-  BOOST_TEST(!v5.empty());
-
-  // Invocation
-  global_int = 0;
-  v5();
-  BOOST_TEST(global_int == 5);
-
-  // Construction of a function from a function
-  func_void_type v6(&write_five);
-
-  // Invocation of a function
-  global_int = 0;
-  v6();
-  BOOST_TEST(global_int == 5);
-
-  // clear() method
-  v6.clear();
-  BOOST_TEST(v6.empty());
-
-  // Assignment to an empty function
-  v6 = three;
-  BOOST_TEST(!v6.empty());
-
-  // Invocation
-  global_int = 0;
-  v6();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment to a non-empty function
-  v6 = five;
-
-  // Invocation
-  global_int = 0;
-  v6();
-  BOOST_TEST(global_int == 5);
-
-  // clear()
-  v6.clear();
-  BOOST_TEST(v6.empty());
-
-  // Assignment to an empty function from a free function
-  v6 = &write_five;
-  BOOST_TEST(!v6.empty());
-
-  // Invocation
-  global_int = 0;
-  v6();
-  BOOST_TEST(global_int == 5);
-
-  // Assignment to a non-empty function from a free function
-  v6 = &write_three;
-  BOOST_TEST(!v6.empty());
-
-  // Invocation
-  global_int = 0;
-  v6();
-  BOOST_TEST(global_int == 3);
-
-  // Assignment
-  v6 = five;
-  BOOST_TEST(!v6.empty());
-
-  // Invocation
-  global_int = 0;
-  v6();
-  BOOST_TEST(global_int == 5);
-
-  // Const vs. non-const
-  write_const_1_nonconst_2 one_or_two;
-  const function<void ()> v7(one_or_two);
-  function<void ()> v8(one_or_two);
-
-  global_int = 0;
-  v7();
-  BOOST_TEST(global_int == 2);
-
-  global_int = 0;
-  v8();
-  BOOST_TEST(global_int == 2);
-
-  // Test construction from 0 and comparison to 0
-  func_void_type v9(0);
-  BOOST_TEST(v9 == 0);
-  BOOST_TEST(0 == v9);
-
-  // Test return values
-  typedef function<int ()> func_int_type;
-  generate_five_obj gen_five;
-  generate_three_obj gen_three;
-
-  func_int_type i0(gen_five);
-
-  BOOST_TEST(i0() == 5);
-  i0 = gen_three;
-  BOOST_TEST(i0() == 3);
-  i0 = &generate_five;
-  BOOST_TEST(i0() == 5);
-  i0 = &generate_three;
-  BOOST_TEST(i0() == 3);
-  BOOST_TEST(i0? true : false);
-  i0.clear();
-  BOOST_TEST(!i0? true : false);
-
-  // Test return values with compatible types
-  typedef function<long ()> func_long_type;
-  func_long_type i1(gen_five);
-
-  BOOST_TEST(i1() == 5);
-  i1 = gen_three;
-  BOOST_TEST(i1() == 3);
-  i1 = &generate_five;
-  BOOST_TEST(i1() == 5);
-  i1 = &generate_three;
-  BOOST_TEST(i1() == 3);
-  BOOST_TEST(i1? true : false);
-  i1.clear();
-  BOOST_TEST(!i1? true : false);
-}
-
-static void
-test_one_arg()
-{
-  negate<int> neg;
-
-  function<int (int)> f1(neg);
-  BOOST_TEST(f1(5) == -5);
-
-  function<string (string)> id(&identity_str);
-  BOOST_TEST(id("str") == "str");
-
-  function<string (const char*)> id2(&identity_str);
-  BOOST_TEST(id2("foo") == "foo");
-
-  add_to_obj add_to(5);
-  function<int (int)> f2(add_to);
-  BOOST_TEST(f2(3) == 8);
-
-  const function<int (int)> cf2(add_to);
-  BOOST_TEST(cf2(3) == 8);
-}
-
-static void
-test_two_args()
-{
-  function<string (const string&, const string&)> cat(&string_cat);
-  BOOST_TEST(cat("str", "ing") == "string");
-
-  function<int (short, short)> sum(&sum_ints);
-  BOOST_TEST(sum(2, 3) == 5);
-}
-
-static void
-test_emptiness()
-{
-  function<float ()> f1;
-  BOOST_TEST(f1.empty());
-
-  function<float ()> f2;
-  f2 = f1;
-  BOOST_TEST(f2.empty());
-
-  function<double ()> f3;
-  f3 = f2;
-  BOOST_TEST(f3.empty());
-}
-
-struct X {
-  X(int v) : value(v) {}
-
-  int twice() const { return 2*value; }
-  int plus(int v) { return value + v; }
-
-  int value;
-};
-
-static void
-test_member_functions()
-{
-  boost::function<int (X*)> f1(&X::twice);
-
-  X one(1);
-  X five(5);
-
-  BOOST_TEST(f1(&one) == 2);
-  BOOST_TEST(f1(&five) == 10);
-
-  boost::function<int (X*)> f1_2;
-  f1_2 = &X::twice;
-
-  BOOST_TEST(f1_2(&one) == 2);
-  BOOST_TEST(f1_2(&five) == 10);
-
-  boost::function<int (X&, int)> f2(&X::plus);
-  BOOST_TEST(f2(one, 3) == 4);
-  BOOST_TEST(f2(five, 4) == 9);
-}
-
-struct add_with_throw_on_copy {
-  int operator()(int x, int y) const { return x+y; }
-
-  add_with_throw_on_copy() {}
-
-  add_with_throw_on_copy(const add_with_throw_on_copy&)
-  {
-    throw 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");
-  }
-};
-
-static void
-test_ref()
-{
-  add_with_throw_on_copy atc;
-  try {
-    boost::function<int (int, int)> f(ref(atc));
-    BOOST_TEST(f(1, 3) == 4);
-  }
-  catch(runtime_error e) {
-    BOOST_ERROR("Nonthrowing constructor threw an exception");
-  }
-}
-
-static int alloc_count = 0;
-static int dealloc_count = 0;
-
-template<typename T>
-struct counting_allocator : public allocator<T>
-{
-  template<typename U>
-  struct rebind
-  {
-    typedef counting_allocator<U> other;
-  };
-
-
-  T* allocate(size_t n)
-  {
-    alloc_count++;
-    return allocator<T>::allocate(n);
-  }
-
-  void deallocate(T* p, size_t n)
-  {
-    dealloc_count++;
-    allocator<T>::deallocate(p, n);
-  }
-};
-
-static int do_minus(int x, int y) { return x-y; }
-
-struct DoNothing
-{
-  void operator()() const {}
-};
-
-static void do_nothing() {}
-
-static void test_allocator()
-{
-#ifndef BOOST_NO_STD_ALLOCATOR
-  boost::function<int (int, int), counting_allocator<int> > f;
-  f = plus<int>();
-  f.clear();
-  BOOST_TEST(alloc_count == 1);
-  BOOST_TEST(dealloc_count == 1);
-
-  alloc_count = 0;
-  dealloc_count = 0;
-  f = &do_minus;
-  f.clear();
-
-  boost::function<void (), counting_allocator<int> > fv;
-  alloc_count = 0;
-  dealloc_count = 0;
-  fv = DoNothing();
-  fv.clear();
-  BOOST_TEST(alloc_count == 1);
-  BOOST_TEST(dealloc_count == 1);
-
-  alloc_count = 0;
-  dealloc_count = 0;
-  fv = &do_nothing;
-  fv.clear();
-#endif // ndef BOOST_NO_STD_ALLOCATOR
-}
-
-static void test_exception()
-{
-  boost::function<int (int, int)> f;
-  try {
-    f(5, 4);
-    BOOST_TEST(false);
-  }
-  catch(boost::bad_function_call) {
-    // okay
-  }
-}
-
-typedef boost::function< void * (void * reader) > reader_type;
-typedef std::pair<int, reader_type> mapped_type;
-
-static void test_implicit()
-{
-  mapped_type m;
-  m = mapped_type();
-}
-
-static void test_call_obj(boost::function<int (int, int)> f)
-{
-  assert(!f.empty());
-}
-
-static void test_call_cref(const boost::function<int (int, int)>& f)
-{
-  assert(!f.empty());
-}
-
-static void test_call()
-{
-  test_call_obj(std::plus<int>());
-  test_call_cref(std::plus<int>());
-}
-
-int test_main(int, char* [])
-{
-  test_zero_args();
-  test_one_arg();
-  test_two_args();
-  test_emptiness();
-  test_member_functions();
-  test_ref();
-  test_allocator();
-  test_exception();
-  test_implicit();
-  test_call();
-
-  return 0;
-}
--- a/test/function_test_fail1.cpp
+++ b/test/function_test_fail1.cpp
@ -1,35 +0,0 @@
-// Boost.Function library
-
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-#include <boost/function.hpp>
-
-using namespace std;
-using namespace boost;
-
-int
-test_main(int, char*[])
-{
-  function0<int> f1;
-  function0<int> f2;
-
-  if (f1 == f2) {
-  }
-
-  BOOST_CRITICAL_ERROR("This should not have compiled.");
-
-  return 0;
-}
--- a/test/function_test_fail2.cpp
+++ b/test/function_test_fail2.cpp
@ -1,34 +0,0 @@
-// Boost.Function library
-
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-#include <boost/function.hpp>
-
-using namespace std;
-using namespace boost;
-
-static int bad_fn(float f) { return static_cast<int>(f); }
-
-int
-test_main(int, char*[])
-{
-  function0<int> f1;
-  f1 = bad_fn;
-
-  BOOST_CRITICAL_ERROR("This should not have compiled.");
-
-  return 0;
-}
--- a/test/lambda_test.cpp
+++ b/test/lambda_test.cpp
@ -1,44 +0,0 @@
-// Boost.Function library
-
-// Copyright (C) 2002-2003 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-#include <iostream>
-#include <cstdlib>
-
-#include <boost/test/test_tools.hpp>
-#include <boost/lambda/lambda.hpp>
-#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)
-{
-  return abs (static_cast<int>((arg2 ? arg1 : 2 * arg1) * arg3));
-}
-
-int test_main(int, char*[])
-{
-  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);
-
-  f3();
-
-  return 0;
-}
-
--- a/test/mem_fun_cxx98.cpp
+++ b/test/mem_fun_cxx98.cpp
@ -1,35 +0,0 @@
-// Function library
-
-// Copyright (C) 2001-2003 Douglas Gregor
-
-// Permission to copy, use, sell and distribute this software is granted 
-// provided this copyright notice appears in all copies. Permission to modify 
-// the code and to distribute modified code is granted provided this copyright 
-// notice appears in all copies, and a notice that the code was modified is 
-// included with the copyright notice. This software is provided "as is" 
-// without express or implied warranty, and with no claim as to its 
-// suitability for any purpose. 
-
-// For more information, see http://www.boost.org/
-
-    
-#include <boost/function.hpp>
-#include <iostream>
-#include <functional>
-
-struct X {
-  int foo(int);
-};
-int X::foo(int x) { return -x; }
-
-int main()
-{
-    boost::function<int (X*, int)> f;
-
-f = &X::foo;
-  
-X x;
-f(&x, 5);
-
-    return 0;
-}
--- a/test/mem_fun_portable.cpp
+++ b/test/mem_fun_portable.cpp
@ -1,35 +0,0 @@
-// Function library
-
-// Copyright (C) 2001-2003 Douglas Gregor
-
-// Permission to copy, use, sell and distribute this software is granted 
-// provided this copyright notice appears in all copies. Permission to modify 
-// the code and to distribute modified code is granted provided this copyright 
-// notice appears in all copies, and a notice that the code was modified is 
-// included with the copyright notice. This software is provided "as is" 
-// without express or implied warranty, and with no claim as to its 
-// suitability for any purpose. 
-
-// For more information, see http://www.boost.org/
-
-    
-#include <boost/function.hpp>
-#include <iostream>
-#include <functional>
-
-struct X {
-  int foo(int);
-};
-int X::foo(int x) { return -x; }
-
-int main()
-{
-    boost::function2<int, X*, int> f;
-
-f = &X::foo;
-  
-X x;
-f(&x, 5);
-
-    return 0;
-}
--- a/test/regression.cfg
+++ b/test/regression.cfg
@ -1,14 +0,0 @@
-// Boost.Function regression test configuration file
-
-// From the boost/status directory, run
-// ./regression --tests ../libs/function/test/regression.cfg -o function.html
-
-
-run libs/function/test/allocator_test.cpp
-run libs/function/test/function_n_test.cpp
-run libs/function/test/function_test.cpp
-compile-fail libs/function/test/function_test_fail1.cpp
-compile-fail libs/function/test/function_test_fail2.cpp
-run libs/function/test/mixin_test.cpp
-run libs/function/test/policy_test.cpp
-run libs/function/test/stateless_test.cpp
--- a/test/stateless_test.cpp
+++ b/test/stateless_test.cpp
@ -1,48 +0,0 @@
-// Boost.Function library
-
-// Copyright (C) 2001 Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to copy, use, sell and distribute this software is granted
-// provided this copyright notice appears in all copies.
-// Permission to modify the code and to distribute modified code is granted
-// provided this copyright notice appears in all copies, and a notice
-// that the code was modified is included with the copyright notice.
-//
-// This software is provided "as is" without express or implied warranty,
-// and with no claim as to its suitability for any purpose.
-
-// For more information, see http://www.boost.org
-
-#define BOOST_INCLUDE_MAIN
-#include <boost/test/test_tools.hpp>
-#include <boost/function.hpp>
-#include <stdexcept>
-
-struct stateless_integer_add {
-  int operator()(int x, int y) const { return x+y; }
-
-  void* operator new(std::size_t, stateless_integer_add*)
-  {
-    throw std::runtime_error("Cannot allocate a stateless_integer_add");
-    return 0; // suppress warnings
-  }
-
-  void operator delete(void*, stateless_integer_add*) throw()
-  {
-  }
-};
-
-namespace boost {
-  template<>
-  struct is_stateless<stateless_integer_add> {
-    BOOST_STATIC_CONSTANT(bool, value = true);
-  };
-}
-
-int test_main(int, char*[])
-{
-  boost::function2<int, int, int> f;
-  f = stateless_integer_add();
-
-  return 0;
-}
--- a/test/std_bind_cxx98.cpp
+++ b/test/std_bind_cxx98.cpp
@ -1,34 +0,0 @@
-// Function library
-
-// Copyright (C) 2001-2003 Douglas Gregor
-
-// Permission to copy, use, sell and distribute this software is granted 
-// provided this copyright notice appears in all copies. Permission to modify 
-// the code and to distribute modified code is granted provided this copyright 
-// notice appears in all copies, and a notice that the code was modified is 
-// included with the copyright notice. This software is provided "as is" 
-// without express or implied warranty, and with no claim as to its 
-// suitability for any purpose. 
-
-// For more information, see http://www.boost.org/
-
-    
-#include <boost/function.hpp>
-#include <iostream>
-#include <functional>
-
-struct X {
-  int foo(int);
-};
-int X::foo(int x) { return -x; }
-
-int main()
-{
-      boost::function<int (int)> f;
-  X x;
-  f = std::bind1st(
-        std::mem_fun(&X::foo), &x);
-  f(5); // Call x.foo(5)
-
-    return 0;
-}
--- a/test/std_bind_portable.cpp
+++ b/test/std_bind_portable.cpp
@ -1,34 +0,0 @@
-// Function library
-
-// Copyright (C) 2001-2003 Douglas Gregor
-
-// Permission to copy, use, sell and distribute this software is granted 
-// provided this copyright notice appears in all copies. Permission to modify 
-// the code and to distribute modified code is granted provided this copyright 
-// notice appears in all copies, and a notice that the code was modified is 
-// included with the copyright notice. This software is provided "as is" 
-// without express or implied warranty, and with no claim as to its 
-// suitability for any purpose. 
-
-// For more information, see http://www.boost.org/
-
-    
-#include <boost/function.hpp>
-#include <iostream>
-#include <functional>
-
-struct X {
-  int foo(int);
-};
-int X::foo(int x) { return -x; }
-
-int main()
-{
-      boost::function1<int, int> f;
-  X x;
-  f = std::bind1st(
-        std::mem_fun(&X::foo), &x);
-  f(5); // Call x.foo(5)
-
-    return 0;
-}
--- a/test/sum_avg_cxx98.cpp
+++ b/test/sum_avg_cxx98.cpp
@ -1,32 +0,0 @@
-// Function library
-
-// Copyright (C) 2001-2003 Douglas Gregor
-
-// Permission to copy, use, sell and distribute this software is granted 
-// provided this copyright notice appears in all copies. Permission to modify 
-// the code and to distribute modified code is granted provided this copyright 
-// notice appears in all copies, and a notice that the code was modified is 
-// included with the copyright notice. This software is provided "as is" 
-// without express or implied warranty, and with no claim as to its 
-// suitability for any purpose. 
-
-// For more information, see http://www.boost.org/
-
-    
-#include <boost/function.hpp>
-#include <iostream>
-
-void do_sum_avg(int values[], int n, int& sum, float& avg)
-{
-  sum = 0;
-  for (int i = 0; i < n; i++)
-    sum += values[i];
-  avg = (float)sum / n;
-}
-int main()
-{
-    boost::function<void (int values[], int n, int& sum, float& avg)> sum_avg;
-    sum_avg = &do_sum_avg;
-
-    return 0;
-}
--- a/test/sum_avg_portable.cpp
+++ b/test/sum_avg_portable.cpp
@ -1,32 +0,0 @@
-// Function library
-
-// Copyright (C) 2001-2003 Douglas Gregor
-
-// Permission to copy, use, sell and distribute this software is granted 
-// provided this copyright notice appears in all copies. Permission to modify 
-// the code and to distribute modified code is granted provided this copyright 
-// notice appears in all copies, and a notice that the code was modified is 
-// included with the copyright notice. This software is provided "as is" 
-// without express or implied warranty, and with no claim as to its 
-// suitability for any purpose. 
-
-// For more information, see http://www.boost.org/
-
-    
-#include <boost/function.hpp>
-#include <iostream>
-
-void do_sum_avg(int values[], int n, int& sum, float& avg)
-{
-  sum = 0;
-  for (int i = 0; i < n; i++)
-    sum += values[i];
-  avg = (float)sum / n;
-}
-int main()
-{
-    boost::function4<void, int[], int, int&, float> sum_avg;
-    sum_avg = &do_sum_avg;
-
-    return 0;
-}
Author	SHA1	Message	Date
nobody	955cf95601	This commit was manufactured by cvs2svn to create branch 'SPIRIT_1_6'. [SVN r23968]	2004-07-23 02:16:28 +00:00
Douglas Gregor	e4f632e5ca	function_template.hpp: Move definition of operator() out-of-line for any compiler that isn't VC++ 6.0 (Vladimir Prus) [SVN r23436]	2004-07-11 03:09:35 +00:00
Douglas Gregor	5b4dc38727	boost/function/function_base.hpp: - Work around a GCC <= 3.3 bug where the return type of a function template that cannot possibly match is instantiated when it should not be, causing errors in the use of operator==. This results in slightly reduced functionality. libs/function/test/contains_test.cpp: - Don't test that which GCC cannot now handle [SVN r23170]	2004-06-23 16:00:01 +00:00
Douglas Gregor	22fd23b00f	function_template.hpp, function_base.hpp: - Comparison operators are now written in terms of function_base so that implicit conversions to function<...> or functionN<...> don't allow arbitrary comparisons. [SVN r23126]	2004-06-20 05:32:28 +00:00
Vladimir Prus	d929aaf814	Update V2 Jamfile [SVN r23078]	2004-06-10 12:37:31 +00:00
Douglas Gregor	ae11f21513	Try to make IBM VisualAge C++ 6 happy [SVN r22795]	2004-05-12 00:39:00 +00:00
Douglas Gregor	dc14c35c38	function_base.hpp: - Fix silly typo where it returned "false" instead of the NULL pointer. [SVN r22760]	2004-05-07 11:43:41 +00:00
Douglas Gregor	1b27dc8f86	Fix some shadow warnings [SVN r22670]	2004-04-20 00:32:48 +00:00
Douglas Gregor	2c0e633307	Added contains() and function_equal() [SVN r22483]	2004-03-12 03:38:20 +00:00
Douglas Gregor	e80a00545c	Added FAQ entry from Matt Hurd about boost::function overhead. [SVN r22309]	2004-02-18 06:37:13 +00:00
Douglas Gregor	1a142a2f94	Fix on GCC 2.9x from Ralf [SVN r22249]	2004-02-12 22:48:22 +00:00
Douglas Gregor	f0c5e5e95b	Work around a GCC 2.95.3 bug triggered by the workaround to a VC++ 7.1 bug... [SVN r22242]	2004-02-11 18:16:55 +00:00
Douglas Gregor	2fb242eae1	Work around CLR bug in .NET 2003 [SVN r22234]	2004-02-11 04:26:53 +00:00
Douglas Gregor	03c7fdcf37	Fix the documentation of empty() (Angus Leeming) [SVN r22193]	2004-02-08 00:11:22 +00:00
Douglas Gregor	b7608dff24	type_info::operator== fixes (Peter Dimov) [SVN r22083]	2004-01-30 17:15:03 +00:00
Douglas Gregor	5f0426a80d	Stupid deprecated XInclude namespace [SVN r22013]	2004-01-28 01:31:00 +00:00
Douglas Gregor	fdb37c35ff	Some aesthetic tweaks [SVN r21905]	2004-01-25 01:17:35 +00:00
Douglas Gregor	b7650282df	tutorial.xml: Add short discussion of the comparison of Boost.Function objects to function objects. [SVN r21904]	2004-01-25 01:15:57 +00:00
Douglas Gregor	c5d8d03b76	libs/function/doc/reference.xml: - Document target() member function - Documented new comparison operators libs/function/doc/tests.xml: Include contains_test.cpp libs/function/doc/function.xml: Use the new XInclude name [SVN r21903]	2004-01-25 00:38:26 +00:00
Douglas Gregor	746676d274	Fix semantics for comparison against reference_wrappers [SVN r21901]	2004-01-24 23:31:40 +00:00
Douglas Gregor	c31ad8700e	Cast pointers, not lvalues [SVN r21897]	2004-01-24 18:29:18 +00:00
Douglas Gregor	cb1bcd5410	"contains" -> "target" [SVN r21845]	2004-01-20 18:07:13 +00:00
Douglas Gregor	7d30d98efd	boost/function/function_template.hpp, boost/function/function_base.hpp: - Added "contains" member function to extract a pointer to the target function object if you know its type - Added operator== that can compare a Boost.Function object against a function object libs/function/test/Jamfile, libs/function/test/contains_test.cpp: - Test contains() and equality comparison operators [SVN r21844]	2004-01-20 18:02:02 +00:00
Douglas Gregor	50ff886c81	MSVC 7.1 can handle Function, preferred syntax [SVN r21333]	2003-12-19 03:33:25 +00:00
Douglas Gregor	44e986afe3	Switch over to the new enable_if library [SVN r21143]	2003-12-04 22:31:09 +00:00
Douglas Gregor	4bb90aae7a	Metrowerks CodeWarrior 8.3 doesn't seem to support SFINAE [SVN r21141]	2003-12-04 22:06:56 +00:00
Douglas Gregor	04eb767238	Possible fix for Metrowerks [SVN r21126]	2003-12-03 19:55:57 +00:00
Douglas Gregor	8abd32bd81	Clean up warnings on Borland C++ 5.5 [SVN r21095]	2003-12-03 01:21:32 +00:00
Douglas Gregor	3f753feb4d	Use the "minimal" test tools, to simplify my life a bit [SVN r20924]	2003-11-23 16:17:24 +00:00
Douglas Gregor	b09e7f3d3d	Fix & regenerate sum_avg_portable.cpp [SVN r20402]	2003-10-17 16:25:51 +00:00
Douglas Gregor	2c708069e8	Answer the eternal operator== question. [SVN r20356]	2003-10-12 16:02:26 +00:00
Douglas Gregor	b8d943ec27	Move to the "new" function<> syntax. He he. [SVN r20320]	2003-10-09 05:00:38 +00:00
Douglas Gregor	8c8f072d09	Update license to the new Boost license (yay!) [SVN r20235]	2003-10-01 04:10:37 +00:00
Douglas Gregor	fad40732a9	function_template.hpp: Works around an annoying bug in one of Apple's 3.3 compilers. [SVN r20233]	2003-10-01 03:40:35 +00:00
Vladimir Prus	5314836215	Add V2 Jamfile [SVN r20210]	2003-09-29 16:09:15 +00:00
Douglas Gregor	66cd32b565	NULL pointers can be of any integral type, not just int (Howard Hinnant) [SVN r19989]	2003-09-10 04:16:17 +00:00
Dave Abrahams	043d0236a7	Use the import rule [SVN r19968]	2003-09-08 17:38:49 +00:00
Douglas Gregor	4b830024f3	Die, foo, die [SVN r19205]	2003-07-19 06:53:21 +00:00
Douglas Gregor	40c9bb204e	Me commit bad code [SVN r19195]	2003-07-18 16:18:16 +00:00
Douglas Gregor	5347683c8e	Remove return statement from operator new to see who screams about it [SVN r19178]	2003-07-18 04:17:30 +00:00
Douglas Gregor	1ef5f459e2	sig needs to be a friend of functionN [SVN r19174]	2003-07-18 03:48:17 +00:00
Douglas Gregor	cb3c1b0d1e	doc/tutorial.xml: fix a typo in the example code (thanks Jens!) test/sum_avg_portable.cpp: regenerated. [SVN r19136]	2003-07-16 04:40:25 +00:00
Douglas Gregor	1a6d95733a	Get rid of a warning in GCC 3.3. [SVN r19069]	2003-07-11 17:42:12 +00:00
Douglas Gregor	2c8fc1b31f	add macro BOOST_FUNCTION_NO_FUNCTION_TYPE_SYNTAX [SVN r19056]	2003-07-11 16:00:29 +00:00
Beman Dawes	fa73a61fcc	VC++ 7.1 has same bug as 7.0. Reported to Microsoft [SVN r18697]	2003-06-06 11:48:50 +00:00
Douglas Gregor	a753dbc048	Jamfile.v2: Jamfile for Boost.Function documentation [SVN r18244]	2003-04-13 14:51:26 +00:00
Douglas Gregor	ce00e49978	Newer Borland compiler still does not handle enable_if [SVN r18064]	2003-03-23 16:58:05 +00:00
Douglas Gregor	eeb15caff2	Document nested class template "sig" [SVN r17946]	2003-03-16 02:00:20 +00:00
Douglas Gregor	ade6c96d5c	Updated to reflect BoostBook changes [SVN r17941]	2003-03-15 23:12:35 +00:00
Douglas Gregor	b54e9df555	Lots of cleanups as BoostBook becomes more strict [SVN r17871]	2003-03-13 00:29:57 +00:00
Douglas Gregor	eb14b70c9c	Move away from attributes, toward elements [SVN r17869]	2003-03-13 00:08:34 +00:00
Douglas Gregor	48e2bc0bdb	Import of BoostBook documentation for any, array, bind, function, ref, and signals libraries. [SVN r17866]	2003-03-12 23:27:25 +00:00