This commit was manufactured by cvs2svn to create tag

'Version_1_28_0'.

[SVN r13949]

doc/tutorial.html

@@ -96,7 +96,7 @@ object. This is often referred to as "argument binding", and is beyond the scope
 
   f(5); // Call x.foo(5)</pre></li>
 
-  <li><a href="http://lambda.cs.utu.fi/">The Lambda library</a>. This library provides a powerful composition mechanism to construct function objects that uses very natural C++ syntax. Lambda requires a compiler that is reasonably conformant to the C++ standard. Note that it is not a Boost library.</li>
+  <li><a href="../../lambda/doc/index.html">The Boost.Lambda library</a>. This library provides a powerful composition mechanism to construct function objects that uses very natural C++ syntax. Lambda requires a compiler that is reasonably conformant to the C++ standard. </li>
 </ul>
 
 <h3>References to Functions</h3>
@@ -199,7 +199,7 @@ boost::function2&lt;float, int, int, SynchronizedPolicy, SynchronizedMixin&gt; f
     <address><a href="mailto:gregod@cs.rpi.edu">Douglas Gregor</a></address>
 <!-- Created: Fri Jul 13 12:47:11 EDT 2001 -->
 <!-- hhmts start -->
-Last modified: Fri Dec 14 19:58:14 EST 2001
+Last modified: Mon May 13 08:31:23 EDT 2002
 <!-- hhmts end -->
   </body>
 </html>

include/boost/function.hpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-// Copyright (C) 2001-2002 Doug Gregor (gregod@cs.rpi.edu)
+// 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.
@@ -53,12 +53,13 @@ namespace boost {
           typename T8,
           typename T9,
           typename T10,
-          typename ThreadingPolicy,
+          typename Policy,
+          typename Mixin,
           typename Allocator
         >
         struct params
         {
-          typedef function0<R, ThreadingPolicy, Allocator> type;
+          typedef function0<R, Policy, Mixin, Allocator> type;
         };
       };
 
@@ -77,12 +78,13 @@ namespace boost {
           typename T8,
           typename T9,
           typename T10,
-          typename ThreadingPolicy,
+          typename Policy,
+          typename Mixin,
           typename Allocator
         >
         struct params
         {
-          typedef function1<R, T1, ThreadingPolicy, Allocator> type;
+          typedef function1<R, T1, Policy, Mixin, Allocator> type;
         };
       };
 
@@ -101,12 +103,13 @@ namespace boost {
           typename T8,
           typename T9,
           typename T10,
-          typename ThreadingPolicy,
+          typename Policy,
+          typename Mixin,
           typename Allocator
         >
         struct params
         {
-          typedef function2<R, T1, T2, ThreadingPolicy, Allocator> type;
+          typedef function2<R, T1, T2, Policy, Mixin, Allocator> type;
         };
       };
 
@@ -125,12 +128,13 @@ namespace boost {
           typename T8,
           typename T9,
           typename T10,
-          typename ThreadingPolicy,
+          typename Policy,
+          typename Mixin,
           typename Allocator
         >
         struct params
         {
-          typedef function3<R, T1, T2, T3, ThreadingPolicy, Allocator> type;
+          typedef function3<R, T1, T2, T3, Policy, Mixin, Allocator> type;
         };
       };
 
@@ -149,12 +153,13 @@ namespace boost {
           typename T8,
           typename T9,
           typename T10,
-          typename ThreadingPolicy,
+          typename Policy,
+          typename Mixin,
           typename Allocator
         >
         struct params
         {
-          typedef function4<R, T1, T2, T3, T4, ThreadingPolicy, Allocator> type;
+          typedef function4<R, T1, T2, T3, T4, Policy, Mixin, Allocator> type;
         };
       };
 
@@ -173,12 +178,13 @@ namespace boost {
           typename T8,
           typename T9,
           typename T10,
-          typename ThreadingPolicy,
+          typename Policy,
+          typename Mixin,
           typename Allocator
         >
         struct params
         {
-          typedef function5<R, T1, T2, T3, T4, T5, ThreadingPolicy, Allocator> 
+          typedef function5<R, T1, T2, T3, T4, T5, Policy, Mixin, Allocator> 
           type;
         };
       };
