libstdc++-v3/include/bits/stl_function.h

   1 /*
   2  *
   3  * Copyright (c) 1994
   4  * Hewlett-Packard Company
   5  *
   6  * Permission to use, copy, modify, distribute and sell this software
   7  * and its documentation for any purpose is hereby granted without fee,
   8  * provided that the above copyright notice appear in all copies and
   9  * that both that copyright notice and this permission notice appear
  10  * in supporting documentation.  Hewlett-Packard Company makes no
  11  * representations about the suitability of this software for any
  12  * purpose.  It is provided "as is" without express or implied warranty.
  13  *
  14  *
  15  * Copyright (c) 1996-1998
  16  * Silicon Graphics Computer Systems, Inc.
  17  *
  18  * Permission to use, copy, modify, distribute and sell this software
  19  * and its documentation for any purpose is hereby granted without fee,
  20  * provided that the above copyright notice appear in all copies and
  21  * that both that copyright notice and this permission notice appear
  22  * in supporting documentation.  Silicon Graphics makes no
  23  * representations about the suitability of this software for any
  24  * purpose.  It is provided "as is" without express or implied warranty.
  25  */
  26
  27 /* NOTE: This is an internal header file, included by other STL headers.
  28  *   You should not attempt to use it directly.
  29  */
  30
  31 #ifndef __SGI_STL_INTERNAL_FUNCTION_H
  32 #define __SGI_STL_INTERNAL_FUNCTION_H
  33
  34 namespace std
  35 {
  36
  37 template <class _Arg, class _Result>
  38 struct unary_function {
  39   typedef _Arg argument_type;
  40   typedef _Result result_type;
  41 };
  42
  43 template <class _Arg1, class _Arg2, class _Result>
  44 struct binary_function {
  45   typedef _Arg1 first_argument_type;
  46   typedef _Arg2 second_argument_type;
  47   typedef _Result result_type;
  48 };
  49
  50 template <class _Tp>
  51 struct plus : public binary_function<_Tp,_Tp,_Tp> {
  52   _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x + __y; }
  53 };
  54
  55 template <class _Tp>
  56 struct minus : public binary_function<_Tp,_Tp,_Tp> {
  57   _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x - __y; }
  58 };
  59
  60 template <class _Tp>
  61 struct multiplies : public binary_function<_Tp,_Tp,_Tp> {
  62   _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x * __y; }
  63 };
  64
  65 template <class _Tp>
  66 struct divides : public binary_function<_Tp,_Tp,_Tp> {
  67   _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x / __y; }
  68 };
  69
  70 // identity_element (not part of the C++ standard).
  71
  72 template <class _Tp> inline _Tp identity_element(plus<_Tp>) {
  73   return _Tp(0);
  74 }
  75 template <class _Tp> inline _Tp identity_element(multiplies<_Tp>) {
  76   return _Tp(1);
  77 }
  78
  79 template <class _Tp>
  80 struct modulus : public binary_function<_Tp,_Tp,_Tp>
  81 {
  82   _Tp operator()(const _Tp& __x, const _Tp& __y) const { return __x % __y; }
  83 };
  84
  85 template <class _Tp>
  86 struct negate : public unary_function<_Tp,_Tp>
  87 {
  88   _Tp operator()(const _Tp& __x) const { return -__x; }
  89 };
  90
  91 template <class _Tp>
  92 struct equal_to : public binary_function<_Tp,_Tp,bool>
  93 {
  94   bool operator()(const _Tp& __x, const _Tp& __y) const { return __x == __y; }
  95 };
  96
  97 template <class _Tp>
  98 struct not_equal_to : public binary_function<_Tp,_Tp,bool>
  99 {
 100   bool operator()(const _Tp& __x, const _Tp& __y) const { return __x != __y; }
 101 };
 102
 103 template <class _Tp>
 104 struct greater : public binary_function<_Tp,_Tp,bool>
 105 {
 106   bool operator()(const _Tp& __x, const _Tp& __y) const { return __x > __y; }
 107 };
 108
 109 template <class _Tp>
 110 struct less : public binary_function<_Tp,_Tp,bool>
 111 {
 112   bool operator()(const _Tp& __x, const _Tp& __y) const { return __x < __y; }
 113 };
 114
 115 template <class _Tp>
 116 struct greater_equal : public binary_function<_Tp,_Tp,bool>
 117 {
 118   bool operator()(const _Tp& __x, const _Tp& __y) const { return __x >= __y; }
 119 };
 120
 121 template <class _Tp>
 122 struct less_equal : public binary_function<_Tp,_Tp,bool>
 123 {
 124   bool operator()(const _Tp& __x, const _Tp& __y) const { return __x <= __y; }
 125 };
 126
 127 template <class _Tp>
 128 struct logical_and : public binary_function<_Tp,_Tp,bool>
 129 {
 130   bool operator()(const _Tp& __x, const _Tp& __y) const { return __x && __y; }
 131 };
 132
 133 template <class _Tp>
 134 struct logical_or : public binary_function<_Tp,_Tp,bool>
 135 {
 136   bool operator()(const _Tp& __x, const _Tp& __y) const { return __x || __y; }
 137 };
 138
 139 template <class _Tp>
 140 struct logical_not : public unary_function<_Tp,bool>
 141 {
 142   bool operator()(const _Tp& __x) const { return !__x; }
 143 };
 144
 145 template <class _Predicate>
 146 class unary_negate
 147   : public unary_function<typename _Predicate::argument_type, bool> {
 148 protected:
 149   _Predicate _M_pred;
 150 public:
 151   explicit unary_negate(const _Predicate& __x) : _M_pred(__x) {}
 152   bool operator()(const typename _Predicate::argument_type& __x) const {
 153     return !_M_pred(__x);
 154   }
 155 };
 156
 157 template <class _Predicate>
 158 inline unary_negate<_Predicate>
 159 not1(const _Predicate& __pred)
 160 {
 161   return unary_negate<_Predicate>(__pred);
 162 }
 163
 164 template <class _Predicate>
 165 class binary_negate
 166   : public binary_function<typename _Predicate::first_argument_type,
 167                            typename _Predicate::second_argument_type,
 168                            bool> {
 169 protected:
 170   _Predicate _M_pred;
 171 public:
 172   explicit binary_negate(const _Predicate& __x) : _M_pred(__x) {}
 173   bool operator()(const typename _Predicate::first_argument_type& __x,
 174                   const typename _Predicate::second_argument_type& __y) const
 175   {
 176     return !_M_pred(__x, __y);
 177   }
 178 };
 179
 180 template <class _Predicate>
 181 inline binary_negate<_Predicate>
 182 not2(const _Predicate& __pred)
 183 {
 184   return binary_negate<_Predicate>(__pred);
 185 }
 186
 187 template <class _Operation>
 188 class binder1st
 189   : public unary_function<typename _Operation::second_argument_type,
 190                           typename _Operation::result_type> {
 191 protected:
 192   _Operation op;
 193   typename _Operation::first_argument_type value;
 194 public:
 195   binder1st(const _Operation& __x,
 196             const typename _Operation::first_argument_type& __y)
 197       : op(__x), value(__y) {}
 198   typename _Operation::result_type
 199   operator()(const typename _Operation::second_argument_type& __x) const {
 200     return op(value, __x);
 201   }
 202 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
 203   // 109. Missing binders for non-const sequence elements
 204   typename _Operation::result_type
 205   operator()(typename _Operation::second_argument_type& __x) const {
 206     return op(value, __x);
 207   }
 208 #endif
 209 };
 210
 211 template <class _Operation, class _Tp>
 212 inline binder1st<_Operation>
 213 bind1st(const _Operation& __fn, const _Tp& __x)
 214 {
 215   typedef typename _Operation::first_argument_type _Arg1_type;
 216   return binder1st<_Operation>(__fn, _Arg1_type(__x));
 217 }
 218
 219 template <class _Operation>
 220 class binder2nd
 221   : public unary_function<typename _Operation::first_argument_type,
 222                           typename _Operation::result_type> {
 223 protected:
 224   _Operation op;
 225   typename _Operation::second_argument_type value;
 226 public:
 227   binder2nd(const _Operation& __x,
 228             const typename _Operation::second_argument_type& __y)
 229       : op(__x), value(__y) {}
 230   typename _Operation::result_type
 231   operator()(const typename _Operation::first_argument_type& __x) const {
 232     return op(__x, value);
 233   }
 234 #ifdef _GLIBCPP_RESOLVE_LIB_DEFECTS
 235   // 109. Missing binders for non-const sequence elements
 236   typename _Operation::result_type
 237   operator()(typename _Operation::first_argument_type& __x) const {
 238     return op(__x, value);
 239   }
 240 #endif
 241 };
 242
 243 template <class _Operation, class _Tp>
 244 inline binder2nd<_Operation>
 245 bind2nd(const _Operation& __fn, const _Tp& __x)
 246 {
 247   typedef typename _Operation::second_argument_type _Arg2_type;
 248   return binder2nd<_Operation>(__fn, _Arg2_type(__x));
 249 }
 250
 251 // unary_compose and binary_compose (extensions, not part of the standard).
 252
 253 template <class _Operation1, class _Operation2>
 254 class unary_compose
 255   : public unary_function<typename _Operation2::argument_type,
 256                           typename _Operation1::result_type>
 257 {
 258 protected:
 259   _Operation1 _M_fn1;
 260   _Operation2 _M_fn2;
 261 public:
 262   unary_compose(const _Operation1& __x, const _Operation2& __y)
 263     : _M_fn1(__x), _M_fn2(__y) {}
 264   typename _Operation1::result_type
 265   operator()(const typename _Operation2::argument_type& __x) const {
 266     return _M_fn1(_M_fn2(__x));
 267   }
 268 };
 269
 270 template <class _Operation1, class _Operation2>
 271 inline unary_compose<_Operation1,_Operation2>
 272 compose1(const _Operation1& __fn1, const _Operation2& __fn2)
 273 {
 274   return unary_compose<_Operation1,_Operation2>(__fn1, __fn2);
 275 }
 276
 277 template <class _Operation1, class _Operation2, class _Operation3>
 278 class binary_compose
 279   : public unary_function<typename _Operation2::argument_type,
 280                           typename _Operation1::result_type> {
 281 protected:
 282   _Operation1 _M_fn1;
 283   _Operation2 _M_fn2;
 284   _Operation3 _M_fn3;
 285 public:
 286   binary_compose(const _Operation1& __x, const _Operation2& __y,
 287                  const _Operation3& __z)
 288     : _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { }
 289   typename _Operation1::result_type
 290   operator()(const typename _Operation2::argument_type& __x) const {
 291     return _M_fn1(_M_fn2(__x), _M_fn3(__x));
 292   }
 293 };
 294
 295 template <class _Operation1, class _Operation2, class _Operation3>
 296 inline binary_compose<_Operation1, _Operation2, _Operation3>
 297 compose2(const _Operation1& __fn1, const _Operation2& __fn2,
 298          const _Operation3& __fn3)
 299 {
 300   return binary_compose<_Operation1,_Operation2,_Operation3>
 301     (__fn1, __fn2, __fn3);
 302 }
 303
 304 template <class _Arg, class _Result>
 305 class pointer_to_unary_function : public unary_function<_Arg, _Result> {
 306 protected:
 307   _Result (*_M_ptr)(_Arg);
 308 public:
 309   pointer_to_unary_function() {}
 310   explicit pointer_to_unary_function(_Result (*__x)(_Arg)) : _M_ptr(__x) {}
 311   _Result operator()(_Arg __x) const { return _M_ptr(__x); }
 312 };
 313
 314 template <class _Arg, class _Result>
 315 inline pointer_to_unary_function<_Arg, _Result> ptr_fun(_Result (*__x)(_Arg))
 316 {
 317   return pointer_to_unary_function<_Arg, _Result>(__x);
 318 }
 319
 320 template <class _Arg1, class _Arg2, class _Result>
 321 class pointer_to_binary_function :
 322   public binary_function<_Arg1,_Arg2,_Result> {
 323 protected:
 324     _Result (*_M_ptr)(_Arg1, _Arg2);
 325 public:
 326     pointer_to_binary_function() {}
 327     explicit pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
 328       : _M_ptr(__x) {}
 329     _Result operator()(_Arg1 __x, _Arg2 __y) const {
 330       return _M_ptr(__x, __y);
 331     }
 332 };
 333
 334 template <class _Arg1, class _Arg2, class _Result>
 335 inline pointer_to_binary_function<_Arg1,_Arg2,_Result>
 336 ptr_fun(_Result (*__x)(_Arg1, _Arg2)) {
 337   return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__x);
 338 }
 339
 340 // identity is an extensions: it is not part of the standard.
 341 template <class _Tp>
 342 struct _Identity : public unary_function<_Tp,_Tp> {
 343   _Tp& operator()(_Tp& __x) const { return __x; }
 344   const _Tp& operator()(const _Tp& __x) const { return __x; }
 345 };
 346
 347 template <class _Tp> struct identity : public _Identity<_Tp> {};
 348
 349 // select1st and select2nd are extensions: they are not part of the standard.
 350 template <class _Pair>
 351 struct _Select1st : public unary_function<_Pair, typename _Pair::first_type> {
 352   typename _Pair::first_type& operator()(_Pair& __x) const {
 353     return __x.first;
 354   }
 355   const typename _Pair::first_type& operator()(const _Pair& __x) const {
 356     return __x.first;
 357   }
 358 };
 359
 360 template <class _Pair>
 361 struct _Select2nd : public unary_function<_Pair, typename _Pair::second_type>
 362 {
 363   typename _Pair::second_type& operator()(_Pair& __x) const {
 364     return __x.second;
 365   }
 366   const typename _Pair::second_type& operator()(const _Pair& __x) const {
 367     return __x.second;
 368   }
 369 };
 370
 371 template <class _Pair> struct select1st : public _Select1st<_Pair> {};
 372 template <class _Pair> struct select2nd : public _Select2nd<_Pair> {};
 373
 374 // project1st and project2nd are extensions: they are not part of the standard
 375 template <class _Arg1, class _Arg2>
 376 struct _Project1st : public binary_function<_Arg1, _Arg2, _Arg1> {
 377   _Arg1 operator()(const _Arg1& __x, const _Arg2&) const { return __x; }
 378 };
 379
 380 template <class _Arg1, class _Arg2>
 381 struct _Project2nd : public binary_function<_Arg1, _Arg2, _Arg2> {
 382   _Arg2 operator()(const _Arg1&, const _Arg2& __y) const { return __y; }
 383 };
 384
 385 template <class _Arg1, class _Arg2>
 386 struct project1st : public _Project1st<_Arg1, _Arg2> {};
 387
 388 template <class _Arg1, class _Arg2>
 389 struct project2nd : public _Project2nd<_Arg1, _Arg2> {};
 390
 391 // constant_void_fun, constant_unary_fun, and constant_binary_fun are
 392 // extensions: they are not part of the standard.  (The same, of course,
 393 // is true of the helper functions constant0, constant1, and constant2.)
 394
 395 template <class _Result>
 396 struct _Constant_void_fun {
 397   typedef _Result result_type;
 398   result_type _M_val;
 399
 400   _Constant_void_fun(const result_type& __v) : _M_val(__v) {}
 401   const result_type& operator()() const { return _M_val; }
 402 };
 403
 404 template <class _Result, class _Argument>
 405 struct _Constant_unary_fun {
 406   typedef _Argument argument_type;
 407   typedef  _Result  result_type;
 408   result_type _M_val;
 409
 410   _Constant_unary_fun(const result_type& __v) : _M_val(__v) {}
 411   const result_type& operator()(const _Argument&) const { return _M_val; }
 412 };
 413
 414 template <class _Result, class _Arg1, class _Arg2>
 415 struct _Constant_binary_fun {
 416   typedef  _Arg1   first_argument_type;
 417   typedef  _Arg2   second_argument_type;
 418   typedef  _Result result_type;
 419   _Result _M_val;
 420
 421   _Constant_binary_fun(const _Result& __v) : _M_val(__v) {}
 422   const result_type& operator()(const _Arg1&, const _Arg2&) const {
 423     return _M_val;
 424   }
 425 };
 426
 427 template <class _Result>
 428 struct constant_void_fun : public _Constant_void_fun<_Result> {
 429   constant_void_fun(const _Result& __v) : _Constant_void_fun<_Result>(__v) {}
 430 };
 431
 432
 433 template <class _Result,
 434           class _Argument = _Result>
 435 struct constant_unary_fun : public _Constant_unary_fun<_Result, _Argument>
 436 {
 437   constant_unary_fun(const _Result& __v)
 438     : _Constant_unary_fun<_Result, _Argument>(__v) {}
 439 };
 440
 441
 442 template <class _Result,
 443           class _Arg1 = _Result,
 444           class _Arg2 = _Arg1>
 445 struct constant_binary_fun
 446   : public _Constant_binary_fun<_Result, _Arg1, _Arg2>
 447 {
 448   constant_binary_fun(const _Result& __v)
 449     : _Constant_binary_fun<_Result, _Arg1, _Arg2>(__v) {}
 450 };
 451
 452 template <class _Result>
 453 inline constant_void_fun<_Result> constant0(const _Result& __val)
 454 {
 455   return constant_void_fun<_Result>(__val);
 456 }
 457
 458 template <class _Result>
 459 inline constant_unary_fun<_Result,_Result> constant1(const _Result& __val)
 460 {
 461   return constant_unary_fun<_Result,_Result>(__val);
 462 }
 463
 464 template <class _Result>
 465 inline constant_binary_fun<_Result,_Result,_Result>
 466 constant2(const _Result& __val)
 467 {
 468   return constant_binary_fun<_Result,_Result,_Result>(__val);
 469 }
 470
 471 // subtractive_rng is an extension: it is not part of the standard.
 472 // Note: this code assumes that int is 32 bits.
 473 class subtractive_rng : public unary_function<unsigned int, unsigned int> {
 474 private:
 475   unsigned int _M_table[55];
 476   size_t _M_index1;
 477   size_t _M_index2;
 478 public:
 479   unsigned int operator()(unsigned int __limit) {
 480     _M_index1 = (_M_index1 + 1) % 55;
 481     _M_index2 = (_M_index2 + 1) % 55;
 482     _M_table[_M_index1] = _M_table[_M_index1] - _M_table[_M_index2];
 483     return _M_table[_M_index1] % __limit;
 484   }
 485
 486   void _M_initialize(unsigned int __seed)
 487   {
 488     unsigned int __k = 1;
 489     _M_table[54] = __seed;
 490     size_t __i;
 491     for (__i = 0; __i < 54; __i++) {
 492         size_t __ii = (21 * (__i + 1) % 55) - 1;
 493         _M_table[__ii] = __k;
 494         __k = __seed - __k;
 495         __seed = _M_table[__ii];
 496     }
 497     for (int __loop = 0; __loop < 4; __loop++) {
 498         for (__i = 0; __i < 55; __i++)
 499             _M_table[__i] = _M_table[__i] - _M_table[(1 + __i + 30) % 55];
 500     }
 501     _M_index1 = 0;
 502     _M_index2 = 31;
 503   }
 504
 505   subtractive_rng(unsigned int __seed) { _M_initialize(__seed); }
 506   subtractive_rng() { _M_initialize(161803398u); }
 507 };
 508
 509
 510 // Adaptor function objects: pointers to member functions.
 511
 512 // There are a total of 16 = 2^4 function objects in this family.
 513 //  (1) Member functions taking no arguments vs member functions taking
 514 //       one argument.
 515 //  (2) Call through pointer vs call through reference.
 516 //  (3) Member function with void return type vs member function with
 517 //      non-void return type.
 518 //  (4) Const vs non-const member function.
 519
 520 // Note that choice (3) is nothing more than a workaround: according
 521 //  to the draft, compilers should handle void and non-void the same way.
 522 //  This feature is not yet widely implemented, though.  You can only use
 523 //  member functions returning void if your compiler supports partial
 524 //  specialization.
 525
 526 // All of this complexity is in the function objects themselves.  You can
 527 //  ignore it by using the helper function mem_fun and mem_fun_ref,
 528 //  which create whichever type of adaptor is appropriate.
 529 //  (mem_fun1 and mem_fun1_ref are no longer part of the C++ standard,
 530 //  but they are provided for backward compatibility.)
 531
 532
 533 template <class _Ret, class _Tp>
 534 class mem_fun_t : public unary_function<_Tp*,_Ret> {
 535 public:
 536   explicit mem_fun_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}
 537   _Ret operator()(_Tp* __p) const { return (__p->*_M_f)(); }
 538 private:
 539   _Ret (_Tp::*_M_f)();
 540 };
 541
 542 template <class _Ret, class _Tp>
 543 class const_mem_fun_t : public unary_function<const _Tp*,_Ret> {
 544 public:
 545   explicit const_mem_fun_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
 546   _Ret operator()(const _Tp* __p) const { return (__p->*_M_f)(); }
 547 private:
 548   _Ret (_Tp::*_M_f)() const;
 549 };
 550
 551
 552 template <class _Ret, class _Tp>
 553 class mem_fun_ref_t : public unary_function<_Tp,_Ret> {
 554 public:
 555   explicit mem_fun_ref_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}
 556   _Ret operator()(_Tp& __r) const { return (__r.*_M_f)(); }
 557 private:
 558   _Ret (_Tp::*_M_f)();
 559 };
 560
 561 template <class _Ret, class _Tp>
 562 class const_mem_fun_ref_t : public unary_function<_Tp,_Ret> {
 563 public:
 564   explicit const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
 565   _Ret operator()(const _Tp& __r) const { return (__r.*_M_f)(); }
 566 private:
 567   _Ret (_Tp::*_M_f)() const;
 568 };
 569
 570 template <class _Ret, class _Tp, class _Arg>
 571 class mem_fun1_t : public binary_function<_Tp*,_Arg,_Ret> {
 572 public:
 573   explicit mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
 574   _Ret operator()(_Tp* __p, _Arg __x) const { return (__p->*_M_f)(__x); }
 575 private:
 576   _Ret (_Tp::*_M_f)(_Arg);
 577 };
 578
 579 template <class _Ret, class _Tp, class _Arg>
 580 class const_mem_fun1_t : public binary_function<const _Tp*,_Arg,_Ret> {
 581 public:
 582   explicit const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
 583   _Ret operator()(const _Tp* __p, _Arg __x) const
 584     { return (__p->*_M_f)(__x); }
 585 private:
 586   _Ret (_Tp::*_M_f)(_Arg) const;
 587 };
 588
 589 template <class _Ret, class _Tp, class _Arg>
 590 class mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
 591 public:
 592   explicit mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
 593   _Ret operator()(_Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
 594 private:
 595   _Ret (_Tp::*_M_f)(_Arg);
 596 };
 597
 598 template <class _Ret, class _Tp, class _Arg>
 599 class const_mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
 600 public:
 601   explicit const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
 602   _Ret operator()(const _Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
 603 private:
 604   _Ret (_Tp::*_M_f)(_Arg) const;
 605 };
 606
 607 template <class _Tp>
 608 class mem_fun_t<void, _Tp> : public unary_function<_Tp*,void> {
 609 public:
 610   explicit mem_fun_t(void (_Tp::*__pf)()) : _M_f(__pf) {}
 611   void operator()(_Tp* __p) const { (__p->*_M_f)(); }
 612 private:
 613   void (_Tp::*_M_f)();
 614 };
 615
 616 template <class _Tp>
 617 class const_mem_fun_t<void, _Tp> : public unary_function<const _Tp*,void> {
 618 public:
 619   explicit const_mem_fun_t(void (_Tp::*__pf)() const) : _M_f(__pf) {}
 620   void operator()(const _Tp* __p) const { (__p->*_M_f)(); }
 621 private:
 622   void (_Tp::*_M_f)() const;
 623 };
 624
 625 template <class _Tp>
 626 class mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {
 627 public:
 628   explicit mem_fun_ref_t(void (_Tp::*__pf)()) : _M_f(__pf) {}
 629   void operator()(_Tp& __r) const { (__r.*_M_f)(); }
 630 private:
 631   void (_Tp::*_M_f)();
 632 };
 633
 634 template <class _Tp>
 635 class const_mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {
 636 public:
 637   explicit const_mem_fun_ref_t(void (_Tp::*__pf)() const) : _M_f(__pf) {}
 638   void operator()(const _Tp& __r) const { (__r.*_M_f)(); }
 639 private:
 640   void (_Tp::*_M_f)() const;
 641 };
 642
 643 template <class _Tp, class _Arg>
 644 class mem_fun1_t<void, _Tp, _Arg> : public binary_function<_Tp*,_Arg,void> {
 645 public:
 646   explicit mem_fun1_t(void (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
 647   void operator()(_Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
 648 private:
 649   void (_Tp::*_M_f)(_Arg);
 650 };
 651
 652 template <class _Tp, class _Arg>
 653 class const_mem_fun1_t<void, _Tp, _Arg>
 654   : public binary_function<const _Tp*,_Arg,void> {
 655 public:
 656   explicit const_mem_fun1_t(void (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
 657   void operator()(const _Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
 658 private:
 659   void (_Tp::*_M_f)(_Arg) const;
 660 };
 661
 662 template <class _Tp, class _Arg>
 663 class mem_fun1_ref_t<void, _Tp, _Arg>
 664   : public binary_function<_Tp,_Arg,void> {
 665 public:
 666   explicit mem_fun1_ref_t(void (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
 667   void operator()(_Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
 668 private:
 669   void (_Tp::*_M_f)(_Arg);
 670 };
 671
 672 template <class _Tp, class _Arg>
 673 class const_mem_fun1_ref_t<void, _Tp, _Arg>
 674   : public binary_function<_Tp,_Arg,void> {
 675 public:
 676   explicit const_mem_fun1_ref_t(void (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
 677   void operator()(const _Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
 678 private:
 679   void (_Tp::*_M_f)(_Arg) const;
 680 };
 681
 682
 683 // Mem_fun adaptor helper functions.  There are only two:
 684 //  mem_fun and mem_fun_ref.  (mem_fun1 and mem_fun1_ref
 685 //  are provided for backward compatibility, but they are no longer
 686 //  part of the C++ standard.)
 687
 688 template <class _Ret, class _Tp>
 689 inline mem_fun_t<_Ret,_Tp> mem_fun(_Ret (_Tp::*__f)())
 690   { return mem_fun_t<_Ret,_Tp>(__f); }
 691
 692 template <class _Ret, class _Tp>
 693 inline const_mem_fun_t<_Ret,_Tp> mem_fun(_Ret (_Tp::*__f)() const)
 694   { return const_mem_fun_t<_Ret,_Tp>(__f); }
 695
 696 template <class _Ret, class _Tp>
 697 inline mem_fun_ref_t<_Ret,_Tp> mem_fun_ref(_Ret (_Tp::*__f)())
 698   { return mem_fun_ref_t<_Ret,_Tp>(__f); }
 699
 700 template <class _Ret, class _Tp>
 701 inline const_mem_fun_ref_t<_Ret,_Tp> mem_fun_ref(_Ret (_Tp::*__f)() const)
 702   { return const_mem_fun_ref_t<_Ret,_Tp>(__f); }
 703
 704 template <class _Ret, class _Tp, class _Arg>
 705 inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun(_Ret (_Tp::*__f)(_Arg))
 706   { return mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
 707
 708 template <class _Ret, class _Tp, class _Arg>
 709 inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun(_Ret (_Tp::*__f)(_Arg) const)
 710   { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
 711
 712 template <class _Ret, class _Tp, class _Arg>
 713 inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
 714   { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
 715
 716 template <class _Ret, class _Tp, class _Arg>
 717 inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>
 718 mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
 719   { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
 720
 721 template <class _Ret, class _Tp, class _Arg>
 722 inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg))
 723   { return mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
 724
 725 template <class _Ret, class _Tp, class _Arg>
 726 inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg) const)
 727   { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
 728
 729 template <class _Ret, class _Tp, class _Arg>
 730 inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun1_ref(_Ret (_Tp::*__f)(_Arg))
 731   { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
 732
 733 template <class _Ret, class _Tp, class _Arg>
 734 inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>
 735 mem_fun1_ref(_Ret (_Tp::*__f)(_Arg) const)
 736   { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
 737
 738 } // namespace std
 739
 740 #endif /* __SGI_STL_INTERNAL_FUNCTION_H */
 741
 742 // Local Variables:
 743 // mode:C++
 744 // End: