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