Installed allocator into std::function

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/trunk@111672 91177308-0d34-0410-b5e6-96231b3b80d8

include/__functional_03

@@ -367,7 +367,7 @@ template<class _F, class _Alloc, class _R>
 _R
 __func<_F, _Alloc, _R()>::operator()()
 {
-    return __invoke<_R>(__f_.first());
+    return __invoke(__f_.first());
 }
 
 #ifndef _LIBCPP_NO_RTTI
@@ -660,16 +660,15 @@ public:
       function(_F,
                typename enable_if<!is_integral<_F>::value>::type* = 0);
 
-//     template<class _Alloc>
-//       function(allocator_arg_t, const _Alloc&);
-//     template<Allocator Alloc>
-//       function(allocator_arg_t, const Alloc&, nullptr_t);
-//     template<Allocator Alloc>
-//       function(allocator_arg_t, const Alloc&, const function&);
-//     template<Allocator Alloc>
-//       function(allocator_arg_t, const Alloc&, function&&);
-//     template<class F, Allocator Alloc>
-//       function(allocator_arg_t, const Alloc&, F);
+    template<class _Alloc>
+      function(allocator_arg_t, const _Alloc&) : __f_(0) {}
+    template<class _Alloc>
+      function(allocator_arg_t, const _Alloc&, nullptr_t) : __f_(0) {}
+    template<class _Alloc>
+      function(allocator_arg_t, const _Alloc&, const function&);
+    template<class _F, class _Alloc>
+      function(allocator_arg_t, const _Alloc& __a, _F __f,
+               typename enable_if<!is_integral<_F>::value>::type* = 0);
 
     function& operator=(const function&);
     function& operator=(nullptr_t);
@@ -685,8 +684,9 @@ public:
 
     // 20.7.16.2.2, function modifiers:
     void swap(function&);
-//     template<class _F, class _Alloc>
-//       void assign(_F, const _Alloc&);
+    template<class _F, class _Alloc>
+      void assign(_F __f, const _Alloc& __a)
+        {function(allocator_arg, __a, __f).swap(*this);}
 
     // 20.7.16.2.3, function capacity:
     operator bool() const {return __f_;}
@@ -723,6 +723,21 @@ function<_R()>::function(const function& __f)
         __f_ = __f.__f_->__clone();
 }
 
+template<class _R>
+template<class _Alloc>
+function<_R()>::function(allocator_arg_t, const _Alloc&, const function& __f)
+{
+    if (__f.__f_ == 0)
+        __f_ = 0;
+    else if (__f.__f_ == (const __base*)&__f.__buf_)
+    {
+        __f_ = (__base*)&__buf_;
+        __f.__f_->__clone(__f_);
+    }
+    else
+        __f_ = __f.__f_->__clone();
+}
+
 template<class _R>
 template <class _F>
 function<_R()>::function(_F __f,
@@ -749,6 +764,39 @@ function<_R()>::function(_F __f,
     }
 }
 
+template<class _R>
+template <class _F, class _Alloc>
+function<_R()>::function(allocator_arg_t, const _Alloc& __a0, _F __f,
+                                     typename enable_if<!is_integral<_F>::value>::type*)
+    : __f_(0)
+{
+    typedef allocator_traits<_Alloc> __alloc_traits;
+    if (__not_null(__f))
+    {
+        typedef __function::__func<_F, _Alloc, _R()> _FF;
+        if (sizeof(_FF) <= sizeof(__buf_))
+        {
+            __f_ = (__base*)&__buf_;
+            ::new (__f_) _FF(__f);
+        }
+        else
+        {
+            typedef typename __alloc_traits::template
+#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+                rebind_alloc<_FF>
+#else
+                rebind_alloc<_FF>::other
+#endif
+                                                         _A;
+            _A __a(__a0);
+            typedef __allocator_destructor<_A> _D;
+            unique_ptr<__base, _D> __hold(__a.allocate(1), _D(__a, 1));
+            ::new (__hold.get()) _FF(__f, _Alloc(__a));
+            __f_ = __hold.release();
+        }
+    }
+}
+
 template<class _R>
 function<_R()>&
 function<_R()>::operator=(const function& __f)
@@ -904,16 +952,15 @@ public:
       function(_F,
                typename enable_if<!is_integral<_F>::value>::type* = 0);
 
-//     template<class _Alloc>
-//       function(allocator_arg_t, const _Alloc&);
-//     template<Allocator Alloc>
-//       function(allocator_arg_t, const Alloc&, nullptr_t);
-//     template<Allocator Alloc>
-//       function(allocator_arg_t, const Alloc&, const function&);
-//     template<Allocator Alloc>
-//       function(allocator_arg_t, const Alloc&, function&&);
-//     template<class F, Allocator Alloc>
-//       function(allocator_arg_t, const Alloc&, F);
+    template<class _Alloc>
+      function(allocator_arg_t, const _Alloc&) : __f_(0) {}
+    template<class _Alloc>
+      function(allocator_arg_t, const _Alloc&, nullptr_t) : __f_(0) {}
+    template<class _Alloc>
+      function(allocator_arg_t, const _Alloc&, const function&);
+    template<class _F, class _Alloc>
+      function(allocator_arg_t, const _Alloc& __a, _F __f,
+               typename enable_if<!is_integral<_F>::value>::type* = 0);
 
     function& operator=(const function&);
     function& operator=(nullptr_t);
