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