libcxx initial import
llvm-svn: 103490
Cr-Mirrored-From: sso://chromium.googlesource.com/_direct/external/github.com/llvm/llvm-project
Cr-Mirrored-Commit: 3e519524c118651123eecf60c2bbc5d65ad9bac3
diff --git a/include/functional b/include/functional
new file mode 100644
index 0000000..1551fb5
--- /dev/null
+++ b/include/functional
@@ -0,0 +1,1850 @@
+// -*- C++ -*-
+//===------------------------ functional ----------------------------------===//
+//
+// ÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊÊThe LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef _LIBCPP_FUNCTIONAL
+#define _LIBCPP_FUNCTIONAL
+
+/*
+ functional synopsis
+
+namespace std
+{
+
+template <class Arg, class Result>
+struct unary_function
+{
+ typedef Arg argument_type;
+ typedef Result result_type;
+};
+
+template <class Arg1, class Arg2, class Result>
+struct binary_function
+{
+ typedef Arg1 first_argument_type;
+ typedef Arg2 second_argument_type;
+ typedef Result result_type;
+};
+
+template <ObjectType 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
+{
+public:
+ // types
+ typedef T type;
+ typedef see below result_type; // Not always defined
+
+ // construct/copy/destroy
+ reference_wrapper(T&);
+ reference_wrapper(T&&) = delete; // do not bind to temps
+ reference_wrapper(const reference_wrapper<T>& x);
+
+ // assignment
+ reference_wrapper& operator=(const reference_wrapper<T>& x);
+
+ // access
+ operator T& () const;
+ T& get() const;
+
+ // invoke
+ template <class... ArgTypes>
+ requires Callable<T, ArgTypes&&...>
+ Callable<T, ArgTypes&&...>::result_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 <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>
+struct plus : binary_function<T, T, T>
+{
+ T operator()(const T& x, const T& y) const;
+};
+
+template <class T>
+struct minus : binary_function<T, T, T>
+{
+ T operator()(const T& x, const T& y) const;
+};
+
+template <class T>
+struct multiplies : binary_function<T, T, T>
+{
+ T operator()(const T& x, const T& y) const;
+};
+
+template <class T>
+struct divides : binary_function<T, T, T>
+{
+ T operator()(const T& x, const T& y) const;
+};
+
+template <class T>
+struct modulus : binary_function<T, T, T>
+{
+ T operator()(const T& x, const T& y) const;
+};
+
+template <class T>
+struct negate : unary_function<T, T>
+{
+ T operator()(const T& x) const;
+};
+
+template <class T>
+struct equal_to : binary_function<T, T, bool>
+{
+ bool operator()(const T& x, const T& y) const;
+};
+
+template <class T>
+struct not_equal_to : binary_function<T, T, bool>
+{
+ bool operator()(const T& x, const T& y) const;
+};
+
+template <class T>
+struct greater : binary_function<T, T, bool>
+{
+ bool operator()(const T& x, const T& y) const;
+};
+
+template <class T>
+struct less : binary_function<T, T, bool>
+{
+ bool operator()(const T& x, const T& y) const;
+};
+
+template <class T>
+struct greater_equal : binary_function<T, T, bool>
+{
+ bool operator()(const T& x, const T& y) const;
+};
+
+template <class T>
+struct less_equal : binary_function<T, T, bool>
+{
+ bool operator()(const T& x, const T& y) const;
+};
+
+template <class T>
+struct logical_and : binary_function<T, T, bool>
+{
+ bool operator()(const T& x, const T& y) const;
+};
+
+template <class T>
+struct logical_or : binary_function<T, T, bool>
+{
+ bool operator()(const T& x, const T& y) const;
+};
+
+template <class T>
+struct logical_not : unary_function<T, bool>
+{
+ bool operator()(const T& x) const;
+};
+
+template <class Predicate>
+class unary_negate
+ : public unary_function<typename Predicate::argument_type, bool>
+{
+public:
+ explicit unary_negate(const Predicate& pred);
+ bool operator()(const typename Predicate::argument_type& x) const;
+};
+
+template <class Predicate> unary_negate<Predicate> not1(const Predicate& pred);
+
+template <class Predicate>
+class binary_negate
+ : public binary_function<typename Predicate::first_argument_type,
+ typename Predicate::second_argument_type,
+ bool>
+{
+public:
+ explicit binary_negate(const Predicate& pred);
+ bool operator()(const typename Predicate::first_argument_type& x,
+ const typename Predicate::second_argument_type& y) const;
+};
+
+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...);
+
+namespace placeholders {
+ // M is the implementation-defined number of placeholders
+ extern unspecified _1;
+ extern unspecified _2;
+ .
+ .
+ .
+ extern unspecified _M;
+}
+
+template <class Operation>
+class binder1st
+ : public unary_function<typename Operation::second_argument_type,
+ typename Operation::result_type>
+{
+protected:
+ Operation op;
+ typename Operation::first_argument_type value;
+public:
+ binder1st(const Operation& x, const typename Operation::first_argument_type y);
+ typename Operation::result_type operator()( typename Operation::second_argument_type& x) const;
+ typename Operation::result_type operator()(const typename Operation::second_argument_type& x) const;
+};
+
+template <class Operation, class T>
+binder1st<Operation> bind1st(const Operation& op, const T& x);
+
+template <class Operation>
+class binder2nd
+ : public unary_function<typename Operation::first_argument_type,
+ typename Operation::result_type>
+{
+protected:
+ Operation op;
+ typename Operation::second_argument_type value;
+public:
+ binder2nd(const Operation& x, const typename Operation::second_argument_type y);
+ typename Operation::result_type operator()( typename Operation::first_argument_type& x) const;
+ typename Operation::result_type operator()(const typename Operation::first_argument_type& x) const;
+};
+
+template <class Operation, class T>
+binder2nd<Operation> bind2nd(const Operation& op, const T& x);
+
+template <class Arg, class Result>
+class pointer_to_unary_function : public unary_function<Arg, Result>
+{
+public:
+ explicit pointer_to_unary_function(Result (*f)(Arg));
+ Result operator()(Arg x) const;
+};
+
+template <class Arg, class Result>
+pointer_to_unary_function<Arg,Result> ptr_fun(Result (*f)(Arg));
+
+template <class Arg1, class Arg2, class Result>
+class pointer_to_binary_function : public binary_function<Arg1, Arg2, Result>
+{
+public:
+ explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2));
+ Result operator()(Arg1 x, Arg2 y) const;
+};
+
+template <class Arg1, class Arg2, class Result>
+pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*f)(Arg1,Arg2));
+
+template<class S, class T>
+class mem_fun_t : public unary_function<T*, S>
+{
+public:
+ explicit mem_fun_t(S (T::*p)());
+ S operator()(T* p) const;
+};
+
+template<class S, class T, class A>
+class mem_fun1_t : public binary_function<T*, A, S>
+{
+public:
+ explicit mem_fun1_t(S (T::*p)(A));
+ S operator()(T* p, A x) const;
+};
+
+template<class S, class T> mem_fun_t<S,T> mem_fun(S (T::*f)());
+template<class S, class T, class A> mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A));
+
+template<class S, class T>
+class mem_fun_ref_t : public unary_function<T, S>
+{
+public:
+ explicit mem_fun_ref_t(S (T::*p)());
+ S operator()(T& p) const;
+};
+
+template<class S, class T, class A>
+class mem_fun1_ref_t : public binary_function<T, A, S>
+{
+public:
+ explicit mem_fun1_ref_t(S (T::*p)(A));
+ S operator()(T& p, A x) const;
+};
+
+template<class S, class T> mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)());
+template<class S, class T, class A> mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A));
+
+template <class S, class T>
+class const_mem_fun_t : public unary_function<const T*, S>
+{
+public:
+ explicit const_mem_fun_t(S (T::*p)() const);
+ S operator()(const T* p) const;
+};
+
+template <class S, class T, class A>
+class const_mem_fun1_t : public binary_function<const T*, A, S>
+{
+public:
+ explicit const_mem_fun1_t(S (T::*p)(A) const);
+ S operator()(const T* p, A x) const;
+};
+
+template <class S, class T> const_mem_fun_t<S,T> mem_fun(S (T::*f)() const);
+template <class S, class T, class A> const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const);
+
+template <class S, class T>
+class const_mem_fun_ref_t : public unary_function<T, S>
+{
+public:
+ explicit const_mem_fun_ref_t(S (T::*p)() const);
+ S operator()(const T& p) const;
+};
+
+template <class S, class T, class A>
+class const_mem_fun1_ref_t : public binary_function<T, A, S>
+{
+public:
+ explicit const_mem_fun1_ref_t(S (T::*p)(A) const);
+ S operator()(const T& p, A x) const;
+};
+
+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);
+
+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<FunctionType> class function; // undefined
+
+template<Returnable R, CopyConstructible... ArgTypes>
+class function<R(ArgTypes...)>
+ : public unary_function<T1, R> // iff sizeof...(ArgTypes) == 1 and
+ // ArgTypes contains T1
+ : public binary_function<T1, T2, R> // iff sizeof...(ArgTypes) == 2 and
+ // ArgTypes contains T1 and T2
+{
+public:
+ typedef R result_type;
+
+ // 20.7.16.2.1, construct/copy/destroy:
+ explicit 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>
+ 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 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&&);
+ 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:
+ void swap(function&);
+ template<class F, Allocator Alloc>
+ requires Callable<F, ArgTypes...>
+ && Convertible<Callable<F, ArgTypes...>::result_type, R>
+ void assign(F, const Alloc&);
+
+ // 20.7.16.2.3, function capacity:
+ explicit operator bool() const;
+
+ // deleted overloads close possible hole in the type system
+ template<class R2, class... ArgTypes2>
+ bool operator==(const function<R2(ArgTypes2...)>&) = delete;
+ template<class R2, class... ArgTypes2>
+ bool operator!=(const function<R2(ArgTypes2...)>&) = delete;
+
+ // 20.7.16.2.4, function invocation:
+ R operator()(ArgTypes...) const;
+
+ // 20.7.16.2.5, 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>
+ bool operator==(const function<R(ArgTypes...)>&, nullptr_t);
+
+template <MoveConstructible R, MoveConstructible ... ArgTypes>
+ bool operator==(nullptr_t, const function<R(ArgTypes...)>&);
+
+template <MoveConstructible R, MoveConstructible ... ArgTypes>
+ bool operator!=(const function<R(ArgTypes...)>&, nullptr_t);
+
+template <MoveConstructible R, MoveConstructible ... ArgTypes>
+ bool operator!=(nullptr_t, const function<R(ArgTypes...)>&);
+
+// 20.7.16.2.7, specialized algorithms:
+template <MoveConstructible R, MoveConstructible ... ArgTypes>
+ void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&);
+
+template <class T> struct hash;
+
+template <> struct hash<bool>;
+template <> struct hash<char>;
+template <> struct hash<signed char>;
+template <> struct hash<unsigned char>;
+template <> struct hash<char16_t>;
+template <> struct hash<char32_t>;
+template <> struct hash<wchar_t>;
+template <> struct hash<short>;
+template <> struct hash<unsigned short>;
+template <> struct hash<int>;
+template <> struct hash<unsigned int>;
+template <> struct hash<long>;
+template <> struct hash<long long>;
+template <> struct hash<unsigned long>;
+template <> struct hash<unsigned long long>;
+
+template <> struct hash<float>;
+template <> struct hash<double>;
+template <> struct hash<long double>;
+
+template<class T> struct hash<T*>;
+
+} // std
+
+POLICY: For non-variadic implementations, the number of arguments is limited
+ to 3. It is hoped that the need for non-variadic implementations
+ will be minimal.
+
+*/
+
+#include <__config>
+#include <type_traits>
+#include <typeinfo>
+#include <exception>
+#include <memory>
+#include <tuple>
+
+#include <__functional_base>
+
+#pragma GCC system_header
+
+_LIBCPP_BEGIN_NAMESPACE_STD
+
+template <class _Tp>
+struct plus : binary_function<_Tp, _Tp, _Tp>
+{
+ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
+ {return __x + __y;}
+};
+
+template <class _Tp>
+struct minus : binary_function<_Tp, _Tp, _Tp>
+{
+ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
+ {return __x - __y;}
+};
+
+template <class _Tp>
+struct multiplies : binary_function<_Tp, _Tp, _Tp>
+{
+ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
+ {return __x * __y;}
+};
+
+template <class _Tp>
+struct divides : binary_function<_Tp, _Tp, _Tp>
+{
+ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
+ {return __x / __y;}
+};
+
+template <class _Tp>
+struct modulus : binary_function<_Tp, _Tp, _Tp>
+{
+ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
+ {return __x % __y;}
+};
+
+template <class _Tp>
+struct negate : unary_function<_Tp, _Tp>
+{
+ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x) const
+ {return -__x;}
+};
+
+template <class _Tp>
+struct equal_to : binary_function<_Tp, _Tp, bool>
+{
+ _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
+ {return __x == __y;}
+};
+
+template <class _Tp>
+struct not_equal_to : binary_function<_Tp, _Tp, bool>
+{
+ _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
+ {return __x != __y;}
+};
+
+template <class _Tp>
+struct greater : binary_function<_Tp, _Tp, bool>
+{
+ _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
+ {return __x > __y;}
+};
+
+template <class _Tp>
+struct less : binary_function<_Tp, _Tp, bool>
+{
+ _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
+ {return __x < __y;}
+};
+
+template <class _Tp>
+struct greater_equal : binary_function<_Tp, _Tp, bool>
+{
+ _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
+ {return __x >= __y;}
+};
+
+template <class _Tp>
+struct less_equal : binary_function<_Tp, _Tp, bool>
+{
+ _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
+ {return __x <= __y;}
+};
+
+template <class _Tp>
+struct logical_and : binary_function<_Tp, _Tp, bool>
+{
+ _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
+ {return __x && __y;}
+};
+
+template <class _Tp>
+struct logical_or : binary_function<_Tp, _Tp, bool>
+{
+ _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x, const _Tp& __y) const
+ {return __x || __y;}
+};
+
+template <class _Tp>
+struct logical_not : unary_function<_Tp, bool>
+{
+ _LIBCPP_INLINE_VISIBILITY bool operator()(const _Tp& __x) const
+ {return !__x;}
+};
+
+template <class _Tp>
+struct bit_and : binary_function<_Tp, _Tp, _Tp>
+{
+ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
+ {return __x & __y;}
+};
+
+template <class _Tp>
+struct bit_or : binary_function<_Tp, _Tp, _Tp>
+{
+ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
+ {return __x | __y;}
+};
+
+template <class _Tp>
+struct bit_xor : binary_function<_Tp, _Tp, _Tp>
+{
+ _LIBCPP_INLINE_VISIBILITY _Tp operator()(const _Tp& __x, const _Tp& __y) const
+ {return __x ^ __y;}
+};
+
+template <class _Predicate>
+class unary_negate
+ : public unary_function<typename _Predicate::argument_type, bool>
+{
+ _Predicate __pred_;
+public:
+ _LIBCPP_INLINE_VISIBILITY explicit unary_negate(const _Predicate& __pred)
+ : __pred_(__pred) {}
+ _LIBCPP_INLINE_VISIBILITY bool operator()(const typename _Predicate::argument_type& __x) const
+ {return !__pred_(__x);}
+};
+
+template <class _Predicate>
+inline _LIBCPP_INLINE_VISIBILITY
+unary_negate<_Predicate>
+not1(const _Predicate& __pred) {return unary_negate<_Predicate>(__pred);}
+
+template <class _Predicate>
+class binary_negate
+ : public binary_function<typename _Predicate::first_argument_type,
+ typename _Predicate::second_argument_type,
+ bool>
+{
+ _Predicate __pred_;
+public:
+ _LIBCPP_INLINE_VISIBILITY explicit binary_negate(const _Predicate& __pred)
+ : __pred_(__pred) {}
+ _LIBCPP_INLINE_VISIBILITY bool operator()(const typename _Predicate::first_argument_type& __x,
+ const typename _Predicate::second_argument_type& __y) const
+ {return !__pred_(__x, __y);}
+};
+
+template <class _Predicate>
+inline _LIBCPP_INLINE_VISIBILITY
+binary_negate<_Predicate>
+not2(const _Predicate& __pred) {return binary_negate<_Predicate>(__pred);}
+
+template <class __Operation>
+class binder1st
+ : public unary_function<typename __Operation::second_argument_type,
+ typename __Operation::result_type>
+{
+protected:
+ __Operation op;
+ typename __Operation::first_argument_type value;
+public:
+ _LIBCPP_INLINE_VISIBILITY binder1st(const __Operation& __x,
+ const typename __Operation::first_argument_type __y)
+ : op(__x), value(__y) {}
+ _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
+ (typename __Operation::second_argument_type& __x) const
+ {return op(value, __x);}
+ _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
+ (const typename __Operation::second_argument_type& __x) const
+ {return op(value, __x);}
+};
+
+template <class __Operation, class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+binder1st<__Operation>
+bind1st(const __Operation& __op, const _Tp& __x)
+ {return binder1st<__Operation>(__op, __x);}
+
+template <class __Operation>
+class binder2nd
+ : public unary_function<typename __Operation::first_argument_type,
+ typename __Operation::result_type>
+{
+protected:
+ __Operation op;
+ typename __Operation::second_argument_type value;
+public:
+ binder2nd(const __Operation& __x, const typename __Operation::second_argument_type __y)
+ : op(__x), value(__y) {}
+ _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
+ ( typename __Operation::first_argument_type& __x) const
+ {return op(__x, value);}
+ _LIBCPP_INLINE_VISIBILITY typename __Operation::result_type operator()
+ (const typename __Operation::first_argument_type& __x) const
+ {return op(__x, value);}
+};
+
+template <class __Operation, class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+binder2nd<__Operation>
+bind2nd(const __Operation& __op, const _Tp& __x)
+ {return binder2nd<__Operation>(__op, __x);}
+
+template <class _Arg, class _Result>
+class pointer_to_unary_function : public unary_function<_Arg, _Result>
+{
+ _Result (*__f_)(_Arg);
+public:
+ _LIBCPP_INLINE_VISIBILITY explicit pointer_to_unary_function(_Result (*__f)(_Arg))
+ : __f_(__f) {}
+ _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg __x) const
+ {return __f_(__x);}
+};
+
+template <class _Arg, class _Result>
+inline _LIBCPP_INLINE_VISIBILITY
+pointer_to_unary_function<_Arg,_Result>
+ptr_fun(_Result (*__f)(_Arg))
+ {return pointer_to_unary_function<_Arg,_Result>(__f);}
+
+template <class _Arg1, class _Arg2, class _Result>
+class pointer_to_binary_function : public binary_function<_Arg1, _Arg2, _Result>
+{
+ _Result (*__f_)(_Arg1, _Arg2);
+public:
+ _LIBCPP_INLINE_VISIBILITY explicit pointer_to_binary_function(_Result (*__f)(_Arg1, _Arg2))
+ : __f_(__f) {}
+ _LIBCPP_INLINE_VISIBILITY _Result operator()(_Arg1 __x, _Arg2 __y) const
+ {return __f_(__x, __y);}
+};
+
+template <class _Arg1, class _Arg2, class _Result>
+inline _LIBCPP_INLINE_VISIBILITY
+pointer_to_binary_function<_Arg1,_Arg2,_Result>
+ptr_fun(_Result (*__f)(_Arg1,_Arg2))
+ {return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__f);}
+
+template<class _Sp, class _Tp>
+class mem_fun_t : public unary_function<_Tp*, _Sp>
+{
+ _Sp (_Tp::*__p_)();
+public:
+ _LIBCPP_INLINE_VISIBILITY explicit mem_fun_t(_Sp (_Tp::*__p)())
+ : __p_(__p) {}
+ _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p) const
+ {return (__p->*__p_)();}
+};
+
+template<class _Sp, class _Tp, class _Ap>
+class mem_fun1_t : public binary_function<_Tp*, _Ap, _Sp>
+{
+ _Sp (_Tp::*__p_)(_Ap);
+public:
+ _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_t(_Sp (_Tp::*__p)(_Ap))
+ : __p_(__p) {}
+ _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp* __p, _Ap __x) const
+ {return (__p->*__p_)(__x);}
+};
+
+template<class _Sp, class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+mem_fun_t<_Sp,_Tp>
+mem_fun(_Sp (_Tp::*__f)())
+ {return mem_fun_t<_Sp,_Tp>(__f);}
+
+template<class _Sp, class _Tp, class _Ap>
+inline _LIBCPP_INLINE_VISIBILITY
+mem_fun1_t<_Sp,_Tp,_Ap>
+mem_fun(_Sp (_Tp::*__f)(_Ap))
+ {return mem_fun1_t<_Sp,_Tp,_Ap>(__f);}
+
+template<class _Sp, class _Tp>
+class mem_fun_ref_t : public unary_function<_Tp, _Sp>
+{
+ _Sp (_Tp::*__p_)();
+public:
+ _LIBCPP_INLINE_VISIBILITY explicit mem_fun_ref_t(_Sp (_Tp::*__p)())
+ : __p_(__p) {}
+ _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p) const
+ {return (__p.*__p_)();}
+};
+
+template<class _Sp, class _Tp, class _Ap>
+class mem_fun1_ref_t : public binary_function<_Tp, _Ap, _Sp>
+{
+ _Sp (_Tp::*__p_)(_Ap);
+public:
+ _LIBCPP_INLINE_VISIBILITY explicit mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap))
+ : __p_(__p) {}
+ _LIBCPP_INLINE_VISIBILITY _Sp operator()(_Tp& __p, _Ap __x) const
+ {return (__p.*__p_)(__x);}
+};
+
+template<class _Sp, class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+mem_fun_ref_t<_Sp,_Tp>
+mem_fun_ref(_Sp (_Tp::*__f)())
+ {return mem_fun_ref_t<_Sp,_Tp>(__f);}
+
+template<class _Sp, class _Tp, class _Ap>
+inline _LIBCPP_INLINE_VISIBILITY
+mem_fun1_ref_t<_Sp,_Tp,_Ap>
+mem_fun_ref(_Sp (_Tp::*__f)(_Ap))
+ {return mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);}
+
+template <class _Sp, class _Tp>
+class const_mem_fun_t : public unary_function<const _Tp*, _Sp>
+{
+ _Sp (_Tp::*__p_)() const;
+public:
+ _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_t(_Sp (_Tp::*__p)() const)
+ : __p_(__p) {}
+ _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p) const
+ {return (__p->*__p_)();}
+};
+
+template <class _Sp, class _Tp, class _Ap>
+class const_mem_fun1_t : public binary_function<const _Tp*, _Ap, _Sp>
+{
+ _Sp (_Tp::*__p_)(_Ap) const;
+public:
+ _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_t(_Sp (_Tp::*__p)(_Ap) const)
+ : __p_(__p) {}
+ _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp* __p, _Ap __x) const
+ {return (__p->*__p_)(__x);}
+};
+
+template <class _Sp, class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+const_mem_fun_t<_Sp,_Tp>
+mem_fun(_Sp (_Tp::*__f)() const)
+ {return const_mem_fun_t<_Sp,_Tp>(__f);}
+
+template <class _Sp, class _Tp, class _Ap>
+inline _LIBCPP_INLINE_VISIBILITY
+const_mem_fun1_t<_Sp,_Tp,_Ap>
+mem_fun(_Sp (_Tp::*__f)(_Ap) const)
+ {return const_mem_fun1_t<_Sp,_Tp,_Ap>(__f);}
+
+template <class _Sp, class _Tp>
+class const_mem_fun_ref_t : public unary_function<_Tp, _Sp>
+{
+ _Sp (_Tp::*__p_)() const;
+public:
+ _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun_ref_t(_Sp (_Tp::*__p)() const)
+ : __p_(__p) {}
+ _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p) const
+ {return (__p.*__p_)();}
+};
+
+template <class _Sp, class _Tp, class _Ap>
+class const_mem_fun1_ref_t : public binary_function<_Tp, _Ap, _Sp>
+{
+ _Sp (_Tp::*__p_)(_Ap) const;
+public:
+ _LIBCPP_INLINE_VISIBILITY explicit const_mem_fun1_ref_t(_Sp (_Tp::*__p)(_Ap) const)
+ : __p_(__p) {}
+ _LIBCPP_INLINE_VISIBILITY _Sp operator()(const _Tp& __p, _Ap __x) const
+ {return (__p.*__p_)(__x);}
+};
+
+template <class _Sp, class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+const_mem_fun_ref_t<_Sp,_Tp>
+mem_fun_ref(_Sp (_Tp::*__f)() const)
+ {return const_mem_fun_ref_t<_Sp,_Tp>(__f);}
+
+template <class _Sp, class _Tp, class _Ap>
+inline _LIBCPP_INLINE_VISIBILITY
+const_mem_fun1_ref_t<_Sp,_Tp,_Ap>
+mem_fun_ref(_Sp (_Tp::*__f)(_Ap) const)
+ {return const_mem_fun1_ref_t<_Sp,_Tp,_Ap>(__f);}
+
+
+#ifdef _LIBCPP_HAS_NO_VARIADICS
+
+#include <__functional_03>
+
+#else // _LIBCPP_HAS_NO_VARIADICS
+
+template <class _Tp>
+class __mem_fn
+ : public __weak_result_type<_Tp>
+{
+public:
+ // types
+ typedef _Tp type;
+private:
+ type __f_;
+
+public:
+ _LIBCPP_INLINE_VISIBILITY __mem_fn(type __f) : __f_(__f) {}
+
+ // invoke
+ template <class... _ArgTypes>
+ typename __invoke_return<type, _ArgTypes...>::type
+ operator() (_ArgTypes&&... __args)
+ {
+ return __invoke(__f_, _STD::forward<_ArgTypes>(__args)...);
+ }
+};
+
+template<class _R, class _T>
+inline _LIBCPP_INLINE_VISIBILITY
+__mem_fn<_R _T::*>
+mem_fn(_R _T::* __pm)
+{
+ return __mem_fn<_R _T::*>(__pm);
+}
+
+template<class _R, class _T, class ..._Args>
+inline _LIBCPP_INLINE_VISIBILITY
+__mem_fn<_R (_T::*)(_Args...)>
+mem_fn(_R (_T::* __pm)(_Args...))
+{
+ return __mem_fn<_R (_T::*)(_Args...)>(__pm);
+}
+
+template<class _R, class _T, class ..._Args>
+inline _LIBCPP_INLINE_VISIBILITY
+__mem_fn<_R (_T::*)(_Args...) const>
+mem_fn(_R (_T::* __pm)(_Args...) const)
+{
+ return __mem_fn<_R (_T::*)(_Args...) const>(__pm);
+}
+
+template<class _R, class _T, class ..._Args>
+inline _LIBCPP_INLINE_VISIBILITY
+__mem_fn<_R (_T::*)(_Args...) volatile>
+mem_fn(_R (_T::* __pm)(_Args...) volatile)
+{
+ return __mem_fn<_R (_T::*)(_Args...) volatile>(__pm);
+}
+
+template<class _R, class _T, class ..._Args>
+inline _LIBCPP_INLINE_VISIBILITY
+__mem_fn<_R (_T::*)(_Args...) const volatile>
+mem_fn(_R (_T::* __pm)(_Args...) const volatile)
+{
+ return __mem_fn<_R (_T::*)(_Args...) const volatile>(__pm);
+}
+
+// bad_function_call
+
+class bad_function_call
+ : public exception
+{
+};
+
+template<class _Fp> class function; // undefined
+
+namespace __function
+{
+
+template<class _R, class ..._ArgTypes>
+struct __maybe_derive_from_unary_function
+{
+};
+
+template<class _R, class _A1>
+struct __maybe_derive_from_unary_function<_R(_A1)>
+ : public unary_function<_A1, _R>
+{
+};
+
+template<class _R, class ..._ArgTypes>
+struct __maybe_derive_from_binary_function
+{
+};
+
+template<class _R, class _A1, class _A2>
+struct __maybe_derive_from_binary_function<_R(_A1, _A2)>
+ : public binary_function<_A1, _A2, _R>
+{
+};
+
+template<class _Fp> class __base;
+
+template<class _R, class ..._ArgTypes>
+class __base<_R(_ArgTypes...)>
+{
+ __base(const __base&);
+ __base& operator=(const __base&);
+public:
+ __base() {}
+ virtual ~__base() {}
+ virtual __base* __clone() const = 0;
+ virtual void __clone(__base*) const = 0;
+ virtual void destroy() = 0;
+ virtual void destroy_deallocate() = 0;
+ virtual _R operator()(_ArgTypes&& ...) = 0;
+ virtual const void* target(const type_info&) const = 0;
+ virtual const std::type_info& target_type() const = 0;
+};
+
+template<class _FD, class _Alloc, class _FB> class __func;
+
+template<class _F, class _Alloc, class _R, class ..._ArgTypes>
+class __func<_F, _Alloc, _R(_ArgTypes...)>
+ : public __base<_R(_ArgTypes...)>
+{
+ __compressed_pair<_F, _Alloc> __f_;
+public:
+ explicit __func(_F __f) : __f_(_STD::move(__f)) {}
+ explicit __func(_F __f, _Alloc __a) : __f_(_STD::move(__f), _STD::move(__a)) {}
+ virtual __base<_R(_ArgTypes...)>* __clone() const;
+ virtual void __clone(__base<_R(_ArgTypes...)>*) const;
+ virtual void destroy();
+ virtual void destroy_deallocate();
+ virtual _R operator()(_ArgTypes&& ... __arg);
+ virtual const void* target(const type_info&) const;
+ virtual const std::type_info& target_type() const;
+};
+
+template<class _F, class _Alloc, class _R, class ..._ArgTypes>
+__base<_R(_ArgTypes...)>*
+__func<_F, _Alloc, _R(_ArgTypes...)>::__clone() const
+{
+ typedef typename _Alloc::template rebind<__func>::other _A;
+ _A __a(__f_.second());
+ typedef __allocator_destructor<_A> _D;
+ unique_ptr<__func, _D> __hold(__a.allocate(1), _D(__a, 1));
+ ::new (__hold.get()) __func(__f_.first(), _Alloc(__a));
+ return __hold.release();
+}
+
+template<class _F, class _Alloc, class _R, class ..._ArgTypes>
+void
+__func<_F, _Alloc, _R(_ArgTypes...)>::__clone(__base<_R(_ArgTypes...)>* __p) const
+{
+ ::new (__p) __func(__f_.first(), __f_.second());
+}
+
+template<class _F, class _Alloc, class _R, class ..._ArgTypes>
+void
+__func<_F, _Alloc, _R(_ArgTypes...)>::destroy()
+{
+ __f_.~__compressed_pair<_F, _Alloc>();
+}
+
+template<class _F, class _Alloc, class _R, class ..._ArgTypes>
+void
+__func<_F, _Alloc, _R(_ArgTypes...)>::destroy_deallocate()
+{
+ typedef typename _Alloc::template rebind<__func>::other _A;
+ _A __a(__f_.second());
+ __f_.~__compressed_pair<_F, _Alloc>();
+ __a.deallocate(this, 1);
+}
+
+template<class _F, class _Alloc, class _R, class ..._ArgTypes>
+_R
+__func<_F, _Alloc, _R(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
+{
+ return __invoke(__f_.first(), _STD::forward<_ArgTypes>(__arg)...);
+}
+
+template<class _F, class _Alloc, class _R, class ..._ArgTypes>
+const void*
+__func<_F, _Alloc, _R(_ArgTypes...)>::target(const type_info& __ti) const
+{
+ if (__ti == typeid(_F))
+ return &__f_.first();
+ return (const void*)0;
+}
+
+template<class _F, class _Alloc, class _R, class ..._ArgTypes>
+const std::type_info&
+__func<_F, _Alloc, _R(_ArgTypes...)>::target_type() const
+{
+ return typeid(_F);
+}
+
+} // __function
+
+template<class _R, class ..._ArgTypes>
+class function<_R(_ArgTypes...)>
+ : public __function::__maybe_derive_from_unary_function<_R(_ArgTypes...)>,
+ public __function::__maybe_derive_from_binary_function<_R(_ArgTypes...)>
+{
+ typedef __function::__base<_R(_ArgTypes...)> __base;
+ aligned_storage<3*sizeof(void*)>::type __buf_;
+ __base* __f_;
+
+ template <class _F>
+ static bool __not_null(const _F&) {return true;}
+ template <class _R2, class ..._A>
+ static bool __not_null(_R2 (*__p)(_A...)) {return __p;}
+ template <class _R2, class _C, class ..._A>
+ static bool __not_null(_R2 (_C::*__p)(_A...)) {return __p;}
+ template <class _R2, class _C, class ..._A>
+ static bool __not_null(_R2 (_C::*__p)(_A...) const) {return __p;}
+ template <class _R2, class _C, class ..._A>
+ static bool __not_null(_R2 (_C::*__p)(_A...) volatile) {return __p;}
+ template <class _R2, class _C, class ..._A>
+ static bool __not_null(_R2 (_C::*__p)(_A...) const volatile) {return __p;}
+ template <class _R2, class ..._A>
+ static bool __not_null(const function<_R(_A...)>& __p) {return __p;}
+public:
+ typedef _R result_type;
+
+ // 20.7.16.2.1, construct/copy/destroy:
+ explicit 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);
+
+ function& operator=(const function&);
+ function& operator=(function&&);
+ function& operator=(nullptr_t);
+ template<class _F>
+ typename enable_if
+ <
+ !is_integral<typename decay<_F>::type>::value,
+ function&
+ >::type
+ operator=(_F&&);
+
+ ~function();
+
+ // 20.7.16.2.2, function modifiers:
+ void swap(function&);
+// template<class _F, class _Alloc>
+// void assign(_F, const _Alloc&);
+
+ // 20.7.16.2.3, 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;
+ template<class _R2, class... _ArgTypes2>
+ bool operator!=(const function<_R2(_ArgTypes2...)>&);// = delete;
+public:
+ // 20.7.16.2.4, function invocation:
+ _R operator()(_ArgTypes...) const;
+
+ // 20.7.16.2.5, function target access:
+ const std::type_info& target_type() const;
+ template <typename _T> _T* target();
+ template <typename _T> const _T* target() const;
+};
+
+template<class _R, class ..._ArgTypes>
+function<_R(_ArgTypes...)>::function(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)
+{
+ 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,
+ typename enable_if<!is_integral<_F>::value>::type*)
+ : __f_(0)
+{
+ if (__not_null(__f))
+ {
+ typedef __function::__func<_F, allocator<_F>, _R(_ArgTypes...)> _FF;
+ if (sizeof(_FF) <= sizeof(__buf_))
+ {
+ __f_ = (__base*)&__buf_;
+ ::new (__f_) _FF(_STD::move(__f));
+ }
+ else
+ {
+ typedef allocator<_FF> _A;
+ _A __a;
+ typedef __allocator_destructor<_A> _D;
+ unique_ptr<__base, _D> __hold(__a.allocate(1), _D(__a, 1));
+ ::new (__hold.get()) _FF(_STD::move(__f), allocator<_F>(__a));
+ __f_ = __hold.release();
+ }
+ }
+}
+
+template<class _R, class ..._ArgTypes>
+function<_R(_ArgTypes...)>&
+function<_R(_ArgTypes...)>::operator=(const function& __f)
+{
+ function(__f).swap(*this);
+ return *this;
+}
+
+template<class _R, class ..._ArgTypes>
+function<_R(_ArgTypes...)>&
+function<_R(_ArgTypes...)>::operator=(function&& __f)
+{
+ if (__f_ == (__base*)&__buf_)
+ __f_->destroy();
+ else if (__f_)
+ __f_->destroy_deallocate();
+ __f_ = 0;
+ 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>
+function<_R(_ArgTypes...)>&
+function<_R(_ArgTypes...)>::operator=(nullptr_t)
+{
+ if (__f_ == (__base*)&__buf_)
+ __f_->destroy();
+ else if (__f_)
+ __f_->destroy_deallocate();
+ __f_ = 0;
+}
+
+template<class _R, class ..._ArgTypes>
+template <class _F>
+typename enable_if
+<
+ !is_integral<typename decay<_F>::type>::value,
+ function<_R(_ArgTypes...)>&
+>::type
+function<_R(_ArgTypes...)>::operator=(_F&& __f)
+{
+ function(_STD::forward<_F>(__f)).swap(*this);
+ return *this;
+}
+
+template<class _R, class ..._ArgTypes>
+function<_R(_ArgTypes...)>::~function()
+{
+ if (__f_ == (__base*)&__buf_)
+ __f_->destroy();
+ else if (__f_)
+ __f_->destroy_deallocate();
+}
+
+template<class _R, class ..._ArgTypes>
+void
+function<_R(_ArgTypes...)>::swap(function& __f)
+{
+ if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_)
+ {
+ typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
+ __base* __t = (__base*)&__tempbuf;
+ __f_->__clone(__t);
+ __f_->destroy();
+ __f_ = 0;
+ __f.__f_->__clone((__base*)&__buf_);
+ __f.__f_->destroy();
+ __f.__f_ = 0;
+ __f_ = (__base*)&__buf_;
+ __t->__clone((__base*)&__f.__buf_);
+ __t->destroy();
+ __f.__f_ = (__base*)&__f.__buf_;
+ }
+ else if (__f_ == (__base*)&__buf_)
+ {
+ __f_->__clone((__base*)&__f.__buf_);
+ __f_->destroy();
+ __f_ = __f.__f_;
+ __f.__f_ = (__base*)&__f.__buf_;
+ }
+ else if (__f.__f_ == (__base*)&__f.__buf_)
+ {
+ __f.__f_->__clone((__base*)&__buf_);
+ __f.__f_->destroy();
+ __f.__f_ = __f_;
+ __f_ = (__base*)&__buf_;
+ }
+ else
+ _STD::swap(__f_, __f.__f_);
+}
+
+template<class _R, class ..._ArgTypes>
+_R
+function<_R(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
+{
+ if (__f_ == 0)
+ throw bad_function_call();
+ return (*__f_)(_STD::forward<_ArgTypes>(__arg)...);
+}
+
+template<class _R, class ..._ArgTypes>
+const std::type_info&
+function<_R(_ArgTypes...)>::target_type() const
+{
+ if (__f_ == 0)
+ return typeid(void);
+ return __f_->target_type();
+}
+
+template<class _R, class ..._ArgTypes>
+template <typename _T>
+_T*
+function<_R(_ArgTypes...)>::target()
+{
+ if (__f_ == 0)
+ return (_T*)0;
+ return (_T*)__f_->target(typeid(_T));
+}
+
+template<class _R, class ..._ArgTypes>
+template <typename _T>
+const _T*
+function<_R(_ArgTypes...)>::target() const
+{
+ if (__f_ == 0)
+ return (const _T*)0;
+ return (const _T*)__f_->target(typeid(_T));
+}
+
+template <class _R, class... _ArgTypes>
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator==(const function<_R(_ArgTypes...)>& __f, nullptr_t) {return !__f;}
+
+template <class _R, class... _ArgTypes>
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator==(nullptr_t, const function<_R(_ArgTypes...)>& __f) {return !__f;}
+
+template <class _R, class... _ArgTypes>
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator!=(const function<_R(_ArgTypes...)>& __f, nullptr_t) {return (bool)__f;}
+
+template <class _R, class... _ArgTypes>
+inline _LIBCPP_INLINE_VISIBILITY
+bool
+operator!=(nullptr_t, const function<_R(_ArgTypes...)>& __f) {return (bool)__f;}
+
+template <class _R, class... _ArgTypes>
+inline _LIBCPP_INLINE_VISIBILITY
+void
+swap(function<_R(_ArgTypes...)>& __x, function<_R(_ArgTypes...)>& __y)
+{return __x.swap(__y);}
+
+template<class _Tp> struct __is_bind_expression : public false_type {};
+template<class _Tp> struct is_bind_expression
+ : public __is_bind_expression<typename remove_cv<_Tp>::type> {};
+
+template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {};
+template<class _Tp> struct is_placeholder
+ : public __is_placeholder<typename remove_cv<_Tp>::type> {};
+
+namespace placeholders
+{
+
+template <int _N> struct __ph {};
+
+extern __ph<1> _1;
+extern __ph<2> _2;
+extern __ph<3> _3;
+extern __ph<4> _4;
+extern __ph<5> _5;
+extern __ph<6> _6;
+extern __ph<7> _7;
+extern __ph<8> _8;
+extern __ph<9> _9;
+extern __ph<10> _10;
+
+} // placeholders
+
+template<int _N>
+struct __is_placeholder<placeholders::__ph<_N> >
+ : public integral_constant<int, _N> {};
+
+template <class _Tp, class _Uj>
+inline _LIBCPP_INLINE_VISIBILITY
+_Tp&
+__mu(reference_wrapper<_Tp> __t, _Uj&)
+{
+ return __t.get();
+}
+
+template <bool _IsBindExpr, class _Ti, class ..._Uj>
+struct __mu_return1 {};
+
+template <class _Ti, class ..._Uj>
+struct __mu_return1<true, _Ti, _Uj...>
+{
+ typedef typename result_of<_Ti(_Uj...)>::type type;
+};
+
+
+template <class _Ti, class ..._Uj, size_t ..._Indx>
+inline _LIBCPP_INLINE_VISIBILITY
+typename __mu_return1<true, _Ti, _Uj...>::type
+__mu_expand(_Ti& __ti, tuple<_Uj...>&& __uj, __tuple_indices<_Indx...>)
+{
+ return __ti(_STD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj))...);
+}
+
+template <class _Ti, class ..._Uj>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+ is_bind_expression<_Ti>::value,
+ typename __mu_return1<is_bind_expression<_Ti>::value, _Ti, _Uj...>::type
+>::type
+__mu(_Ti& __ti, tuple<_Uj...>& __uj)
+{
+ typedef typename __make_tuple_indices<sizeof...(_Uj)>::type __indices;
+ return __mu_expand(__ti, __uj, __indices());
+}
+
+template <bool IsPh, class _Ti, class _Uj>
+struct __mu_return2 {};
+
+template <class _Ti, class _Uj>
+struct __mu_return2<true, _Ti, _Uj>
+{
+ typedef typename tuple_element<is_placeholder<_Ti>::value - 1, _Uj>::type type;
+};
+
+template <class _Ti, class _Uj>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+ 0 < is_placeholder<_Ti>::value,
+ typename __mu_return2<0 < is_placeholder<_Ti>::value, _Ti, _Uj>::type
+>::type
+__mu(_Ti&, _Uj& __uj)
+{
+ const size_t _Indx = is_placeholder<_Ti>::value - 1;
+ // compiler bug workaround
+ typename tuple_element<_Indx, _Uj>::type __t = get<_Indx>(__uj);
+ return __t;
+// return _STD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj));
+}
+
+template <class _Ti, class _Uj>
+inline _LIBCPP_INLINE_VISIBILITY
+typename enable_if
+<
+ !is_bind_expression<_Ti>::value &&
+ is_placeholder<_Ti>::value == 0 &&
+ !__is_reference_wrapper<_Ti>::value,
+ _Ti&
+>::type
+__mu(_Ti& __ti, _Uj& __uj)
+{
+ return __ti;
+}
+
+template <class _Ti, bool IsBindEx, bool IsPh, class _TupleUj>
+struct ____mu_return;
+
+template <class _Ti, class ..._Uj>
+struct ____mu_return<_Ti, true, false, tuple<_Uj...> >
+{
+ typedef typename result_of<_Ti(_Uj...)>::type type;
+};
+
+template <class _Ti, class _TupleUj>
+struct ____mu_return<_Ti, false, true, _TupleUj>
+{
+ typedef typename tuple_element<is_placeholder<_Ti>::value - 1,
+ _TupleUj>::type&& type;
+};
+
+template <class _Ti, class _TupleUj>
+struct ____mu_return<_Ti, false, false, _TupleUj>
+{
+ typedef _Ti& type;
+};
+
+template <class _Ti, class _TupleUj>
+struct __mu_return
+ : public ____mu_return<_Ti,
+ is_bind_expression<_Ti>::value,
+ 0 < is_placeholder<_Ti>::value,
+ _TupleUj>
+{
+};
+
+template <class _Ti, class _TupleUj>
+struct __mu_return<reference_wrapper<_Ti>, _TupleUj>
+{
+ typedef _Ti& type;
+};
+
+template <class _F, class _BoundArgs, class _TupleUj>
+struct __bind_return;
+
+template <class _F, class ..._BoundArgs, class _TupleUj>
+struct __bind_return<_F, tuple<_BoundArgs...>, _TupleUj>
+{
+ typedef typename __invoke_return
+ <
+ _F&,
+ typename __mu_return
+ <
+ _BoundArgs,
+ _TupleUj
+ >::type...
+ >::type type;
+};
+
+template <class _F, class ..._BoundArgs, class _TupleUj>
+struct __bind_return<_F, const tuple<_BoundArgs...>, _TupleUj>
+{
+ typedef typename __invoke_return
+ <
+ _F&,
+ typename __mu_return
+ <
+ const _BoundArgs,
+ _TupleUj
+ >::type...
+ >::type type;
+};
+
+template <class _F, class _BoundArgs, size_t ..._Indx, class _Args>
+inline _LIBCPP_INLINE_VISIBILITY
+typename __bind_return<_F, _BoundArgs, _Args>::type
+__apply_functor(_F& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>,
+ _Args&& __args)
+{
+ return __invoke(__f, __mu(get<_Indx>(__bound_args), __args)...);
+}
+
+template<class _F, class ..._BoundArgs>
+class __bind
+ : public __weak_result_type<_F>
+{
+ _F __f_;
+ tuple<_BoundArgs...> __bound_args_;
+
+ typedef typename __make_tuple_indices<sizeof...(_BoundArgs)>::type __indices;
+public:
+ __bind(__bind&& __b)
+ : __f_(_STD::move(__b.__f_)),
+ __bound_args_(_STD::move(__b.__bound_args_)) {}
+
+ template <class _G, class ..._BA>
+ explicit __bind(_G&& __f, _BA&& ...__bound_args)
+ : __f_(_STD::forward<_G>(__f)),
+ __bound_args_(_STD::forward<_BA>(__bound_args)...) {}
+
+ template <class ..._Args>
+ typename __bind_return<_F, tuple<_BoundArgs...>, tuple<_Args&&...> >::type
+ operator()(_Args&& ...__args)
+ {
+ // compiler bug workaround
+ return __apply_functor(__f_, __bound_args_, __indices(),
+ tuple<_Args&&...>(__args...));
+ }
+
+ template <class ..._Args>
+ typename __bind_return<_F, tuple<_BoundArgs...>, tuple<_Args&&...> >::type
+ operator()(_Args&& ...__args) const
+ {
+ return __apply_functor(__f_, __bound_args_, __indices(),
+ tuple<_Args&&...>(__args...));
+ }
+};
+
+template<class _F, class ..._BoundArgs>
+struct __is_bind_expression<__bind<_F, _BoundArgs...> > : public true_type {};
+
+template<class _R, class _F, class ..._BoundArgs>
+class __bind_r
+ : public __bind<_F, _BoundArgs...>
+{
+ typedef __bind<_F, _BoundArgs...> base;
+public:
+ typedef _R result_type;
+
+ template <class _G, class ..._BA>
+ explicit __bind_r(_G&& __f, _BA&& ...__bound_args)
+ : base(_STD::forward<_G>(__f),
+ _STD::forward<_BA>(__bound_args)...) {}
+
+ template <class ..._Args>
+ result_type
+ operator()(_Args&& ...__args)
+ {
+ return base::operator()(_STD::forward<_Args>(__args)...);
+ }
+
+ template <class ..._Args>
+ result_type
+ operator()(_Args&& ...__args) const
+ {
+ return base::operator()(_STD::forward<_Args>(__args)...);
+ }
+};
+
+template<class _R, class _F, class ..._BoundArgs>
+struct __is_bind_expression<__bind_r<_R, _F, _BoundArgs...> > : public true_type {};
+
+template<class _F, class ..._BoundArgs>
+inline _LIBCPP_INLINE_VISIBILITY
+__bind<typename decay<_F>::type, typename decay<_BoundArgs>::type...>
+bind(_F&& __f, _BoundArgs&&... __bound_args)
+{
+ typedef __bind<typename decay<_F>::type, typename decay<_BoundArgs>::type...> type;
+ return type(_STD::forward<_F>(__f), _STD::forward<_BoundArgs>(__bound_args)...);
+}
+
+template<class _R, class _F, class ..._BoundArgs>
+inline _LIBCPP_INLINE_VISIBILITY
+__bind_r<_R, typename decay<_F>::type, typename decay<_BoundArgs>::type...>
+bind(_F&& __f, _BoundArgs&&... __bound_args)
+{
+ typedef __bind_r<_R, typename decay<_F>::type, typename decay<_BoundArgs>::type...> type;
+ return type(_STD::forward<_F>(__f), _STD::forward<_BoundArgs>(__bound_args)...);
+}
+
+#endif // _LIBCPP_HAS_NO_VARIADICS
+
+template <>
+struct hash<bool>
+ : public unary_function<bool, size_t>
+{
+ size_t operator()(bool __v) const {return static_cast<size_t>(__v);}
+};
+
+template <>
+struct hash<char>
+ : public unary_function<char, size_t>
+{
+ size_t operator()(char __v) const {return static_cast<size_t>(__v);}
+};
+
+template <>
+struct hash<signed char>
+ : public unary_function<signed char, size_t>
+{
+ size_t operator()(signed char __v) const {return static_cast<size_t>(__v);}
+};
+
+template <>
+struct hash<unsigned char>
+ : public unary_function<unsigned char, size_t>
+{
+ size_t operator()(unsigned char __v) const {return static_cast<size_t>(__v);}
+};
+
+#ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
+
+template <>
+struct hash<char16_t>
+ : public unary_function<char16_t, size_t>
+{
+ size_t operator()(char16_t __v) const {return static_cast<size_t>(__v);}
+};
+
+template <>
+struct hash<char32_t>
+ : public unary_function<char32_t, size_t>
+{
+ size_t operator()(char32_t __v) const {return static_cast<size_t>(__v);}
+};
+
+#endif
+
+template <>
+struct hash<wchar_t>
+ : public unary_function<wchar_t, size_t>
+{
+ size_t operator()(wchar_t __v) const {return static_cast<size_t>(__v);}
+};
+
+template <>
+struct hash<short>
+ : public unary_function<short, size_t>
+{
+ size_t operator()(short __v) const {return static_cast<size_t>(__v);}
+};
+
+template <>
+struct hash<unsigned short>
+ : public unary_function<unsigned short, size_t>
+{
+ size_t operator()(unsigned short __v) const {return static_cast<size_t>(__v);}
+};
+
+template <>
+struct hash<int>
+ : public unary_function<int, size_t>
+{
+ size_t operator()(int __v) const {return static_cast<size_t>(__v);}
+};
+
+template <>
+struct hash<unsigned int>
+ : public unary_function<unsigned int, size_t>
+{
+ size_t operator()(unsigned int __v) const {return static_cast<size_t>(__v);}
+};
+
+template <>
+struct hash<long>
+ : public unary_function<long, size_t>
+{
+ size_t operator()(long __v) const {return static_cast<size_t>(__v);}
+};
+
+template <>
+struct hash<unsigned long>
+ : public unary_function<unsigned long, size_t>
+{
+ size_t operator()(unsigned long __v) const {return static_cast<size_t>(__v);}
+};
+
+template <>
+struct hash<long long>
+ : public unary_function<long long, size_t>
+{
+ size_t operator()(long long __v) const
+ {
+ size_t __r = 0;
+ const size_t* const __p = reinterpret_cast<const size_t*>(&__v);
+ for (unsigned __i = 0; __i < sizeof(argument_type)/sizeof(size_t); ++__i)
+ __r ^= __p[__i];
+ return __r;
+ }
+};
+
+template <>
+struct hash<unsigned long long>
+ : public unary_function<unsigned long long, size_t>
+{
+ size_t operator()(unsigned long long __v) const
+ {
+ size_t __r = 0;
+ const size_t* const __p = reinterpret_cast<const size_t*>(&__v);
+ for (unsigned __i = 0; __i < sizeof(argument_type)/sizeof(size_t); ++__i)
+ __r ^= __p[__i];
+ return __r;
+ }
+};
+
+template <>
+struct hash<float>
+ : public unary_function<float, size_t>
+{
+ size_t operator()(float __v) const
+ {
+ if (__v == 0)
+ return 0;
+ const size_t* const __p = reinterpret_cast<const size_t*>(&__v);
+ return *__p;
+ }
+};
+
+template <>
+struct hash<double>
+ : public unary_function<double, size_t>
+{
+ size_t operator()(double __v) const
+ {
+ if (__v == 0)
+ return 0;
+ size_t __r = 0;
+ const size_t* const __p = reinterpret_cast<const size_t*>(&__v);
+ for (unsigned __i = 0; __i < sizeof(argument_type)/sizeof(size_t); ++__i)
+ __r ^= __p[__i];
+ return __r;
+ }
+};
+
+template <>
+struct hash<long double>
+ : public unary_function<long double, size_t>
+{
+ size_t operator()(long double __v) const
+ {
+ if (__v == 0)
+ return 0;
+ size_t __r = 0;
+ const size_t* const __p = reinterpret_cast<const size_t*>(&__v);
+ for (unsigned __i = 0; __i < sizeof(argument_type)/sizeof(size_t); ++__i)
+ __r ^= __p[__i];
+ return __r;
+ }
+};
+
+template<class _Tp>
+struct hash<_Tp*>
+ : public unary_function<_Tp*, size_t>
+{
+ size_t operator()(_Tp* __v) const
+ {
+ const size_t* const __p = reinterpret_cast<const size_t*>(&__v);
+ return *__p;
+ }
+};
+
+_LIBCPP_END_NAMESPACE_STD
+
+#endif // _LIBCPP_FUNCTIONAL