@@ -929,8 +976,9 @@ public:
 
     // 20.7.16.2.2, function modifiers:
     void swap(function&);
-//     template<class _F, class _Alloc>
-//       void assign(_F, const _Alloc&);
+    template<class _F, class _Alloc>
+      void assign(_F __f, const _Alloc& __a)
+        {function(allocator_arg, __a, __f).swap(*this);}
 
     // 20.7.16.2.3, function capacity:
     operator bool() const {return __f_;}
@@ -967,6 +1015,21 @@ function<_R(_A0)>::function(const function& __f)
         __f_ = __f.__f_->__clone();
 }
 
+template<class _R, class _A0>
+template<class _Alloc>
+function<_R(_A0)>::function(allocator_arg_t, const _Alloc&, const function& __f)
+{
+    if (__f.__f_ == 0)
+        __f_ = 0;
+    else if (__f.__f_ == (const __base*)&__f.__buf_)
+    {
+        __f_ = (__base*)&__buf_;
+        __f.__f_->__clone(__f_);
+    }
+    else
+        __f_ = __f.__f_->__clone();
+}
+
 template<class _R, class _A0>
 template <class _F>
 function<_R(_A0)>::function(_F __f,
@@ -993,6 +1056,39 @@ function<_R(_A0)>::function(_F __f,
     }
 }
 
+template<class _R, class _A0>
+template <class _F, class _Alloc>
+function<_R(_A0)>::function(allocator_arg_t, const _Alloc& __a0, _F __f,
+                                     typename enable_if<!is_integral<_F>::value>::type*)
+    : __f_(0)
+{
+    typedef allocator_traits<_Alloc> __alloc_traits;
+    if (__not_null(__f))
+    {
+        typedef __function::__func<_F, _Alloc, _R(_A0)> _FF;
+        if (sizeof(_FF) <= sizeof(__buf_))
+        {
+            __f_ = (__base*)&__buf_;
+            ::new (__f_) _FF(__f);
+        }
+        else
+        {
+            typedef typename __alloc_traits::template
+#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+                rebind_alloc<_FF>
+#else
+                rebind_alloc<_FF>::other
+#endif
+                                                         _A;
+            _A __a(__a0);
+            typedef __allocator_destructor<_A> _D;
+            unique_ptr<__base, _D> __hold(__a.allocate(1), _D(__a, 1));
+            ::new (__hold.get()) _FF(__f, _Alloc(__a));
+            __f_ = __hold.release();
+        }
+    }
+}
+
 template<class _R, class _A0>
 function<_R(_A0)>&
 function<_R(_A0)>::operator=(const function& __f)
@@ -1148,16 +1244,15 @@ public:
       function(_F,
                typename enable_if<!is_integral<_F>::value>::type* = 0);
 
-//     template<class _Alloc>
-//       function(allocator_arg_t, const _Alloc&);
-//     template<Allocator Alloc>
-//       function(allocator_arg_t, const Alloc&, nullptr_t);
-//     template<Allocator Alloc>
-//       function(allocator_arg_t, const Alloc&, const function&);
-//     template<Allocator Alloc>
-//       function(allocator_arg_t, const Alloc&, function&&);
-//     template<class F, Allocator Alloc>
-//       function(allocator_arg_t, const Alloc&, F);
+    template<class _Alloc>
+      function(allocator_arg_t, const _Alloc&) : __f_(0) {}
+    template<class _Alloc>
+      function(allocator_arg_t, const _Alloc&, nullptr_t) : __f_(0) {}
+    template<class _Alloc>
+      function(allocator_arg_t, const _Alloc&, const function&);
+    template<class _F, class _Alloc>
+      function(allocator_arg_t, const _Alloc& __a, _F __f,
+               typename enable_if<!is_integral<_F>::value>::type* = 0);
 
     function& operator=(const function&);
     function& operator=(nullptr_t);
@@ -1173,8 +1268,9 @@ public:
 
     // 20.7.16.2.2, function modifiers:
     void swap(function&);
-//     template<class _F, class _Alloc>
-//       void assign(_F, const _Alloc&);
+    template<class _F, class _Alloc>
+      void assign(_F __f, const _Alloc& __a)
+        {function(allocator_arg, __a, __f).swap(*this);}
 
     // 20.7.16.2.3, function capacity:
     operator bool() const {return __f_;}
@@ -1211,10 +1307,25 @@ function<_R(_A0, _A1)>::function(const function& __f)
         __f_ = __f.__f_->__clone();
 }
 
+template<class _R, class _A0, class _A1>
+template<class _Alloc>
+function<_R(_A0, _A1)>::function(allocator_arg_t, const _Alloc&, const function& __f)
+{
+    if (__f.__f_ == 0)
+        __f_ = 0;
+    else if (__f.__f_ == (const __base*)&__f.__buf_)
+    {
+        __f_ = (__base*)&__buf_;
+        __f.__f_->__clone(__f_);
+    }
+    else
+        __f_ = __f.__f_->__clone();
+}
+
 template<class _R, class _A0, class _A1>
 template <class _F>
 function<_R(_A0, _A1)>::function(_F __f,
-                                     typename enable_if<!is_integral<_F>::value>::type*)
+                                 typename enable_if<!is_integral<_F>::value>::type*)
     : __f_(0)
 {
     if (__not_null(__f))
@@ -1237,6 +1348,39 @@ function<_R(_A0, _A1)>::function(_F __f,
     }
 }
 