@@ -198,12 +204,13 @@ namespace boost {
           typename T8,
           typename T9,
           typename T10,
-          typename ThreadingPolicy,
+          typename Policy,
+          typename Mixin,
           typename Allocator
         >
         struct params
         {
-          typedef function6<R, T1, T2, T3, T4, T5, T6, ThreadingPolicy, Allocator>
+          typedef function6<R, T1, T2, T3, T4, T5, T6, Policy, Mixin, Allocator>
           type;
         };
       };
@@ -223,12 +230,13 @@ namespace boost {
           typename T8,
           typename T9,
           typename T10,
-          typename ThreadingPolicy,
+          typename Policy,
+          typename Mixin,
           typename Allocator
         >
         struct params
         {
-          typedef function7<R, T1, T2, T3, T4, T5, T6, T7, ThreadingPolicy, 
+          typedef function7<R, T1, T2, T3, T4, T5, T6, T7, Policy, Mixin, 
                             Allocator> type;
         };
       };
@@ -248,12 +256,13 @@ namespace boost {
           typename T8,
           typename T9,
           typename T10,
-          typename ThreadingPolicy,
+          typename Policy,
+          typename Mixin,
           typename Allocator
         >
         struct params
         {
-          typedef function8<R, T1, T2, T3, T4, T5, T6, T7, T8, ThreadingPolicy, 
+          typedef function8<R, T1, T2, T3, T4, T5, T6, T7, T8, Policy, Mixin, 
                             Allocator> type;
         };
       };
@@ -273,13 +282,14 @@ namespace boost {
           typename T8,
           typename T9,
           typename T10,
-          typename ThreadingPolicy,
+          typename Policy,
+          typename Mixin,
           typename Allocator
         >
         struct params
         {
-          typedef function9<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, 
+          typedef function9<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, Policy, 
-                            ThreadingPolicy, Allocator> type;
+                            Mixin, Allocator> type;
         };
       };
 
@@ -298,13 +308,14 @@ namespace boost {
           typename T8,
           typename T9,
           typename T10,
-          typename ThreadingPolicy,
+          typename Policy,
+          typename Mixin,
           typename Allocator
         >
         struct params
         {
           typedef function10<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, 
-                             ThreadingPolicy, Allocator> type;
+                             Policy, Mixin, Allocator> type;
         };
       };
 
