Branch data Line data Source code
1 : : // Functor implementations -*- C++ -*-
2 : :
3 : : // Copyright (C) 2001-2013 Free Software Foundation, Inc.
4 : : //
5 : : // This file is part of the GNU ISO C++ Library. This library is free
6 : : // software; you can redistribute it and/or modify it under the
7 : : // terms of the GNU General Public License as published by the
8 : : // Free Software Foundation; either version 3, or (at your option)
9 : : // any later version.
10 : :
11 : : // This library is distributed in the hope that it will be useful,
12 : : // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : : // GNU General Public License for more details.
15 : :
16 : : // Under Section 7 of GPL version 3, you are granted additional
17 : : // permissions described in the GCC Runtime Library Exception, version
18 : : // 3.1, as published by the Free Software Foundation.
19 : :
20 : : // You should have received a copy of the GNU General Public License and
21 : : // a copy of the GCC Runtime Library Exception along with this program;
22 : : // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23 : : // <http://www.gnu.org/licenses/>.
24 : :
25 : : /*
26 : : *
27 : : * Copyright (c) 1994
28 : : * Hewlett-Packard Company
29 : : *
30 : : * Permission to use, copy, modify, distribute and sell this software
31 : : * and its documentation for any purpose is hereby granted without fee,
32 : : * provided that the above copyright notice appear in all copies and
33 : : * that both that copyright notice and this permission notice appear
34 : : * in supporting documentation. Hewlett-Packard Company makes no
35 : : * representations about the suitability of this software for any
36 : : * purpose. It is provided "as is" without express or implied warranty.
37 : : *
38 : : *
39 : : * Copyright (c) 1996-1998
40 : : * Silicon Graphics Computer Systems, Inc.
41 : : *
42 : : * Permission to use, copy, modify, distribute and sell this software
43 : : * and its documentation for any purpose is hereby granted without fee,
44 : : * provided that the above copyright notice appear in all copies and
45 : : * that both that copyright notice and this permission notice appear
46 : : * in supporting documentation. Silicon Graphics makes no
47 : : * representations about the suitability of this software for any
48 : : * purpose. It is provided "as is" without express or implied warranty.
49 : : */
50 : :
51 : : /** @file bits/stl_function.h
52 : : * This is an internal header file, included by other library headers.
53 : : * Do not attempt to use it directly. @headername{functional}
54 : : */
55 : :
56 : : #ifndef _STL_FUNCTION_H
57 : : #define _STL_FUNCTION_H 1
58 : :
59 : : namespace std _GLIBCXX_VISIBILITY(default)
60 : : {
61 : : _GLIBCXX_BEGIN_NAMESPACE_VERSION
62 : :
63 : : // 20.3.1 base classes
64 : : /** @defgroup functors Function Objects
65 : : * @ingroup utilities
66 : : *
67 : : * Function objects, or @e functors, are objects with an @c operator()
68 : : * defined and accessible. They can be passed as arguments to algorithm
69 : : * templates and used in place of a function pointer. Not only is the
70 : : * resulting expressiveness of the library increased, but the generated
71 : : * code can be more efficient than what you might write by hand. When we
72 : : * refer to @a functors, then, generally we include function pointers in
73 : : * the description as well.
74 : : *
75 : : * Often, functors are only created as temporaries passed to algorithm
76 : : * calls, rather than being created as named variables.
77 : : *
78 : : * Two examples taken from the standard itself follow. To perform a
79 : : * by-element addition of two vectors @c a and @c b containing @c double,
80 : : * and put the result in @c a, use
81 : : * \code
82 : : * transform (a.begin(), a.end(), b.begin(), a.begin(), plus<double>());
83 : : * \endcode
84 : : * To negate every element in @c a, use
85 : : * \code
86 : : * transform(a.begin(), a.end(), a.begin(), negate<double>());
87 : : * \endcode
88 : : * The addition and negation functions will be inlined directly.
89 : : *
90 : : * The standard functors are derived from structs named @c unary_function
91 : : * and @c binary_function. These two classes contain nothing but typedefs,
92 : : * to aid in generic (template) programming. If you write your own
93 : : * functors, you might consider doing the same.
94 : : *
95 : : * @{
96 : : */
97 : : /**
98 : : * This is one of the @link functors functor base classes@endlink.
99 : : */
100 : : template<typename _Arg, typename _Result>
101 : 333 : struct unary_function
102 : : {
103 : : /// @c argument_type is the type of the argument
104 : : typedef _Arg argument_type;
105 : :
106 : : /// @c result_type is the return type
107 : : typedef _Result result_type;
108 : : };
109 : :
110 : : /**
111 : : * This is one of the @link functors functor base classes@endlink.
112 : : */
113 : : template<typename _Arg1, typename _Arg2, typename _Result>
114 : 54054 : struct binary_function
115 : : {
116 : : /// @c first_argument_type is the type of the first argument
117 : : typedef _Arg1 first_argument_type;
118 : :
119 : : /// @c second_argument_type is the type of the second argument
120 : : typedef _Arg2 second_argument_type;
121 : :
122 : : /// @c result_type is the return type
123 : : typedef _Result result_type;
124 : : };
125 : : /** @} */
126 : :
127 : : // 20.3.2 arithmetic
128 : : /** @defgroup arithmetic_functors Arithmetic Classes
129 : : * @ingroup functors
130 : : *
131 : : * Because basic math often needs to be done during an algorithm,
132 : : * the library provides functors for those operations. See the
133 : : * documentation for @link functors the base classes@endlink
134 : : * for examples of their use.
135 : : *
136 : : * @{
137 : : */
138 : : /// One of the @link arithmetic_functors math functors@endlink.
139 : : template<typename _Tp>
140 : : struct plus : public binary_function<_Tp, _Tp, _Tp>
141 : : {
142 : : _Tp
143 : : operator()(const _Tp& __x, const _Tp& __y) const
144 : : { return __x + __y; }
145 : : };
146 : :
147 : : /// One of the @link arithmetic_functors math functors@endlink.
148 : : template<typename _Tp>
149 : : struct minus : public binary_function<_Tp, _Tp, _Tp>
150 : : {
151 : : _Tp
152 : : operator()(const _Tp& __x, const _Tp& __y) const
153 : : { return __x - __y; }
154 : : };
155 : :
156 : : /// One of the @link arithmetic_functors math functors@endlink.
157 : : template<typename _Tp>
158 : : struct multiplies : public binary_function<_Tp, _Tp, _Tp>
159 : : {
160 : : _Tp
161 : : operator()(const _Tp& __x, const _Tp& __y) const
162 : : { return __x * __y; }
163 : : };
164 : :
165 : : /// One of the @link arithmetic_functors math functors@endlink.
166 : : template<typename _Tp>
167 : : struct divides : public binary_function<_Tp, _Tp, _Tp>
168 : : {
169 : : _Tp
170 : : operator()(const _Tp& __x, const _Tp& __y) const
171 : : { return __x / __y; }
172 : : };
173 : :
174 : : /// One of the @link arithmetic_functors math functors@endlink.
175 : : template<typename _Tp>
176 : : struct modulus : public binary_function<_Tp, _Tp, _Tp>
177 : : {
178 : : _Tp
179 : : operator()(const _Tp& __x, const _Tp& __y) const
180 : : { return __x % __y; }
181 : : };
182 : :
183 : : /// One of the @link arithmetic_functors math functors@endlink.
184 : : template<typename _Tp>
185 : : struct negate : public unary_function<_Tp, _Tp>
186 : : {
187 : : _Tp
188 : : operator()(const _Tp& __x) const
189 : : { return -__x; }
190 : : };
191 : : /** @} */
192 : :
193 : : // 20.3.3 comparisons
194 : : /** @defgroup comparison_functors Comparison Classes
195 : : * @ingroup functors
196 : : *
197 : : * The library provides six wrapper functors for all the basic comparisons
198 : : * in C++, like @c <.
199 : : *
200 : : * @{
201 : : */
202 : : /// One of the @link comparison_functors comparison functors@endlink.
203 : : template<typename _Tp>
204 : : struct equal_to : public binary_function<_Tp, _Tp, bool>
205 : : {
206 : : bool
207 : 1530 : operator()(const _Tp& __x, const _Tp& __y) const
208 : 1530 : { return __x == __y; }
209 : : };
210 : :
211 : : /// One of the @link comparison_functors comparison functors@endlink.
212 : : template<typename _Tp>
213 : : struct not_equal_to : public binary_function<_Tp, _Tp, bool>
214 : : {
215 : : bool
216 : : operator()(const _Tp& __x, const _Tp& __y) const
217 : : { return __x != __y; }
218 : : };
219 : :
220 : : /// One of the @link comparison_functors comparison functors@endlink.
221 : : template<typename _Tp>
222 : : struct greater : public binary_function<_Tp, _Tp, bool>
223 : : {
224 : : bool
225 : 1500 : operator()(const _Tp& __x, const _Tp& __y) const
226 : 1500 : { return __x > __y; }
227 : : };
228 : :
229 : : /// One of the @link comparison_functors comparison functors@endlink.
230 : : template<typename _Tp>
231 : : struct less : public binary_function<_Tp, _Tp, bool>
232 : : {
233 : : bool
234 : 45015 : operator()(const _Tp& __x, const _Tp& __y) const
235 : 45015 : { return __x < __y; }
236 : : };
237 : :
238 : : /// One of the @link comparison_functors comparison functors@endlink.
239 : : template<typename _Tp>
240 : : struct greater_equal : public binary_function<_Tp, _Tp, bool>
241 : : {
242 : : bool
243 : : operator()(const _Tp& __x, const _Tp& __y) const
244 : : { return __x >= __y; }
245 : : };
246 : :
247 : : /// One of the @link comparison_functors comparison functors@endlink.
248 : : template<typename _Tp>
249 : : struct less_equal : public binary_function<_Tp, _Tp, bool>
250 : : {
251 : : bool
252 : 101 : operator()(const _Tp& __x, const _Tp& __y) const
253 : 101 : { return __x <= __y; }
254 : : };
255 : : /** @} */
256 : :
257 : : // 20.3.4 logical operations
258 : : /** @defgroup logical_functors Boolean Operations Classes
259 : : * @ingroup functors
260 : : *
261 : : * Here are wrapper functors for Boolean operations: @c &&, @c ||,
262 : : * and @c !.
263 : : *
264 : : * @{
265 : : */
266 : : /// One of the @link logical_functors Boolean operations functors@endlink.
267 : : template<typename _Tp>
268 : : struct logical_and : public binary_function<_Tp, _Tp, bool>
269 : : {
270 : : bool
271 : : operator()(const _Tp& __x, const _Tp& __y) const
272 : : { return __x && __y; }
273 : : };
274 : :
275 : : /// One of the @link logical_functors Boolean operations functors@endlink.
276 : : template<typename _Tp>
277 : : struct logical_or : public binary_function<_Tp, _Tp, bool>
278 : : {
279 : : bool
280 : : operator()(const _Tp& __x, const _Tp& __y) const
281 : : { return __x || __y; }
282 : : };
283 : :
284 : : /// One of the @link logical_functors Boolean operations functors@endlink.
285 : : template<typename _Tp>
286 : : struct logical_not : public unary_function<_Tp, bool>
287 : : {
288 : : bool
289 : : operator()(const _Tp& __x) const
290 : : { return !__x; }
291 : : };
292 : : /** @} */
293 : :
294 : : // _GLIBCXX_RESOLVE_LIB_DEFECTS
295 : : // DR 660. Missing Bitwise Operations.
296 : : template<typename _Tp>
297 : : struct bit_and : public binary_function<_Tp, _Tp, _Tp>
298 : : {
299 : : _Tp
300 : : operator()(const _Tp& __x, const _Tp& __y) const
301 : : { return __x & __y; }
302 : : };
303 : :
304 : : template<typename _Tp>
305 : : struct bit_or : public binary_function<_Tp, _Tp, _Tp>
306 : : {
307 : : _Tp
308 : : operator()(const _Tp& __x, const _Tp& __y) const
309 : : { return __x | __y; }
310 : : };
311 : :
312 : : template<typename _Tp>
313 : : struct bit_xor : public binary_function<_Tp, _Tp, _Tp>
314 : : {
315 : : _Tp
316 : : operator()(const _Tp& __x, const _Tp& __y) const
317 : : { return __x ^ __y; }
318 : : };
319 : :
320 : : // 20.3.5 negators
321 : : /** @defgroup negators Negators
322 : : * @ingroup functors
323 : : *
324 : : * The functions @c not1 and @c not2 each take a predicate functor
325 : : * and return an instance of @c unary_negate or
326 : : * @c binary_negate, respectively. These classes are functors whose
327 : : * @c operator() performs the stored predicate function and then returns
328 : : * the negation of the result.
329 : : *
330 : : * For example, given a vector of integers and a trivial predicate,
331 : : * \code
332 : : * struct IntGreaterThanThree
333 : : * : public std::unary_function<int, bool>
334 : : * {
335 : : * bool operator() (int x) { return x > 3; }
336 : : * };
337 : : *
338 : : * std::find_if (v.begin(), v.end(), not1(IntGreaterThanThree()));
339 : : * \endcode
340 : : * The call to @c find_if will locate the first index (i) of @c v for which
341 : : * <code>!(v[i] > 3)</code> is true.
342 : : *
343 : : * The not1/unary_negate combination works on predicates taking a single
344 : : * argument. The not2/binary_negate combination works on predicates which
345 : : * take two arguments.
346 : : *
347 : : * @{
348 : : */
349 : : /// One of the @link negators negation functors@endlink.
350 : : template<typename _Predicate>
351 : : class unary_negate
352 : : : public unary_function<typename _Predicate::argument_type, bool>
353 : : {
354 : : protected:
355 : : _Predicate _M_pred;
356 : :
357 : : public:
358 : : explicit
359 : : unary_negate(const _Predicate& __x) : _M_pred(__x) { }
360 : :
361 : : bool
362 : : operator()(const typename _Predicate::argument_type& __x) const
363 : : { return !_M_pred(__x); }
364 : : };
365 : :
366 : : /// One of the @link negators negation functors@endlink.
367 : : template<typename _Predicate>
368 : : inline unary_negate<_Predicate>
369 : : not1(const _Predicate& __pred)
370 : : { return unary_negate<_Predicate>(__pred); }
371 : :
372 : : /// One of the @link negators negation functors@endlink.
373 : : template<typename _Predicate>
374 : : class binary_negate
375 : : : public binary_function<typename _Predicate::first_argument_type,
376 : : typename _Predicate::second_argument_type, bool>
377 : : {
378 : : protected:
379 : : _Predicate _M_pred;
380 : :
381 : : public:
382 : : explicit
383 : : binary_negate(const _Predicate& __x) : _M_pred(__x) { }
384 : :
385 : : bool
386 : : operator()(const typename _Predicate::first_argument_type& __x,
387 : : const typename _Predicate::second_argument_type& __y) const
388 : : { return !_M_pred(__x, __y); }
389 : : };
390 : :
391 : : /// One of the @link negators negation functors@endlink.
392 : : template<typename _Predicate>
393 : : inline binary_negate<_Predicate>
394 : : not2(const _Predicate& __pred)
395 : : { return binary_negate<_Predicate>(__pred); }
396 : : /** @} */
397 : :
398 : : // 20.3.7 adaptors pointers functions
399 : : /** @defgroup pointer_adaptors Adaptors for pointers to functions
400 : : * @ingroup functors
401 : : *
402 : : * The advantage of function objects over pointers to functions is that
403 : : * the objects in the standard library declare nested typedefs describing
404 : : * their argument and result types with uniform names (e.g., @c result_type
405 : : * from the base classes @c unary_function and @c binary_function).
406 : : * Sometimes those typedefs are required, not just optional.
407 : : *
408 : : * Adaptors are provided to turn pointers to unary (single-argument) and
409 : : * binary (double-argument) functions into function objects. The
410 : : * long-winded functor @c pointer_to_unary_function is constructed with a
411 : : * function pointer @c f, and its @c operator() called with argument @c x
412 : : * returns @c f(x). The functor @c pointer_to_binary_function does the same
413 : : * thing, but with a double-argument @c f and @c operator().
414 : : *
415 : : * The function @c ptr_fun takes a pointer-to-function @c f and constructs
416 : : * an instance of the appropriate functor.
417 : : *
418 : : * @{
419 : : */
420 : : /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
421 : : template<typename _Arg, typename _Result>
422 : : class pointer_to_unary_function : public unary_function<_Arg, _Result>
423 : : {
424 : : protected:
425 : : _Result (*_M_ptr)(_Arg);
426 : :
427 : : public:
428 : : pointer_to_unary_function() { }
429 : :
430 : : explicit
431 : : pointer_to_unary_function(_Result (*__x)(_Arg))
432 : : : _M_ptr(__x) { }
433 : :
434 : : _Result
435 : : operator()(_Arg __x) const
436 : : { return _M_ptr(__x); }
437 : : };
438 : :
439 : : /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
440 : : template<typename _Arg, typename _Result>
441 : : inline pointer_to_unary_function<_Arg, _Result>
442 : : ptr_fun(_Result (*__x)(_Arg))
443 : : { return pointer_to_unary_function<_Arg, _Result>(__x); }
444 : :
445 : : /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
446 : : template<typename _Arg1, typename _Arg2, typename _Result>
447 : : class pointer_to_binary_function
448 : : : public binary_function<_Arg1, _Arg2, _Result>
449 : : {
450 : : protected:
451 : : _Result (*_M_ptr)(_Arg1, _Arg2);
452 : :
453 : : public:
454 : : pointer_to_binary_function() { }
455 : :
456 : : explicit
457 : : pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
458 : : : _M_ptr(__x) { }
459 : :
460 : : _Result
461 : : operator()(_Arg1 __x, _Arg2 __y) const
462 : : { return _M_ptr(__x, __y); }
463 : : };
464 : :
465 : : /// One of the @link pointer_adaptors adaptors for function pointers@endlink.
466 : : template<typename _Arg1, typename _Arg2, typename _Result>
467 : : inline pointer_to_binary_function<_Arg1, _Arg2, _Result>
468 : : ptr_fun(_Result (*__x)(_Arg1, _Arg2))
469 : : { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); }
470 : : /** @} */
471 : :
472 : : template<typename _Tp>
473 : : struct _Identity
474 : : : public unary_function<_Tp,_Tp>
475 : : {
476 : : _Tp&
477 : : operator()(_Tp& __x) const
478 : : { return __x; }
479 : :
480 : : const _Tp&
481 : 4 : operator()(const _Tp& __x) const
482 : 4 : { return __x; }
483 : : };
484 : :
485 : : template<typename _Pair>
486 : : struct _Select1st
487 : : : public unary_function<_Pair, typename _Pair::first_type>
488 : : {
489 : : typename _Pair::first_type&
490 : : operator()(_Pair& __x) const
491 : : { return __x.first; }
492 : :
493 : : const typename _Pair::first_type&
494 : 42698 : operator()(const _Pair& __x) const
495 : 42698 : { return __x.first; }
496 : :
497 : : #if __cplusplus >= 201103L
498 : : template<typename _Pair2>
499 : : typename _Pair2::first_type&
500 : : operator()(_Pair2& __x) const
501 : : { return __x.first; }
502 : :
503 : : template<typename _Pair2>
504 : : const typename _Pair2::first_type&
505 : : operator()(const _Pair2& __x) const
506 : : { return __x.first; }
507 : : #endif
508 : : };
509 : :
510 : : template<typename _Pair>
511 : : struct _Select2nd
512 : : : public unary_function<_Pair, typename _Pair::second_type>
513 : : {
514 : : typename _Pair::second_type&
515 : : operator()(_Pair& __x) const
516 : : { return __x.second; }
517 : :
518 : : const typename _Pair::second_type&
519 : : operator()(const _Pair& __x) const
520 : : { return __x.second; }
521 : : };
522 : :
523 : : // 20.3.8 adaptors pointers members
524 : : /** @defgroup memory_adaptors Adaptors for pointers to members
525 : : * @ingroup functors
526 : : *
527 : : * There are a total of 8 = 2^3 function objects in this family.
528 : : * (1) Member functions taking no arguments vs member functions taking
529 : : * one argument.
530 : : * (2) Call through pointer vs call through reference.
531 : : * (3) Const vs non-const member function.
532 : : *
533 : : * All of this complexity is in the function objects themselves. You can
534 : : * ignore it by using the helper function mem_fun and mem_fun_ref,
535 : : * which create whichever type of adaptor is appropriate.
536 : : *
537 : : * @{
538 : : */
539 : : /// One of the @link memory_adaptors adaptors for member
540 : : /// pointers@endlink.
541 : : template<typename _Ret, typename _Tp>
542 : : class mem_fun_t : public unary_function<_Tp*, _Ret>
543 : : {
544 : : public:
545 : : explicit
546 : : mem_fun_t(_Ret (_Tp::*__pf)())
547 : : : _M_f(__pf) { }
548 : :
549 : : _Ret
550 : : operator()(_Tp* __p) const
551 : : { return (__p->*_M_f)(); }
552 : :
553 : : private:
554 : : _Ret (_Tp::*_M_f)();
555 : : };
556 : :
557 : : /// One of the @link memory_adaptors adaptors for member
558 : : /// pointers@endlink.
559 : : template<typename _Ret, typename _Tp>
560 : : class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
561 : : {
562 : : public:
563 : : explicit
564 : : const_mem_fun_t(_Ret (_Tp::*__pf)() const)
565 : : : _M_f(__pf) { }
566 : :
567 : : _Ret
568 : : operator()(const _Tp* __p) const
569 : : { return (__p->*_M_f)(); }
570 : :
571 : : private:
572 : : _Ret (_Tp::*_M_f)() const;
573 : : };
574 : :
575 : : /// One of the @link memory_adaptors adaptors for member
576 : : /// pointers@endlink.
577 : : template<typename _Ret, typename _Tp>
578 : : class mem_fun_ref_t : public unary_function<_Tp, _Ret>
579 : : {
580 : : public:
581 : : explicit
582 : : mem_fun_ref_t(_Ret (_Tp::*__pf)())
583 : : : _M_f(__pf) { }
584 : :
585 : : _Ret
586 : : operator()(_Tp& __r) const
587 : : { return (__r.*_M_f)(); }
588 : :
589 : : private:
590 : : _Ret (_Tp::*_M_f)();
591 : : };
592 : :
593 : : /// One of the @link memory_adaptors adaptors for member
594 : : /// pointers@endlink.
595 : : template<typename _Ret, typename _Tp>
596 : : class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
597 : : {
598 : : public:
599 : : explicit
600 : : const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const)
601 : : : _M_f(__pf) { }
602 : :
603 : : _Ret
604 : : operator()(const _Tp& __r) const
605 : : { return (__r.*_M_f)(); }
606 : :
607 : : private:
608 : : _Ret (_Tp::*_M_f)() const;
609 : : };
610 : :
611 : : /// One of the @link memory_adaptors adaptors for member
612 : : /// pointers@endlink.
613 : : template<typename _Ret, typename _Tp, typename _Arg>
614 : : class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
615 : : {
616 : : public:
617 : : explicit
618 : : mem_fun1_t(_Ret (_Tp::*__pf)(_Arg))
619 : : : _M_f(__pf) { }
620 : :
621 : : _Ret
622 : : operator()(_Tp* __p, _Arg __x) const
623 : : { return (__p->*_M_f)(__x); }
624 : :
625 : : private:
626 : : _Ret (_Tp::*_M_f)(_Arg);
627 : : };
628 : :
629 : : /// One of the @link memory_adaptors adaptors for member
630 : : /// pointers@endlink.
631 : : template<typename _Ret, typename _Tp, typename _Arg>
632 : : class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
633 : : {
634 : : public:
635 : : explicit
636 : : const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const)
637 : : : _M_f(__pf) { }
638 : :
639 : : _Ret
640 : : operator()(const _Tp* __p, _Arg __x) const
641 : : { return (__p->*_M_f)(__x); }
642 : :
643 : : private:
644 : : _Ret (_Tp::*_M_f)(_Arg) const;
645 : : };
646 : :
647 : : /// One of the @link memory_adaptors adaptors for member
648 : : /// pointers@endlink.
649 : : template<typename _Ret, typename _Tp, typename _Arg>
650 : : class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
651 : : {
652 : : public:
653 : : explicit
654 : : mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg))
655 : : : _M_f(__pf) { }
656 : :
657 : : _Ret
658 : : operator()(_Tp& __r, _Arg __x) const
659 : : { return (__r.*_M_f)(__x); }
660 : :
661 : : private:
662 : : _Ret (_Tp::*_M_f)(_Arg);
663 : : };
664 : :
665 : : /// One of the @link memory_adaptors adaptors for member
666 : : /// pointers@endlink.
667 : : template<typename _Ret, typename _Tp, typename _Arg>
668 : : class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
669 : : {
670 : : public:
671 : : explicit
672 : : const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const)
673 : : : _M_f(__pf) { }
674 : :
675 : : _Ret
676 : : operator()(const _Tp& __r, _Arg __x) const
677 : : { return (__r.*_M_f)(__x); }
678 : :
679 : : private:
680 : : _Ret (_Tp::*_M_f)(_Arg) const;
681 : : };
682 : :
683 : : // Mem_fun adaptor helper functions. There are only two:
684 : : // mem_fun and mem_fun_ref.
685 : : template<typename _Ret, typename _Tp>
686 : : inline mem_fun_t<_Ret, _Tp>
687 : : mem_fun(_Ret (_Tp::*__f)())
688 : : { return mem_fun_t<_Ret, _Tp>(__f); }
689 : :
690 : : template<typename _Ret, typename _Tp>
691 : : inline const_mem_fun_t<_Ret, _Tp>
692 : : mem_fun(_Ret (_Tp::*__f)() const)
693 : : { return const_mem_fun_t<_Ret, _Tp>(__f); }
694 : :
695 : : template<typename _Ret, typename _Tp>
696 : : inline mem_fun_ref_t<_Ret, _Tp>
697 : : mem_fun_ref(_Ret (_Tp::*__f)())
698 : : { return mem_fun_ref_t<_Ret, _Tp>(__f); }
699 : :
700 : : template<typename _Ret, typename _Tp>
701 : : inline const_mem_fun_ref_t<_Ret, _Tp>
702 : : mem_fun_ref(_Ret (_Tp::*__f)() const)
703 : : { return const_mem_fun_ref_t<_Ret, _Tp>(__f); }
704 : :
705 : : template<typename _Ret, typename _Tp, typename _Arg>
706 : : inline mem_fun1_t<_Ret, _Tp, _Arg>
707 : : mem_fun(_Ret (_Tp::*__f)(_Arg))
708 : : { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
709 : :
710 : : template<typename _Ret, typename _Tp, typename _Arg>
711 : : inline const_mem_fun1_t<_Ret, _Tp, _Arg>
712 : : mem_fun(_Ret (_Tp::*__f)(_Arg) const)
713 : : { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
714 : :
715 : : template<typename _Ret, typename _Tp, typename _Arg>
716 : : inline mem_fun1_ref_t<_Ret, _Tp, _Arg>
717 : : mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
718 : : { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
719 : :
720 : : template<typename _Ret, typename _Tp, typename _Arg>
721 : : inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
722 : : mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
723 : : { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
724 : :
725 : : /** @} */
726 : :
727 : : _GLIBCXX_END_NAMESPACE_VERSION
728 : : } // namespace
729 : :
730 : : #if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED
731 : : # include <backward/binders.h>
732 : : #endif
733 : :
734 : : #endif /* _STL_FUNCTION_H */
|