+template<class _R, class _A0, class _A1>
+template <class _F, class _Alloc>
+function<_R(_A0, _A1)>::function(allocator_arg_t, const _Alloc& __a0, _F __f,
+                                 typename enable_if<!is_integral<_F>::value>::type*)
+    : __f_(0)
+{
+    typedef allocator_traits<_Alloc> __alloc_traits;
+    if (__not_null(__f))
+    {
+        typedef __function::__func<_F, _Alloc, _R(_A0, _A1)> _FF;
+        if (sizeof(_FF) <= sizeof(__buf_))
+        {
+            __f_ = (__base*)&__buf_;
+            ::new (__f_) _FF(__f);
+        }
+        else
+        {
+            typedef typename __alloc_traits::template
+#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+                rebind_alloc<_FF>
+#else
+                rebind_alloc<_FF>::other
+#endif
+                                                         _A;
+            _A __a(__a0);
+            typedef __allocator_destructor<_A> _D;
+            unique_ptr<__base, _D> __hold(__a.allocate(1), _D(__a, 1));
+            ::new (__hold.get()) _FF(__f, _Alloc(__a));
+            __f_ = __hold.release();
+        }
+    }
+}
+
 template<class _R, class _A0, class _A1>
 function<_R(_A0, _A1)>&
 function<_R(_A0, _A1)>::operator=(const function& __f)
@@ -1391,16 +1535,15 @@ public:
       function(_F,
                typename enable_if<!is_integral<_F>::value>::type* = 0);
 
-//     template<class _Alloc>
-//       function(allocator_arg_t, const _Alloc&);
-//     template<Allocator Alloc>
-//       function(allocator_arg_t, const Alloc&, nullptr_t);
-//     template<Allocator Alloc>
-//       function(allocator_arg_t, const Alloc&, const function&);
-//     template<Allocator Alloc>
-//       function(allocator_arg_t, const Alloc&, function&&);
-//     template<class F, Allocator Alloc>
-//       function(allocator_arg_t, const Alloc&, F);
+    template<class _Alloc>
+      function(allocator_arg_t, const _Alloc&) : __f_(0) {}
+    template<class _Alloc>
+      function(allocator_arg_t, const _Alloc&, nullptr_t) : __f_(0) {}
+    template<class _Alloc>
+      function(allocator_arg_t, const _Alloc&, const function&);
+    template<class _F, class _Alloc>
+      function(allocator_arg_t, const _Alloc& __a, _F __f,
+               typename enable_if<!is_integral<_F>::value>::type* = 0);
 
     function& operator=(const function&);
     function& operator=(nullptr_t);
@@ -1416,8 +1559,9 @@ public:
 
     // 20.7.16.2.2, function modifiers:
     void swap(function&);
-//     template<class _F, class _Alloc>
-//       void assign(_F, const _Alloc&);
+    template<class _F, class _Alloc>
+      void assign(_F __f, const _Alloc& __a)
+        {function(allocator_arg, __a, __f).swap(*this);}
 
     // 20.7.16.2.3, function capacity:
     operator bool() const {return __f_;}
@@ -1454,6 +1598,22 @@ function<_R(_A0, _A1, _A2)>::function(const function& __f)
         __f_ = __f.__f_->__clone();
 }
 
+template<class _R, class _A0, class _A1, class _A2>
+template<class _Alloc>
+function<_R(_A0, _A1, _A2)>::function(allocator_arg_t, const _Alloc&,
+                                      const function& __f)
+{
+    if (__f.__f_ == 0)
+        __f_ = 0;
+    else if (__f.__f_ == (const __base*)&__f.__buf_)
+    {
+        __f_ = (__base*)&__buf_;
+        __f.__f_->__clone(__f_);
+    }
+    else
+        __f_ = __f.__f_->__clone();
+}
+
 template<class _R, class _A0, class _A1, class _A2>
 template <class _F>
 function<_R(_A0, _A1, _A2)>::function(_F __f,
@@ -1480,6 +1640,39 @@ function<_R(_A0, _A1, _A2)>::function(_F __f,
     }
 }
 
+template<class _R, class _A0, class _A1, class _A2>
+template <class _F, class _Alloc>
+function<_R(_A0, _A1, _A2)>::function(allocator_arg_t, const _Alloc& __a0, _F __f,
+                                     typename enable_if<!is_integral<_F>::value>::type*)
+    : __f_(0)
+{
+    typedef allocator_traits<_Alloc> __alloc_traits;
+    if (__not_null(__f))
+    {
+        typedef __function::__func<_F, _Alloc, _R(_A0, _A1, _A2)> _FF;
+        if (sizeof(_FF) <= sizeof(__buf_))
+        {
+            __f_ = (__base*)&__buf_;
+            ::new (__f_) _FF(__f);
+        }
+        else
+        {
+            typedef typename __alloc_traits::template
+#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+                rebind_alloc<_FF>
+#else
+                rebind_alloc<_FF>::other
+#endif
+                                                         _A;
+            _A __a(__a0);
+            typedef __allocator_destructor<_A> _D;
+            unique_ptr<__base, _D> __hold(__a.allocate(1), _D(__a, 1));
+            ::new (__hold.get()) _FF(__f, _Alloc(__a));
+            __f_ = __hold.release();
+        }
+    }
+}
+
 template<class _R, class _A0, class _A1, class _A2>
 function<_R(_A0, _A1, _A2)>&
 function<_R(_A0, _A1, _A2)>::operator=(const function& __f)

