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