forked from OSchip/llvm-project
536 lines
17 KiB
C++
536 lines
17 KiB
C++
// -*- C++ -*-
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
|
|
// See https://llvm.org/LICENSE.txt for license information.
|
|
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef _LIBCPP_FUNCTIONAL
|
|
#define _LIBCPP_FUNCTIONAL
|
|
|
|
/*
|
|
functional synopsis
|
|
|
|
namespace std
|
|
{
|
|
|
|
template <class Arg, class Result>
|
|
struct unary_function
|
|
{
|
|
typedef Arg argument_type;
|
|
typedef Result result_type;
|
|
};
|
|
|
|
template <class Arg1, class Arg2, class Result>
|
|
struct binary_function
|
|
{
|
|
typedef Arg1 first_argument_type;
|
|
typedef Arg2 second_argument_type;
|
|
typedef Result result_type;
|
|
};
|
|
|
|
template <class T>
|
|
class reference_wrapper
|
|
: public unary_function<T1, R> // if wrapping a unary functor
|
|
: public binary_function<T1, T2, R> // if wraping a binary functor
|
|
{
|
|
public:
|
|
// types
|
|
typedef T type;
|
|
typedef see below result_type; // Not always defined
|
|
|
|
// construct/copy/destroy
|
|
template<class U>
|
|
reference_wrapper(U&&);
|
|
reference_wrapper(const reference_wrapper<T>& x) noexcept;
|
|
|
|
// assignment
|
|
reference_wrapper& operator=(const reference_wrapper<T>& x) noexcept;
|
|
|
|
// access
|
|
operator T& () const noexcept;
|
|
T& get() const noexcept;
|
|
|
|
// invoke
|
|
template <class... ArgTypes>
|
|
typename result_of<T&(ArgTypes&&...)>::type
|
|
operator() (ArgTypes&&...) const;
|
|
};
|
|
|
|
template <class T>
|
|
reference_wrapper(T&) -> reference_wrapper<T>;
|
|
|
|
template <class T> reference_wrapper<T> ref(T& t) noexcept;
|
|
template <class T> void ref(const T&& t) = delete;
|
|
template <class T> reference_wrapper<T> ref(reference_wrapper<T>t) noexcept;
|
|
|
|
template <class T> reference_wrapper<const T> cref(const T& t) noexcept;
|
|
template <class T> void cref(const T&& t) = delete;
|
|
template <class T> reference_wrapper<const T> cref(reference_wrapper<T> t) noexcept;
|
|
|
|
template <class T> struct unwrap_reference; // since C++20
|
|
template <class T> struct unwrap_ref_decay : unwrap_reference<decay_t<T>> { }; // since C++20
|
|
template <class T> using unwrap_reference_t = typename unwrap_reference<T>::type; // since C++20
|
|
template <class T> using unwrap_ref_decay_t = typename unwrap_ref_decay<T>::type; // since C++20
|
|
|
|
template <class T> // <class T=void> in C++14
|
|
struct plus {
|
|
T operator()(const T& x, const T& y) const;
|
|
};
|
|
|
|
template <class T> // <class T=void> in C++14
|
|
struct minus {
|
|
T operator()(const T& x, const T& y) const;
|
|
};
|
|
|
|
template <class T> // <class T=void> in C++14
|
|
struct multiplies {
|
|
T operator()(const T& x, const T& y) const;
|
|
};
|
|
|
|
template <class T> // <class T=void> in C++14
|
|
struct divides {
|
|
T operator()(const T& x, const T& y) const;
|
|
};
|
|
|
|
template <class T> // <class T=void> in C++14
|
|
struct modulus {
|
|
T operator()(const T& x, const T& y) const;
|
|
};
|
|
|
|
template <class T> // <class T=void> in C++14
|
|
struct negate {
|
|
T operator()(const T& x) const;
|
|
};
|
|
|
|
template <class T> // <class T=void> in C++14
|
|
struct equal_to {
|
|
bool operator()(const T& x, const T& y) const;
|
|
};
|
|
|
|
template <class T> // <class T=void> in C++14
|
|
struct not_equal_to {
|
|
bool operator()(const T& x, const T& y) const;
|
|
};
|
|
|
|
template <class T> // <class T=void> in C++14
|
|
struct greater {
|
|
bool operator()(const T& x, const T& y) const;
|
|
};
|
|
|
|
template <class T> // <class T=void> in C++14
|
|
struct less {
|
|
bool operator()(const T& x, const T& y) const;
|
|
};
|
|
|
|
template <class T> // <class T=void> in C++14
|
|
struct greater_equal {
|
|
bool operator()(const T& x, const T& y) const;
|
|
};
|
|
|
|
template <class T> // <class T=void> in C++14
|
|
struct less_equal {
|
|
bool operator()(const T& x, const T& y) const;
|
|
};
|
|
|
|
// [comparisons.three.way], class compare_three_way
|
|
struct compare_three_way;
|
|
|
|
template <class T> // <class T=void> in C++14
|
|
struct logical_and {
|
|
bool operator()(const T& x, const T& y) const;
|
|
};
|
|
|
|
template <class T> // <class T=void> in C++14
|
|
struct logical_or {
|
|
bool operator()(const T& x, const T& y) const;
|
|
};
|
|
|
|
template <class T> // <class T=void> in C++14
|
|
struct logical_not {
|
|
bool operator()(const T& x) const;
|
|
};
|
|
|
|
template <class T> // <class T=void> in C++14
|
|
struct bit_and {
|
|
T operator()(const T& x, const T& y) const;
|
|
};
|
|
|
|
template <class T> // <class T=void> in C++14
|
|
struct bit_or {
|
|
T operator()(const T& x, const T& y) const;
|
|
};
|
|
|
|
template <class T> // <class T=void> in C++14
|
|
struct bit_xor {
|
|
T operator()(const T& x, const T& y) const;
|
|
};
|
|
|
|
template <class T=void> // C++14
|
|
struct bit_not {
|
|
T operator()(const T& x) const;
|
|
};
|
|
|
|
struct identity; // C++20
|
|
|
|
template <class Predicate>
|
|
class unary_negate // deprecated in C++17, removed in C++20
|
|
: 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> // deprecated in C++17, removed in C++20
|
|
unary_negate<Predicate> not1(const Predicate& pred);
|
|
|
|
template <class Predicate>
|
|
class binary_negate // deprecated in C++17, removed in C++20
|
|
: 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> // deprecated in C++17, removed in C++20
|
|
binary_negate<Predicate> not2(const Predicate& pred);
|
|
|
|
template <class F>
|
|
constexpr unspecified not_fn(F&& f); // C++17, constexpr in C++20
|
|
|
|
template<class T> struct is_bind_expression;
|
|
template<class T> struct is_placeholder;
|
|
|
|
// See C++14 20.9.9, Function object binders
|
|
template <class T> inline constexpr bool is_bind_expression_v
|
|
= is_bind_expression<T>::value; // C++17
|
|
template <class T> inline constexpr int is_placeholder_v
|
|
= is_placeholder<T>::value; // C++17
|
|
|
|
|
|
template<class Fn, class... BoundArgs>
|
|
constexpr unspecified bind(Fn&&, BoundArgs&&...); // constexpr in C++20
|
|
template<class R, class Fn, class... BoundArgs>
|
|
constexpr unspecified bind(Fn&&, BoundArgs&&...); // constexpr in C++20
|
|
|
|
template<class F, class... Args>
|
|
constexpr // constexpr in C++20
|
|
invoke_result_t<F, Args...> invoke(F&& f, Args&&... args) // C++17
|
|
noexcept(is_nothrow_invocable_v<F, Args...>);
|
|
|
|
namespace placeholders {
|
|
// M is the implementation-defined number of placeholders
|
|
extern unspecified _1;
|
|
extern unspecified _2;
|
|
.
|
|
.
|
|
.
|
|
extern unspecified _Mp;
|
|
}
|
|
|
|
template <class Operation>
|
|
class binder1st // deprecated in C++11, removed in C++17
|
|
: public unary_function<typename Operation::second_argument_type,
|
|
typename Operation::result_type>
|
|
{
|
|
protected:
|
|
Operation op;
|
|
typename Operation::first_argument_type value;
|
|
public:
|
|
binder1st(const Operation& x, const typename Operation::first_argument_type y);
|
|
typename Operation::result_type operator()( typename Operation::second_argument_type& x) const;
|
|
typename Operation::result_type operator()(const typename Operation::second_argument_type& x) const;
|
|
};
|
|
|
|
template <class Operation, class T>
|
|
binder1st<Operation> bind1st(const Operation& op, const T& x); // deprecated in C++11, removed in C++17
|
|
|
|
template <class Operation>
|
|
class binder2nd // deprecated in C++11, removed in C++17
|
|
: public unary_function<typename Operation::first_argument_type,
|
|
typename Operation::result_type>
|
|
{
|
|
protected:
|
|
Operation op;
|
|
typename Operation::second_argument_type value;
|
|
public:
|
|
binder2nd(const Operation& x, const typename Operation::second_argument_type y);
|
|
typename Operation::result_type operator()( typename Operation::first_argument_type& x) const;
|
|
typename Operation::result_type operator()(const typename Operation::first_argument_type& x) const;
|
|
};
|
|
|
|
template <class Operation, class T>
|
|
binder2nd<Operation> bind2nd(const Operation& op, const T& x); // deprecated in C++11, removed in C++17
|
|
|
|
template <class Arg, class Result> // deprecated in C++11, removed in C++17
|
|
class pointer_to_unary_function : public unary_function<Arg, Result>
|
|
{
|
|
public:
|
|
explicit pointer_to_unary_function(Result (*f)(Arg));
|
|
Result operator()(Arg x) const;
|
|
};
|
|
|
|
template <class Arg, class Result>
|
|
pointer_to_unary_function<Arg,Result> ptr_fun(Result (*f)(Arg)); // deprecated in C++11, removed in C++17
|
|
|
|
template <class Arg1, class Arg2, class Result> // deprecated in C++11, removed in C++17
|
|
class pointer_to_binary_function : public binary_function<Arg1, Arg2, Result>
|
|
{
|
|
public:
|
|
explicit pointer_to_binary_function(Result (*f)(Arg1, Arg2));
|
|
Result operator()(Arg1 x, Arg2 y) const;
|
|
};
|
|
|
|
template <class Arg1, class Arg2, class Result>
|
|
pointer_to_binary_function<Arg1,Arg2,Result> ptr_fun(Result (*f)(Arg1,Arg2)); // deprecated in C++11, removed in C++17
|
|
|
|
template<class S, class T> // deprecated in C++11, removed in C++17
|
|
class mem_fun_t : public unary_function<T*, S>
|
|
{
|
|
public:
|
|
explicit mem_fun_t(S (T::*p)());
|
|
S operator()(T* p) const;
|
|
};
|
|
|
|
template<class S, class T, class A>
|
|
class mem_fun1_t : public binary_function<T*, A, S> // deprecated in C++11, removed in C++17
|
|
{
|
|
public:
|
|
explicit mem_fun1_t(S (T::*p)(A));
|
|
S operator()(T* p, A x) const;
|
|
};
|
|
|
|
template<class S, class T> mem_fun_t<S,T> mem_fun(S (T::*f)()); // 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
|
|
|
|
template<class S, class T>
|
|
class mem_fun_ref_t : public unary_function<T, S> // deprecated in C++11, removed in C++17
|
|
{
|
|
public:
|
|
explicit mem_fun_ref_t(S (T::*p)());
|
|
S operator()(T& p) const;
|
|
};
|
|
|
|
template<class S, class T, class A>
|
|
class mem_fun1_ref_t : public binary_function<T, A, S> // deprecated in C++11, removed in C++17
|
|
{
|
|
public:
|
|
explicit mem_fun1_ref_t(S (T::*p)(A));
|
|
S operator()(T& p, A x) const;
|
|
};
|
|
|
|
template<class S, class T> mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)()); // 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
|
|
|
|
template <class S, class T>
|
|
class const_mem_fun_t : public unary_function<const T*, S> // deprecated in C++11, removed in C++17
|
|
{
|
|
public:
|
|
explicit const_mem_fun_t(S (T::*p)() const);
|
|
S operator()(const T* p) const;
|
|
};
|
|
|
|
template <class S, class T, class A>
|
|
class const_mem_fun1_t : public binary_function<const T*, A, S> // deprecated in C++11, removed in C++17
|
|
{
|
|
public:
|
|
explicit const_mem_fun1_t(S (T::*p)(A) const);
|
|
S operator()(const T* p, A x) const;
|
|
};
|
|
|
|
template <class S, class T> const_mem_fun_t<S,T> mem_fun(S (T::*f)() const); // 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
|
|
|
|
template <class S, class T>
|
|
class const_mem_fun_ref_t : public unary_function<T, S> // deprecated in C++11, removed in C++17
|
|
{
|
|
public:
|
|
explicit const_mem_fun_ref_t(S (T::*p)() const);
|
|
S operator()(const T& p) const;
|
|
};
|
|
|
|
template <class S, class T, class A>
|
|
class const_mem_fun1_ref_t : public binary_function<T, A, S> // deprecated in C++11, removed in C++17
|
|
{
|
|
public:
|
|
explicit const_mem_fun1_ref_t(S (T::*p)(A) const);
|
|
S operator()(const T& p, A x) const;
|
|
};
|
|
|
|
template <class S, class T> const_mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)() const); // 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
|
|
|
|
template<class R, class T>
|
|
constexpr unspecified mem_fn(R T::*); // constexpr in C++20
|
|
|
|
class bad_function_call
|
|
: public exception
|
|
{
|
|
};
|
|
|
|
template<class> class function; // undefined
|
|
|
|
template<class R, class... ArgTypes>
|
|
class function<R(ArgTypes...)>
|
|
: public unary_function<T1, R> // iff sizeof...(ArgTypes) == 1 and
|
|
// ArgTypes contains T1
|
|
: public binary_function<T1, T2, R> // iff sizeof...(ArgTypes) == 2 and
|
|
// ArgTypes contains T1 and T2
|
|
{
|
|
public:
|
|
typedef R result_type;
|
|
|
|
// construct/copy/destroy:
|
|
function() noexcept;
|
|
function(nullptr_t) noexcept;
|
|
function(const function&);
|
|
function(function&&) noexcept;
|
|
template<class F>
|
|
function(F);
|
|
template<Allocator Alloc>
|
|
function(allocator_arg_t, const Alloc&) noexcept; // removed in C++17
|
|
template<Allocator Alloc>
|
|
function(allocator_arg_t, const Alloc&, nullptr_t) noexcept; // removed in C++17
|
|
template<Allocator Alloc>
|
|
function(allocator_arg_t, const Alloc&, const function&); // removed in C++17
|
|
template<Allocator Alloc>
|
|
function(allocator_arg_t, const Alloc&, function&&); // removed in C++17
|
|
template<class F, Allocator Alloc>
|
|
function(allocator_arg_t, const Alloc&, F); // removed in C++17
|
|
|
|
function& operator=(const function&);
|
|
function& operator=(function&&) noexcept;
|
|
function& operator=(nullptr_t) noexcept;
|
|
template<class F>
|
|
function& operator=(F&&);
|
|
template<class F>
|
|
function& operator=(reference_wrapper<F>) noexcept;
|
|
|
|
~function();
|
|
|
|
// function modifiers:
|
|
void swap(function&) noexcept;
|
|
template<class F, class Alloc>
|
|
void assign(F&&, const Alloc&); // Removed in C++17
|
|
|
|
// function capacity:
|
|
explicit operator bool() const noexcept;
|
|
|
|
// function invocation:
|
|
R operator()(ArgTypes...) const;
|
|
|
|
// function target access:
|
|
const std::type_info& target_type() const noexcept;
|
|
template <typename T> T* target() noexcept;
|
|
template <typename T> const T* target() const noexcept;
|
|
};
|
|
|
|
// Deduction guides
|
|
template<class R, class ...Args>
|
|
function(R(*)(Args...)) -> function<R(Args...)>; // since C++17
|
|
|
|
template<class F>
|
|
function(F) -> function<see-below>; // since C++17
|
|
|
|
// Null pointer comparisons:
|
|
template <class R, class ... ArgTypes>
|
|
bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
|
|
|
|
template <class R, class ... ArgTypes>
|
|
bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
|
|
|
|
template <class R, class ... ArgTypes>
|
|
bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
|
|
|
|
template <class R, class ... ArgTypes>
|
|
bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
|
|
|
|
// specialized algorithms:
|
|
template <class R, class ... ArgTypes>
|
|
void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;
|
|
|
|
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<char8_t>; // since C++20
|
|
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*>;
|
|
template <> struct hash<nullptr_t>; // C++17
|
|
|
|
} // 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 <__algorithm/search.h>
|
|
#include <__compare/compare_three_way.h>
|
|
#include <__config>
|
|
#include <__debug>
|
|
#include <__functional/binary_function.h> // TODO: deprecate
|
|
#include <__functional/binary_negate.h>
|
|
#include <__functional/bind_back.h>
|
|
#include <__functional/bind_front.h>
|
|
#include <__functional/bind.h>
|
|
#include <__functional/binder1st.h>
|
|
#include <__functional/binder2nd.h>
|
|
#include <__functional/compose.h>
|
|
#include <__functional/default_searcher.h>
|
|
#include <__functional/function.h>
|
|
#include <__functional/hash.h>
|
|
#include <__functional/identity.h>
|
|
#include <__functional/invoke.h>
|
|
#include <__functional/mem_fn.h> // TODO: deprecate
|
|
#include <__functional/mem_fun_ref.h>
|
|
#include <__functional/not_fn.h>
|
|
#include <__functional/operations.h>
|
|
#include <__functional/pointer_to_binary_function.h>
|
|
#include <__functional/pointer_to_unary_function.h>
|
|
#include <__functional/ranges_operations.h>
|
|
#include <__functional/reference_wrapper.h>
|
|
#include <__functional/unary_function.h> // TODO: deprecate
|
|
#include <__functional/unary_negate.h>
|
|
#include <__functional/unwrap_ref.h>
|
|
#include <__utility/forward.h>
|
|
#include <concepts>
|
|
#include <exception>
|
|
#include <memory>
|
|
#include <tuple>
|
|
#include <type_traits>
|
|
#include <typeinfo>
|
|
#include <utility>
|
|
#include <version>
|
|
|
|
#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
|
|
#pragma GCC system_header
|
|
#endif
|
|
|
|
#endif // _LIBCPP_FUNCTIONAL
|