include/functional

@@ -32,7 +32,7 @@ struct binary_function
     typedef Result result_type;
 };
 
-template <ObjectType T>
+template <class T>
 class reference_wrapper
     : public unary_function<T1, R> // if wrapping a unary functor
     : public binary_function<T1, T2, R> // if wraping a binary functor
@@ -56,18 +56,17 @@ public:
 
     // invoke
     template <class... ArgTypes>
-      requires Callable<T, ArgTypes&&...>
-        Callable<T, ArgTypes&&...>::result_type
+      typename result_of<T(ArgTypes...)>::type
           operator() (ArgTypes&&...) const;
 };
 
-template <ObjectType T> reference_wrapper<T> ref(T& t);
-template <ObjectType T> void ref(const T&& t) = delete; // LWG 688
-template <ObjectType T> reference_wrapper<T> ref(reference_wrapper<T>t);
+template <class T> reference_wrapper<T> ref(T& t);
+template <class T> void ref(const T&& t) = delete;
+template <class T> reference_wrapper<T> ref(reference_wrapper<T>t);
 
-template <ObjectType T> reference_wrapper<const T> cref(const T& t);
-template <ObjectType T> void cref(const T&& t) = delete; // LWG 688
-template <ObjectType T> reference_wrapper<const T> cref(reference_wrapper<T> t);
+template <class T> reference_wrapper<const T> cref(const T& t);
+template <class T> void cref(const T&& t) = delete;
+template <class T> reference_wrapper<const T> cref(reference_wrapper<T> t);
 
 template <class T>
 struct plus : binary_function<T, T, T>
@@ -187,10 +186,10 @@ template <class Predicate> binary_negate<Predicate> not2(const Predicate& pred);
 template<class T> struct is_bind_expression;
 template<class T> struct is_placeholder;
 
-template<CopyConstructible Fn, CopyConstructible... Types> 
-  unspecified bind(Fn, Types...);
-template<Returnable R, CopyConstructible Fn, CopyConstructible... Types> 
-  unspecified bind(Fn, Types...);
+template<class Fn, class... BoundArgs> 
+  unspecified bind(Fn&&, BoundArgs&&...);
+template<class R, class Fn, class... BoundArgs> 
+  unspecified bind(Fn&&, BoundArgs&&...);
 
 namespace placeholders { 
   // M is the implementation-defined number of placeholders 
@@ -334,24 +333,28 @@ public:
 template <class S, class T>          const_mem_fun_ref_t<S,T>    mem_fun_ref(S (T::*f)() const);
 template <class S, class T, class A> const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const);
 
+template<class R, class T> unspecified mem_fn(R T::*);
+template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...));
+template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const);
+template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) volatile);
+template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const volatile);
+template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) &);
+template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const &);
+template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) volatile &);
+template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const volatile &);
+template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) &&);
+template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const &&);
+template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) volatile &&);
+template<class R, class T, class... Args> unspecified mem_fn(R (T::*)(Args...) const volatile &&);
+
 class bad_function_call
     : public exception
 {
 };
 
-template<Returnable R, class T> unspecified mem_fn(R T::* pm);
-template<Returnable R, class T, CopyConstructible... Args> 
-  unspecified mem_fn(R (T::* pm)(Args...));
-template<Returnable R, class T, CopyConstructible... Args> 
-  unspecified mem_fn(R (T::* pm)(Args...) const);
-template<Returnable R, class T, CopyConstructible... Args> 
-  unspecified mem_fn(R (T::* pm)(Args...) volatile);
-template<Returnable R, class T, CopyConstructible... Args> 
-  unspecified mem_fn(R (T::* pm)(Args...) const volatile);
+template<class> class function; // undefined
 
-template<FunctionType> class function; // undefined
-
-template<Returnable R, CopyConstructible... ArgTypes>
+template<class R, class... ArgTypes>
 class function<R(ArgTypes...)>
   : public unary_function<T1, R>      // iff sizeof...(ArgTypes) == 1 and
                                       // ArgTypes contains T1
@@ -361,19 +364,13 @@ class function<R(ArgTypes...)>
 public:
     typedef R result_type;
 
-    // 20.7.16.2.1, construct/copy/destroy:
-    explicit function();
+    // construct/copy/destroy:
+    function();
     function(nullptr_t);
     function(const function&);
     function(function&&);
     template<class F>
-      requires CopyConstructible<F> && Callable<F, ArgTypes...>
-            && Convertible<Callable<F, ArgTypes...>::result_type, R>
       function(F);
-//     template<class F>
-//       requires CopyConstructible<F> && Callable<F, ArgTypes...>
-//             && Convertible<Callable<F, ArgTypes...>::result_type, R>
-//       function(F&&);
     template<Allocator Alloc>
       function(allocator_arg_t, const Alloc&);
     template<Allocator Alloc>
@@ -384,35 +381,23 @@ public:
       function(allocator_arg_t, const Alloc&, function&&);
     template<class F, Allocator Alloc>
       function(allocator_arg_t, const Alloc&, F);