@@ -320,15 +331,16 @@ namespace boost {
         typename T8, 
         typename T9,
         typename T10,
-        typename ThreadingPolicy = BOOST_FUNCTION_DEFAULT_THREADING_POLICY,
+        typename Policy = empty_function_policy,
-        typename Allocator = BOOST_FUNCTION_DEFAULT_ALLOCATOR 
+        typename Mixin = empty_function_mixin,
+        typename Allocator = std::allocator<function_base> 
       >
       struct get_function_impl
       {
         typedef typename real_get_function_impl<
           (count_used_args<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>::value)
           >::template params<R, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, 
-                             ThreadingPolicy, Allocator>::type
+                             Policy, Mixin, Allocator>::type
         type;
       };
 
@@ -344,37 +356,55 @@ namespace boost {
     typename T8, 
     typename T9,
     typename T10,
-    typename MyThreadingPolicy = BOOST_FUNCTION_DEFAULT_THREADING_POLICY,
+    typename MyPolicy = empty_function_policy,
-    typename MyAllocator = BOOST_FUNCTION_DEFAULT_ALLOCATOR 
+    typename MyMixin = empty_function_mixin,
+    typename MyAllocator = std::allocator<function_base> 
   >
   struct function_traits_builder
   {
     typedef typename get_function_impl<R, T1, T2, T3, T4, T5, T6, T7, 
-                                       T8, T9, T10, MyThreadingPolicy,
+                                       T8, T9, T10, MyPolicy, MyMixin, 
                                        MyAllocator>::type
       type;
 
-    typedef MyThreadingPolicy threading_policy_type;
+    typedef MyPolicy    policy_type;
+    typedef MyMixin     mixin_type;
     typedef MyAllocator allocator_type;
 
 #ifndef BOOST_NO_DEPENDENT_NESTED_DERIVATIONS
-    template<typename ThreadingPolicy>
+    template<typename Policy>
-    struct threading_policy : 
+    struct policy : 
         public function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7, T8, T9,
-                                       T10, ThreadingPolicy,
+                                       T10, Policy, mixin_type, 
+                                       allocator_type> {};
+
+    template<typename Mixin>
+    struct mixin : 
+        public function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7, T8, T9,
+                                       T10, policy_type, Mixin, 
                                        allocator_type> {};
 
     template<typename Allocator>
     struct allocator : 
         public function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7, T8, T9,
-                                       T10, threading_policy_type,
+                                       T10, policy_type, mixin_type, 
                                        Allocator> {};
 #else
-    template<typename ThreadingPolicy>
+    template<typename Policy>
-    struct threading_policy 
+    struct policy 
     {
       typedef typename function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7,
-                                               T8, T9, T10, ThreadingPolicy, 
+                                               T8, T9, T10, Policy, 
+                                               mixin_type, 
+                                               allocator_type>::type
+        type;
+    };
+
+    template<typename Mixin>
+    struct mixin
+    {
+      typedef typename function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7,
+                                               T8, T9, T10, policy_type, Mixin,
                                                allocator_type>::type
         type;
     };
@@ -383,9 +413,8 @@ namespace boost {
     struct allocator
     {
       typedef typename function_traits_builder<R, T1, T2, T3, T4, T5, T6, T7,
-                                               T8, T9, T10, 
+                                               T8, T9, T10, policy_type, 
-                                               threading_policy_type, 
+                                               mixin_type, Allocator>::type
-                                               Allocator>::type
         type;
     };
 #endif
@@ -419,7 +448,8 @@ namespace boost {
       base_type;
 
   public:
-    typedef typename base_type::threading_policy_type policy_type;
+    typedef typename base_type::policy_type policy_type;
+    typedef typename base_type::mixin_type mixin_type;
     typedef typename base_type::allocator_type allocator_type;              
     typedef function self_type;                                     
                                                                             
@@ -433,21 +463,37 @@ namespace boost {
     template<typename Functor>
     self_type& operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
     {
-      base_type::operator=(f);
+      self_type(f).swap(*this);
       return *this;
     }
 
     self_type& operator=(const base_type& f)
     {
-      base_type::operator=(f);
+      self_type(f).swap(*this);
       return *this;
     }
 
     self_type& operator=(const self_type& f)
     {   
-      base_type::operator=(static_cast<const base_type&>(f));
+      self_type(f).swap(*this);
       return *this;
     }
+
+    template<typename Functor>
+    void set(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
+    {
+      self_type(f).swap(*this);
+    }
+
+    void set(const base_type& f)
+    {
+      self_type(f).swap(*this);
+    }
+
+    void set(const self_type& f)                             
+    {
+      self_type(f).swap(*this);
+    }   
   };
 
   template<typename R,

include/boost/function/function_base.hpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-// Copyright (C) 2001-2002 Doug Gregor (gregod@cs.rpi.edu)
+// 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.
@@ -24,8 +24,6 @@
 #include <boost/config.hpp>
 #include <boost/type_traits.hpp>
 #include <boost/ref.hpp>
-#include <boost/function/threading/single.hpp>
-#include <boost/pending/ct_if.hpp>
 
 #if defined(BOOST_MSVC) && BOOST_MSVC <= 1300 || defined(__ICL) && __ICL <= 600 || defined(__MWERKS__) && __MWERKS__ < 0x2406
 #  define BOOST_FUNCTION_TARGET_FIX(x) x
@@ -33,22 +31,54 @@
 #  define BOOST_FUNCTION_TARGET_FIX(x)
 #endif // not MSVC
 
-#ifndef BOOST_FUNCTION_DEFAULT_THREADING_POLICY
-#  define BOOST_FUNCTION_DEFAULT_THREADING_POLICY single_threaded
-#endif
-
-// Type of the default allocator
-#ifndef BOOST_NO_STD_ALLOCATOR
-#  define BOOST_FUNCTION_DEFAULT_ALLOCATOR std::allocator<function_base>
-#else
-#  define BOOST_FUNCTION_DEFAULT_ALLOCATOR int
-#endif // BOOST_NO_STD_ALLOCATOR
-
 namespace boost {
   namespace detail {
     namespace function {
       template<bool> struct truth {};
 
+      /*
+       * The ct_if implementation is temporary code. When a Boost metaprogramming
+       * library is introduced, Boost.Function will use it instead. 
+       */
+      namespace intimate {
+        struct SelectThen 
+        {       
+          template<typename Then, typename Else>
+          struct Result
+          {       
+            typedef Then type;
+          };
+        };
+ 
+        struct SelectElse
+        {
+          template<typename Then, typename Else>
+          struct Result
+          { 
+            typedef Else type;
+          };
+        };
+ 
+        template<bool Condition>
+        struct Selector
+        {
+          typedef SelectThen type;
+        };
+ 
+        template<>
+        struct Selector<false>
+        {
+          typedef SelectElse type;
+        };
+      } // end namespace intimate 
+ 
+      template<bool Condition, typename Then, typename Else>
+      struct ct_if
+      {
+        typedef typename intimate::Selector<Condition>::type select;
+        typedef typename select::template Result<Then,Else>::type type;
+      };
+
       /**
        * A union of a function pointer and a void pointer. This is necessary
        * because 5.2.10/6 allows reinterpret_cast<> to safely cast between 
@@ -128,7 +158,7 @@ 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)
+					 functor_manager_operation_type op)
       {
         if (op == clone_functor_tag)
           return f;
@@ -149,7 +179,7 @@ namespace boost {
         // For function pointers, the manager is trivial
         static inline any_pointer
         manager(any_pointer function_ptr, 
-                functor_manager_operation_type op,
+		functor_manager_operation_type op,
                 function_ptr_tag)
         {
           if (op == clone_functor_tag)
@@ -294,10 +324,10 @@ namespace boost {
   public:
     operator safe_bool () const 
       { return (this->empty())? 0 : &dummy::nonnull; }
-#endif
 
     safe_bool operator!() const
       { return (this->empty())? &dummy::nonnull : 0; }
+#endif
   };
 
   /* Poison comparison between Boost.Function objects (because it is 
@@ -311,35 +341,38 @@ namespace boost {
 
   namespace detail {
     namespace function {
-      // The result is not a Boost.Function object, so we assume that this
+      inline bool has_empty_target(const function_base* f)
-      // target is not empty
+      {
-      template<typename FunctionObj>
+        return f->empty();
-      inline bool has_empty_target(const FunctionObj&, truth<false>)
+      }
+
+      inline bool has_empty_target(...)
       {
         return false;
       }
-
-      // The result is a Boost.Function object, so query whether it is empty
-      // or not
-      template<typename FunctionObj>
-      inline bool has_empty_target(const FunctionObj& f, truth<true>)
-      { 
-        return f.empty();
-      }
-
-      template<typename Lock, typename Mixin>
-      struct scoped_double_lock
-      {
-        scoped_double_lock(const Mixin& m1, const Mixin& m2) :
-          lock1(&m1 < &m2? m1 : m2), lock2(!(&m1 < &m2)? m1 : m2)
-        {
-        }
-        
-        Lock lock1;
-        Lock lock2;
-      };
     } // end namespace function
   } // end namespace detail
+
+  // The default function policy is to do nothing before and after the call.
+  struct empty_function_policy
+  {
+    inline void precall(const function_base*) {}
+    inline void postcall(const function_base*) {}
+  };
+
+  // The default function mixin does nothing. The assignment and
+  // copy-construction operators are all defined because MSVC defines broken
+  // versions.
+  struct empty_function_mixin 
+  {
+    empty_function_mixin() {}
+    empty_function_mixin(const empty_function_mixin&) {}
+
+    empty_function_mixin& operator=(const empty_function_mixin&) 
+    {
+      return *this; 
+    }
+  };
 }
 
 #endif // BOOST_FUNCTION_BASE_HEADER

include/boost/function/function_template.hpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-// Copyright (C) 2001-2002 Doug Gregor (gregod@cs.rpi.edu)
+// 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.
@@ -25,6 +25,13 @@
 #  include <boost/mem_fn.hpp>
 #endif // BOOST_FUNCTION_FUNCTION_TEMPLATE_HPP
 
+// Type of the default allocator
+#ifndef BOOST_NO_STD_ALLOCATOR
+#  define BOOST_FUNCTION_DEFAULT_ALLOCATOR std::allocator<function_base>
+#else
+#  define BOOST_FUNCTION_DEFAULT_ALLOCATOR int
+#endif // BOOST_NO_STD_ALLOCATOR
+
 // Comma if nonzero number of arguments
 #if BOOST_FUNCTION_NUM_ARGS == 0
 #  define BOOST_FUNCTION_COMMA 
@@ -222,18 +229,15 @@ namespace boost {
   template<
     typename R BOOST_FUNCTION_COMMA
     BOOST_FUNCTION_TEMPLATE_PARMS,
-    typename ThreadingPolicy = BOOST_FUNCTION_DEFAULT_THREADING_POLICY,
+    typename Policy    = empty_function_policy,
+    typename Mixin     = empty_function_mixin,
     typename Allocator = BOOST_FUNCTION_DEFAULT_ALLOCATOR
   >
-  class BOOST_FUNCTION_FUNCTION : public function_base,
+  class BOOST_FUNCTION_FUNCTION : public function_base, public Mixin
-                                  public ThreadingPolicy::mixin
   {
     typedef typename detail::function::function_return_type<R>::type 
       internal_result_type;
 
-    typedef typename ThreadingPolicy::mixin threading_mixin;
-    typedef typename ThreadingPolicy::lock lock;
-
   public:
     BOOST_STATIC_CONSTANT(int, args = BOOST_FUNCTION_NUM_ARGS);
     
@@ -249,48 +253,54 @@ namespace boost {
 #else
     typedef internal_result_type result_type;
 #endif // BOOST_NO_VOID_RETURNS
+    typedef Policy    policy_type;
+    typedef Mixin     mixin_type;
     typedef Allocator allocator_type;
     typedef BOOST_FUNCTION_FUNCTION self_type;
-    typedef ThreadingPolicy threading_policy_type;
 
-    BOOST_FUNCTION_FUNCTION() : function_base(), invoker(0) {}
+    BOOST_FUNCTION_FUNCTION() : function_base(), Mixin(), invoker(0) {}
+
+    explicit BOOST_FUNCTION_FUNCTION(const Mixin& m) : 
+      function_base(), Mixin(m), invoker(0) 
+    {
+    }
 
     // MSVC chokes if the following two constructors are collapsed into
     // one with a default parameter.
     template<typename Functor>
     BOOST_FUNCTION_FUNCTION(Functor BOOST_FUNCTION_TARGET_FIX(const &) f) :
-      function_base(), invoker(0)
+      function_base(), Mixin(), invoker(0)
+    {
+      this->assign_to(f);
+    }
+
+    template<typename Functor>
+    BOOST_FUNCTION_FUNCTION(Functor f, const Mixin& m) :
+      function_base(), Mixin(m), invoker(0)
     {
       this->assign_to(f);
     }
 
     BOOST_FUNCTION_FUNCTION(const BOOST_FUNCTION_FUNCTION& f) :
-      function_base(), invoker(0)
+      function_base(), Mixin(static_cast<const Mixin&>(f)), invoker(0)
     {
-      // Lock the other function object so it can't change during assignment
-      lock l(static_cast<const self_type&>(f));
-      (void)l;
       this->assign_to_own(f);
     }
 
-    ~BOOST_FUNCTION_FUNCTION() 
+    ~BOOST_FUNCTION_FUNCTION() { clear(); }
-    { 
-      lock l(static_cast<const threading_mixin&>(*this));
-      (void)l;
-      clear(); 
-    }
 
     result_type operator()(BOOST_FUNCTION_PARMS) const
     {
-      // Make sure this function can't change while it is being invoked
-      lock l(static_cast<const threading_mixin&>(*this));
-      (void)l;
       assert(!this->empty());
 
+      policy_type policy;
+      policy.precall(this);
+
       internal_result_type result = invoker(function_base::functor 
                                             BOOST_FUNCTION_COMMA
                                             BOOST_FUNCTION_ARGS);
 
+      policy.postcall(this);
 #ifndef BOOST_NO_VOID_RETURNS
       return static_cast<result_type>(result);
 #else
@@ -307,45 +317,49 @@ namespace boost {
     BOOST_FUNCTION_FUNCTION& 
     operator=(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
     {
-      self_type other(f);
+      self_type(f, static_cast<const Mixin&>(*this)).swap(*this);
-      lock l(static_cast<const threading_mixin&>(*this));
-      (void)l;
-      other.unlocked_swap(*this);
       return *this;
     }
 
+    template<typename Functor>
+    void set(Functor BOOST_FUNCTION_TARGET_FIX(const &) f)
+    {
+      self_type(f, static_cast<const Mixin&>(*this)).swap(*this);
+    }
+
     // Assignment from another BOOST_FUNCTION_FUNCTION
     BOOST_FUNCTION_FUNCTION& operator=(const BOOST_FUNCTION_FUNCTION& f)
     {
       if (&f == this)
         return *this;
 
-      self_type other(f);
+      self_type(f).swap(*this);
-      lock l(static_cast<const threading_mixin&>(*this));
-      (void)l;
-      other.unlocked_swap(*this);
-
       return *this;
     }
 
+    // Assignment from another BOOST_FUNCTION_FUNCTION
+    void set(const BOOST_FUNCTION_FUNCTION& f)
+    {
+      if (&f == this)
+        return;
+
+      self_type(f).swap(*this);
+    }
+
     void swap(BOOST_FUNCTION_FUNCTION& other)
     {
       if (&other == this)
         return;
 
-      detail::function::scoped_double_lock<lock, threading_mixin> l(*this, 
+      std::swap(function_base::manager, other.manager);
-                                                                    other);
+      std::swap(function_base::functor, other.functor);
-      (void)l;
+      std::swap(invoker, other.invoker);
-
+      std::swap(static_cast<Mixin&>(*this), static_cast<Mixin&>(other));
-      unlocked_swap(other);
     }
 
     // Clear out a target, if there is one
     void clear()
     {
-      lock l(static_cast<const threading_mixin&>(*this));
-      (void)l;
-
       if (function_base::manager) {
         function_base::functor = 
 	  function_base::manager(function_base::functor, 
@@ -364,7 +378,7 @@ namespace boost {
         function_base::manager = f.manager;
         function_base::functor = 
 	  f.manager(f.functor, detail::function::clone_functor_tag);
-      }
+      }          
     }
 
     template<typename Functor>
@@ -411,11 +425,7 @@ namespace boost {
     template<typename FunctionObj>
     void assign_to(FunctionObj f, detail::function::function_obj_tag)
     {
-      typedef detail::function::truth<
+      if (!detail::function::has_empty_target(addressof(f))) {
-                boost::is_base_and_derived<function_base, FunctionObj>::value>
-	is_boost_function;
-
-      if (!detail::function::has_empty_target(f, is_boost_function())) {
         typedef 
           typename detail::function::BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
                                        FunctionObj,
@@ -449,11 +459,7 @@ namespace boost {
     void assign_to(const reference_wrapper<FunctionObj>& f, 
                    detail::function::function_obj_ref_tag)
     {
-      typedef detail::function::truth<
+      if (!detail::function::has_empty_target(f.get_pointer())) {
-                boost::is_base_and_derived<function_base, FunctionObj>::value>
-	is_boost_function;
-
-      if (!detail::function::has_empty_target(f.get(), is_boost_function())) {
         typedef 
           typename detail::function::BOOST_FUNCTION_GET_FUNCTION_OBJ_INVOKER<
                                        FunctionObj,
@@ -488,13 +494,6 @@ namespace boost {
       function_base::functor = detail::function::any_pointer(this);
     }
 
-    void unlocked_swap(BOOST_FUNCTION_FUNCTION& other)
-    {
-      std::swap(function_base::manager, other.manager);
-      std::swap(function_base::functor, other.functor);
-      std::swap(invoker, other.invoker);
-    }
-
     typedef internal_result_type (*invoker_type)(detail::function::any_pointer
                                                  BOOST_FUNCTION_COMMA
                                                  BOOST_FUNCTION_TEMPLATE_ARGS);
@@ -503,17 +502,19 @@ namespace boost {
   };
 
   template<typename R BOOST_FUNCTION_COMMA BOOST_FUNCTION_TEMPLATE_PARMS ,
-           typename ThreadingPolicy, typename Allocator>
+           typename Policy, typename Mixin, typename Allocator>
   inline void swap(BOOST_FUNCTION_FUNCTION<
                      R BOOST_FUNCTION_COMMA
                      BOOST_FUNCTION_TEMPLATE_ARGS ,
-                     ThreadingPolicy,
+                     Policy,
+                     Mixin,
                      Allocator
                    >& f1,
                    BOOST_FUNCTION_FUNCTION<
                      R BOOST_FUNCTION_COMMA 
                      BOOST_FUNCTION_TEMPLATE_ARGS,
-                     ThreadingPolicy,
+                     Policy,
+                     Mixin,
                      Allocator
                    >& f2)
   {
@@ -522,6 +523,7 @@ namespace boost {
 }
 
 // Cleanup after ourselves...
+#undef BOOST_FUNCTION_DEFAULT_ALLOCATOR
 #undef BOOST_FUNCTION_COMMA
 #undef BOOST_FUNCTION_FUNCTION
 #undef BOOST_FUNCTION_FUNCTION_INVOKER

include/boost/function/threading/detail/mutex_mixin.hpp

@@ -1,48 +0,0 @@
-// Copyright (C) 2002
-// Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-#ifndef BOOST_THREAD_MODEL_DETAIL_MUTEX_MIXIN_HPP
-#define BOOST_THREAD_MODEL_DETAIL_MUTEX_MIXIN_HPP
-
-namespace boost {
-namespace detail {
-
-template<typename Mutex>
-class mutex_mixin
-{
-public:
-  mutex_mixin(const mutex_mixin&) {}
-  mutex_mixin& operator=(const mutex_mixin&) { return *this; }
-
-  operator const Mutex&() const { return mutex; }
-  operator Mutex&() { return mutex; }
-
-private:
-  Mutex mutex;
-};
-
-template<typename Mutex>
-class static_mutex_mixin
-{
-public:
-  static_mutex_mixin(const mutex_mixin&) {}
-  static_mutex_mixin& operator=(const mutex_mixin&) { return *this; }
-
-  operator const Mutex&() const { return mutex; }
-  operator Mutex&() { return mutex; }
-
-private:
-  static Mutex mutex;
-};
-
-} // end namespace detail
-} // end namespace boost
-
-#endif // BOOST_THREAD_MODEL_DETAIL_MUTEX_MIXIN_HPP

include/boost/function/threading/per_class.hpp

@@ -1,28 +0,0 @@
-// Copyright (C) 2002
-// Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-#ifndef BOOST_THREAD_MODEL_PER_CLASS_HPP
-#define BOOST_THREAD_MODEL_PER_CLASS_HPP
-
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/model/detail/mutex_mixin.hpp>
-
-namespace boost {
-
-  template<typename Mutex = boost::mutex>
-  struct per_class_locking
-  {
-    typedef detail::static_mutex_mixin<Mutex> mixin;
-    typedef typename Mutex::scoped_lock lock;
-  };
-
-} // end namespace boost
-
-#endif // BOOST_THREAD_MODEL_PER_CLASS_HPP

include/boost/function/threading/per_object.hpp

@@ -1,28 +0,0 @@
-// Copyright (C) 2002
-// Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-#ifndef BOOST_THREAD_MODEL_PER_OBJECT_HPP
-#define BOOST_THREAD_MODEL_PER_OBJECT_HPP
-
-#include <boost/thread/mutex.hpp>
-#include <boost/thread/model/detail/mutex_mixin.hpp>
-
-namespace boost {
-
-  template<typename Mutex = boost::mutex>
-  struct per_object_locking
-  {
-    typedef detail::mutex_mixin<Mutex> mixin;
-    typedef typename Mutex::scoped_lock lock;
-  };
-
-} // end namespace boost
-
-#endif // BOOST_THREAD_MODEL_PER_OBJECT_HPP

include/boost/function/threading/single.hpp

@@ -1,27 +0,0 @@
-// Copyright (C) 2002
-// Doug Gregor (gregod@cs.rpi.edu)
-//
-// Permission to use, copy, modify, distribute and sell this software
-// and its documentation for any purpose is hereby granted without fee,
-// provided that the above copyright notice appear in all copies and
-// that both that copyright notice and this permission notice appear
-// in supporting documentation.  William E. Kempf makes no representations
-// about the suitability of this software for any purpose.
-// It is provided "as is" without express or implied warranty.
-#ifndef BOOST_THREAD_MODEL_SINGLE_HPP
-#define BOOST_THREAD_MODEL_SINGLE_HPP
-
-namespace boost {
-
-struct single_threaded {
-  struct mixin {};
-
-  struct lock 
-  {
-    lock(const mixin&) {}
-  };
-};
-
-} // end namespace boost
-
-#endif // BOOST_THREAD_MODEL_SINGLE_HPP

test/function_n_test.cpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-// Copyright (C) 2001-2002 Doug Gregor (gregod@cs.rpi.edu)
+// 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.
@@ -93,7 +93,7 @@ test_zero_args()
 
   // Invocation and self-assignment
   global_int = 0;
-  v1 = (v1);
+  v1.set(v1);
   v1();
   BOOST_TEST(global_int == 5);
 
@@ -152,7 +152,7 @@ test_zero_args()
   BOOST_TEST(global_int == 3);
 
   // Assignment to a non-empty function
-  v2 = (five);
+  v2.set(five);
 
   // Invocation
   global_int = 0;
@@ -163,7 +163,7 @@ test_zero_args()
   BOOST_TEST(v2.empty());
 
   // Assignment to an empty function from a free function
-  v2 = (&write_five);
+  v2.set(&write_five);
   BOOST_TEST(v2);
 
   // Invocation

test/function_test.cpp

@@ -1,6 +1,6 @@
 // Boost.Function library
 
-// Copyright (C) 2001-2002 Doug Gregor (gregod@cs.rpi.edu)
+// 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.
@@ -93,7 +93,7 @@ test_zero_args()
 
   // Invocation and self-assignment
   global_int = 0;
-  v1 = (v1);
+  v1.set(v1);
   v1();
   BOOST_TEST(global_int == 5);
 
@@ -152,7 +152,7 @@ test_zero_args()
   BOOST_TEST(global_int == 3);
 
   // Assignment to a non-empty function
-  v2 = (five);
+  v2.set(five);
 
   // Invocation
   global_int = 0;
@@ -163,7 +163,7 @@ test_zero_args()
   BOOST_TEST(v2.empty());
 
   // Assignment to an empty function from a free function
-  v2 = (BOOST_FUNCTION_TARGET_FIX(&) write_five);
+  v2.set(BOOST_FUNCTION_TARGET_FIX(&) write_five);
   BOOST_TEST(v2);
 
   // Invocation

test/mixin_test.cpp

@@ -0,0 +1,60 @@
+// 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>
+
+struct id_mixin
+{       
+  id_mixin(const id_mixin& rhs) : id(rhs.id) {}
+  id_mixin& operator=(const id_mixin& rhs){id = rhs.id; return *this;}
+  id_mixin(int i = 0){ id = i;}
+  int id;
+};
+
+static int do_plus(int x, int y) { return x+y; }
+
+typedef boost::function<int,int,int>::mixin<id_mixin>::type func;
+
+int test_main(int, char*[])
+{
+  func f(id_mixin(3));  
+  f = std::plus<int>();
+  BOOST_TEST(f.id == 3);
+  
+  f = &do_plus;
+  BOOST_TEST(f.id == 3);
+
+  f.clear();
+  f.id = 7;    
+  BOOST_TEST(f.id == 7);
+    
+  func g(f);
+  BOOST_TEST(g.id == 7);
+
+  f.id = 21;    
+  BOOST_TEST(f.id == 21);
+          
+  boost::swap(f,g);  
+  BOOST_TEST(f.id == 7);
+  BOOST_TEST(g.id == 21);
+
+  g = f;          
+  BOOST_TEST(g.id == 7);  
+  return 0;
+}

test/policy_test.cpp

@@ -0,0 +1,47 @@
+// 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 <iostream>
+#include <functional>
+#include <boost/function.hpp>
+
+using namespace std;
+using namespace boost;
+
+struct counting_policy
+{
+  static int count;
+
+  void precall(const function_base*) { count++; }
+  void postcall(const function_base*) { count+=2; }
+};
+
+int counting_policy::count = 0;
+
+int
+test_main(int, char*[])
+{
+  function<int, int, int>::policy<counting_policy>::type f; 
+
+  f = plus<int>();
+
+  BOOST_TEST(5 == f(2,3));
+  BOOST_TEST(counting_policy::count==3);
+
+  return 0;
+}