2010-05-12 03:42:16 +08:00
|
|
|
// -*- C++ -*-
|
|
|
|
//===------------------------ functional ----------------------------------===//
|
|
|
|
//
|
2010-05-12 05:36:01 +08:00
|
|
|
// The LLVM Compiler Infrastructure
|
2010-05-12 03:42:16 +08:00
|
|
|
//
|
2010-11-17 06:09:02 +08:00
|
|
|
// This file is dual licensed under the MIT and the University of Illinois Open
|
|
|
|
// Source Licenses. See LICENSE.TXT for details.
|
2010-05-12 03:42:16 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#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;
|
|
|
|
};
|
|
|
|
|
2010-08-21 03:36:46 +08:00
|
|
|
template <class T>
|
2010-05-12 03:42:16 +08:00
|
|
|
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
|
2011-05-29 01:59:48 +08:00
|
|
|
reference_wrapper(T&) noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
reference_wrapper(T&&) = delete; // do not bind to temps
|
2011-05-29 01:59:48 +08:00
|
|
|
reference_wrapper(const reference_wrapper<T>& x) noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
// assignment
|
2011-05-29 01:59:48 +08:00
|
|
|
reference_wrapper& operator=(const reference_wrapper<T>& x) noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
// access
|
2011-05-29 01:59:48 +08:00
|
|
|
operator T& () const noexcept;
|
|
|
|
T& get() const noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
// invoke
|
|
|
|
template <class... ArgTypes>
|
2013-09-22 01:58:58 +08:00
|
|
|
typename result_of<T&(ArgTypes&&...)>::type
|
2010-05-12 03:42:16 +08:00
|
|
|
operator() (ArgTypes&&...) const;
|
|
|
|
};
|
|
|
|
|
2011-05-29 01:59:48 +08:00
|
|
|
template <class T> reference_wrapper<T> ref(T& t) noexcept;
|
2010-08-21 03:36:46 +08:00
|
|
|
template <class T> void ref(const T&& t) = delete;
|
2011-05-29 01:59:48 +08:00
|
|
|
template <class T> reference_wrapper<T> ref(reference_wrapper<T>t) noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2011-05-29 01:59:48 +08:00
|
|
|
template <class T> reference_wrapper<const T> cref(const T& t) noexcept;
|
2010-08-21 03:36:46 +08:00
|
|
|
template <class T> void cref(const T&& t) = delete;
|
2011-05-29 01:59:48 +08:00
|
|
|
template <class T> reference_wrapper<const T> cref(reference_wrapper<T> t) noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
template <class T> // <class T=void> in C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
struct plus : binary_function<T, T, T>
|
|
|
|
{
|
|
|
|
T operator()(const T& x, const T& y) const;
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
template <class T> // <class T=void> in C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
struct minus : binary_function<T, T, T>
|
|
|
|
{
|
|
|
|
T operator()(const T& x, const T& y) const;
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
template <class T> // <class T=void> in C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
struct multiplies : binary_function<T, T, T>
|
|
|
|
{
|
|
|
|
T operator()(const T& x, const T& y) const;
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
template <class T> // <class T=void> in C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
struct divides : binary_function<T, T, T>
|
|
|
|
{
|
|
|
|
T operator()(const T& x, const T& y) const;
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
template <class T> // <class T=void> in C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
struct modulus : binary_function<T, T, T>
|
|
|
|
{
|
|
|
|
T operator()(const T& x, const T& y) const;
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
template <class T> // <class T=void> in C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
struct negate : unary_function<T, T>
|
|
|
|
{
|
|
|
|
T operator()(const T& x) const;
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
template <class T> // <class T=void> in C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
struct equal_to : binary_function<T, T, bool>
|
|
|
|
{
|
|
|
|
bool operator()(const T& x, const T& y) const;
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
template <class T> // <class T=void> in C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
struct not_equal_to : binary_function<T, T, bool>
|
|
|
|
{
|
|
|
|
bool operator()(const T& x, const T& y) const;
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
template <class T> // <class T=void> in C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
struct greater : binary_function<T, T, bool>
|
|
|
|
{
|
|
|
|
bool operator()(const T& x, const T& y) const;
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
template <class T> // <class T=void> in C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
struct less : binary_function<T, T, bool>
|
|
|
|
{
|
|
|
|
bool operator()(const T& x, const T& y) const;
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
template <class T> // <class T=void> in C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
struct greater_equal : binary_function<T, T, bool>
|
|
|
|
{
|
|
|
|
bool operator()(const T& x, const T& y) const;
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
template <class T> // <class T=void> in C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
struct less_equal : binary_function<T, T, bool>
|
|
|
|
{
|
|
|
|
bool operator()(const T& x, const T& y) const;
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
template <class T> // <class T=void> in C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
struct logical_and : binary_function<T, T, bool>
|
|
|
|
{
|
|
|
|
bool operator()(const T& x, const T& y) const;
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
template <class T> // <class T=void> in C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
struct logical_or : binary_function<T, T, bool>
|
|
|
|
{
|
|
|
|
bool operator()(const T& x, const T& y) const;
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
template <class T> // <class T=void> in C++14
|
2010-05-12 03:42:16 +08:00
|
|
|
struct logical_not : unary_function<T, bool>
|
|
|
|
{
|
|
|
|
bool operator()(const T& x) const;
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
template <class T> // <class T=void> in C++14
|
|
|
|
struct bit_and : unary_function<T, bool>
|
|
|
|
{
|
|
|
|
bool operator()(const T& x, const T& y) const;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <class T> // <class T=void> in C++14
|
|
|
|
struct bit_or : unary_function<T, bool>
|
|
|
|
{
|
|
|
|
bool operator()(const T& x, const T& y) const;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <class T> // <class T=void> in C++14
|
|
|
|
struct bit_xor : unary_function<T, bool>
|
|
|
|
{
|
|
|
|
bool operator()(const T& x, const T& y) const;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <class T=void> // C++14
|
|
|
|
struct bit_xor : unary_function<T, bool>
|
|
|
|
{
|
|
|
|
bool operator()(const T& x) const;
|
|
|
|
};
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
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);
|
|
|
|
|
2016-06-02 09:25:41 +08:00
|
|
|
template <class F> unspecified not_fn(F&& f); // C++17
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
template<class T> struct is_bind_expression;
|
|
|
|
template<class T> struct is_placeholder;
|
|
|
|
|
2016-09-22 08:23:15 +08:00
|
|
|
// See C++14 20.9.9, Function object binders
|
|
|
|
template <class T> constexpr bool is_bind_expression_v
|
|
|
|
= is_bind_expression<T>::value; // C++17
|
|
|
|
template <class T> constexpr int is_placeholder_v
|
|
|
|
= is_placeholder<T>::value; // C++17
|
|
|
|
|
|
|
|
|
2010-08-22 08:02:43 +08:00
|
|
|
template<class Fn, class... BoundArgs>
|
2010-08-21 03:36:46 +08:00
|
|
|
unspecified bind(Fn&&, BoundArgs&&...);
|
2010-08-22 08:02:43 +08:00
|
|
|
template<class R, class Fn, class... BoundArgs>
|
2010-08-21 03:36:46 +08:00
|
|
|
unspecified bind(Fn&&, BoundArgs&&...);
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-08-22 08:02:43 +08:00
|
|
|
namespace placeholders {
|
|
|
|
// M is the implementation-defined number of placeholders
|
2010-05-12 03:42:16 +08:00
|
|
|
extern unspecified _1;
|
|
|
|
extern unspecified _2;
|
2010-08-22 08:02:43 +08:00
|
|
|
.
|
|
|
|
.
|
|
|
|
.
|
2011-11-30 02:15:50 +08:00
|
|
|
extern unspecified _Mp;
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class Operation>
|
2017-04-14 02:25:32 +08:00
|
|
|
class binder1st // deprecated in C++11, removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
: 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>
|
2017-04-14 02:25:32 +08:00
|
|
|
binder1st<Operation> bind1st(const Operation& op, const T& x); // deprecated in C++11, removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
template <class Operation>
|
2017-04-14 02:25:32 +08:00
|
|
|
class binder2nd // deprecated in C++11, removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
: 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>
|
2017-04-14 02:25:32 +08:00
|
|
|
binder2nd<Operation> bind2nd(const Operation& op, const T& x); // deprecated in C++11, removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2017-04-14 02:25:32 +08:00
|
|
|
template <class Arg, class Result> // deprecated in C++11, removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
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>
|
2017-04-14 02:25:32 +08:00
|
|
|
pointer_to_unary_function<Arg,Result> ptr_fun(Result (*f)(Arg)); // deprecated in C++11, removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2017-04-14 02:25:32 +08:00
|
|
|
template <class Arg1, class Arg2, class Result> // deprecated in C++11, removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
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>
|
2017-04-14 02:25:32 +08:00
|
|
|
pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*f)(Arg1,Arg2)); // deprecated in C++11, removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2017-04-14 02:25:32 +08:00
|
|
|
template<class S, class T> // deprecated in C++11, removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
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>
|
2017-04-14 02:25:32 +08:00
|
|
|
class mem_fun1_t : public binary_function<T*, A, S> // deprecated in C++11, removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
explicit mem_fun1_t(S (T::*p)(A));
|
|
|
|
S operator()(T* p, A x) const;
|
|
|
|
};
|
|
|
|
|
2017-04-14 02:25:32 +08:00
|
|
|
template<class S, class T> mem_fun_t<S,T> mem_fun(S (T::*f)()); // deprecated in C++11, removed in C++17
|
|
|
|
template<class S, class T, class A> mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A)); // deprecated in C++11, removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
template<class S, class T>
|
2017-04-14 02:25:32 +08:00
|
|
|
class mem_fun_ref_t : public unary_function<T, S> // deprecated in C++11, removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
explicit mem_fun_ref_t(S (T::*p)());
|
|
|
|
S operator()(T& p) const;
|
|
|
|
};
|
|
|
|
|
|
|
|
template<class S, class T, class A>
|
2017-04-14 02:25:32 +08:00
|
|
|
class mem_fun1_ref_t : public binary_function<T, A, S> // deprecated in C++11, removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
explicit mem_fun1_ref_t(S (T::*p)(A));
|
|
|
|
S operator()(T& p, A x) const;
|
|
|
|
};
|
|
|
|
|
2017-04-14 02:25:32 +08:00
|
|
|
template<class S, class T> mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)()); // deprecated in C++11, removed in C++17
|
|
|
|
template<class S, class T, class A> mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A)); // deprecated in C++11, removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
template <class S, class T>
|
2017-04-14 02:25:32 +08:00
|
|
|
class const_mem_fun_t : public unary_function<const T*, S> // deprecated in C++11, removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
explicit const_mem_fun_t(S (T::*p)() const);
|
|
|
|
S operator()(const T* p) const;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <class S, class T, class A>
|
2017-04-14 02:25:32 +08:00
|
|
|
class const_mem_fun1_t : public binary_function<const T*, A, S> // deprecated in C++11, removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
explicit const_mem_fun1_t(S (T::*p)(A) const);
|
|
|
|
S operator()(const T* p, A x) const;
|
|
|
|
};
|
|
|
|
|
2017-04-14 02:25:32 +08:00
|
|
|
template <class S, class T> const_mem_fun_t<S,T> mem_fun(S (T::*f)() const); // deprecated in C++11, removed in C++17
|
|
|
|
template <class S, class T, class A> const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const); // deprecated in C++11, removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
template <class S, class T>
|
2017-04-14 02:25:32 +08:00
|
|
|
class const_mem_fun_ref_t : public unary_function<T, S> // deprecated in C++11, removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
explicit const_mem_fun_ref_t(S (T::*p)() const);
|
|
|
|
S operator()(const T& p) const;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <class S, class T, class A>
|
2017-04-14 02:25:32 +08:00
|
|
|
class const_mem_fun1_ref_t : public binary_function<T, A, S> // deprecated in C++11, removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
explicit const_mem_fun1_ref_t(S (T::*p)(A) const);
|
|
|
|
S operator()(const T& p, A x) const;
|
|
|
|
};
|
|
|
|
|
2017-04-14 02:25:32 +08:00
|
|
|
template <class S, class T> const_mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)() const); // deprecated in C++11, removed in C++17
|
|
|
|
template <class S, class T, class A> const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const); // deprecated in C++11, removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-08-21 03:36:46 +08:00
|
|
|
template<class R, class T> unspecified mem_fn(R T::*);
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
class bad_function_call
|
|
|
|
: public exception
|
|
|
|
{
|
|
|
|
};
|
|
|
|
|
2010-08-21 03:36:46 +08:00
|
|
|
template<class> class function; // undefined
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-08-21 03:36:46 +08:00
|
|
|
template<class R, class... ArgTypes>
|
2010-05-12 03:42:16 +08:00
|
|
|
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;
|
|
|
|
|
2010-08-21 03:36:46 +08:00
|
|
|
// construct/copy/destroy:
|
2011-05-29 01:59:48 +08:00
|
|
|
function() noexcept;
|
|
|
|
function(nullptr_t) noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
function(const function&);
|
2011-05-29 01:59:48 +08:00
|
|
|
function(function&&) noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
template<class F>
|
|
|
|
function(F);
|
|
|
|
template<Allocator Alloc>
|
2016-10-14 05:06:03 +08:00
|
|
|
function(allocator_arg_t, const Alloc&) noexcept; // removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
template<Allocator Alloc>
|
2016-10-14 05:06:03 +08:00
|
|
|
function(allocator_arg_t, const Alloc&, nullptr_t) noexcept; // removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
template<Allocator Alloc>
|
2016-10-14 05:06:03 +08:00
|
|
|
function(allocator_arg_t, const Alloc&, const function&); // removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
template<Allocator Alloc>
|
2016-10-14 05:06:03 +08:00
|
|
|
function(allocator_arg_t, const Alloc&, function&&); // removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
template<class F, Allocator Alloc>
|
2016-10-14 05:06:03 +08:00
|
|
|
function(allocator_arg_t, const Alloc&, F); // removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
function& operator=(const function&);
|
2011-05-29 01:59:48 +08:00
|
|
|
function& operator=(function&&) noexcept;
|
2011-05-29 21:53:56 +08:00
|
|
|
function& operator=(nullptr_t) noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
template<class F>
|
2010-08-21 03:36:46 +08:00
|
|
|
function& operator=(F&&);
|
2010-05-12 03:42:16 +08:00
|
|
|
template<class F>
|
2011-05-29 01:59:48 +08:00
|
|
|
function& operator=(reference_wrapper<F>) noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
~function();
|
|
|
|
|
2010-08-21 03:36:46 +08:00
|
|
|
// function modifiers:
|
2011-05-29 01:59:48 +08:00
|
|
|
void swap(function&) noexcept;
|
2010-08-21 03:36:46 +08:00
|
|
|
template<class F, class Alloc>
|
2016-01-26 01:29:55 +08:00
|
|
|
void assign(F&&, const Alloc&); // Removed in C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-08-21 03:36:46 +08:00
|
|
|
// function capacity:
|
2011-05-29 01:59:48 +08:00
|
|
|
explicit operator bool() const noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-08-21 03:36:46 +08:00
|
|
|
// function invocation:
|
2010-05-12 03:42:16 +08:00
|
|
|
R operator()(ArgTypes...) const;
|
|
|
|
|
2010-08-21 03:36:46 +08:00
|
|
|
// function target access:
|
2011-05-29 01:59:48 +08:00
|
|
|
const std::type_info& target_type() const noexcept;
|
|
|
|
template <typename T> T* target() noexcept;
|
|
|
|
template <typename T> const T* target() const noexcept;
|
2010-08-21 03:36:46 +08:00
|
|
|
};
|
|
|
|
|
2010-08-22 08:02:43 +08:00
|
|
|
// Null pointer comparisons:
|
|
|
|
template <class R, class ... ArgTypes>
|
2011-05-29 01:59:48 +08:00
|
|
|
bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-08-22 08:02:43 +08:00
|
|
|
template <class R, class ... ArgTypes>
|
2011-05-29 01:59:48 +08:00
|
|
|
bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-08-22 08:02:43 +08:00
|
|
|
template <class R, class ... ArgTypes>
|
2011-05-29 01:59:48 +08:00
|
|
|
bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-08-22 08:02:43 +08:00
|
|
|
template <class R, class ... ArgTypes>
|
2011-05-29 01:59:48 +08:00
|
|
|
bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-08-22 08:02:43 +08:00
|
|
|
// specialized algorithms:
|
|
|
|
template <class R, class ... ArgTypes>
|
2011-05-29 01:59:48 +08:00
|
|
|
void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
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*>;
|
2017-03-23 14:20:18 +08:00
|
|
|
template <> struct hash<nullptr_t>; // C++17
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
} // 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>
|
2017-01-21 08:02:12 +08:00
|
|
|
#include <utility>
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
#include <__functional_base>
|
|
|
|
|
2011-10-18 04:05:10 +08:00
|
|
|
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
2010-05-12 03:42:16 +08:00
|
|
|
#pragma GCC system_header
|
2011-10-18 04:05:10 +08:00
|
|
|
#endif
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
_LIBCPP_BEGIN_NAMESPACE_STD
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <class _Tp = void>
|
|
|
|
#else
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Tp>
|
2013-07-29 22:21:53 +08:00
|
|
|
#endif
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS plus : binary_function<_Tp, _Tp, _Tp>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
_Tp operator()(const _Tp& __x, const _Tp& __y) const
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __x + __y;}
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <>
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS plus<void>
|
2013-07-29 22:21:53 +08:00
|
|
|
{
|
|
|
|
template <class _T1, class _T2>
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
auto operator()(_T1&& __t, _T2&& __u) const
|
2015-02-25 20:20:52 +08:00
|
|
|
_NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u)))
|
|
|
|
-> decltype (_VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u))
|
|
|
|
{ return _VSTD::forward<_T1>(__t) + _VSTD::forward<_T2>(__u); }
|
2013-08-13 09:11:06 +08:00
|
|
|
typedef void is_transparent;
|
2013-07-29 22:21:53 +08:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <class _Tp = void>
|
|
|
|
#else
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Tp>
|
2013-07-29 22:21:53 +08:00
|
|
|
#endif
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS minus : binary_function<_Tp, _Tp, _Tp>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
_Tp operator()(const _Tp& __x, const _Tp& __y) const
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __x - __y;}
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <>
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS minus<void>
|
2013-07-29 22:21:53 +08:00
|
|
|
{
|
|
|
|
template <class _T1, class _T2>
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
auto operator()(_T1&& __t, _T2&& __u) const
|
2015-02-25 20:20:52 +08:00
|
|
|
_NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u)))
|
|
|
|
-> decltype (_VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u))
|
|
|
|
{ return _VSTD::forward<_T1>(__t) - _VSTD::forward<_T2>(__u); }
|
2013-08-13 09:11:06 +08:00
|
|
|
typedef void is_transparent;
|
2013-07-29 22:21:53 +08:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <class _Tp = void>
|
|
|
|
#else
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Tp>
|
2013-07-29 22:21:53 +08:00
|
|
|
#endif
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS multiplies : binary_function<_Tp, _Tp, _Tp>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
_Tp operator()(const _Tp& __x, const _Tp& __y) const
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __x * __y;}
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <>
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS multiplies<void>
|
2013-07-29 22:21:53 +08:00
|
|
|
{
|
|
|
|
template <class _T1, class _T2>
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
auto operator()(_T1&& __t, _T2&& __u) const
|
2015-02-25 20:20:52 +08:00
|
|
|
_NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u)))
|
|
|
|
-> decltype (_VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u))
|
|
|
|
{ return _VSTD::forward<_T1>(__t) * _VSTD::forward<_T2>(__u); }
|
2013-08-13 09:11:06 +08:00
|
|
|
typedef void is_transparent;
|
2013-07-29 22:21:53 +08:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <class _Tp = void>
|
|
|
|
#else
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Tp>
|
2013-07-29 22:21:53 +08:00
|
|
|
#endif
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS divides : binary_function<_Tp, _Tp, _Tp>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
_Tp operator()(const _Tp& __x, const _Tp& __y) const
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __x / __y;}
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <>
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS divides<void>
|
2013-07-29 22:21:53 +08:00
|
|
|
{
|
|
|
|
template <class _T1, class _T2>
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
auto operator()(_T1&& __t, _T2&& __u) const
|
2015-02-25 20:20:52 +08:00
|
|
|
_NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u)))
|
|
|
|
-> decltype (_VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u))
|
|
|
|
{ return _VSTD::forward<_T1>(__t) / _VSTD::forward<_T2>(__u); }
|
2013-08-13 09:11:06 +08:00
|
|
|
typedef void is_transparent;
|
2013-07-29 22:21:53 +08:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <class _Tp = void>
|
|
|
|
#else
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Tp>
|
2013-07-29 22:21:53 +08:00
|
|
|
#endif
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS modulus : binary_function<_Tp, _Tp, _Tp>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
_Tp operator()(const _Tp& __x, const _Tp& __y) const
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __x % __y;}
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <>
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS modulus<void>
|
2013-07-29 22:21:53 +08:00
|
|
|
{
|
|
|
|
template <class _T1, class _T2>
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
auto operator()(_T1&& __t, _T2&& __u) const
|
2015-02-25 20:20:52 +08:00
|
|
|
_NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u)))
|
|
|
|
-> decltype (_VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u))
|
|
|
|
{ return _VSTD::forward<_T1>(__t) % _VSTD::forward<_T2>(__u); }
|
2013-08-13 09:11:06 +08:00
|
|
|
typedef void is_transparent;
|
2013-07-29 22:21:53 +08:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <class _Tp = void>
|
|
|
|
#else
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Tp>
|
2013-07-29 22:21:53 +08:00
|
|
|
#endif
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS negate : unary_function<_Tp, _Tp>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
_Tp operator()(const _Tp& __x) const
|
2010-05-12 03:42:16 +08:00
|
|
|
{return -__x;}
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <>
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS negate<void>
|
2013-07-29 22:21:53 +08:00
|
|
|
{
|
|
|
|
template <class _Tp>
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
auto operator()(_Tp&& __x) const
|
2015-02-25 20:20:52 +08:00
|
|
|
_NOEXCEPT_(noexcept(- _VSTD::forward<_Tp>(__x)))
|
|
|
|
-> decltype (- _VSTD::forward<_Tp>(__x))
|
|
|
|
{ return - _VSTD::forward<_Tp>(__x); }
|
2013-08-13 09:11:06 +08:00
|
|
|
typedef void is_transparent;
|
2013-07-29 22:21:53 +08:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <class _Tp = void>
|
|
|
|
#else
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Tp>
|
2013-07-29 22:21:53 +08:00
|
|
|
#endif
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS equal_to : binary_function<_Tp, _Tp, bool>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator()(const _Tp& __x, const _Tp& __y) const
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __x == __y;}
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <>
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS equal_to<void>
|
2013-07-29 22:21:53 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
template <class _T1, class _T2>
|
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
2013-07-29 22:21:53 +08:00
|
|
|
auto operator()(_T1&& __t, _T2&& __u) const
|
2015-02-25 20:20:52 +08:00
|
|
|
_NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u)))
|
|
|
|
-> decltype (_VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u))
|
|
|
|
{ return _VSTD::forward<_T1>(__t) == _VSTD::forward<_T2>(__u); }
|
2013-08-13 09:11:06 +08:00
|
|
|
typedef void is_transparent;
|
2013-07-29 22:21:53 +08:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <class _Tp = void>
|
|
|
|
#else
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Tp>
|
2013-07-29 22:21:53 +08:00
|
|
|
#endif
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS not_equal_to : binary_function<_Tp, _Tp, bool>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator()(const _Tp& __x, const _Tp& __y) const
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __x != __y;}
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <>
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS not_equal_to<void>
|
2013-07-29 22:21:53 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
template <class _T1, class _T2>
|
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
2013-07-29 22:21:53 +08:00
|
|
|
auto operator()(_T1&& __t, _T2&& __u) const
|
2015-02-25 20:20:52 +08:00
|
|
|
_NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u)))
|
|
|
|
-> decltype (_VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u))
|
|
|
|
{ return _VSTD::forward<_T1>(__t) != _VSTD::forward<_T2>(__u); }
|
2013-08-13 09:11:06 +08:00
|
|
|
typedef void is_transparent;
|
2013-07-29 22:21:53 +08:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <class _Tp = void>
|
|
|
|
#else
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Tp>
|
2013-07-29 22:21:53 +08:00
|
|
|
#endif
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS greater : binary_function<_Tp, _Tp, bool>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator()(const _Tp& __x, const _Tp& __y) const
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __x > __y;}
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <>
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS greater<void>
|
2013-07-29 22:21:53 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
template <class _T1, class _T2>
|
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
2013-07-29 22:21:53 +08:00
|
|
|
auto operator()(_T1&& __t, _T2&& __u) const
|
2015-02-25 20:20:52 +08:00
|
|
|
_NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u)))
|
|
|
|
-> decltype (_VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u))
|
|
|
|
{ return _VSTD::forward<_T1>(__t) > _VSTD::forward<_T2>(__u); }
|
2013-08-13 09:11:06 +08:00
|
|
|
typedef void is_transparent;
|
2013-07-29 22:21:53 +08:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
2012-02-22 05:02:58 +08:00
|
|
|
// less in <__functional_base>
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <class _Tp = void>
|
|
|
|
#else
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Tp>
|
2013-07-29 22:21:53 +08:00
|
|
|
#endif
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS greater_equal : binary_function<_Tp, _Tp, bool>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator()(const _Tp& __x, const _Tp& __y) const
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __x >= __y;}
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <>
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS greater_equal<void>
|
2013-07-29 22:21:53 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
template <class _T1, class _T2>
|
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
2013-07-29 22:21:53 +08:00
|
|
|
auto operator()(_T1&& __t, _T2&& __u) const
|
2015-02-25 20:20:52 +08:00
|
|
|
_NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u)))
|
|
|
|
-> decltype (_VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u))
|
|
|
|
{ return _VSTD::forward<_T1>(__t) >= _VSTD::forward<_T2>(__u); }
|
2013-08-13 09:11:06 +08:00
|
|
|
typedef void is_transparent;
|
2013-07-29 22:21:53 +08:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <class _Tp = void>
|
|
|
|
#else
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Tp>
|
2013-07-29 22:21:53 +08:00
|
|
|
#endif
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS less_equal : binary_function<_Tp, _Tp, bool>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator()(const _Tp& __x, const _Tp& __y) const
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __x <= __y;}
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <>
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS less_equal<void>
|
2013-07-29 22:21:53 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
template <class _T1, class _T2>
|
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
2013-07-29 22:21:53 +08:00
|
|
|
auto operator()(_T1&& __t, _T2&& __u) const
|
2015-02-25 20:20:52 +08:00
|
|
|
_NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u)))
|
|
|
|
-> decltype (_VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u))
|
|
|
|
{ return _VSTD::forward<_T1>(__t) <= _VSTD::forward<_T2>(__u); }
|
2013-08-13 09:11:06 +08:00
|
|
|
typedef void is_transparent;
|
2013-07-29 22:21:53 +08:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <class _Tp = void>
|
|
|
|
#else
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Tp>
|
2013-07-29 22:21:53 +08:00
|
|
|
#endif
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS logical_and : binary_function<_Tp, _Tp, bool>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator()(const _Tp& __x, const _Tp& __y) const
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __x && __y;}
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <>
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS logical_and<void>
|
2013-07-29 22:21:53 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
template <class _T1, class _T2>
|
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
2013-07-29 22:21:53 +08:00
|
|
|
auto operator()(_T1&& __t, _T2&& __u) const
|
2015-02-25 20:20:52 +08:00
|
|
|
_NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u)))
|
|
|
|
-> decltype (_VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u))
|
|
|
|
{ return _VSTD::forward<_T1>(__t) && _VSTD::forward<_T2>(__u); }
|
2013-08-13 09:11:06 +08:00
|
|
|
typedef void is_transparent;
|
2013-07-29 22:21:53 +08:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <class _Tp = void>
|
|
|
|
#else
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Tp>
|
2013-07-29 22:21:53 +08:00
|
|
|
#endif
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS logical_or : binary_function<_Tp, _Tp, bool>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator()(const _Tp& __x, const _Tp& __y) const
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __x || __y;}
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <>
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS logical_or<void>
|
2013-07-29 22:21:53 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
template <class _T1, class _T2>
|
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
2013-07-29 22:21:53 +08:00
|
|
|
auto operator()(_T1&& __t, _T2&& __u) const
|
2015-02-25 20:20:52 +08:00
|
|
|
_NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u)))
|
|
|
|
-> decltype (_VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u))
|
|
|
|
{ return _VSTD::forward<_T1>(__t) || _VSTD::forward<_T2>(__u); }
|
2013-08-13 09:11:06 +08:00
|
|
|
typedef void is_transparent;
|
2013-07-29 22:21:53 +08:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <class _Tp = void>
|
|
|
|
#else
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Tp>
|
2013-07-29 22:21:53 +08:00
|
|
|
#endif
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS logical_not : unary_function<_Tp, bool>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator()(const _Tp& __x) const
|
2010-05-12 03:42:16 +08:00
|
|
|
{return !__x;}
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <>
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS logical_not<void>
|
2013-07-29 22:21:53 +08:00
|
|
|
{
|
|
|
|
template <class _Tp>
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
auto operator()(_Tp&& __x) const
|
2015-02-25 20:20:52 +08:00
|
|
|
_NOEXCEPT_(noexcept(!_VSTD::forward<_Tp>(__x)))
|
|
|
|
-> decltype (!_VSTD::forward<_Tp>(__x))
|
|
|
|
{ return !_VSTD::forward<_Tp>(__x); }
|
2013-08-13 09:11:06 +08:00
|
|
|
typedef void is_transparent;
|
2013-07-29 22:21:53 +08:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <class _Tp = void>
|
|
|
|
#else
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Tp>
|
2013-07-29 22:21:53 +08:00
|
|
|
#endif
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS bit_and : binary_function<_Tp, _Tp, _Tp>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
_Tp operator()(const _Tp& __x, const _Tp& __y) const
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __x & __y;}
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <>
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS bit_and<void>
|
2013-07-29 22:21:53 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
template <class _T1, class _T2>
|
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
2013-07-29 22:21:53 +08:00
|
|
|
auto operator()(_T1&& __t, _T2&& __u) const
|
2015-02-25 20:20:52 +08:00
|
|
|
_NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u)))
|
|
|
|
-> decltype (_VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u))
|
|
|
|
{ return _VSTD::forward<_T1>(__t) & _VSTD::forward<_T2>(__u); }
|
2013-08-13 09:11:06 +08:00
|
|
|
typedef void is_transparent;
|
2013-07-29 22:21:53 +08:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <class _Tp = void>
|
|
|
|
#else
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Tp>
|
2013-07-29 22:21:53 +08:00
|
|
|
#endif
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS bit_or : binary_function<_Tp, _Tp, _Tp>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
_Tp operator()(const _Tp& __x, const _Tp& __y) const
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __x | __y;}
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <>
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS bit_or<void>
|
2013-07-29 22:21:53 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
template <class _T1, class _T2>
|
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
2013-07-29 22:21:53 +08:00
|
|
|
auto operator()(_T1&& __t, _T2&& __u) const
|
2015-02-25 20:20:52 +08:00
|
|
|
_NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u)))
|
|
|
|
-> decltype (_VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u))
|
|
|
|
{ return _VSTD::forward<_T1>(__t) | _VSTD::forward<_T2>(__u); }
|
2013-08-13 09:11:06 +08:00
|
|
|
typedef void is_transparent;
|
2013-07-29 22:21:53 +08:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <class _Tp = void>
|
|
|
|
#else
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Tp>
|
2013-07-29 22:21:53 +08:00
|
|
|
#endif
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS bit_xor : binary_function<_Tp, _Tp, _Tp>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
_Tp operator()(const _Tp& __x, const _Tp& __y) const
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __x ^ __y;}
|
|
|
|
};
|
|
|
|
|
2013-07-29 22:21:53 +08:00
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <>
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS bit_xor<void>
|
2013-07-29 22:21:53 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
template <class _T1, class _T2>
|
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
2013-07-29 22:21:53 +08:00
|
|
|
auto operator()(_T1&& __t, _T2&& __u) const
|
2015-02-25 20:20:52 +08:00
|
|
|
_NOEXCEPT_(noexcept(_VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u)))
|
|
|
|
-> decltype (_VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u))
|
|
|
|
{ return _VSTD::forward<_T1>(__t) ^ _VSTD::forward<_T2>(__u); }
|
2013-08-13 09:11:06 +08:00
|
|
|
typedef void is_transparent;
|
2013-07-29 22:21:53 +08:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
|
|
#if _LIBCPP_STD_VER > 11
|
|
|
|
template <class _Tp = void>
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS bit_not : unary_function<_Tp, _Tp>
|
2013-07-29 22:21:53 +08:00
|
|
|
{
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
_Tp operator()(const _Tp& __x) const
|
2013-07-29 22:21:53 +08:00
|
|
|
{return ~__x;}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <>
|
2017-01-05 07:56:00 +08:00
|
|
|
struct _LIBCPP_TEMPLATE_VIS bit_not<void>
|
2013-07-29 22:21:53 +08:00
|
|
|
{
|
|
|
|
template <class _Tp>
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
auto operator()(_Tp&& __x) const
|
2015-02-25 20:20:52 +08:00
|
|
|
_NOEXCEPT_(noexcept(~_VSTD::forward<_Tp>(__x)))
|
|
|
|
-> decltype (~_VSTD::forward<_Tp>(__x))
|
|
|
|
{ return ~_VSTD::forward<_Tp>(__x); }
|
2013-08-13 09:11:06 +08:00
|
|
|
typedef void is_transparent;
|
2013-07-29 22:21:53 +08:00
|
|
|
};
|
|
|
|
#endif
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Predicate>
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS unary_negate
|
2010-05-12 03:42:16 +08:00
|
|
|
: public unary_function<typename _Predicate::argument_type, bool>
|
|
|
|
{
|
|
|
|
_Predicate __pred_;
|
|
|
|
public:
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
explicit unary_negate(const _Predicate& __pred)
|
2010-05-12 03:42:16 +08:00
|
|
|
: __pred_(__pred) {}
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator()(const typename _Predicate::argument_type& __x) const
|
2010-05-12 03:42:16 +08:00
|
|
|
{return !__pred_(__x);}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <class _Predicate>
|
2013-09-29 03:06:12 +08:00
|
|
|
inline _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
unary_negate<_Predicate>
|
|
|
|
not1(const _Predicate& __pred) {return unary_negate<_Predicate>(__pred);}
|
|
|
|
|
|
|
|
template <class _Predicate>
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS binary_negate
|
2010-05-12 03:42:16 +08:00
|
|
|
: public binary_function<typename _Predicate::first_argument_type,
|
|
|
|
typename _Predicate::second_argument_type,
|
|
|
|
bool>
|
|
|
|
{
|
|
|
|
_Predicate __pred_;
|
|
|
|
public:
|
2013-09-29 03:06:12 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY explicit _LIBCPP_CONSTEXPR_AFTER_CXX11
|
|
|
|
binary_negate(const _Predicate& __pred) : __pred_(__pred) {}
|
|
|
|
|
|
|
|
_LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool operator()(const typename _Predicate::first_argument_type& __x,
|
2010-05-12 03:42:16 +08:00
|
|
|
const typename _Predicate::second_argument_type& __y) const
|
|
|
|
{return !__pred_(__x, __y);}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <class _Predicate>
|
2013-09-29 03:06:12 +08:00
|
|
|
inline _LIBCPP_CONSTEXPR_AFTER_CXX11 _LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
binary_negate<_Predicate>
|
|
|
|
not2(const _Predicate& __pred) {return binary_negate<_Predicate>(__pred);}
|
|
|
|
|
2017-04-14 02:25:32 +08:00
|
|
|
#if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_BINDERS)
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class __Operation>
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS binder1st
|
2010-05-12 03:42:16 +08:00
|
|
|
: 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>
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS binder2nd
|
2010-05-12 03:42:16 +08:00
|
|
|
: public unary_function<typename __Operation::first_argument_type,
|
|
|
|
typename __Operation::result_type>
|
|
|
|
{
|
|
|
|
protected:
|
|
|
|
__Operation op;
|
|
|
|
typename __Operation::second_argument_type value;
|
|
|
|
public:
|
2010-09-22 06:55:27 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2010-05-12 03:42:16 +08:00
|
|
|
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>
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS pointer_to_unary_function
|
2010-09-22 06:55:27 +08:00
|
|
|
: public unary_function<_Arg, _Result>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
_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>
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS pointer_to_binary_function
|
2010-09-22 06:55:27 +08:00
|
|
|
: public binary_function<_Arg1, _Arg2, _Result>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
_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>
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS mem_fun_t : public unary_function<_Tp*, _Sp>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
_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>
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS mem_fun1_t : public binary_function<_Tp*, _Ap, _Sp>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
_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>
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS mem_fun_ref_t : public unary_function<_Tp, _Sp>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
_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>
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS mem_fun1_ref_t : public binary_function<_Tp, _Ap, _Sp>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
_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>
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS const_mem_fun_t : public unary_function<const _Tp*, _Sp>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
_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>
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS const_mem_fun1_t : public binary_function<const _Tp*, _Ap, _Sp>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
_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>
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS const_mem_fun_ref_t : public unary_function<_Tp, _Sp>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
_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>
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS const_mem_fun1_ref_t
|
2010-09-22 06:55:27 +08:00
|
|
|
: public binary_function<_Tp, _Ap, _Sp>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
_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);}
|
2017-04-14 02:25:32 +08:00
|
|
|
#endif
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2015-07-22 12:14:38 +08:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// MEMFUN
|
|
|
|
//==============================================================================
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
template <class _Tp>
|
|
|
|
class __mem_fn
|
|
|
|
: public __weak_result_type<_Tp>
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
// types
|
|
|
|
typedef _Tp type;
|
|
|
|
private:
|
|
|
|
type __f_;
|
|
|
|
|
|
|
|
public:
|
2015-10-26 04:12:16 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY __mem_fn(type __f) _NOEXCEPT : __f_(__f) {}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2017-04-19 09:28:47 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
// invoke
|
|
|
|
template <class... _ArgTypes>
|
2015-07-23 06:43:27 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename __invoke_return<type, _ArgTypes...>::type
|
|
|
|
operator() (_ArgTypes&&... __args) const {
|
|
|
|
return __invoke(__f_, _VSTD::forward<_ArgTypes>(__args)...);
|
|
|
|
}
|
|
|
|
#else
|
|
|
|
|
|
|
|
template <class _A0>
|
[libcxx] Rewrite C++03 __invoke.
Summary:
This patch rewrites the C++03 `__invoke` and related meta-programming. There are a number of major changes.
`__invoke` in C++03 now has a fallback overload for when the invoke expression is ill-formed (similar to C++11). This means that the `__invoke_return` traits will return `__nat` when `__invoke(...)` is ill formed. This would previously cause a compile error.
Bullets 1-4 of `__invoke` have been rewritten. In the old version `__invoke` had 32 overloads for bullets 1 and 2,
one for each possible cv-qualified function signature with arities 0-3. 64 overloads would be needed to support member functions
with varargs. Currently these overloads were fundamentally broken. An example overload looked like:
```
template <class Rp, class Tp, class T1, class A0>
Rp __invoke(Rp (Tp::*pm)(A0) const, T1&, A0&)
```
Because `A0` appeared in two different deducible contexts it would have to deduce to be an exact match or the overload
would be rejected. This is made even worse because `A0` appears without a reference qualifier in the member function signature
and with a reference qualifier as an `__invoke` parameter. This means that only member functions that took all
of their arguments by value could be matched.
One possible fix would be to make the second occurrence of `A0` appear in a non-deducible context. This way
any type convertible to `A0` could be passed as the first parameter. The benefit of this approach is that the
signature of the member function enforces the arity and types taken by the `__invoke` signature it generates. However
nothing in the `INVOKE` specification requires this behavior.
My solution is to use a `__invoke_enable_if<PM_Type, Tp>` metafunction to selectively enable the `__invoke` overloads for bullets 1, 2, 3 and 4. It uses `__member_function_traits` to inspect and extract the return type and class type of the pointer to member. Using `__member_function_traits` to inspect `PM_Type` also allows us to reduce the number of `__invoke` overloads from 32 to 8 and add
varargs support at the same time.
Because `__invoke_enable_if` knows the exact return type of `__invoke` for bullets 1-4 we no longer need to use `decltype(__invoke(...))` to
compute the return type in the `__invoke_return*` traits. This will reduce the problems caused by `#define decltype(X) __typeof__(X)` in C++03.
Tests for this change have already been committed. All tests in `test/std/utilities/function.objects` now pass in C++03, previously there were 20 failures.
Reviewers: K-ballo, howard.hinnant, mclow.lists
Subscribers: cfe-commits
Differential Revision: http://reviews.llvm.org/D11553
llvm-svn: 246068
2015-08-27 04:15:02 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2015-07-23 06:43:27 +08:00
|
|
|
typename __invoke_return0<type, _A0>::type
|
|
|
|
operator() (_A0& __a0) const {
|
|
|
|
return __invoke(__f_, __a0);
|
|
|
|
}
|
|
|
|
|
[libcxx] Rewrite C++03 __invoke.
Summary:
This patch rewrites the C++03 `__invoke` and related meta-programming. There are a number of major changes.
`__invoke` in C++03 now has a fallback overload for when the invoke expression is ill-formed (similar to C++11). This means that the `__invoke_return` traits will return `__nat` when `__invoke(...)` is ill formed. This would previously cause a compile error.
Bullets 1-4 of `__invoke` have been rewritten. In the old version `__invoke` had 32 overloads for bullets 1 and 2,
one for each possible cv-qualified function signature with arities 0-3. 64 overloads would be needed to support member functions
with varargs. Currently these overloads were fundamentally broken. An example overload looked like:
```
template <class Rp, class Tp, class T1, class A0>
Rp __invoke(Rp (Tp::*pm)(A0) const, T1&, A0&)
```
Because `A0` appeared in two different deducible contexts it would have to deduce to be an exact match or the overload
would be rejected. This is made even worse because `A0` appears without a reference qualifier in the member function signature
and with a reference qualifier as an `__invoke` parameter. This means that only member functions that took all
of their arguments by value could be matched.
One possible fix would be to make the second occurrence of `A0` appear in a non-deducible context. This way
any type convertible to `A0` could be passed as the first parameter. The benefit of this approach is that the
signature of the member function enforces the arity and types taken by the `__invoke` signature it generates. However
nothing in the `INVOKE` specification requires this behavior.
My solution is to use a `__invoke_enable_if<PM_Type, Tp>` metafunction to selectively enable the `__invoke` overloads for bullets 1, 2, 3 and 4. It uses `__member_function_traits` to inspect and extract the return type and class type of the pointer to member. Using `__member_function_traits` to inspect `PM_Type` also allows us to reduce the number of `__invoke` overloads from 32 to 8 and add
varargs support at the same time.
Because `__invoke_enable_if` knows the exact return type of `__invoke` for bullets 1-4 we no longer need to use `decltype(__invoke(...))` to
compute the return type in the `__invoke_return*` traits. This will reduce the problems caused by `#define decltype(X) __typeof__(X)` in C++03.
Tests for this change have already been committed. All tests in `test/std/utilities/function.objects` now pass in C++03, previously there were 20 failures.
Reviewers: K-ballo, howard.hinnant, mclow.lists
Subscribers: cfe-commits
Differential Revision: http://reviews.llvm.org/D11553
llvm-svn: 246068
2015-08-27 04:15:02 +08:00
|
|
|
template <class _A0>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename __invoke_return0<type, _A0 const>::type
|
|
|
|
operator() (_A0 const& __a0) const {
|
|
|
|
return __invoke(__f_, __a0);
|
|
|
|
}
|
|
|
|
|
2015-07-23 06:43:27 +08:00
|
|
|
template <class _A0, class _A1>
|
[libcxx] Rewrite C++03 __invoke.
Summary:
This patch rewrites the C++03 `__invoke` and related meta-programming. There are a number of major changes.
`__invoke` in C++03 now has a fallback overload for when the invoke expression is ill-formed (similar to C++11). This means that the `__invoke_return` traits will return `__nat` when `__invoke(...)` is ill formed. This would previously cause a compile error.
Bullets 1-4 of `__invoke` have been rewritten. In the old version `__invoke` had 32 overloads for bullets 1 and 2,
one for each possible cv-qualified function signature with arities 0-3. 64 overloads would be needed to support member functions
with varargs. Currently these overloads were fundamentally broken. An example overload looked like:
```
template <class Rp, class Tp, class T1, class A0>
Rp __invoke(Rp (Tp::*pm)(A0) const, T1&, A0&)
```
Because `A0` appeared in two different deducible contexts it would have to deduce to be an exact match or the overload
would be rejected. This is made even worse because `A0` appears without a reference qualifier in the member function signature
and with a reference qualifier as an `__invoke` parameter. This means that only member functions that took all
of their arguments by value could be matched.
One possible fix would be to make the second occurrence of `A0` appear in a non-deducible context. This way
any type convertible to `A0` could be passed as the first parameter. The benefit of this approach is that the
signature of the member function enforces the arity and types taken by the `__invoke` signature it generates. However
nothing in the `INVOKE` specification requires this behavior.
My solution is to use a `__invoke_enable_if<PM_Type, Tp>` metafunction to selectively enable the `__invoke` overloads for bullets 1, 2, 3 and 4. It uses `__member_function_traits` to inspect and extract the return type and class type of the pointer to member. Using `__member_function_traits` to inspect `PM_Type` also allows us to reduce the number of `__invoke` overloads from 32 to 8 and add
varargs support at the same time.
Because `__invoke_enable_if` knows the exact return type of `__invoke` for bullets 1-4 we no longer need to use `decltype(__invoke(...))` to
compute the return type in the `__invoke_return*` traits. This will reduce the problems caused by `#define decltype(X) __typeof__(X)` in C++03.
Tests for this change have already been committed. All tests in `test/std/utilities/function.objects` now pass in C++03, previously there were 20 failures.
Reviewers: K-ballo, howard.hinnant, mclow.lists
Subscribers: cfe-commits
Differential Revision: http://reviews.llvm.org/D11553
llvm-svn: 246068
2015-08-27 04:15:02 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2015-07-23 06:43:27 +08:00
|
|
|
typename __invoke_return1<type, _A0, _A1>::type
|
|
|
|
operator() (_A0& __a0, _A1& __a1) const {
|
|
|
|
return __invoke(__f_, __a0, __a1);
|
|
|
|
}
|
|
|
|
|
[libcxx] Rewrite C++03 __invoke.
Summary:
This patch rewrites the C++03 `__invoke` and related meta-programming. There are a number of major changes.
`__invoke` in C++03 now has a fallback overload for when the invoke expression is ill-formed (similar to C++11). This means that the `__invoke_return` traits will return `__nat` when `__invoke(...)` is ill formed. This would previously cause a compile error.
Bullets 1-4 of `__invoke` have been rewritten. In the old version `__invoke` had 32 overloads for bullets 1 and 2,
one for each possible cv-qualified function signature with arities 0-3. 64 overloads would be needed to support member functions
with varargs. Currently these overloads were fundamentally broken. An example overload looked like:
```
template <class Rp, class Tp, class T1, class A0>
Rp __invoke(Rp (Tp::*pm)(A0) const, T1&, A0&)
```
Because `A0` appeared in two different deducible contexts it would have to deduce to be an exact match or the overload
would be rejected. This is made even worse because `A0` appears without a reference qualifier in the member function signature
and with a reference qualifier as an `__invoke` parameter. This means that only member functions that took all
of their arguments by value could be matched.
One possible fix would be to make the second occurrence of `A0` appear in a non-deducible context. This way
any type convertible to `A0` could be passed as the first parameter. The benefit of this approach is that the
signature of the member function enforces the arity and types taken by the `__invoke` signature it generates. However
nothing in the `INVOKE` specification requires this behavior.
My solution is to use a `__invoke_enable_if<PM_Type, Tp>` metafunction to selectively enable the `__invoke` overloads for bullets 1, 2, 3 and 4. It uses `__member_function_traits` to inspect and extract the return type and class type of the pointer to member. Using `__member_function_traits` to inspect `PM_Type` also allows us to reduce the number of `__invoke` overloads from 32 to 8 and add
varargs support at the same time.
Because `__invoke_enable_if` knows the exact return type of `__invoke` for bullets 1-4 we no longer need to use `decltype(__invoke(...))` to
compute the return type in the `__invoke_return*` traits. This will reduce the problems caused by `#define decltype(X) __typeof__(X)` in C++03.
Tests for this change have already been committed. All tests in `test/std/utilities/function.objects` now pass in C++03, previously there were 20 failures.
Reviewers: K-ballo, howard.hinnant, mclow.lists
Subscribers: cfe-commits
Differential Revision: http://reviews.llvm.org/D11553
llvm-svn: 246068
2015-08-27 04:15:02 +08:00
|
|
|
template <class _A0, class _A1>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename __invoke_return1<type, _A0 const, _A1>::type
|
|
|
|
operator() (_A0 const& __a0, _A1& __a1) const {
|
|
|
|
return __invoke(__f_, __a0, __a1);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _A0, class _A1>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename __invoke_return1<type, _A0, _A1 const>::type
|
|
|
|
operator() (_A0& __a0, _A1 const& __a1) const {
|
|
|
|
return __invoke(__f_, __a0, __a1);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _A0, class _A1>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename __invoke_return1<type, _A0 const, _A1 const>::type
|
|
|
|
operator() (_A0 const& __a0, _A1 const& __a1) const {
|
|
|
|
return __invoke(__f_, __a0, __a1);
|
|
|
|
}
|
|
|
|
|
2015-07-23 06:43:27 +08:00
|
|
|
template <class _A0, class _A1, class _A2>
|
[libcxx] Rewrite C++03 __invoke.
Summary:
This patch rewrites the C++03 `__invoke` and related meta-programming. There are a number of major changes.
`__invoke` in C++03 now has a fallback overload for when the invoke expression is ill-formed (similar to C++11). This means that the `__invoke_return` traits will return `__nat` when `__invoke(...)` is ill formed. This would previously cause a compile error.
Bullets 1-4 of `__invoke` have been rewritten. In the old version `__invoke` had 32 overloads for bullets 1 and 2,
one for each possible cv-qualified function signature with arities 0-3. 64 overloads would be needed to support member functions
with varargs. Currently these overloads were fundamentally broken. An example overload looked like:
```
template <class Rp, class Tp, class T1, class A0>
Rp __invoke(Rp (Tp::*pm)(A0) const, T1&, A0&)
```
Because `A0` appeared in two different deducible contexts it would have to deduce to be an exact match or the overload
would be rejected. This is made even worse because `A0` appears without a reference qualifier in the member function signature
and with a reference qualifier as an `__invoke` parameter. This means that only member functions that took all
of their arguments by value could be matched.
One possible fix would be to make the second occurrence of `A0` appear in a non-deducible context. This way
any type convertible to `A0` could be passed as the first parameter. The benefit of this approach is that the
signature of the member function enforces the arity and types taken by the `__invoke` signature it generates. However
nothing in the `INVOKE` specification requires this behavior.
My solution is to use a `__invoke_enable_if<PM_Type, Tp>` metafunction to selectively enable the `__invoke` overloads for bullets 1, 2, 3 and 4. It uses `__member_function_traits` to inspect and extract the return type and class type of the pointer to member. Using `__member_function_traits` to inspect `PM_Type` also allows us to reduce the number of `__invoke` overloads from 32 to 8 and add
varargs support at the same time.
Because `__invoke_enable_if` knows the exact return type of `__invoke` for bullets 1-4 we no longer need to use `decltype(__invoke(...))` to
compute the return type in the `__invoke_return*` traits. This will reduce the problems caused by `#define decltype(X) __typeof__(X)` in C++03.
Tests for this change have already been committed. All tests in `test/std/utilities/function.objects` now pass in C++03, previously there were 20 failures.
Reviewers: K-ballo, howard.hinnant, mclow.lists
Subscribers: cfe-commits
Differential Revision: http://reviews.llvm.org/D11553
llvm-svn: 246068
2015-08-27 04:15:02 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2015-07-23 06:43:27 +08:00
|
|
|
typename __invoke_return2<type, _A0, _A1, _A2>::type
|
|
|
|
operator() (_A0& __a0, _A1& __a1, _A2& __a2) const {
|
|
|
|
return __invoke(__f_, __a0, __a1, __a2);
|
|
|
|
}
|
[libcxx] Rewrite C++03 __invoke.
Summary:
This patch rewrites the C++03 `__invoke` and related meta-programming. There are a number of major changes.
`__invoke` in C++03 now has a fallback overload for when the invoke expression is ill-formed (similar to C++11). This means that the `__invoke_return` traits will return `__nat` when `__invoke(...)` is ill formed. This would previously cause a compile error.
Bullets 1-4 of `__invoke` have been rewritten. In the old version `__invoke` had 32 overloads for bullets 1 and 2,
one for each possible cv-qualified function signature with arities 0-3. 64 overloads would be needed to support member functions
with varargs. Currently these overloads were fundamentally broken. An example overload looked like:
```
template <class Rp, class Tp, class T1, class A0>
Rp __invoke(Rp (Tp::*pm)(A0) const, T1&, A0&)
```
Because `A0` appeared in two different deducible contexts it would have to deduce to be an exact match or the overload
would be rejected. This is made even worse because `A0` appears without a reference qualifier in the member function signature
and with a reference qualifier as an `__invoke` parameter. This means that only member functions that took all
of their arguments by value could be matched.
One possible fix would be to make the second occurrence of `A0` appear in a non-deducible context. This way
any type convertible to `A0` could be passed as the first parameter. The benefit of this approach is that the
signature of the member function enforces the arity and types taken by the `__invoke` signature it generates. However
nothing in the `INVOKE` specification requires this behavior.
My solution is to use a `__invoke_enable_if<PM_Type, Tp>` metafunction to selectively enable the `__invoke` overloads for bullets 1, 2, 3 and 4. It uses `__member_function_traits` to inspect and extract the return type and class type of the pointer to member. Using `__member_function_traits` to inspect `PM_Type` also allows us to reduce the number of `__invoke` overloads from 32 to 8 and add
varargs support at the same time.
Because `__invoke_enable_if` knows the exact return type of `__invoke` for bullets 1-4 we no longer need to use `decltype(__invoke(...))` to
compute the return type in the `__invoke_return*` traits. This will reduce the problems caused by `#define decltype(X) __typeof__(X)` in C++03.
Tests for this change have already been committed. All tests in `test/std/utilities/function.objects` now pass in C++03, previously there were 20 failures.
Reviewers: K-ballo, howard.hinnant, mclow.lists
Subscribers: cfe-commits
Differential Revision: http://reviews.llvm.org/D11553
llvm-svn: 246068
2015-08-27 04:15:02 +08:00
|
|
|
|
|
|
|
template <class _A0, class _A1, class _A2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename __invoke_return2<type, _A0 const, _A1, _A2>::type
|
|
|
|
operator() (_A0 const& __a0, _A1& __a1, _A2& __a2) const {
|
|
|
|
return __invoke(__f_, __a0, __a1, __a2);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _A0, class _A1, class _A2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename __invoke_return2<type, _A0, _A1 const, _A2>::type
|
|
|
|
operator() (_A0& __a0, _A1 const& __a1, _A2& __a2) const {
|
|
|
|
return __invoke(__f_, __a0, __a1, __a2);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _A0, class _A1, class _A2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename __invoke_return2<type, _A0, _A1, _A2 const>::type
|
|
|
|
operator() (_A0& __a0, _A1& __a1, _A2 const& __a2) const {
|
|
|
|
return __invoke(__f_, __a0, __a1, __a2);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _A0, class _A1, class _A2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename __invoke_return2<type, _A0 const, _A1 const, _A2>::type
|
|
|
|
operator() (_A0 const& __a0, _A1 const& __a1, _A2& __a2) const {
|
|
|
|
return __invoke(__f_, __a0, __a1, __a2);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _A0, class _A1, class _A2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename __invoke_return2<type, _A0 const, _A1, _A2 const>::type
|
|
|
|
operator() (_A0 const& __a0, _A1& __a1, _A2 const& __a2) const {
|
|
|
|
return __invoke(__f_, __a0, __a1, __a2);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _A0, class _A1, class _A2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename __invoke_return2<type, _A0, _A1 const, _A2 const>::type
|
|
|
|
operator() (_A0& __a0, _A1 const& __a1, _A2 const& __a2) const {
|
|
|
|
return __invoke(__f_, __a0, __a1, __a2);
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _A0, class _A1, class _A2>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
typename __invoke_return2<type, _A0 const, _A1 const, _A2 const>::type
|
|
|
|
operator() (_A0 const& __a0, _A1 const& __a1, _A2 const& __a2) const {
|
|
|
|
return __invoke(__f_, __a0, __a1, __a2);
|
|
|
|
}
|
2015-07-23 06:43:27 +08:00
|
|
|
#endif
|
2010-05-12 03:42:16 +08:00
|
|
|
};
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Rp, class _Tp>
|
2010-05-12 03:42:16 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2011-11-30 02:15:50 +08:00
|
|
|
__mem_fn<_Rp _Tp::*>
|
2015-10-26 04:12:16 +08:00
|
|
|
mem_fn(_Rp _Tp::* __pm) _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2011-11-30 02:15:50 +08:00
|
|
|
return __mem_fn<_Rp _Tp::*>(__pm);
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
2015-07-22 12:14:38 +08:00
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// FUNCTION
|
|
|
|
//==============================================================================
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
// bad_function_call
|
|
|
|
|
2010-09-22 06:55:27 +08:00
|
|
|
class _LIBCPP_EXCEPTION_ABI bad_function_call
|
2010-05-12 03:42:16 +08:00
|
|
|
: public exception
|
|
|
|
{
|
[libc++] Add a key function for bad_function_call
Summary:
bad_function_call is currently an empty class, so any object files using
that class will end up with their own copy of its typeinfo, typeinfo
name and vtable, leading to unnecessary duplication that has to be
resolved by the dynamic linker. Instead, give bad_function_call a key
function and put a definition for that key function in libc++ itself, to
centralize the typeinfo and vtable.
This is consistent with the behavior for other exception classes. The
key functions are defined in libc++ rather than libc++abi since the
class is defined in the libc++ versioning namespace, so ABI
compatibility with libstdc++ is not a concern.
Guard this change behind an ABI macro, since it isn't backwards
compatible (i.e., clients built against the new libc++ headers wouldn't
be able to run against an older libc++ library).
Reviewers: mclow.lists, EricWF
Subscribers: mgorny, cfe-commits
Differential Revision: https://reviews.llvm.org/D27387
llvm-svn: 298937
2017-03-29 03:33:31 +08:00
|
|
|
#ifdef _LIBCPP_ABI_BAD_FUNCTION_CALL_KEY_FUNCTION
|
|
|
|
public:
|
|
|
|
virtual ~bad_function_call() _NOEXCEPT;
|
|
|
|
|
|
|
|
virtual const char* what() const _NOEXCEPT;
|
|
|
|
#endif
|
2010-05-12 03:42:16 +08:00
|
|
|
};
|
|
|
|
|
2016-08-25 23:09:01 +08:00
|
|
|
_LIBCPP_NORETURN inline _LIBCPP_ALWAYS_INLINE
|
|
|
|
void __throw_bad_function_call()
|
|
|
|
{
|
|
|
|
#ifndef _LIBCPP_NO_EXCEPTIONS
|
|
|
|
throw bad_function_call();
|
|
|
|
#else
|
|
|
|
_VSTD::abort();
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2017-01-05 07:56:00 +08:00
|
|
|
template<class _Fp> class _LIBCPP_TEMPLATE_VIS function; // undefined
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
namespace __function
|
|
|
|
{
|
|
|
|
|
2015-07-22 12:14:38 +08:00
|
|
|
template<class _Rp>
|
2010-05-12 03:42:16 +08:00
|
|
|
struct __maybe_derive_from_unary_function
|
|
|
|
{
|
|
|
|
};
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Rp, class _A1>
|
|
|
|
struct __maybe_derive_from_unary_function<_Rp(_A1)>
|
|
|
|
: public unary_function<_A1, _Rp>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
};
|
|
|
|
|
2015-07-22 12:14:38 +08:00
|
|
|
template<class _Rp>
|
2010-05-12 03:42:16 +08:00
|
|
|
struct __maybe_derive_from_binary_function
|
|
|
|
{
|
|
|
|
};
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Rp, class _A1, class _A2>
|
|
|
|
struct __maybe_derive_from_binary_function<_Rp(_A1, _A2)>
|
|
|
|
: public binary_function<_A1, _A2, _Rp>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
};
|
|
|
|
|
2015-08-19 03:41:51 +08:00
|
|
|
template <class _Fp>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool __not_null(_Fp const&) { return true; }
|
|
|
|
|
|
|
|
template <class _Fp>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool __not_null(_Fp* __ptr) { return __ptr; }
|
|
|
|
|
|
|
|
template <class _Ret, class _Class>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool __not_null(_Ret _Class::*__ptr) { return __ptr; }
|
|
|
|
|
|
|
|
template <class _Fp>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool __not_null(function<_Fp> const& __f) { return !!__f; }
|
|
|
|
|
2015-07-22 12:14:38 +08:00
|
|
|
} // namespace __function
|
|
|
|
|
2017-04-19 09:28:47 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2015-07-22 12:14:38 +08:00
|
|
|
|
|
|
|
namespace __function {
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
template<class _Fp> class __base;
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Rp, class ..._ArgTypes>
|
|
|
|
class __base<_Rp(_ArgTypes...)>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
__base(const __base&);
|
|
|
|
__base& operator=(const __base&);
|
|
|
|
public:
|
2010-09-22 06:55:27 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY __base() {}
|
|
|
|
_LIBCPP_INLINE_VISIBILITY virtual ~__base() {}
|
2010-05-12 03:42:16 +08:00
|
|
|
virtual __base* __clone() const = 0;
|
|
|
|
virtual void __clone(__base*) const = 0;
|
2011-05-29 01:59:48 +08:00
|
|
|
virtual void destroy() _NOEXCEPT = 0;
|
|
|
|
virtual void destroy_deallocate() _NOEXCEPT = 0;
|
2011-11-30 02:15:50 +08:00
|
|
|
virtual _Rp operator()(_ArgTypes&& ...) = 0;
|
2010-08-12 01:04:31 +08:00
|
|
|
#ifndef _LIBCPP_NO_RTTI
|
2011-05-29 01:59:48 +08:00
|
|
|
virtual const void* target(const type_info&) const _NOEXCEPT = 0;
|
|
|
|
virtual const std::type_info& target_type() const _NOEXCEPT = 0;
|
2010-08-22 08:02:43 +08:00
|
|
|
#endif // _LIBCPP_NO_RTTI
|
2010-05-12 03:42:16 +08:00
|
|
|
};
|
|
|
|
|
|
|
|
template<class _FD, class _Alloc, class _FB> class __func;
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
|
|
|
|
class __func<_Fp, _Alloc, _Rp(_ArgTypes...)>
|
|
|
|
: public __base<_Rp(_ArgTypes...)>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2011-11-30 02:15:50 +08:00
|
|
|
__compressed_pair<_Fp, _Alloc> __f_;
|
2010-05-12 03:42:16 +08:00
|
|
|
public:
|
2010-09-22 06:55:27 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2012-02-29 03:47:38 +08:00
|
|
|
explicit __func(_Fp&& __f)
|
|
|
|
: __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)),
|
|
|
|
_VSTD::forward_as_tuple()) {}
|
2010-09-22 06:55:27 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2012-02-29 03:47:38 +08:00
|
|
|
explicit __func(const _Fp& __f, const _Alloc& __a)
|
|
|
|
: __f_(piecewise_construct, _VSTD::forward_as_tuple(__f),
|
|
|
|
_VSTD::forward_as_tuple(__a)) {}
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
explicit __func(const _Fp& __f, _Alloc&& __a)
|
|
|
|
: __f_(piecewise_construct, _VSTD::forward_as_tuple(__f),
|
|
|
|
_VSTD::forward_as_tuple(_VSTD::move(__a))) {}
|
|
|
|
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
explicit __func(_Fp&& __f, _Alloc&& __a)
|
|
|
|
: __f_(piecewise_construct, _VSTD::forward_as_tuple(_VSTD::move(__f)),
|
|
|
|
_VSTD::forward_as_tuple(_VSTD::move(__a))) {}
|
2011-11-30 02:15:50 +08:00
|
|
|
virtual __base<_Rp(_ArgTypes...)>* __clone() const;
|
|
|
|
virtual void __clone(__base<_Rp(_ArgTypes...)>*) const;
|
2011-05-29 01:59:48 +08:00
|
|
|
virtual void destroy() _NOEXCEPT;
|
|
|
|
virtual void destroy_deallocate() _NOEXCEPT;
|
2011-11-30 02:15:50 +08:00
|
|
|
virtual _Rp operator()(_ArgTypes&& ... __arg);
|
2010-08-12 01:04:31 +08:00
|
|
|
#ifndef _LIBCPP_NO_RTTI
|
2011-05-29 01:59:48 +08:00
|
|
|
virtual const void* target(const type_info&) const _NOEXCEPT;
|
|
|
|
virtual const std::type_info& target_type() const _NOEXCEPT;
|
2010-08-22 08:02:43 +08:00
|
|
|
#endif // _LIBCPP_NO_RTTI
|
2010-05-12 03:42:16 +08:00
|
|
|
};
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
|
|
|
|
__base<_Rp(_ArgTypes...)>*
|
|
|
|
__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone() const
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2015-03-19 06:56:50 +08:00
|
|
|
typedef allocator_traits<_Alloc> __alloc_traits;
|
2015-04-07 13:21:38 +08:00
|
|
|
typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap;
|
2011-11-30 02:15:50 +08:00
|
|
|
_Ap __a(__f_.second());
|
|
|
|
typedef __allocator_destructor<_Ap> _Dp;
|
|
|
|
unique_ptr<__func, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
|
2010-05-12 03:42:16 +08:00
|
|
|
::new (__hold.get()) __func(__f_.first(), _Alloc(__a));
|
|
|
|
return __hold.release();
|
|
|
|
}
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
|
2010-05-12 03:42:16 +08:00
|
|
|
void
|
2011-11-30 02:15:50 +08:00
|
|
|
__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::__clone(__base<_Rp(_ArgTypes...)>* __p) const
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
::new (__p) __func(__f_.first(), __f_.second());
|
|
|
|
}
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
|
2010-05-12 03:42:16 +08:00
|
|
|
void
|
2011-11-30 02:15:50 +08:00
|
|
|
__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy() _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2011-11-30 02:15:50 +08:00
|
|
|
__f_.~__compressed_pair<_Fp, _Alloc>();
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
|
2010-05-12 03:42:16 +08:00
|
|
|
void
|
2011-11-30 02:15:50 +08:00
|
|
|
__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::destroy_deallocate() _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2015-03-19 06:56:50 +08:00
|
|
|
typedef allocator_traits<_Alloc> __alloc_traits;
|
2015-04-07 13:21:38 +08:00
|
|
|
typedef typename __rebind_alloc_helper<__alloc_traits, __func>::type _Ap;
|
2011-11-30 02:15:50 +08:00
|
|
|
_Ap __a(__f_.second());
|
|
|
|
__f_.~__compressed_pair<_Fp, _Alloc>();
|
2010-05-12 03:42:16 +08:00
|
|
|
__a.deallocate(this, 1);
|
|
|
|
}
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
|
|
|
|
_Rp
|
|
|
|
__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2015-02-11 00:48:45 +08:00
|
|
|
typedef __invoke_void_return_wrapper<_Rp> _Invoker;
|
|
|
|
return _Invoker::__call(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...);
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
2010-08-12 01:04:31 +08:00
|
|
|
#ifndef _LIBCPP_NO_RTTI
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
|
2010-05-12 03:42:16 +08:00
|
|
|
const void*
|
2011-11-30 02:15:50 +08:00
|
|
|
__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target(const type_info& __ti) const _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2011-11-30 02:15:50 +08:00
|
|
|
if (__ti == typeid(_Fp))
|
2010-05-12 03:42:16 +08:00
|
|
|
return &__f_.first();
|
|
|
|
return (const void*)0;
|
|
|
|
}
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Fp, class _Alloc, class _Rp, class ..._ArgTypes>
|
2010-05-12 03:42:16 +08:00
|
|
|
const std::type_info&
|
2011-11-30 02:15:50 +08:00
|
|
|
__func<_Fp, _Alloc, _Rp(_ArgTypes...)>::target_type() const _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2011-11-30 02:15:50 +08:00
|
|
|
return typeid(_Fp);
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
2010-08-22 08:02:43 +08:00
|
|
|
#endif // _LIBCPP_NO_RTTI
|
2010-08-12 01:04:31 +08:00
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
} // __function
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Rp, class ..._ArgTypes>
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS function<_Rp(_ArgTypes...)>
|
2011-11-30 02:15:50 +08:00
|
|
|
: public __function::__maybe_derive_from_unary_function<_Rp(_ArgTypes...)>,
|
|
|
|
public __function::__maybe_derive_from_binary_function<_Rp(_ArgTypes...)>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2011-11-30 02:15:50 +08:00
|
|
|
typedef __function::__base<_Rp(_ArgTypes...)> __base;
|
2013-01-22 01:26:55 +08:00
|
|
|
typename aligned_storage<3*sizeof(void*)>::type __buf_;
|
2010-05-12 03:42:16 +08:00
|
|
|
__base* __f_;
|
|
|
|
|
2016-02-11 05:53:28 +08:00
|
|
|
_LIBCPP_NO_CFI static __base *__as_base(void *p) {
|
|
|
|
return reinterpret_cast<__base*>(p);
|
|
|
|
}
|
|
|
|
|
2012-07-21 02:56:07 +08:00
|
|
|
template <class _Fp, bool = !is_same<_Fp, function>::value &&
|
|
|
|
__invokable<_Fp&, _ArgTypes...>::value>
|
2011-06-01 05:45:26 +08:00
|
|
|
struct __callable;
|
2011-11-30 02:15:50 +08:00
|
|
|
template <class _Fp>
|
|
|
|
struct __callable<_Fp, true>
|
2011-06-01 05:45:26 +08:00
|
|
|
{
|
2015-02-11 00:48:45 +08:00
|
|
|
static const bool value = is_same<void, _Rp>::value ||
|
2011-11-30 02:15:50 +08:00
|
|
|
is_convertible<typename __invoke_of<_Fp&, _ArgTypes...>::type,
|
|
|
|
_Rp>::value;
|
2011-06-01 05:45:26 +08:00
|
|
|
};
|
2011-11-30 02:15:50 +08:00
|
|
|
template <class _Fp>
|
|
|
|
struct __callable<_Fp, false>
|
2011-06-01 05:45:26 +08:00
|
|
|
{
|
|
|
|
static const bool value = false;
|
|
|
|
};
|
2010-05-12 03:42:16 +08:00
|
|
|
public:
|
2011-11-30 02:15:50 +08:00
|
|
|
typedef _Rp result_type;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-08-21 03:36:46 +08:00
|
|
|
// construct/copy/destroy:
|
2010-09-22 06:55:27 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-05-29 01:59:48 +08:00
|
|
|
function() _NOEXCEPT : __f_(0) {}
|
2010-09-22 06:55:27 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-05-29 01:59:48 +08:00
|
|
|
function(nullptr_t) _NOEXCEPT : __f_(0) {}
|
2010-05-12 03:42:16 +08:00
|
|
|
function(const function&);
|
2011-05-29 01:59:48 +08:00
|
|
|
function(function&&) _NOEXCEPT;
|
2016-07-20 13:21:00 +08:00
|
|
|
template<class _Fp, class = typename enable_if<
|
|
|
|
__callable<_Fp>::value && !is_same<_Fp, function>::value
|
|
|
|
>::type>
|
|
|
|
function(_Fp);
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2016-10-14 05:06:03 +08:00
|
|
|
#if _LIBCPP_STD_VER <= 14
|
2010-08-21 03:36:46 +08:00
|
|
|
template<class _Alloc>
|
2010-09-22 06:55:27 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-05-29 01:59:48 +08:00
|
|
|
function(allocator_arg_t, const _Alloc&) _NOEXCEPT : __f_(0) {}
|
2010-08-21 03:36:46 +08:00
|
|
|
template<class _Alloc>
|
2010-09-22 06:55:27 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-05-29 01:59:48 +08:00
|
|
|
function(allocator_arg_t, const _Alloc&, nullptr_t) _NOEXCEPT : __f_(0) {}
|
2010-08-21 03:36:46 +08:00
|
|
|
template<class _Alloc>
|
|
|
|
function(allocator_arg_t, const _Alloc&, const function&);
|
|
|
|
template<class _Alloc>
|
|
|
|
function(allocator_arg_t, const _Alloc&, function&&);
|
2016-07-20 13:21:00 +08:00
|
|
|
template<class _Fp, class _Alloc, class = typename enable_if<__callable<_Fp>::value>::type>
|
|
|
|
function(allocator_arg_t, const _Alloc& __a, _Fp __f);
|
2016-10-14 05:06:03 +08:00
|
|
|
#endif
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
function& operator=(const function&);
|
2011-05-29 01:59:48 +08:00
|
|
|
function& operator=(function&&) _NOEXCEPT;
|
|
|
|
function& operator=(nullptr_t) _NOEXCEPT;
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Fp>
|
2010-05-12 03:42:16 +08:00
|
|
|
typename enable_if
|
|
|
|
<
|
2013-07-01 08:01:51 +08:00
|
|
|
__callable<typename decay<_Fp>::type>::value &&
|
|
|
|
!is_same<typename remove_reference<_Fp>::type, function>::value,
|
2010-05-12 03:42:16 +08:00
|
|
|
function&
|
|
|
|
>::type
|
2011-11-30 02:15:50 +08:00
|
|
|
operator=(_Fp&&);
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
~function();
|
|
|
|
|
2010-08-21 03:36:46 +08:00
|
|
|
// function modifiers:
|
2011-05-29 01:59:48 +08:00
|
|
|
void swap(function&) _NOEXCEPT;
|
2016-01-26 01:29:55 +08:00
|
|
|
|
|
|
|
#if _LIBCPP_STD_VER <= 14
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Fp, class _Alloc>
|
2010-09-22 06:55:27 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-11-30 02:15:50 +08:00
|
|
|
void assign(_Fp&& __f, const _Alloc& __a)
|
|
|
|
{function(allocator_arg, __a, _VSTD::forward<_Fp>(__f)).swap(*this);}
|
2016-01-26 01:29:55 +08:00
|
|
|
#endif
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-08-21 03:36:46 +08:00
|
|
|
// function capacity:
|
2010-09-22 06:55:27 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2012-02-22 05:46:43 +08:00
|
|
|
_LIBCPP_EXPLICIT operator bool() const _NOEXCEPT {return __f_;}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
// deleted overloads close possible hole in the type system
|
|
|
|
template<class _R2, class... _ArgTypes2>
|
2010-09-11 23:33:21 +08:00
|
|
|
bool operator==(const function<_R2(_ArgTypes2...)>&) const = delete;
|
2010-05-12 03:42:16 +08:00
|
|
|
template<class _R2, class... _ArgTypes2>
|
2010-09-11 23:33:21 +08:00
|
|
|
bool operator!=(const function<_R2(_ArgTypes2...)>&) const = delete;
|
2010-05-12 03:42:16 +08:00
|
|
|
public:
|
2010-08-21 03:36:46 +08:00
|
|
|
// function invocation:
|
2011-11-30 02:15:50 +08:00
|
|
|
_Rp operator()(_ArgTypes...) const;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2010-08-12 01:04:31 +08:00
|
|
|
#ifndef _LIBCPP_NO_RTTI
|
2010-08-21 03:36:46 +08:00
|
|
|
// function target access:
|
2011-05-29 01:59:48 +08:00
|
|
|
const std::type_info& target_type() const _NOEXCEPT;
|
2011-11-30 02:15:50 +08:00
|
|
|
template <typename _Tp> _Tp* target() _NOEXCEPT;
|
|
|
|
template <typename _Tp> const _Tp* target() const _NOEXCEPT;
|
2010-08-22 08:02:43 +08:00
|
|
|
#endif // _LIBCPP_NO_RTTI
|
2010-05-12 03:42:16 +08:00
|
|
|
};
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Rp, class ..._ArgTypes>
|
|
|
|
function<_Rp(_ArgTypes...)>::function(const function& __f)
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
if (__f.__f_ == 0)
|
|
|
|
__f_ = 0;
|
2016-02-11 05:53:28 +08:00
|
|
|
else if ((void *)__f.__f_ == &__f.__buf_)
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2016-02-11 05:53:28 +08:00
|
|
|
__f_ = __as_base(&__buf_);
|
2010-05-12 03:42:16 +08:00
|
|
|
__f.__f_->__clone(__f_);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
__f_ = __f.__f_->__clone();
|
|
|
|
}
|
|
|
|
|
2016-10-14 05:06:03 +08:00
|
|
|
#if _LIBCPP_STD_VER <= 14
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Rp, class ..._ArgTypes>
|
2010-08-21 03:36:46 +08:00
|
|
|
template <class _Alloc>
|
2011-11-30 02:15:50 +08:00
|
|
|
function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
|
2010-08-21 03:36:46 +08:00
|
|
|
const function& __f)
|
|
|
|
{
|
|
|
|
if (__f.__f_ == 0)
|
|
|
|
__f_ = 0;
|
2016-02-11 05:53:28 +08:00
|
|
|
else if ((void *)__f.__f_ == &__f.__buf_)
|
2010-08-21 03:36:46 +08:00
|
|
|
{
|
2016-02-11 05:53:28 +08:00
|
|
|
__f_ = __as_base(&__buf_);
|
2010-08-21 03:36:46 +08:00
|
|
|
__f.__f_->__clone(__f_);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
__f_ = __f.__f_->__clone();
|
|
|
|
}
|
2016-10-14 05:06:03 +08:00
|
|
|
#endif
|
2010-08-21 03:36:46 +08:00
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Rp, class ..._ArgTypes>
|
|
|
|
function<_Rp(_ArgTypes...)>::function(function&& __f) _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
if (__f.__f_ == 0)
|
|
|
|
__f_ = 0;
|
2016-02-11 05:53:28 +08:00
|
|
|
else if ((void *)__f.__f_ == &__f.__buf_)
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2016-02-11 05:53:28 +08:00
|
|
|
__f_ = __as_base(&__buf_);
|
2010-05-12 03:42:16 +08:00
|
|
|
__f.__f_->__clone(__f_);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
__f_ = __f.__f_;
|
|
|
|
__f.__f_ = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-14 05:06:03 +08:00
|
|
|
#if _LIBCPP_STD_VER <= 14
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Rp, class ..._ArgTypes>
|
2010-08-21 03:36:46 +08:00
|
|
|
template <class _Alloc>
|
2011-11-30 02:15:50 +08:00
|
|
|
function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
|
2010-08-21 03:36:46 +08:00
|
|
|
function&& __f)
|
|
|
|
{
|
|
|
|
if (__f.__f_ == 0)
|
|
|
|
__f_ = 0;
|
2016-02-11 05:53:28 +08:00
|
|
|
else if ((void *)__f.__f_ == &__f.__buf_)
|
2010-08-21 03:36:46 +08:00
|
|
|
{
|
2016-02-11 05:53:28 +08:00
|
|
|
__f_ = __as_base(&__buf_);
|
2010-08-21 03:36:46 +08:00
|
|
|
__f.__f_->__clone(__f_);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
__f_ = __f.__f_;
|
|
|
|
__f.__f_ = 0;
|
|
|
|
}
|
|
|
|
}
|
2016-10-14 05:06:03 +08:00
|
|
|
#endif
|
2010-08-21 03:36:46 +08:00
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Rp, class ..._ArgTypes>
|
2016-07-20 13:21:00 +08:00
|
|
|
template <class _Fp, class>
|
|
|
|
function<_Rp(_ArgTypes...)>::function(_Fp __f)
|
2010-05-12 03:42:16 +08:00
|
|
|
: __f_(0)
|
|
|
|
{
|
2015-08-19 03:41:51 +08:00
|
|
|
if (__function::__not_null(__f))
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2011-11-30 02:15:50 +08:00
|
|
|
typedef __function::__func<_Fp, allocator<_Fp>, _Rp(_ArgTypes...)> _FF;
|
|
|
|
if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value)
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2016-02-11 05:53:28 +08:00
|
|
|
__f_ = ::new((void*)&__buf_) _FF(_VSTD::move(__f));
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-11-30 02:15:50 +08:00
|
|
|
typedef allocator<_FF> _Ap;
|
|
|
|
_Ap __a;
|
|
|
|
typedef __allocator_destructor<_Ap> _Dp;
|
|
|
|
unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
|
|
|
|
::new (__hold.get()) _FF(_VSTD::move(__f), allocator<_Fp>(__a));
|
2010-05-12 03:42:16 +08:00
|
|
|
__f_ = __hold.release();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2016-10-14 05:06:03 +08:00
|
|
|
#if _LIBCPP_STD_VER <= 14
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Rp, class ..._ArgTypes>
|
2016-07-20 13:21:00 +08:00
|
|
|
template <class _Fp, class _Alloc, class>
|
|
|
|
function<_Rp(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a0, _Fp __f)
|
2010-08-21 03:36:46 +08:00
|
|
|
: __f_(0)
|
|
|
|
{
|
|
|
|
typedef allocator_traits<_Alloc> __alloc_traits;
|
2015-08-19 03:41:51 +08:00
|
|
|
if (__function::__not_null(__f))
|
2010-08-21 03:36:46 +08:00
|
|
|
{
|
2011-11-30 02:15:50 +08:00
|
|
|
typedef __function::__func<_Fp, _Alloc, _Rp(_ArgTypes...)> _FF;
|
2015-04-07 13:21:38 +08:00
|
|
|
typedef typename __rebind_alloc_helper<__alloc_traits, _FF>::type _Ap;
|
2014-04-19 01:23:36 +08:00
|
|
|
_Ap __a(__a0);
|
|
|
|
if (sizeof(_FF) <= sizeof(__buf_) &&
|
|
|
|
is_nothrow_copy_constructible<_Fp>::value && is_nothrow_copy_constructible<_Ap>::value)
|
2010-08-21 03:36:46 +08:00
|
|
|
{
|
2016-02-11 05:53:28 +08:00
|
|
|
__f_ = ::new((void*)&__buf_) _FF(_VSTD::move(__f), _Alloc(__a));
|
2010-08-21 03:36:46 +08:00
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2011-11-30 02:15:50 +08:00
|
|
|
typedef __allocator_destructor<_Ap> _Dp;
|
|
|
|
unique_ptr<__base, _Dp> __hold(__a.allocate(1), _Dp(__a, 1));
|
2011-07-01 05:18:19 +08:00
|
|
|
::new (__hold.get()) _FF(_VSTD::move(__f), _Alloc(__a));
|
2010-08-21 03:36:46 +08:00
|
|
|
__f_ = __hold.release();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2016-10-14 05:06:03 +08:00
|
|
|
#endif
|
2010-08-21 03:36:46 +08:00
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Rp, class ..._ArgTypes>
|
|
|
|
function<_Rp(_ArgTypes...)>&
|
|
|
|
function<_Rp(_ArgTypes...)>::operator=(const function& __f)
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
function(__f).swap(*this);
|
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Rp, class ..._ArgTypes>
|
|
|
|
function<_Rp(_ArgTypes...)>&
|
|
|
|
function<_Rp(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2016-02-11 05:53:28 +08:00
|
|
|
if ((void *)__f_ == &__buf_)
|
2010-05-12 03:42:16 +08:00
|
|
|
__f_->destroy();
|
|
|
|
else if (__f_)
|
|
|
|
__f_->destroy_deallocate();
|
|
|
|
__f_ = 0;
|
|
|
|
if (__f.__f_ == 0)
|
|
|
|
__f_ = 0;
|
2016-02-11 05:53:28 +08:00
|
|
|
else if ((void *)__f.__f_ == &__f.__buf_)
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2016-02-11 05:53:28 +08:00
|
|
|
__f_ = __as_base(&__buf_);
|
2010-05-12 03:42:16 +08:00
|
|
|
__f.__f_->__clone(__f_);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
__f_ = __f.__f_;
|
|
|
|
__f.__f_ = 0;
|
|
|
|
}
|
2012-10-13 10:03:45 +08:00
|
|
|
return *this;
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Rp, class ..._ArgTypes>
|
|
|
|
function<_Rp(_ArgTypes...)>&
|
|
|
|
function<_Rp(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2016-02-11 05:53:28 +08:00
|
|
|
if ((void *)__f_ == &__buf_)
|
2010-05-12 03:42:16 +08:00
|
|
|
__f_->destroy();
|
|
|
|
else if (__f_)
|
|
|
|
__f_->destroy_deallocate();
|
|
|
|
__f_ = 0;
|
2012-10-13 10:03:45 +08:00
|
|
|
return *this;
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Rp, class ..._ArgTypes>
|
|
|
|
template <class _Fp>
|
2010-05-12 03:42:16 +08:00
|
|
|
typename enable_if
|
|
|
|
<
|
2013-07-01 08:01:51 +08:00
|
|
|
function<_Rp(_ArgTypes...)>::template __callable<typename decay<_Fp>::type>::value &&
|
|
|
|
!is_same<typename remove_reference<_Fp>::type, function<_Rp(_ArgTypes...)>>::value,
|
2011-11-30 02:15:50 +08:00
|
|
|
function<_Rp(_ArgTypes...)>&
|
2010-05-12 03:42:16 +08:00
|
|
|
>::type
|
2011-11-30 02:15:50 +08:00
|
|
|
function<_Rp(_ArgTypes...)>::operator=(_Fp&& __f)
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2011-11-30 02:15:50 +08:00
|
|
|
function(_VSTD::forward<_Fp>(__f)).swap(*this);
|
2010-05-12 03:42:16 +08:00
|
|
|
return *this;
|
|
|
|
}
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Rp, class ..._ArgTypes>
|
|
|
|
function<_Rp(_ArgTypes...)>::~function()
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2016-02-11 05:53:28 +08:00
|
|
|
if ((void *)__f_ == &__buf_)
|
2010-05-12 03:42:16 +08:00
|
|
|
__f_->destroy();
|
|
|
|
else if (__f_)
|
|
|
|
__f_->destroy_deallocate();
|
|
|
|
}
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Rp, class ..._ArgTypes>
|
2010-05-12 03:42:16 +08:00
|
|
|
void
|
2011-11-30 02:15:50 +08:00
|
|
|
function<_Rp(_ArgTypes...)>::swap(function& __f) _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2016-12-30 04:03:55 +08:00
|
|
|
if (_VSTD::addressof(__f) == this)
|
|
|
|
return;
|
2016-02-11 05:53:28 +08:00
|
|
|
if ((void *)__f_ == &__buf_ && (void *)__f.__f_ == &__f.__buf_)
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
typename aligned_storage<sizeof(__buf_)>::type __tempbuf;
|
2016-02-11 05:53:28 +08:00
|
|
|
__base* __t = __as_base(&__tempbuf);
|
2010-05-12 03:42:16 +08:00
|
|
|
__f_->__clone(__t);
|
|
|
|
__f_->destroy();
|
|
|
|
__f_ = 0;
|
2016-02-11 05:53:28 +08:00
|
|
|
__f.__f_->__clone(__as_base(&__buf_));
|
2010-05-12 03:42:16 +08:00
|
|
|
__f.__f_->destroy();
|
|
|
|
__f.__f_ = 0;
|
2016-02-11 05:53:28 +08:00
|
|
|
__f_ = __as_base(&__buf_);
|
|
|
|
__t->__clone(__as_base(&__f.__buf_));
|
2010-05-12 03:42:16 +08:00
|
|
|
__t->destroy();
|
2016-02-11 05:53:28 +08:00
|
|
|
__f.__f_ = __as_base(&__f.__buf_);
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
2016-02-11 05:53:28 +08:00
|
|
|
else if ((void *)__f_ == &__buf_)
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2016-02-11 05:53:28 +08:00
|
|
|
__f_->__clone(__as_base(&__f.__buf_));
|
2010-05-12 03:42:16 +08:00
|
|
|
__f_->destroy();
|
|
|
|
__f_ = __f.__f_;
|
2016-02-11 05:53:28 +08:00
|
|
|
__f.__f_ = __as_base(&__f.__buf_);
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
2016-02-11 05:53:28 +08:00
|
|
|
else if ((void *)__f.__f_ == &__f.__buf_)
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2016-02-11 05:53:28 +08:00
|
|
|
__f.__f_->__clone(__as_base(&__buf_));
|
2010-05-12 03:42:16 +08:00
|
|
|
__f.__f_->destroy();
|
|
|
|
__f.__f_ = __f_;
|
2016-02-11 05:53:28 +08:00
|
|
|
__f_ = __as_base(&__buf_);
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
else
|
2011-07-01 05:18:19 +08:00
|
|
|
_VSTD::swap(__f_, __f.__f_);
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Rp, class ..._ArgTypes>
|
|
|
|
_Rp
|
|
|
|
function<_Rp(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
if (__f_ == 0)
|
2016-08-25 23:09:01 +08:00
|
|
|
__throw_bad_function_call();
|
2011-07-01 05:18:19 +08:00
|
|
|
return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...);
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
2010-08-12 01:04:31 +08:00
|
|
|
#ifndef _LIBCPP_NO_RTTI
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Rp, class ..._ArgTypes>
|
2010-05-12 03:42:16 +08:00
|
|
|
const std::type_info&
|
2011-11-30 02:15:50 +08:00
|
|
|
function<_Rp(_ArgTypes...)>::target_type() const _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
if (__f_ == 0)
|
|
|
|
return typeid(void);
|
|
|
|
return __f_->target_type();
|
|
|
|
}
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Rp, class ..._ArgTypes>
|
|
|
|
template <typename _Tp>
|
|
|
|
_Tp*
|
|
|
|
function<_Rp(_ArgTypes...)>::target() _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
if (__f_ == 0)
|
2011-11-30 02:15:50 +08:00
|
|
|
return (_Tp*)0;
|
|
|
|
return (_Tp*)__f_->target(typeid(_Tp));
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Rp, class ..._ArgTypes>
|
|
|
|
template <typename _Tp>
|
|
|
|
const _Tp*
|
|
|
|
function<_Rp(_ArgTypes...)>::target() const _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
if (__f_ == 0)
|
2011-11-30 02:15:50 +08:00
|
|
|
return (const _Tp*)0;
|
|
|
|
return (const _Tp*)__f_->target(typeid(_Tp));
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
2010-08-22 08:02:43 +08:00
|
|
|
#endif // _LIBCPP_NO_RTTI
|
2010-08-12 01:04:31 +08:00
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template <class _Rp, class... _ArgTypes>
|
2010-05-12 03:42:16 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool
|
2011-11-30 02:15:50 +08:00
|
|
|
operator==(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return !__f;}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template <class _Rp, class... _ArgTypes>
|
2010-05-12 03:42:16 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool
|
2011-11-30 02:15:50 +08:00
|
|
|
operator==(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return !__f;}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template <class _Rp, class... _ArgTypes>
|
2010-05-12 03:42:16 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool
|
2011-11-30 02:15:50 +08:00
|
|
|
operator!=(const function<_Rp(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return (bool)__f;}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template <class _Rp, class... _ArgTypes>
|
2010-05-12 03:42:16 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
|
|
bool
|
2011-11-30 02:15:50 +08:00
|
|
|
operator!=(nullptr_t, const function<_Rp(_ArgTypes...)>& __f) _NOEXCEPT {return (bool)__f;}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template <class _Rp, class... _ArgTypes>
|
2010-05-12 03:42:16 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
|
|
void
|
2011-11-30 02:15:50 +08:00
|
|
|
swap(function<_Rp(_ArgTypes...)>& __x, function<_Rp(_ArgTypes...)>& __y) _NOEXCEPT
|
2010-05-12 03:42:16 +08:00
|
|
|
{return __x.swap(__y);}
|
|
|
|
|
2017-04-19 09:28:47 +08:00
|
|
|
#else // _LIBCPP_CXX03_LANG
|
2015-07-23 06:43:27 +08:00
|
|
|
|
|
|
|
#include <__functional_03>
|
|
|
|
|
|
|
|
#endif
|
2015-07-22 12:14:38 +08:00
|
|
|
|
|
|
|
////////////////////////////////////////////////////////////////////////////////
|
|
|
|
// BIND
|
|
|
|
//==============================================================================
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
template<class _Tp> struct __is_bind_expression : public false_type {};
|
2017-01-05 07:56:00 +08:00
|
|
|
template<class _Tp> struct _LIBCPP_TEMPLATE_VIS is_bind_expression
|
2010-05-12 03:42:16 +08:00
|
|
|
: public __is_bind_expression<typename remove_cv<_Tp>::type> {};
|
|
|
|
|
2016-09-22 08:23:15 +08:00
|
|
|
#if _LIBCPP_STD_VER > 14
|
|
|
|
template <class _Tp>
|
|
|
|
constexpr size_t is_bind_expression_v = is_bind_expression<_Tp>::value;
|
|
|
|
#endif
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
template<class _Tp> struct __is_placeholder : public integral_constant<int, 0> {};
|
2017-01-05 07:56:00 +08:00
|
|
|
template<class _Tp> struct _LIBCPP_TEMPLATE_VIS is_placeholder
|
2010-05-12 03:42:16 +08:00
|
|
|
: public __is_placeholder<typename remove_cv<_Tp>::type> {};
|
|
|
|
|
2016-09-22 08:23:15 +08:00
|
|
|
#if _LIBCPP_STD_VER > 14
|
|
|
|
template <class _Tp>
|
|
|
|
constexpr size_t is_placeholder_v = is_placeholder<_Tp>::value;
|
|
|
|
#endif
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
namespace placeholders
|
|
|
|
{
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template <int _Np> struct __ph {};
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2016-06-27 05:01:34 +08:00
|
|
|
#if defined(_LIBCPP_CXX03_LANG) || defined(_LIBCPP_BUILDING_BIND)
|
|
|
|
_LIBCPP_FUNC_VIS extern const __ph<1> _1;
|
|
|
|
_LIBCPP_FUNC_VIS extern const __ph<2> _2;
|
|
|
|
_LIBCPP_FUNC_VIS extern const __ph<3> _3;
|
|
|
|
_LIBCPP_FUNC_VIS extern const __ph<4> _4;
|
|
|
|
_LIBCPP_FUNC_VIS extern const __ph<5> _5;
|
|
|
|
_LIBCPP_FUNC_VIS extern const __ph<6> _6;
|
|
|
|
_LIBCPP_FUNC_VIS extern const __ph<7> _7;
|
|
|
|
_LIBCPP_FUNC_VIS extern const __ph<8> _8;
|
|
|
|
_LIBCPP_FUNC_VIS extern const __ph<9> _9;
|
|
|
|
_LIBCPP_FUNC_VIS extern const __ph<10> _10;
|
|
|
|
#else
|
|
|
|
constexpr __ph<1> _1{};
|
|
|
|
constexpr __ph<2> _2{};
|
|
|
|
constexpr __ph<3> _3{};
|
|
|
|
constexpr __ph<4> _4{};
|
|
|
|
constexpr __ph<5> _5{};
|
|
|
|
constexpr __ph<6> _6{};
|
|
|
|
constexpr __ph<7> _7{};
|
|
|
|
constexpr __ph<8> _8{};
|
|
|
|
constexpr __ph<9> _9{};
|
|
|
|
constexpr __ph<10> _10{};
|
|
|
|
#endif // defined(_LIBCPP_CXX03_LANG) || defined(_LIBCPP_BUILDING_BIND)
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
} // placeholders
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<int _Np>
|
|
|
|
struct __is_placeholder<placeholders::__ph<_Np> >
|
|
|
|
: public integral_constant<int, _Np> {};
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2015-07-22 12:14:38 +08:00
|
|
|
|
2017-04-19 09:28:47 +08:00
|
|
|
#ifndef _LIBCPP_CXX03_LANG
|
2015-07-22 12:14:38 +08:00
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Tp, class _Uj>
|
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
|
|
_Tp&
|
|
|
|
__mu(reference_wrapper<_Tp> __t, _Uj&)
|
|
|
|
{
|
|
|
|
return __t.get();
|
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Ti, class ..._Uj, size_t ..._Indx>
|
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2011-05-20 03:41:47 +08:00
|
|
|
typename __invoke_of<_Ti&, _Uj...>::type
|
|
|
|
__mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>)
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2014-06-24 08:46:19 +08:00
|
|
|
return __ti(_VSTD::forward<_Uj>(_VSTD::get<_Indx>(__uj))...);
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class _Ti, class ..._Uj>
|
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2014-12-23 13:54:34 +08:00
|
|
|
typename __lazy_enable_if
|
2010-05-12 03:42:16 +08:00
|
|
|
<
|
|
|
|
is_bind_expression<_Ti>::value,
|
2014-12-23 13:54:34 +08:00
|
|
|
__invoke_of<_Ti&, _Uj...>
|
2010-05-12 03:42:16 +08:00
|
|
|
>::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;
|
2014-06-24 08:46:19 +08:00
|
|
|
return _VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(_VSTD::get<_Indx>(__uj));
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
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
|
2011-12-02 04:21:04 +08:00
|
|
|
__mu(_Ti& __ti, _Uj&)
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
return __ti;
|
|
|
|
}
|
|
|
|
|
2011-05-22 23:07:43 +08:00
|
|
|
template <class _Ti, bool IsReferenceWrapper, bool IsBindEx, bool IsPh,
|
|
|
|
class _TupleUj>
|
2010-05-12 03:42:16 +08:00
|
|
|
struct ____mu_return;
|
|
|
|
|
2013-07-01 03:48:15 +08:00
|
|
|
template <bool _Invokable, class _Ti, class ..._Uj>
|
|
|
|
struct ____mu_return_invokable // false
|
|
|
|
{
|
|
|
|
typedef __nat type;
|
|
|
|
};
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Ti, class ..._Uj>
|
2013-07-01 03:48:15 +08:00
|
|
|
struct ____mu_return_invokable<true, _Ti, _Uj...>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2011-05-20 03:41:47 +08:00
|
|
|
typedef typename __invoke_of<_Ti&, _Uj...>::type type;
|
2010-05-12 03:42:16 +08:00
|
|
|
};
|
|
|
|
|
2013-07-01 03:48:15 +08:00
|
|
|
template <class _Ti, class ..._Uj>
|
|
|
|
struct ____mu_return<_Ti, false, true, false, tuple<_Uj...> >
|
|
|
|
: public ____mu_return_invokable<__invokable<_Ti&, _Uj...>::value, _Ti, _Uj...>
|
|
|
|
{
|
|
|
|
};
|
|
|
|
|
2010-05-12 03:42:16 +08:00
|
|
|
template <class _Ti, class _TupleUj>
|
2011-05-22 23:07:43 +08:00
|
|
|
struct ____mu_return<_Ti, false, false, true, _TupleUj>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
typedef typename tuple_element<is_placeholder<_Ti>::value - 1,
|
|
|
|
_TupleUj>::type&& type;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <class _Ti, class _TupleUj>
|
2011-05-22 23:07:43 +08:00
|
|
|
struct ____mu_return<_Ti, true, false, false, _TupleUj>
|
|
|
|
{
|
|
|
|
typedef typename _Ti::type& type;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <class _Ti, class _TupleUj>
|
|
|
|
struct ____mu_return<_Ti, false, false, false, _TupleUj>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
|
|
|
typedef _Ti& type;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <class _Ti, class _TupleUj>
|
|
|
|
struct __mu_return
|
|
|
|
: public ____mu_return<_Ti,
|
2011-05-22 23:07:43 +08:00
|
|
|
__is_reference_wrapper<_Ti>::value,
|
2010-05-12 03:42:16 +08:00
|
|
|
is_bind_expression<_Ti>::value,
|
2013-02-22 02:16:55 +08:00
|
|
|
0 < is_placeholder<_Ti>::value &&
|
|
|
|
is_placeholder<_Ti>::value <= tuple_size<_TupleUj>::value,
|
2010-05-12 03:42:16 +08:00
|
|
|
_TupleUj>
|
|
|
|
{
|
|
|
|
};
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template <class _Fp, class _BoundArgs, class _TupleUj>
|
2015-05-20 06:27:18 +08:00
|
|
|
struct __is_valid_bind_return
|
2013-02-22 02:16:55 +08:00
|
|
|
{
|
|
|
|
static const bool value = false;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <class _Fp, class ..._BoundArgs, class _TupleUj>
|
2015-05-20 06:27:18 +08:00
|
|
|
struct __is_valid_bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj>
|
2013-02-22 02:16:55 +08:00
|
|
|
{
|
|
|
|
static const bool value = __invokable<_Fp,
|
|
|
|
typename __mu_return<_BoundArgs, _TupleUj>::type...>::value;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <class _Fp, class ..._BoundArgs, class _TupleUj>
|
2015-05-20 06:27:18 +08:00
|
|
|
struct __is_valid_bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj>
|
2013-02-22 02:16:55 +08:00
|
|
|
{
|
|
|
|
static const bool value = __invokable<_Fp,
|
|
|
|
typename __mu_return<const _BoundArgs, _TupleUj>::type...>::value;
|
|
|
|
};
|
|
|
|
|
|
|
|
template <class _Fp, class _BoundArgs, class _TupleUj,
|
2015-05-20 06:27:18 +08:00
|
|
|
bool = __is_valid_bind_return<_Fp, _BoundArgs, _TupleUj>::value>
|
2010-05-12 03:42:16 +08:00
|
|
|
struct __bind_return;
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template <class _Fp, class ..._BoundArgs, class _TupleUj>
|
2013-02-22 02:16:55 +08:00
|
|
|
struct __bind_return<_Fp, tuple<_BoundArgs...>, _TupleUj, true>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2011-05-20 03:41:47 +08:00
|
|
|
typedef typename __invoke_of
|
2010-05-12 03:42:16 +08:00
|
|
|
<
|
2011-11-30 02:15:50 +08:00
|
|
|
_Fp&,
|
2010-05-12 03:42:16 +08:00
|
|
|
typename __mu_return
|
|
|
|
<
|
|
|
|
_BoundArgs,
|
|
|
|
_TupleUj
|
|
|
|
>::type...
|
|
|
|
>::type type;
|
|
|
|
};
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template <class _Fp, class ..._BoundArgs, class _TupleUj>
|
2013-02-22 02:16:55 +08:00
|
|
|
struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj, true>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2011-05-20 03:41:47 +08:00
|
|
|
typedef typename __invoke_of
|
2010-05-12 03:42:16 +08:00
|
|
|
<
|
2011-11-30 02:15:50 +08:00
|
|
|
_Fp&,
|
2010-05-12 03:42:16 +08:00
|
|
|
typename __mu_return
|
|
|
|
<
|
|
|
|
const _BoundArgs,
|
|
|
|
_TupleUj
|
|
|
|
>::type...
|
|
|
|
>::type type;
|
|
|
|
};
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template <class _Fp, class _BoundArgs, size_t ..._Indx, class _Args>
|
2010-05-12 03:42:16 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2011-11-30 02:15:50 +08:00
|
|
|
typename __bind_return<_Fp, _BoundArgs, _Args>::type
|
|
|
|
__apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>,
|
2010-05-12 03:42:16 +08:00
|
|
|
_Args&& __args)
|
|
|
|
{
|
2017-05-04 05:02:19 +08:00
|
|
|
return _VSTD::__invoke(__f, _VSTD::__mu(_VSTD::get<_Indx>(__bound_args), __args)...);
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Fp, class ..._BoundArgs>
|
2010-05-12 03:42:16 +08:00
|
|
|
class __bind
|
2011-11-30 02:15:50 +08:00
|
|
|
: public __weak_result_type<typename decay<_Fp>::type>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2013-02-22 02:16:55 +08:00
|
|
|
protected:
|
2011-11-30 02:15:50 +08:00
|
|
|
typedef typename decay<_Fp>::type _Fd;
|
2011-05-20 03:41:47 +08:00
|
|
|
typedef tuple<typename decay<_BoundArgs>::type...> _Td;
|
2013-02-22 02:16:55 +08:00
|
|
|
private:
|
2011-05-20 03:41:47 +08:00
|
|
|
_Fd __f_;
|
|
|
|
_Td __bound_args_;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
typedef typename __make_tuple_indices<sizeof...(_BoundArgs)>::type __indices;
|
|
|
|
public:
|
2012-05-05 01:21:02 +08:00
|
|
|
template <class _Gp, class ..._BA,
|
|
|
|
class = typename enable_if
|
|
|
|
<
|
2013-07-01 08:01:51 +08:00
|
|
|
is_constructible<_Fd, _Gp>::value &&
|
|
|
|
!is_same<typename remove_reference<_Gp>::type,
|
|
|
|
__bind>::value
|
2012-05-05 01:21:02 +08:00
|
|
|
>::type>
|
2010-09-22 06:55:27 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-11-30 02:15:50 +08:00
|
|
|
explicit __bind(_Gp&& __f, _BA&& ...__bound_args)
|
|
|
|
: __f_(_VSTD::forward<_Gp>(__f)),
|
2011-07-01 05:18:19 +08:00
|
|
|
__bound_args_(_VSTD::forward<_BA>(__bound_args)...) {}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
template <class ..._Args>
|
2010-09-22 06:55:27 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-05-20 03:41:47 +08:00
|
|
|
typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type
|
2010-05-12 03:42:16 +08:00
|
|
|
operator()(_Args&& ...__args)
|
|
|
|
{
|
2017-05-04 05:02:19 +08:00
|
|
|
return _VSTD::__apply_functor(__f_, __bound_args_, __indices(),
|
2011-07-01 05:18:19 +08:00
|
|
|
tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class ..._Args>
|
2010-09-22 06:55:27 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2013-02-22 02:16:55 +08:00
|
|
|
typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type
|
2010-05-12 03:42:16 +08:00
|
|
|
operator()(_Args&& ...__args) const
|
|
|
|
{
|
2017-05-04 05:02:19 +08:00
|
|
|
return _VSTD::__apply_functor(__f_, __bound_args_, __indices(),
|
2011-07-01 05:18:19 +08:00
|
|
|
tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Fp, class ..._BoundArgs>
|
|
|
|
struct __is_bind_expression<__bind<_Fp, _BoundArgs...> > : public true_type {};
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Rp, class _Fp, class ..._BoundArgs>
|
2010-05-12 03:42:16 +08:00
|
|
|
class __bind_r
|
2011-11-30 02:15:50 +08:00
|
|
|
: public __bind<_Fp, _BoundArgs...>
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2011-11-30 02:15:50 +08:00
|
|
|
typedef __bind<_Fp, _BoundArgs...> base;
|
2013-02-22 02:16:55 +08:00
|
|
|
typedef typename base::_Fd _Fd;
|
|
|
|
typedef typename base::_Td _Td;
|
2010-05-12 03:42:16 +08:00
|
|
|
public:
|
2011-11-30 02:15:50 +08:00
|
|
|
typedef _Rp result_type;
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2011-07-03 02:22:36 +08:00
|
|
|
|
2013-07-01 08:01:51 +08:00
|
|
|
template <class _Gp, class ..._BA,
|
|
|
|
class = typename enable_if
|
|
|
|
<
|
|
|
|
is_constructible<_Fd, _Gp>::value &&
|
|
|
|
!is_same<typename remove_reference<_Gp>::type,
|
|
|
|
__bind_r>::value
|
|
|
|
>::type>
|
2010-09-22 06:55:27 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2011-11-30 02:15:50 +08:00
|
|
|
explicit __bind_r(_Gp&& __f, _BA&& ...__bound_args)
|
|
|
|
: base(_VSTD::forward<_Gp>(__f),
|
2011-07-01 05:18:19 +08:00
|
|
|
_VSTD::forward<_BA>(__bound_args)...) {}
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
template <class ..._Args>
|
2010-09-22 06:55:27 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2013-02-22 02:16:55 +08:00
|
|
|
typename enable_if
|
|
|
|
<
|
|
|
|
is_convertible<typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type,
|
2015-07-11 07:29:18 +08:00
|
|
|
result_type>::value || is_void<_Rp>::value,
|
2013-02-22 02:16:55 +08:00
|
|
|
result_type
|
|
|
|
>::type
|
2010-05-12 03:42:16 +08:00
|
|
|
operator()(_Args&& ...__args)
|
|
|
|
{
|
2015-07-11 07:29:18 +08:00
|
|
|
typedef __invoke_void_return_wrapper<_Rp> _Invoker;
|
|
|
|
return _Invoker::__call(static_cast<base&>(*this), _VSTD::forward<_Args>(__args)...);
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
template <class ..._Args>
|
2010-09-22 06:55:27 +08:00
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2013-02-22 02:16:55 +08:00
|
|
|
typename enable_if
|
|
|
|
<
|
|
|
|
is_convertible<typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type,
|
2015-07-11 07:29:18 +08:00
|
|
|
result_type>::value || is_void<_Rp>::value,
|
2013-02-22 02:16:55 +08:00
|
|
|
result_type
|
|
|
|
>::type
|
2010-05-12 03:42:16 +08:00
|
|
|
operator()(_Args&& ...__args) const
|
|
|
|
{
|
2015-07-11 07:29:18 +08:00
|
|
|
typedef __invoke_void_return_wrapper<_Rp> _Invoker;
|
|
|
|
return _Invoker::__call(static_cast<base const&>(*this), _VSTD::forward<_Args>(__args)...);
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Rp, class _Fp, class ..._BoundArgs>
|
|
|
|
struct __is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {};
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Fp, class ..._BoundArgs>
|
2010-05-12 03:42:16 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2011-11-30 02:15:50 +08:00
|
|
|
__bind<_Fp, _BoundArgs...>
|
|
|
|
bind(_Fp&& __f, _BoundArgs&&... __bound_args)
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2011-11-30 02:15:50 +08:00
|
|
|
typedef __bind<_Fp, _BoundArgs...> type;
|
|
|
|
return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
2011-11-30 02:15:50 +08:00
|
|
|
template<class _Rp, class _Fp, class ..._BoundArgs>
|
2010-05-12 03:42:16 +08:00
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
2011-11-30 02:15:50 +08:00
|
|
|
__bind_r<_Rp, _Fp, _BoundArgs...>
|
|
|
|
bind(_Fp&& __f, _BoundArgs&&... __bound_args)
|
2010-05-12 03:42:16 +08:00
|
|
|
{
|
2011-11-30 02:15:50 +08:00
|
|
|
typedef __bind_r<_Rp, _Fp, _BoundArgs...> type;
|
|
|
|
return type(_VSTD::forward<_Fp>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
|
2010-05-12 03:42:16 +08:00
|
|
|
}
|
|
|
|
|
2017-04-19 09:28:47 +08:00
|
|
|
#endif // _LIBCPP_CXX03_LANG
|
2010-05-12 03:42:16 +08:00
|
|
|
|
2015-07-15 04:16:15 +08:00
|
|
|
#if _LIBCPP_STD_VER > 14
|
2016-06-02 09:25:41 +08:00
|
|
|
|
2016-10-14 15:19:52 +08:00
|
|
|
#define __cpp_lib_invoke 201411
|
|
|
|
|
2015-07-15 04:16:15 +08:00
|
|
|
template <class _Fn, class ..._Args>
|
|
|
|
result_of_t<_Fn&&(_Args&&...)>
|
2016-06-02 09:25:41 +08:00
|
|
|
invoke(_Fn&& __f, _Args&&... __args)
|
|
|
|
noexcept(noexcept(_VSTD::__invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...)))
|
|
|
|
{
|
|
|
|
return _VSTD::__invoke(_VSTD::forward<_Fn>(__f), _VSTD::forward<_Args>(__args)...);
|
2015-07-15 04:16:15 +08:00
|
|
|
}
|
2016-06-02 09:25:41 +08:00
|
|
|
|
|
|
|
template <class _DecayFunc>
|
2017-01-05 07:56:00 +08:00
|
|
|
class _LIBCPP_TEMPLATE_VIS __not_fn_imp {
|
2016-06-02 09:25:41 +08:00
|
|
|
_DecayFunc __fd;
|
|
|
|
|
|
|
|
public:
|
|
|
|
__not_fn_imp() = delete;
|
|
|
|
|
|
|
|
template <class ..._Args>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2016-06-27 08:40:41 +08:00
|
|
|
auto operator()(_Args&& ...__args) &
|
2016-06-02 09:25:41 +08:00
|
|
|
noexcept(noexcept(!_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...)))
|
2016-10-10 22:37:18 +08:00
|
|
|
-> decltype( !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...))
|
|
|
|
{ return !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...); }
|
2016-06-02 09:25:41 +08:00
|
|
|
|
|
|
|
template <class ..._Args>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
2016-06-27 08:40:41 +08:00
|
|
|
auto operator()(_Args&& ...__args) &&
|
|
|
|
noexcept(noexcept(!_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...)))
|
2016-10-10 22:37:18 +08:00
|
|
|
-> decltype( !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...))
|
|
|
|
{ return !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...); }
|
2016-06-27 08:40:41 +08:00
|
|
|
|
|
|
|
template <class ..._Args>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
auto operator()(_Args&& ...__args) const&
|
2016-06-02 09:25:41 +08:00
|
|
|
noexcept(noexcept(!_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...)))
|
2016-10-10 22:37:18 +08:00
|
|
|
-> decltype( !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...))
|
|
|
|
{ return !_VSTD::invoke(__fd, _VSTD::forward<_Args>(__args)...); }
|
2016-06-02 09:25:41 +08:00
|
|
|
|
2016-06-27 08:40:41 +08:00
|
|
|
|
|
|
|
template <class ..._Args>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
auto operator()(_Args&& ...__args) const&&
|
|
|
|
noexcept(noexcept(!_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...)))
|
2016-10-10 22:37:18 +08:00
|
|
|
-> decltype( !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...))
|
|
|
|
{ return !_VSTD::invoke(_VSTD::move(__fd), _VSTD::forward<_Args>(__args)...); }
|
2016-06-27 08:40:41 +08:00
|
|
|
|
2016-06-02 09:25:41 +08:00
|
|
|
private:
|
|
|
|
template <class _RawFunc,
|
|
|
|
class = enable_if_t<!is_same<decay_t<_RawFunc>, __not_fn_imp>::value>>
|
|
|
|
_LIBCPP_INLINE_VISIBILITY
|
|
|
|
explicit __not_fn_imp(_RawFunc&& __rf)
|
|
|
|
: __fd(_VSTD::forward<_RawFunc>(__rf)) {}
|
|
|
|
|
|
|
|
template <class _RawFunc>
|
|
|
|
friend inline _LIBCPP_INLINE_VISIBILITY
|
|
|
|
__not_fn_imp<decay_t<_RawFunc>> not_fn(_RawFunc&&);
|
|
|
|
};
|
|
|
|
|
|
|
|
template <class _RawFunc>
|
|
|
|
inline _LIBCPP_INLINE_VISIBILITY
|
|
|
|
__not_fn_imp<decay_t<_RawFunc>> not_fn(_RawFunc&& __fn) {
|
|
|
|
return __not_fn_imp<decay_t<_RawFunc>>(_VSTD::forward<_RawFunc>(__fn));
|
|
|
|
}
|
|
|
|
|
2015-07-15 04:16:15 +08:00
|
|
|
#endif
|
|
|
|
|
2010-06-04 00:42:57 +08:00
|
|
|
// struct hash<T*> in <memory>
|
2010-05-12 03:42:16 +08:00
|
|
|
|
|
|
|
_LIBCPP_END_NAMESPACE_STD
|
|
|
|
|
|
|
|
#endif // _LIBCPP_FUNCTIONAL
|