-//     template<class F, Allocator Alloc>
-//       function(allocator_arg_t, const Alloc&, F&&);
 
     function& operator=(const function&);
     function& operator=(function&&);
     function& operator=(nullptr_t);
     template<class F>
-      requires CopyConstructible<F> && Callable<F, ArgTypes..>
-            && Convertible<Callable<F, ArgTypes...>::result_type
-      function& operator=(F);
-//     template<class F>
-//       requires CopyConstructible<F> && Callable<F, ArgTypes...>
-//             && Convertible<Callable<F, ArgTypes...>::result_type, R>
-//       function& operator=(F&&);
+      function& operator=(F&&);
     template<class F>
-      requires Callable<F, ArgTypes...>
-            && Convertible<Callable<F, ArgTypes...>::result_type, R>
       function& operator=(reference_wrapper<F>);
 
     ~function();
 
-    // 20.7.16.2.2, function modifiers:
+    // function modifiers:
     void swap(function&);
-    template<class F, Allocator Alloc>
-      requires Callable<F, ArgTypes...>
-            && Convertible<Callable<F, ArgTypes...>::result_type, R>
-      void assign(F, const Alloc&);
+    template<class F, class Alloc>
+      void assign(F&&, const Alloc&);
 
-    // 20.7.16.2.3, function capacity:
+    // function capacity:
     explicit operator bool() const;
 
     // deleted overloads close possible hole in the type system
@@ -421,36 +406,30 @@ public:
     template<class R2, class... ArgTypes2>
       bool operator!=(const function<R2(ArgTypes2...)>&) = delete;
 
-    // 20.7.16.2.4, function invocation:
+    // function invocation:
     R operator()(ArgTypes...) const;
 
-    // 20.7.16.2.5, function target access:
+    // function target access:
     const std::type_info& target_type() const;
-    template <typename T>
-      requires Callable<T, ArgTypes...>
-            && Convertible<Callable<T, ArgTypes...>::result_type, R>
-      T* target();
-    template <typename T>
-      requires Callable<T, ArgTypes...>
-            && Convertible<Callable<T, ArgTypes...>::result_type, R>
-      const T* target() const;
-};
-
-// 20.7.16.2.6, Null pointer comparisons: 
-template <MoveConstructible R, MoveConstructible ... ArgTypes> 
+    template <typename T>       T* target();
+    template <typename T> const T* target() const;
+};
+
+// Null pointer comparisons: 
+template <class R, class ... ArgTypes> 
   bool operator==(const function<R(ArgTypes...)>&, nullptr_t);
 
-template <MoveConstructible R, MoveConstructible ... ArgTypes> 
+template <class R, class ... ArgTypes> 
   bool operator==(nullptr_t, const function<R(ArgTypes...)>&);
 
-template <MoveConstructible R, MoveConstructible ... ArgTypes> 
+template <class R, class ... ArgTypes> 
   bool operator!=(const function<R(ArgTypes...)>&, nullptr_t);
 
-template <MoveConstructible  R, MoveConstructible ... ArgTypes> 
+template <class  R, class ... ArgTypes> 
   bool operator!=(nullptr_t, const function<R(ArgTypes...)>&);
 
-// 20.7.16.2.7, specialized algorithms: 
-template <MoveConstructible  R, MoveConstructible ... ArgTypes> 
+// specialized algorithms: 
+template <class  R, class ... ArgTypes> 
   void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&);
 
 template <class T> struct hash;
@@ -1118,27 +1097,26 @@ class function<_R(_ArgTypes...)>
 public:
     typedef _R result_type;
 
-    // 20.7.16.2.1, construct/copy/destroy:
+    // construct/copy/destroy:
     function() : __f_(0) {}
     function(nullptr_t) : __f_(0) {}
     function(const function&);
-#ifdef _LIBCPP_MOVE
     function(function&&);
-#endif
     template<class _F>
       function(_F,
                typename enable_if<!is_integral<_F>::value>::type* = 0);
 
-//     template<class _Alloc>
-//       function(allocator_arg_t, const _Alloc&);
-//     template<Allocator Alloc>
-//       function(allocator_arg_t, const Alloc&, nullptr_t);
-//     template<Allocator Alloc>
-//       function(allocator_arg_t, const Alloc&, const function&);
-//     template<Allocator Alloc>
-//       function(allocator_arg_t, const Alloc&, function&&);
-//     template<class F, Allocator Alloc>
-//       function(allocator_arg_t, const Alloc&, F);
+    template<class _Alloc>
+      function(allocator_arg_t, const _Alloc&) : __f_(0) {}
+    template<class _Alloc>
+      function(allocator_arg_t, const _Alloc&, nullptr_t) : __f_(0) {}
+    template<class _Alloc>
+      function(allocator_arg_t, const _Alloc&, const function&);
+    template<class _Alloc>
+      function(allocator_arg_t, const _Alloc&, function&&);
+    template<class _F, class _Alloc>
+      function(allocator_arg_t, const _Alloc& __a, _F __f,
+               typename enable_if<!is_integral<_F>::value>::type* = 0);
 
     function& operator=(const function&);
     function& operator=(function&&);
@@ -1153,26 +1131,26 @@ public:
 
     ~function();
 
-    // 20.7.16.2.2, function modifiers:
+    // function modifiers:
     void swap(function&);
