Lines Matching +full:- +full:t
1 // -*- C++ -*-
2 //===----------------------------------------------------------------------===//
6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
8 //===----------------------------------------------------------------------===//
34 template <class T>
41 typedef T type;
47 constexpr reference_wrapper(const reference_wrapper<T>& x) noexcept; // constexpr since C++20
51 operator=(const reference_wrapper<T>& x) noexcept; // constexpr since C++20
54 constexpr operator T& () const noexcept; // constexpr since C++20
55 constexpr T& get() const noexcept; // constexpr since C++20
59 constexpr typename result_of<T&(ArgTypes&&...)>::type // constexpr since C++20
61 noexcept(is_nothrow_invocable_v<T&, ArgTypes...>); // noexcept since C++17
64 template <class T>
65 reference_wrapper(T&) -> reference_wrapper<T>;
67 template <class T> reference_wrapper<T> ref(T& t) noexcept;
68 template <class T> void ref(const T&& t) = delete;
69 template <class T> reference_wrapper<T> ref(reference_wrapper<T>t) noexcept;
71 template <class T> reference_wrapper<const T> cref(const T& t) noexcept;
72 template <class T> void cref(const T&& t) = delete;
73 template <class T> reference_wrapper<const T> cref(reference_wrapper<T> t) noexcept;
75 template <class T> struct unwrap_reference; // since C++20
76 template <class T> struct unwrap_ref_decay : unwrap_reference<decay_t<T>> { }; // since C++20
77 template <class T> using unwrap_reference_t = typename unwrap_reference<T>::type; // since C++20
78 template <class T> using unwrap_ref_decay_t = typename unwrap_ref_decay<T>::type; // since C++20
82 friend constexpr bool operator==(reference_wrapper, const T&); // Since C++26
83 friend constexpr bool operator==(reference_wrapper, reference_wrapper<const T>); // Since C++26
86 friend constexpr auto operator<=>(reference_wrapper, const T&); // Since C++26
87 friend constexpr auto operator<=>(reference_wrapper, reference_wrapper<const T>); // Since C++26
89 template <class T> // <class T=void> in C++14
91 T operator()(const T& x, const T& y) const;
94 template <class T> // <class T=void> in C++14
96 T operator()(const T& x, const T& y) const;
99 template <class T> // <class T=void> in C++14
101 T operator()(const T& x, const T& y) const;
104 template <class T> // <class T=void> in C++14
106 T operator()(const T& x, const T& y) const;
109 template <class T> // <class T=void> in C++14
111 T operator()(const T& x, const T& y) const;
114 template <class T> // <class T=void> in C++14
116 T operator()(const T& x) const;
119 template <class T> // <class T=void> in C++14
121 bool operator()(const T& x, const T& y) const;
124 template <class T> // <class T=void> in C++14
126 bool operator()(const T& x, const T& y) const;
129 template <class T> // <class T=void> in C++14
131 bool operator()(const T& x, const T& y) const;
134 template <class T> // <class T=void> in C++14
136 bool operator()(const T& x, const T& y) const;
139 template <class T> // <class T=void> in C++14
141 bool operator()(const T& x, const T& y) const;
144 template <class T> // <class T=void> in C++14
146 bool operator()(const T& x, const T& y) const;
152 template <class T> // <class T=void> in C++14
154 bool operator()(const T& x, const T& y) const;
157 template <class T> // <class T=void> in C++14
159 bool operator()(const T& x, const T& y) const;
162 template <class T> // <class T=void> in C++14
164 bool operator()(const T& x) const;
167 template <class T> // <class T=void> in C++14
169 T operator()(const T& x, const T& y) const;
172 template <class T> // <class T=void> in C++14
174 T operator()(const T& x, const T& y) const;
177 template <class T> // <class T=void> in C++14
179 T operator()(const T& x, const T& y) const;
182 template <class T=void> // C++14
184 T operator()(const T& x) const;
225 template<class T> struct is_bind_expression;
226 template<class T> struct is_placeholder;
229 template <class T> inline constexpr bool is_bind_expression_v
230 = is_bind_expression<T>::value; // C++17
231 template <class T> inline constexpr int is_placeholder_v
232 = is_placeholder<T>::value; // C++17
251 // M is the implementation-defined number of placeholders
274 template <class Operation, class T>
275 binder1st<Operation> bind1st(const Operation& op, const T& x); // deprecated in C+…
291 template <class Operation, class T>
292 binder2nd<Operation> bind2nd(const Operation& op, const T& x); // deprecated in C+…
316 template<class S, class T> // deprecated in C+…
317 class mem_fun_t : public unary_function<T*, S>
320 explicit mem_fun_t(S (T::*p)());
321 S operator()(T* p) const;
324 template<class S, class T, class A>
325 class mem_fun1_t : public binary_function<T*, A, S> // deprecated in C+…
328 explicit mem_fun1_t(S (T::*p)(A));
329 S operator()(T* p, A x) const;
332 template<class S, class T> mem_fun_t<S,T> mem_fun(S (T::*f)()); // deprecated in C+…
333 template<class S, class T, class A> mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A)); // deprecated in C+…
335 template<class S, class T>
336 class mem_fun_ref_t : public unary_function<T, S> // deprecated in C+…
339 explicit mem_fun_ref_t(S (T::*p)());
340 S operator()(T& p) const;
343 template<class S, class T, class A>
344 class mem_fun1_ref_t : public binary_function<T, A, S> // deprecated in C+…
347 explicit mem_fun1_ref_t(S (T::*p)(A));
348 S operator()(T& p, A x) const;
351 template<class S, class T>
352 mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)()); // deprecated in C+…
353 template<class S, class T, class A>
354 mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A)); // deprecated in C+…
356 template <class S, class T>
357 class const_mem_fun_t : public unary_function<const T*, S> // deprecated in C+…
360 explicit const_mem_fun_t(S (T::*p)() const);
361 S operator()(const T* p) const;
364 template <class S, class T, class A>
365 class const_mem_fun1_t : public binary_function<const T*, A, S> // deprecated in C+…
368 explicit const_mem_fun1_t(S (T::*p)(A) const);
369 S operator()(const T* p, A x) const;
372 template <class S, class T>
373 const_mem_fun_t<S,T> mem_fun(S (T::*f)() const); // deprecated in C+…
374 template <class S, class T, class A>
375 const_mem_fun1_t<S,T,A> mem_fun(S (T::*f)(A) const); // deprecated in C+…
377 template <class S, class T>
378 class const_mem_fun_ref_t : public unary_function<T, S> // deprecated in C+…
381 explicit const_mem_fun_ref_t(S (T::*p)() const);
382 S operator()(const T& p) const;
385 template <class S, class T, class A>
386 class const_mem_fun1_ref_t : public binary_function<T, A, S> // deprecated in C+…
389 explicit const_mem_fun1_ref_t(S (T::*p)(A) const);
390 S operator()(const T& p, A x) const;
393 template <class S, class T>
394 const_mem_fun_ref_t<S,T> mem_fun_ref(S (T::*f)() const); // deprecated in C+…
395 template <class S, class T, class A>
396 const_mem_fun1_ref_t<S,T,A> mem_fun_ref(S (T::*f)(A) const); // deprecated in C+…
398 template<class R, class T> constexpr unspecified mem_fn(R T::*); // constexpr in C++…
458 template <typename T> T* target() noexcept;
459 template <typename T> const T* target() const noexcept;
464 function(R(*)(Args...)) -> function<R(Args...)>; // since C++17
467 function(F) -> function<see-below>; // since C++17
486 template <class T> struct hash;
509 template<class T> struct hash<T*>;
513 // [range.cmp], concept-constrained comparisons
524 POLICY: For non-variadic implementations, the number of arguments is limited
525 to 3. It is hoped that the need for non-variadic implementations