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