-//     template<class _F, class _Alloc>
-//       void assign(_F, const _Alloc&);
+    template<class _F, class _Alloc>
+      void assign(_F&& __f, const _Alloc& __a)
+        {function(allocator_arg, __a, _STD::forward<_F>(__f)).swap(*this);}
 
-    // 20.7.16.2.3, function capacity:
+    // function capacity:
     /*explicit*/ operator bool() const {return __f_;}
 
-private:
     // deleted overloads close possible hole in the type system
     template<class _R2, class... _ArgTypes2>
-      bool operator==(const function<_R2(_ArgTypes2...)>&);// = delete;
+      bool operator==(const function<_R2(_ArgTypes2...)>&) = delete;
     template<class _R2, class... _ArgTypes2>
-      bool operator!=(const function<_R2(_ArgTypes2...)>&);// = delete;
+      bool operator!=(const function<_R2(_ArgTypes2...)>&) = delete;
 public:
-    // 20.7.16.2.4, function invocation:
+    // function invocation:
     _R operator()(_ArgTypes...) const;
 
 #ifndef _LIBCPP_NO_RTTI
-    // 20.7.16.2.5, function target access:
+    // function target access:
     const std::type_info& target_type() const;
     template <typename _T> _T* target();
     template <typename _T> const _T* target() const;
@@ -1193,6 +1171,22 @@ function<_R(_ArgTypes...)>::function(const function& __f)
         __f_ = __f.__f_->__clone();
 }
 
+template<class _R, class ..._ArgTypes>
+template <class _Alloc>
+function<_R(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
+                                     const function& __f)
+{
+    if (__f.__f_ == 0)
+        __f_ = 0;
+    else if (__f.__f_ == (const __base*)&__f.__buf_)
+    {
+        __f_ = (__base*)&__buf_;
+        __f.__f_->__clone(__f_);
+    }
+    else
+        __f_ = __f.__f_->__clone();
+}
+
 template<class _R, class ..._ArgTypes>
 function<_R(_ArgTypes...)>::function(function&& __f)
 {
@@ -1210,6 +1204,25 @@ function<_R(_ArgTypes...)>::function(function&& __f)
     }
 }
 
+template<class _R, class ..._ArgTypes>
+template <class _Alloc>
+function<_R(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
+                                     function&& __f)
+{
+    if (__f.__f_ == 0)
+        __f_ = 0;
+    else if (__f.__f_ == (__base*)&__f.__buf_)
+    {
+        __f_ = (__base*)&__buf_;
+        __f.__f_->__clone(__f_);
+    }
+    else
+    {
+        __f_ = __f.__f_;
+        __f.__f_ = 0;
+    }
+}
+
 template<class _R, class ..._ArgTypes>
 template <class _F>
 function<_R(_ArgTypes...)>::function(_F __f,
@@ -1236,6 +1249,39 @@ function<_R(_ArgTypes...)>::function(_F __f,
     }
 }
 
+template<class _R, class ..._ArgTypes>
+template <class _F, class _Alloc>
+function<_R(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a0, _F __f,
+                                     typename enable_if<!is_integral<_F>::value>::type*)
+    : __f_(0)
+{
+    typedef allocator_traits<_Alloc> __alloc_traits;
+    if (__not_null(__f))
+    {
+        typedef __function::__func<_F, _Alloc, _R(_ArgTypes...)> _FF;
+        if (sizeof(_FF) <= sizeof(__buf_))
+        {
+            __f_ = (__base*)&__buf_;
+            ::new (__f_) _FF(_STD::move(__f));
+        }
+        else
+        {
+            typedef typename __alloc_traits::template
+#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
+                rebind_alloc<_FF>
+#else
+                rebind_alloc<_FF>::other
+#endif
+                                                         _A;
+            _A __a(__a0);
+            typedef __allocator_destructor<_A> _D;
+            unique_ptr<__base, _D> __hold(__a.allocate(1), _D(__a, 1));
+            ::new (__hold.get()) _FF(_STD::move(__f), _Alloc(__a));
+            __f_ = __hold.release();
+        }
+    }
+}
+
 template<class _R, class ..._ArgTypes>
 function<_R(_ArgTypes...)>&
 function<_R(_ArgTypes...)>::operator=(const function& __f)

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc.pass.cpp

@@ -16,7 +16,10 @@
 #include <functional>
 #include <cassert>
 
+#include "../test_allocator.h"
+
 int main()
 {
-#error template<class A> function(allocator_arg_t, const A&); not implemented
+    std::function<int(int)> f(std::allocator_arg, test_allocator<int>());
+    assert(!f);
 }

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_F.pass.cpp

@@ -16,7 +16,65 @@
 #include <functional>
 #include <cassert>
 
