include/c++/stlport/stl/_function_adaptors.h

   1 /*
   2  *
   3  * Copyright (c) 1994
   4  * Hewlett-Packard Company
   5  *
   6  * Copyright (c) 1996-1998
   7  * Silicon Graphics Computer Systems, Inc.
   8  *
   9  * Copyright (c) 1997
  10  * Moscow Center for SPARC Technology
  11  *
  12  * Copyright (c) 1999
  13  * Boris Fomitchev
  14  *
  15  * Copyright (c) 2000
  16  * Pavel Kuznetsov
  17  *
  18  * Copyright (c) 2001
  19  * Meridian'93
  20  *
  21  * This material is provided "as is", with absolutely no warranty expressed
  22  * or implied. Any use is at your own risk.
  23  *
  24  * Permission to use or copy this software for any purpose is hereby granted
  25  * without fee, provided the above notices are retained on all copies.
  26  * Permission to modify the code and to distribute modified code is granted,
  27  * provided the above notices are retained, and a notice that the code was
  28  * modified is included with the above copyright notice.
  29  *
  30  */
  31
  32 /* NOTE: This is an internal header file, included by other STL headers.
  33  *   You should not attempt to use it directly.
  34  */
  35
  36 // This file has noo macro protection as it is meant to be included several times
  37 // from other header.
  38 // Adaptor function objects: pointers to member functions.
  39
  40 // There are a total of 16 = 2^4 function objects in this family.
  41 //  (1) Member functions taking no arguments vs member functions taking
  42 //       one argument.
  43 //  (2) Call through pointer vs call through reference.
  44 //  (3) Member function with void return type vs member function with
  45 //      non-void return type.
  46 //  (4) Const vs non-const member function.
  47
  48 // Note that choice (3) is nothing more than a workaround: according
  49 //  to the draft, compilers should handle void and non-void the same way.
  50 //  This feature is not yet widely implemented, though.  You can only use
  51 //  member functions returning void if your compiler supports partial
  52 //  specialization.
  53
  54 // All of this complexity is in the function objects themselves.  You can
  55 //  ignore it by using the helper function mem_fun and mem_fun_ref,
  56 //  which create whichever type of adaptor is appropriate.
  57
  58 _STLP_BEGIN_NAMESPACE
  59
  60 //This implementation will only be used if needed, that is to say when there is the return void bug
  61 //and when there is no partial template specialization
  62 #if defined (_STLP_DONT_RETURN_VOID) && defined (_STLP_NO_CLASS_PARTIAL_SPECIALIZATION) && defined (_STLP_MEMBER_TEMPLATE_CLASSES)
  63
  64 template<class _Result, class _Tp>
  65 class _Mem_fun0_ptr : public unary_function<_Tp*, _Result> {
  66 protected:
  67   typedef _Result (_Tp::*__fun_type) ();
  68   explicit _Mem_fun0_ptr(__fun_type __f) : _M_f(__f) {}
  69
  70 public:
  71   _Result operator ()(_Tp* __p) const { return (__p->*_M_f)(); }
  72
  73 private:
  74   __fun_type _M_f;
  75 };
  76
  77 template<class _Result, class _Tp, class _Arg>
  78 class _Mem_fun1_ptr : public binary_function<_Tp*,_Arg,_Result> {
  79 protected:
  80   typedef _Result (_Tp::*__fun_type) (_Arg);
  81   explicit _Mem_fun1_ptr(__fun_type __f) : _M_f(__f) {}
  82
  83 public:
  84   _Result operator ()(_Tp* __p, _Arg __x) const { return (__p->*_M_f)(__x); }
  85
  86 private:
  87   __fun_type _M_f;
  88 };
  89
  90 template<class _Result, class _Tp>
  91 class _Const_mem_fun0_ptr : public unary_function<const _Tp*,_Result> {
  92 protected:
  93   typedef _Result (_Tp::*__fun_type) () const;
  94   explicit _Const_mem_fun0_ptr(__fun_type __f) : _M_f(__f) {}
  95
  96 public:
  97   _Result operator ()(const _Tp* __p) const { return (__p->*_M_f)(); }
  98
  99 private:
 100   __fun_type _M_f;
 101 };
 102
 103 template<class _Result, class _Tp, class _Arg>
 104 class _Const_mem_fun1_ptr : public binary_function<const _Tp*,_Arg,_Result> {
 105 protected:
 106   typedef _Result (_Tp::*__fun_type) (_Arg) const;
 107   explicit _Const_mem_fun1_ptr(__fun_type __f) : _M_f(__f) {}
 108
 109 public:
 110   _Result operator ()(const _Tp* __p, _Arg __x) const {
 111     return (__p->*_M_f)(__x); }
 112
 113 private:
 114   __fun_type _M_f;
 115 };
 116
 117 template<class _Result, class _Tp>
 118 class _Mem_fun0_ref : public unary_function<_Tp,_Result> {
 119 protected:
 120   typedef _Result (_Tp::*__fun_type) ();
 121   explicit _Mem_fun0_ref(__fun_type __f) : _M_f(__f) {}
 122
 123 public:
 124   _Result operator ()(_Tp& __p) const { return (__p.*_M_f)(); }
 125
 126 private:
 127   __fun_type _M_f;
 128 };
 129
 130 template<class _Result, class _Tp, class _Arg>
 131 class _Mem_fun1_ref : public binary_function<_Tp,_Arg,_Result> {
 132 protected:
 133   typedef _Result (_Tp::*__fun_type) (_Arg);
 134   explicit _Mem_fun1_ref(__fun_type __f) : _M_f(__f) {}
 135
 136 public:
 137   _Result operator ()(_Tp& __p, _Arg __x) const { return (__p.*_M_f)(__x); }
 138
 139 private:
 140   __fun_type _M_f;
 141 };
 142
 143 template<class _Result, class _Tp>
 144 class _Const_mem_fun0_ref : public unary_function<_Tp,_Result> {
 145 protected:
 146   typedef _Result (_Tp::*__fun_type) () const;
 147   explicit _Const_mem_fun0_ref(__fun_type __f) : _M_f(__f) {}
 148
 149 public:
 150   _Result operator ()(const _Tp& __p) const { return (__p.*_M_f)(); }
 151
 152 private:
 153   __fun_type _M_f;
 154 };
 155
 156 template<class _Result, class _Tp, class _Arg>
 157 class _Const_mem_fun1_ref : public binary_function<_Tp,_Arg,_Result> {
 158 protected:
 159   typedef _Result (_Tp::*__fun_type) (_Arg) const;
 160   explicit _Const_mem_fun1_ref(__fun_type __f) : _M_f(__f) {}
 161
 162 public:
 163   _Result operator ()(const _Tp& __p, _Arg __x) const { return (__p.*_M_f)(__x); }
 164
 165 private:
 166   __fun_type _M_f;
 167 };
 168
 169 template<class _Result>
 170 struct _Mem_fun_traits {
 171   template<class _Tp>
 172   struct _Args0 {
 173     typedef _Mem_fun0_ptr<_Result,_Tp>            _Ptr;
 174     typedef _Const_mem_fun0_ptr<_Result,_Tp>      _Ptr_const;
 175     typedef _Mem_fun0_ref<_Result,_Tp>            _Ref;
 176     typedef _Const_mem_fun0_ref<_Result,_Tp>      _Ref_const;
 177   };
 178
 179   template<class _Tp, class _Arg>
 180   struct _Args1 {
 181     typedef _Mem_fun1_ptr<_Result,_Tp,_Arg>       _Ptr;
 182     typedef _Const_mem_fun1_ptr<_Result,_Tp,_Arg> _Ptr_const;
 183     typedef _Mem_fun1_ref<_Result,_Tp,_Arg>       _Ref;
 184     typedef _Const_mem_fun1_ref<_Result,_Tp,_Arg> _Ref_const;
 185   };
 186 };
 187
 188 template<class _Arg, class _Result>
 189 class _Ptr_fun1_base : public unary_function<_Arg, _Result> {
 190 protected:
 191   typedef _Result (*__fun_type) (_Arg);
 192   explicit _Ptr_fun1_base(__fun_type __f) : _M_f(__f) {}
 193
 194 public:
 195   _Result operator()(_Arg __x) const { return _M_f(__x); }
 196
 197 private:
 198   __fun_type _M_f;
 199 };
 200
 201 template <class _Arg1, class _Arg2, class _Result>
 202 class _Ptr_fun2_base : public binary_function<_Arg1,_Arg2,_Result> {
 203 protected:
 204   typedef _Result (*__fun_type) (_Arg1, _Arg2);
 205   explicit _Ptr_fun2_base(__fun_type __f) : _M_f(__f) {}
 206
 207 public:
 208   _Result operator()(_Arg1 __x, _Arg2 __y) const { return _M_f(__x, __y); }
 209
 210 private:
 211   __fun_type _M_f;
 212 };
 213
 214 template<class _Result>
 215 struct _Ptr_fun_traits {
 216   template<class _Arg> struct _Args1 {
 217     typedef _Ptr_fun1_base<_Arg,_Result> _Fun;
 218   };
 219
 220   template<class _Arg1, class _Arg2> struct _Args2 {
 221     typedef _Ptr_fun2_base<_Arg1,_Arg2,_Result> _Fun;
 222   };
 223 };
 224
 225 /* Specializations for void return type */
 226 template<class _Tp>
 227 class _Void_mem_fun0_ptr : public unary_function<_Tp*,void> {
 228 protected:
 229   typedef void (_Tp::*__fun_type) ();
 230   explicit _Void_mem_fun0_ptr(__fun_type __f) : _M_f(__f) {}
 231
 232 public:
 233   void operator ()(_Tp* __p) const { (__p->*_M_f)(); }
 234
 235 private:
 236   __fun_type _M_f;
 237 };
 238
 239 template<class _Tp, class _Arg>
 240 class _Void_mem_fun1_ptr : public binary_function<_Tp*,_Arg,void> {
 241 protected:
 242   typedef void (_Tp::*__fun_type) (_Arg);
 243   explicit _Void_mem_fun1_ptr(__fun_type __f) : _M_f(__f) {}
 244
 245 public:
 246   void operator ()(_Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
 247
 248 private:
 249   __fun_type _M_f;
 250 };
 251
 252 template<class _Tp>
 253 class _Void_const_mem_fun0_ptr : public unary_function<const _Tp*,void> {
 254 protected:
 255   typedef void (_Tp::*__fun_type) () const;
 256   explicit _Void_const_mem_fun0_ptr(__fun_type __f) : _M_f(__f) {}
 257
 258 public:
 259   void operator ()(const _Tp* __p) const { (__p->*_M_f)(); }
 260
 261 private:
 262   __fun_type _M_f;
 263 };
 264
 265 template<class _Tp, class _Arg>
 266 class _Void_const_mem_fun1_ptr : public binary_function<const _Tp*,_Arg,void> {
 267 protected:
 268   typedef void (_Tp::*__fun_type) (_Arg) const;
 269   explicit _Void_const_mem_fun1_ptr(__fun_type __f) : _M_f(__f) {}
 270
 271 public:
 272   void operator ()(const _Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
 273
 274 private:
 275   __fun_type _M_f;
 276 };
 277
 278 template<class _Tp>
 279 class _Void_mem_fun0_ref : public unary_function<_Tp,void> {
 280 protected:
 281   typedef void (_Tp::*__fun_type) ();
 282   explicit _Void_mem_fun0_ref(__fun_type __f) : _M_f(__f) {}
 283
 284 public:
 285   void operator ()(_Tp& __p) const { (__p.*_M_f)(); }
 286
 287 private:
 288   __fun_type _M_f;
 289 };
 290
 291 template<class _Tp, class _Arg>
 292 class _Void_mem_fun1_ref : public binary_function<_Tp,_Arg,void> {
 293 protected:
 294   typedef void (_Tp::*__fun_type) (_Arg);
 295   explicit _Void_mem_fun1_ref(__fun_type __f) : _M_f(__f) {}
 296
 297 public:
 298   void operator ()(_Tp& __p, _Arg __x) const { (__p.*_M_f)(__x); }
 299
 300 private:
 301   __fun_type _M_f;
 302 };
 303
 304 template<class _Tp>
 305 class _Void_const_mem_fun0_ref : public unary_function<_Tp,void> {
 306 protected:
 307   typedef void (_Tp::*__fun_type) () const;
 308   explicit _Void_const_mem_fun0_ref(__fun_type __f) : _M_f(__f) {}
 309
 310 public:
 311   void operator ()(const _Tp& __p) const { (__p.*_M_f)(); }
 312
 313 private:
 314   __fun_type _M_f;
 315 };
 316
 317 template<class _Tp, class _Arg>
 318 class _Void_const_mem_fun1_ref : public binary_function<_Tp,_Arg,void> {
 319 protected:
 320   typedef void (_Tp::*__fun_type) (_Arg) const;
 321   explicit _Void_const_mem_fun1_ref(__fun_type __f) : _M_f(__f) {}
 322
 323 public:
 324   void operator ()(const _Tp& __p, _Arg __x) const { (__p.*_M_f)(__x); }
 325
 326 private:
 327   __fun_type _M_f;
 328 };
 329
 330 _STLP_TEMPLATE_NULL
 331 struct _Mem_fun_traits<void> {
 332   template<class _Tp> struct _Args0 {
 333     typedef _Void_mem_fun0_ptr<_Tp>             _Ptr;
 334     typedef _Void_const_mem_fun0_ptr<_Tp>       _Ptr_const;
 335     typedef _Void_mem_fun0_ref<_Tp>             _Ref;
 336     typedef _Void_const_mem_fun0_ref<_Tp>       _Ref_const;
 337   };
 338
 339   template<class _Tp, class _Arg> struct _Args1 {
 340     typedef _Void_mem_fun1_ptr<_Tp,_Arg>        _Ptr;
 341     typedef _Void_const_mem_fun1_ptr<_Tp,_Arg>  _Ptr_const;
 342     typedef _Void_mem_fun1_ref<_Tp,_Arg>        _Ref;
 343     typedef _Void_const_mem_fun1_ref<_Tp,_Arg>  _Ref_const;
 344   };
 345 };
 346
 347 template<class _Arg>
 348 class _Ptr_void_fun1_base : public unary_function<_Arg, void> {
 349 protected:
 350   typedef void (*__fun_type) (_Arg);
 351   explicit _Ptr_void_fun1_base(__fun_type __f) : _M_f(__f) {}
 352
 353 public:
 354   void operator()(_Arg __x) const { _M_f(__x); }
 355
 356 private:
 357   __fun_type _M_f;
 358 };
 359
 360 template <class _Arg1, class _Arg2>
 361 class _Ptr_void_fun2_base : public binary_function<_Arg1,_Arg2,void> {
 362 protected:
 363   typedef void (*__fun_type) (_Arg1, _Arg2);
 364   explicit _Ptr_void_fun2_base(__fun_type __f) : _M_f(__f) {}
 365
 366 public:
 367   void operator()(_Arg1 __x, _Arg2 __y) const { _M_f(__x, __y); }
 368
 369 private:
 370   __fun_type _M_f;
 371 };
 372
 373 _STLP_TEMPLATE_NULL
 374 struct _Ptr_fun_traits<void> {
 375   template<class _Arg> struct _Args1 {
 376     typedef _Ptr_void_fun1_base<_Arg> _Fun;
 377   };
 378
 379   template<class _Arg1, class _Arg2> struct _Args2 {
 380     typedef _Ptr_void_fun2_base<_Arg1,_Arg2> _Fun;
 381   };
 382 };
 383
 384 // pavel: need extra level of inheritance here since MSVC++ does not
 385 // accept traits-based fake partial specialization for template
 386 // arguments other than first
 387
 388 template<class _Result, class _Arg>
 389 class _Ptr_fun1 :
 390   public _Ptr_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Arg>::_Fun {
 391 protected:
 392   typedef typename _Ptr_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Arg>::_Fun _Base;
 393   explicit _Ptr_fun1(typename _Base::__fun_type __f) : _Base(__f) {}
 394 };
 395
 396 template<class _Result, class _Arg1, class _Arg2>
 397 class _Ptr_fun2 :
 398   public _Ptr_fun_traits<_Result>::_STLP_TEMPLATE _Args2<_Arg1,_Arg2>::_Fun {
 399 protected:
 400   typedef typename _Ptr_fun_traits<_Result>::_STLP_TEMPLATE _Args2<_Arg1,_Arg2>::_Fun _Base;
 401   explicit _Ptr_fun2(typename _Base::__fun_type __f) : _Base(__f) {}
 402 };
 403
 404 template <class _Result, class _Tp>
 405 class mem_fun_t :
 406   public _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args0<_Tp>::_Ptr {
 407   typedef typename
 408     _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args0<_Tp>::_Ptr _Base;
 409 public:
 410   explicit mem_fun_t(typename _Base::__fun_type __f) : _Base(__f) {}
 411 };
 412
 413 template <class _Result, class _Tp>
 414 class const_mem_fun_t :
 415   public _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args0<_Tp>::_Ptr_const {
 416   typedef typename
 417     _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args0<_Tp>::_Ptr_const _Base;
 418 public:
 419   explicit const_mem_fun_t(typename _Base::__fun_type __f) : _Base(__f) {}
 420 };
 421
 422 template <class _Result, class _Tp>
 423 class mem_fun_ref_t :
 424   public _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args0<_Tp>::_Ref {
 425   typedef typename
 426     _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args0<_Tp>::_Ref _Base;
 427 public:
 428   explicit mem_fun_ref_t(typename _Base::__fun_type __f) : _Base(__f) {}
 429 };
 430
 431 template <class _Result, class _Tp>
 432 class const_mem_fun_ref_t :
 433   public _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args0<_Tp>::_Ref_const {
 434   typedef typename
 435     _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args0<_Tp>::_Ref_const _Base;
 436 public:
 437   explicit const_mem_fun_ref_t(typename _Base::__fun_type __f) : _Base(__f) {}
 438 };
 439
 440 template <class _Result, class _Tp, class _Arg>
 441 class mem_fun1_t :
 442   public _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Tp,_Arg>::_Ptr {
 443   typedef typename
 444     _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Tp,_Arg>::_Ptr _Base;
 445 public:
 446   explicit mem_fun1_t(typename _Base::__fun_type __f) : _Base(__f) {}
 447 };
 448
 449 template <class _Result, class _Tp, class _Arg>
 450 class const_mem_fun1_t :
 451   public _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Tp,_Arg>::_Ptr_const {
 452   typedef typename
 453     _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Tp,_Arg>::_Ptr_const _Base;
 454 public:
 455   explicit const_mem_fun1_t(typename _Base::__fun_type __f) : _Base(__f) {}
 456 };
 457
 458 template <class _Result, class _Tp, class _Arg>
 459 class mem_fun1_ref_t :
 460   public _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Tp,_Arg>::_Ref {
 461   typedef typename
 462     _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Tp,_Arg>::_Ref _Base;
 463 public:
 464   explicit mem_fun1_ref_t(typename _Base::__fun_type __f) : _Base(__f) {}
 465 };
 466
 467 template <class _Result, class _Tp, class _Arg>
 468 class const_mem_fun1_ref_t :
 469   public _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Tp,_Arg>::_Ref_const {
 470   typedef typename
 471     _Mem_fun_traits<_Result>::_STLP_TEMPLATE _Args1<_Tp,_Arg>::_Ref_const _Base;
 472 public:
 473   explicit const_mem_fun1_ref_t(typename _Base::__fun_type __f) : _Base(__f) {}
 474 };
 475
 476 template <class _Arg, class _Result>
 477 class pointer_to_unary_function :
 478   public _Ptr_fun1<_Result,_Arg> {
 479   typedef typename
 480     _Ptr_fun1<_Result,_Arg>::__fun_type __fun_type;
 481 public:
 482   explicit pointer_to_unary_function(__fun_type __f)
 483     : _Ptr_fun1<_Result,_Arg>(__f) {}
 484 };
 485
 486 template <class _Arg1, class _Arg2, class _Result>
 487 class pointer_to_binary_function :
 488   public _Ptr_fun2<_Result,_Arg1,_Arg2> {
 489   typedef typename
 490     _Ptr_fun2<_Result,_Arg1,_Arg2>::__fun_type __fun_type;
 491 public:
 492   explicit pointer_to_binary_function(__fun_type __f)
 493     : _Ptr_fun2<_Result,_Arg1,_Arg2>(__f) {}
 494 };
 495
 496 #else
 497
 498 template <class _Ret, class _Tp>
 499 class mem_fun_t : public unary_function<_Tp*,_Ret> {
 500   typedef _Ret (_Tp::*__fun_type)(void);
 501 public:
 502   explicit mem_fun_t(__fun_type __pf) : _M_f(__pf) {}
 503   _Ret operator()(_Tp* __p) const { return (__p->*_M_f)(); }
 504 private:
 505   __fun_type _M_f;
 506 };
 507
 508 template <class _Ret, class _Tp>
 509 class const_mem_fun_t : public unary_function<const _Tp*,_Ret> {
 510   typedef _Ret (_Tp::*__fun_type)(void) const;
 511 public:
 512   explicit const_mem_fun_t(__fun_type __pf) : _M_f(__pf) {}
 513   _Ret operator()(const _Tp* __p) const { return (__p->*_M_f)(); }
 514 private:
 515   __fun_type _M_f;
 516 };
 517
 518 template <class _Ret, class _Tp>
 519 class mem_fun_ref_t : public unary_function<_Tp,_Ret> {
 520   typedef _Ret (_Tp::*__fun_type)(void);
 521 public:
 522   explicit mem_fun_ref_t(__fun_type __pf) : _M_f(__pf) {}
 523   _Ret operator()(_Tp& __r) const { return (__r.*_M_f)(); }
 524 private:
 525   __fun_type _M_f;
 526 };
 527
 528 template <class _Ret, class _Tp>
 529 class const_mem_fun_ref_t : public unary_function<_Tp,_Ret> {
 530   typedef _Ret (_Tp::*__fun_type)(void) const;
 531 public:
 532   explicit const_mem_fun_ref_t(__fun_type __pf) : _M_f(__pf) {}
 533   _Ret operator()(const _Tp& __r) const { return (__r.*_M_f)(); }
 534 private:
 535   __fun_type _M_f;
 536 };
 537
 538 template <class _Ret, class _Tp, class _Arg>
 539 class mem_fun1_t : public binary_function<_Tp*,_Arg,_Ret> {
 540   typedef _Ret (_Tp::*__fun_type)(_Arg);
 541 public:
 542   explicit mem_fun1_t(__fun_type __pf) : _M_f(__pf) {}
 543   _Ret operator()(_Tp* __p, _Arg __x) const { return (__p->*_M_f)(__x); }
 544 private:
 545   __fun_type _M_f;
 546 };
 547
 548 template <class _Ret, class _Tp, class _Arg>
 549 class const_mem_fun1_t : public binary_function<const _Tp*,_Arg,_Ret> {
 550   typedef _Ret (_Tp::*__fun_type)(_Arg) const;
 551 public:
 552   explicit const_mem_fun1_t(__fun_type __pf) : _M_f(__pf) {}
 553   _Ret operator()(const _Tp* __p, _Arg __x) const
 554     { return (__p->*_M_f)(__x); }
 555 private:
 556   __fun_type _M_f;
 557 };
 558
 559 template <class _Ret, class _Tp, class _Arg>
 560 class mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
 561   typedef _Ret (_Tp::*__fun_type)(_Arg);
 562 public:
 563   explicit mem_fun1_ref_t(__fun_type __pf) : _M_f(__pf) {}
 564   _Ret operator()(_Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
 565 private:
 566   __fun_type _M_f;
 567 };
 568
 569 template <class _Ret, class _Tp, class _Arg>
 570 class const_mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
 571   typedef _Ret (_Tp::*__fun_type)(_Arg) const;
 572 public:
 573   explicit const_mem_fun1_ref_t(__fun_type __pf) : _M_f(__pf) {}
 574   _Ret operator()(const _Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
 575 private:
 576   __fun_type _M_f;
 577 };
 578
 579 template <class _Arg, class _Result>
 580 class pointer_to_unary_function : public unary_function<_Arg, _Result> {
 581 protected:
 582   _Result (*_M_ptr)(_Arg);
 583 public:
 584   pointer_to_unary_function() {}
 585   explicit pointer_to_unary_function(_Result (*__x)(_Arg)) : _M_ptr(__x) {}
 586   _Result operator()(_Arg __x) const { return _M_ptr(__x); }
 587 };
 588
 589 template <class _Arg1, class _Arg2, class _Result>
 590 class pointer_to_binary_function :
 591   public binary_function<_Arg1,_Arg2,_Result> {
 592 protected:
 593     _Result (*_M_ptr)(_Arg1, _Arg2);
 594 public:
 595     pointer_to_binary_function() {}
 596     explicit pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2))
 597       : _M_ptr(__x) {}
 598     _Result operator()(_Arg1 __x, _Arg2 __y) const {
 599       return _M_ptr(__x, __y);
 600     }
 601 };
 602
 603 #  if defined (_STLP_DONT_RETURN_VOID) && !defined (_STLP_NO_CLASS_PARTIAL_SPECIALIZATION)
 604 //Partial specializations for the void type
 605 template <class _Tp>
 606 class mem_fun_t<void, _Tp> : public unary_function<_Tp*,void> {
 607   typedef void (_Tp::*__fun_type)(void);
 608 public:
 609   explicit mem_fun_t _STLP_PSPEC2(void,_Tp) (__fun_type __pf) : _M_f(__pf) {}
 610   void operator()(_Tp* __p) const { (__p->*_M_f)(); }
 611 private:
 612   __fun_type _M_f;
 613 };
 614
 615 template <class _Tp>
 616 class const_mem_fun_t<void, _Tp> : public unary_function<const _Tp*,void> {
 617   typedef void (_Tp::*__fun_type)(void) const;
 618 public:
 619   explicit const_mem_fun_t _STLP_PSPEC2(void,_Tp) (__fun_type __pf) : _M_f(__pf) {}
 620   void operator()(const _Tp* __p) const { (__p->*_M_f)(); }
 621 private:
 622   __fun_type _M_f;
 623 };
 624
 625 template <class _Tp>
 626 class mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {
 627   typedef void (_Tp::*__fun_type)(void);
 628 public:
 629   explicit mem_fun_ref_t _STLP_PSPEC2(void,_Tp) (__fun_type __pf) : _M_f(__pf) {}
 630   void operator()(_Tp& __r) const { (__r.*_M_f)(); }
 631 private:
 632   __fun_type _M_f;
 633 };
 634
 635 template <class _Tp>
 636 class const_mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {
 637   typedef void (_Tp::*__fun_type)(void) const;
 638 public:
 639   explicit const_mem_fun_ref_t _STLP_PSPEC2(void,_Tp) (__fun_type __pf) : _M_f(__pf) {}
 640   void operator()(const _Tp& __r) const { (__r.*_M_f)(); }
 641 private:
 642   __fun_type _M_f;
 643 };
 644
 645 template <class _Tp, class _Arg>
 646 class mem_fun1_t<void, _Tp, _Arg> : public binary_function<_Tp*,_Arg,void> {
 647   typedef void (_Tp::*__fun_type)(_Arg);
 648 public:
 649   explicit mem_fun1_t _STLP_PSPEC3(void,_Tp,_Arg) (__fun_type __pf) : _M_f(__pf) {}
 650   void operator()(_Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
 651 private:
 652   __fun_type _M_f;
 653 };
 654
 655 template <class _Tp, class _Arg>
 656 class const_mem_fun1_t<void, _Tp, _Arg>
 657   : public binary_function<const _Tp*,_Arg,void> {
 658   typedef void (_Tp::*__fun_type)(_Arg) const;
 659 public:
 660   explicit const_mem_fun1_t _STLP_PSPEC3(void,_Tp,_Arg) (__fun_type __pf) : _M_f(__pf) {}
 661   void operator()(const _Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
 662 private:
 663   __fun_type _M_f;
 664 };
 665
 666 template <class _Tp, class _Arg>
 667 class mem_fun1_ref_t<void, _Tp, _Arg>
 668   : public binary_function<_Tp,_Arg,void> {
 669   typedef void (_Tp::*__fun_type)(_Arg);
 670 public:
 671   explicit mem_fun1_ref_t _STLP_PSPEC3(void,_Tp,_Arg) (__fun_type __pf) : _M_f(__pf) {}
 672   void operator()(_Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
 673 private:
 674   __fun_type _M_f;
 675 };
 676
 677 template <class _Tp, class _Arg>
 678 class const_mem_fun1_ref_t<void, _Tp, _Arg>
 679   : public binary_function<_Tp,_Arg,void> {
 680   typedef void (_Tp::*__fun_type)(_Arg) const;
 681 public:
 682   explicit const_mem_fun1_ref_t _STLP_PSPEC3(void,_Tp,_Arg) (__fun_type __pf) : _M_f(__pf) {}
 683   void operator()(const _Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
 684 private:
 685   __fun_type _M_f;
 686 };
 687
 688 template <class _Arg>
 689 class pointer_to_unary_function<_Arg, void> : public unary_function<_Arg, void> {
 690   typedef void (*__fun_type)(_Arg);
 691   __fun_type _M_ptr;
 692 public:
 693   pointer_to_unary_function() {}
 694   explicit pointer_to_unary_function(__fun_type __x) : _M_ptr(__x) {}
 695   void operator()(_Arg __x) const { _M_ptr(__x); }
 696 };
 697
 698 template <class _Arg1, class _Arg2>
 699 class pointer_to_binary_function<_Arg1, _Arg2, void> : public binary_function<_Arg1,_Arg2,void> {
 700   typedef void (*__fun_type)(_Arg1, _Arg2);
 701   __fun_type _M_ptr;
 702 public:
 703   pointer_to_binary_function() {}
 704   explicit pointer_to_binary_function(__fun_type __x) : _M_ptr(__x) {}
 705   void operator()(_Arg1 __x, _Arg2 __y) const { _M_ptr(__x, __y); }
 706 };
 707
 708 #  endif
 709
 710 #endif
 711
 712 #if !defined (_STLP_MEMBER_POINTER_PARAM_BUG)
 713 // Mem_fun adaptor helper functions.  There are only two:
 714 //  mem_fun and mem_fun_ref.  (mem_fun1 and mem_fun1_ref
 715 //  are provided for backward compatibility, but they are no longer
 716 //  part of the C++ standard.)
 717
 718 template <class _Result, class _Tp>
 719 inline mem_fun_t<_Result,_Tp>
 720 mem_fun(_Result (_Tp::*__f)()) { return mem_fun_t<_Result,_Tp>(__f); }
 721
 722 template <class _Result, class _Tp>
 723 inline const_mem_fun_t<_Result,_Tp>
 724 mem_fun(_Result (_Tp::*__f)() const)  { return const_mem_fun_t<_Result,_Tp>(__f); }
 725
 726 template <class _Result, class _Tp>
 727 inline mem_fun_ref_t<_Result,_Tp>
 728 mem_fun_ref(_Result (_Tp::*__f)())  { return mem_fun_ref_t<_Result,_Tp>(__f); }
 729
 730 template <class _Result, class _Tp>
 731 inline const_mem_fun_ref_t<_Result,_Tp>
 732 mem_fun_ref(_Result (_Tp::*__f)() const)  { return const_mem_fun_ref_t<_Result,_Tp>(__f); }
 733
 734 template <class _Result, class _Tp, class _Arg>
 735 inline mem_fun1_t<_Result,_Tp,_Arg>
 736 mem_fun(_Result (_Tp::*__f)(_Arg)) { return mem_fun1_t<_Result,_Tp,_Arg>(__f); }
 737
 738 template <class _Result, class _Tp, class _Arg>
 739 inline const_mem_fun1_t<_Result,_Tp,_Arg>
 740 mem_fun(_Result (_Tp::*__f)(_Arg) const) { return const_mem_fun1_t<_Result,_Tp,_Arg>(__f); }
 741
 742 template <class _Result, class _Tp, class _Arg>
 743 inline mem_fun1_ref_t<_Result,_Tp,_Arg>
 744 mem_fun_ref(_Result (_Tp::*__f)(_Arg)) { return mem_fun1_ref_t<_Result,_Tp,_Arg>(__f); }
 745
 746 template <class _Result, class _Tp, class _Arg>
 747 inline const_mem_fun1_ref_t<_Result,_Tp,_Arg>
 748 mem_fun_ref(_Result (_Tp::*__f)(_Arg) const) { return const_mem_fun1_ref_t<_Result,_Tp,_Arg>(__f); }
 749
 750 #  if !(defined (_STLP_NO_EXTENSIONS) || defined (_STLP_NO_ANACHRONISMS))
 751 //  mem_fun1 and mem_fun1_ref are no longer part of the C++ standard,
 752 //  but they are provided for backward compatibility.
 753 template <class _Result, class _Tp, class _Arg>
 754 inline mem_fun1_t<_Result,_Tp,_Arg>
 755 mem_fun1(_Result (_Tp::*__f)(_Arg)) { return mem_fun1_t<_Result,_Tp,_Arg>(__f); }
 756
 757 template <class _Result, class _Tp, class _Arg>
 758 inline const_mem_fun1_t<_Result,_Tp,_Arg>
 759 mem_fun1(_Result (_Tp::*__f)(_Arg) const) { return const_mem_fun1_t<_Result,_Tp,_Arg>(__f); }
 760
 761 template <class _Result, class _Tp, class _Arg>
 762 inline mem_fun1_ref_t<_Result,_Tp,_Arg>
 763 mem_fun1_ref(_Result (_Tp::*__f)(_Arg)) { return mem_fun1_ref_t<_Result,_Tp,_Arg>(__f); }
 764
 765 template <class _Result, class _Tp, class _Arg>
 766 inline const_mem_fun1_ref_t<_Result,_Tp,_Arg>
 767 mem_fun1_ref(_Result (_Tp::*__f)(_Arg) const) { return const_mem_fun1_ref_t<_Result,_Tp,_Arg>(__f); }
 768
 769 #  endif
 770
 771 #endif
 772
 773 template <class _Arg, class _Result>
 774 inline pointer_to_unary_function<_Arg, _Result>
 775 ptr_fun(_Result (*__f)(_Arg))
 776 { return pointer_to_unary_function<_Arg, _Result>(__f); }
 777
 778 template <class _Arg1, class _Arg2, class _Result>
 779 inline pointer_to_binary_function<_Arg1,_Arg2,_Result>
 780 ptr_fun(_Result (*__f)(_Arg1, _Arg2))
 781 { return pointer_to_binary_function<_Arg1,_Arg2,_Result>(__f); }
 782
 783 _STLP_END_NAMESPACE