+#include "../test_allocator.h"
+
+class A
+{
+    int data_[10];
+public:
+    static int count;
+
+    A()
+    {
+        ++count;
+        for (int i = 0; i < 10; ++i)
+            data_[i] = i;
+    }
+
+    A(const A&) {++count;}
+
+    ~A() {--count;}
+
+    int operator()(int i) const
+    {
+        for (int j = 0; j < 10; ++j)
+            i += data_[j];
+        return i;
+    }
+
+    int foo(int) const {return 1;}
+};
+
+int A::count = 0;
+
+int g(int) {return 0;}
+
 int main()
 {
-#error template<class F, class A> function(allocator_arg_t, const A&, F); not implemented
+    {
+    std::function<int(int)> f(std::allocator_arg, test_allocator<A>(), A());
+    assert(A::count == 1);
+    assert(f.target<A>());
+    assert(f.target<int(*)(int)>() == 0);
+    }
+    assert(A::count == 0);
+    {
+    std::function<int(int)> f(std::allocator_arg, test_allocator<int(*)(int)>(), g);
+    assert(f.target<int(*)(int)>());
+    assert(f.target<A>() == 0);
+    }
+    {
+    std::function<int(int)> f(std::allocator_arg, test_allocator<int(*)(int)>(),
+                              (int (*)(int))0);
+    assert(!f);
+    assert(f.target<int(*)(int)>() == 0);
+    assert(f.target<A>() == 0);
+    }
+    {
+    std::function<int(const A*, int)> f(std::allocator_arg,
+                                        test_allocator<int(A::*)(int)const>(),
+                                        &A::foo);
+    assert(f);
+    assert(f.target<int (A::*)(int) const>() != 0);
+    }
 }

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_function.pass.cpp

@@ -14,9 +14,91 @@
 // template<class A> function(allocator_arg_t, const A&, const function&);
 
 #include <functional>
+#include <new>
+#include <cstdlib>
 #include <cassert>
 
+#include "../test_allocator.h"
+
+int new_called = 0;
+
+void* operator new(std::size_t s) throw(std::bad_alloc)
+{
+    ++new_called;
+    return std::malloc(s);
+}
+
+void  operator delete(void* p) throw()
+{
+    --new_called;
+    std::free(p);
+}
+
+class A
+{
+    int data_[10];
+public:
+    static int count;
+
+    A()
+    {
+        ++count;
+        for (int i = 0; i < 10; ++i)
+            data_[i] = i;
+    }
+
+    A(const A&) {++count;}
+
+    ~A() {--count;}
+
+    int operator()(int i) const
+    {
+        for (int j = 0; j < 10; ++j)
+            i += data_[j];
+        return i;
+    }
+};
+
+int A::count = 0;
+
+int g(int) {return 0;}
+
 int main()
 {
-#error template<class A> function(allocator_arg_t, const A&, const function&); not implemented
+    assert(new_called == 0);
+    {
+    std::function<int(int)> f = A();
+    assert(A::count == 1);
+    assert(new_called == 1);
+    assert(f.target<A>());
+    assert(f.target<int(*)(int)>() == 0);
+    std::function<int(int)> f2(std::allocator_arg, test_allocator<A>(), f);
+    assert(A::count == 2);
+    assert(new_called == 2);
+    assert(f2.target<A>());
+    assert(f2.target<int(*)(int)>() == 0);
+    }
+    assert(A::count == 0);
+    assert(new_called == 0);
+    {
+    std::function<int(int)> f = g;
+    assert(new_called == 0);
+    assert(f.target<int(*)(int)>());
+    assert(f.target<A>() == 0);
+    std::function<int(int)> f2(std::allocator_arg, test_allocator<int(*)(int)>(), f);
+    assert(new_called == 0);
+    assert(f2.target<int(*)(int)>());
+    assert(f2.target<A>() == 0);
+    }
+    assert(new_called == 0);
+    {
+    std::function<int(int)> f;
+    assert(new_called == 0);
+    assert(f.target<int(*)(int)>() == 0);
+    assert(f.target<A>() == 0);
+    std::function<int(int)> f2(std::allocator_arg, test_allocator<int>(), f);
+    assert(new_called == 0);
+    assert(f2.target<int(*)(int)>() == 0);
+    assert(f2.target<A>() == 0);
+    }
 }

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_nullptr.pass.cpp

@@ -16,7 +16,10 @@
 #include <functional>
 #include <cassert>
 
+#include "../test_allocator.h"
+
 int main()
 {
-#error template<class A> function(allocator_arg_t, const A&, nullptr_t); not implemented
+    std::function<int(int)> f(std::allocator_arg, test_allocator<int>(), nullptr);
+    assert(!f);
 }

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/alloc_rfunction.pass.cpp

@@ -16,7 +16,66 @@
 #include <functional>
 #include <cassert>
 
+#include "../test_allocator.h"
+
+int new_called = 0;
+
+void* operator new(std::size_t s) throw(std::bad_alloc)
+{
+    ++new_called;
+    return std::malloc(s);
+}
+
+void  operator delete(void* p) throw()
+{
+    --new_called;
+    std::free(p);
+}
+
+class A
+{
+    int data_[10];
+public:
+    static int count;
+
+    A()
+    {
+        ++count;
+        for (int i = 0; i < 10; ++i)
+            data_[i] = i;
+    }
+
+    A(const A&) {++count;}
+
+    ~A() {--count;}
+
+    int operator()(int i) const
+    {
+        for (int j = 0; j < 10; ++j)
+            i += data_[j];
+        return i;
+    }
+};
+
+int A::count = 0;
+
 int main()
 {
-#error template<class A> function(allocator_arg_t, const A&, function&&); not implemented
+#ifdef _LIBCPP_MOVE
+    assert(new_called == 0);
+    {
+    std::function<int(int)> f = A();
+    assert(A::count == 1);
+    assert(new_called == 1);
+    assert(f.target<A>());
+    assert(f.target<int(*)(int)>() == 0);
+    std::function<int(int)> f2(std::allocator_arg, test_allocator<A>(), std::move(f));
+    assert(A::count == 1);
+    assert(new_called == 1);
+    assert(f2.target<A>());
+    assert(f2.target<int(*)(int)>() == 0);
+    assert(f.target<A>() == 0);
+    assert(f.target<int(*)(int)>() == 0);
+    }
+#endif
 }

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.mod/assign_F_alloc.pass.cpp

@@ -16,7 +16,45 @@
 #include <functional>
 #include <cassert>
 
+#include "../test_allocator.h"
+
+class A
+{
+    int data_[10];
+public:
+    static int count;
+
+    A()
+    {
+        ++count;
+        for (int i = 0; i < 10; ++i)
+            data_[i] = i;
+    }
+
+    A(const A&) {++count;}
+
+    ~A() {--count;}
+
+    int operator()(int i) const
+    {
+        for (int j = 0; j < 10; ++j)
+            i += data_[j];
+        return i;
+    }
+
+    int foo(int) const {return 1;}
+};
+
+int A::count = 0;
+
 int main()
 {
-#error template<class F, class A> void assign(F&&, const A&); not implemented
+    {
+    std::function<int(int)> f;
+    f.assign(A(), test_allocator<A>());
+    assert(A::count == 1);
+    assert(f.target<A>());
+    assert(f.target<int(*)(int)>() == 0);
+    }
+    assert(A::count == 0);
 }

test/utilities/function.objects/func.wrap/func.wrap.func/test_allocator.h

@@ -0,0 +1,112 @@
+#ifndef TEST_ALLOCATOR_H
+#define TEST_ALLOCATOR_H
+
+#include <cstddef>
+#include <type_traits>
+#include <cstdlib>
+#include <new>
+#include <climits>
+
+class test_alloc_base
+{
+protected:
+    static int count;
+public:
+    static int throw_after;
+};
+
+int test_alloc_base::count = 0;
+int test_alloc_base::throw_after = INT_MAX;
+
+template <class T>
+class test_allocator
+    : public test_alloc_base
+{
+    int data_;
+
+    template <class U> friend class test_allocator;
+public:
+
+    typedef unsigned                                                   size_type;
+    typedef int                                                        difference_type;
+    typedef T                                                          value_type;
+    typedef value_type*                                                pointer;
+    typedef const value_type*                                          const_pointer;
+    typedef typename std::add_lvalue_reference<value_type>::type       reference;
+    typedef typename std::add_lvalue_reference<const value_type>::type const_reference;
+
+    template <class U> struct rebind {typedef test_allocator<U> other;};
+
+    test_allocator() throw() : data_(-1) {}
+    explicit test_allocator(int i) throw() : data_(i) {}
+    test_allocator(const test_allocator& a) throw()
+        : data_(a.data_) {}
+    template <class U> test_allocator(const test_allocator<U>& a) throw()
+        : data_(a.data_) {}
+    ~test_allocator() throw() {data_ = 0;}
+    pointer address(reference x) const {return &x;}
+    const_pointer address(const_reference x) const {return &x;}
+    pointer allocate(size_type n, const void* = 0)
+        {
+            if (count >= throw_after)
+                throw std::bad_alloc();
+            ++count;
+            return (pointer)std::malloc(n * sizeof(T));
+        }
+    void deallocate(pointer p, size_type n)
+        {std::free(p);}
+    size_type max_size() const throw()
+        {return UINT_MAX / sizeof(T);}
+    void construct(pointer p, const T& val)
+        {::new(p) T(val);}
+#ifdef _LIBCPP_MOVE
+    void construct(pointer p, T&& val)
+        {::new(p) T(std::move(val));}
+#endif
+    void destroy(pointer p) {p->~T();}
+
+    friend bool operator==(const test_allocator& x, const test_allocator& y)
+        {return x.data_ == y.data_;}
+    friend bool operator!=(const test_allocator& x, const test_allocator& y)
+        {return !(x == y);}
+};
+
+template <class T>
+class other_allocator
+{
+    int data_;
+
+    template <class U> friend class other_allocator;
+
+public:
+    typedef T value_type;
+
+    other_allocator() : data_(-1) {}
+    explicit other_allocator(int i) : data_(i) {}
+    template <class U> other_allocator(const other_allocator<U>& a)
+        : data_(a.data_) {}
+    T* allocate(std::size_t n)
+        {return (T*)std::malloc(n * sizeof(T));}
+    void deallocate(T* p, std::size_t n)
+        {std::free(p);}
+
+    other_allocator select_on_container_copy_construction() const
+        {return other_allocator(-2);}
+
+    friend bool operator==(const other_allocator& x, const other_allocator& y)
+        {return x.data_ == y.data_;}
+    friend bool operator!=(const other_allocator& x, const other_allocator& y)
+        {return !(x == y);}
+
+    typedef std::true_type propagate_on_container_copy_assignment;
+    typedef std::true_type propagate_on_container_move_assignment;
+    typedef std::true_type propagate_on_container_swap;
+
+#ifdef _LIBCPP_HAS_NO_ADVANCED_SFINAE
+    std::size_t max_size() const
+        {return UINT_MAX / sizeof(T);}
+#endif
+
+};
+
+#endif