home *** CD-ROM | disk | FTP | other *** search
/ PC World 2001 March / PCWorld_2001-03_cd.bin / Software / TemaCD / devc / _SETUP.6 / Group14 / stl_function.h < prev    next >
C/C++ Source or Header  |  2000-01-21  |  22KB  |  701 lines
  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& __oper, const _Tp& __x) 
  206. {
  207.   typedef typename _Operation::first_argument_type _Arg1_type;
  208.   return binder1st<_Operation>(__oper, _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& __oper, const _Tp& __x) 
  231. {
  232.   typedef typename _Operation::second_argument_type _Arg2_type;
  233.   return binder2nd<_Operation>(__oper, _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 __op1;
  245.   _Operation2 __op2;
  246. public:
  247.   unary_compose(const _Operation1& __x, const _Operation2& __y) 
  248.     : __op1(__x), __op2(__y) {}
  249.   typename _Operation1::result_type
  250.   operator()(const typename _Operation2::argument_type& __x) const {
  251.     return __op1(__op2(__x));
  252.   }
  253. };
  254.  
  255. template <class _Operation1, class _Operation2>
  256. inline unary_compose<_Operation1,_Operation2> 
  257. compose1(const _Operation1& __op1, const _Operation2& __op2)
  258. {
  259.   return unary_compose<_Operation1,_Operation2>(__op1, __op2);
  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_op1;
  268.   _Operation2 _M_op2;
  269.   _Operation3 _M_op3;
  270. public:
  271.   binary_compose(const _Operation1& __x, const _Operation2& __y, 
  272.                  const _Operation3& __z) 
  273.     : _M_op1(__x), _M_op2(__y), _M_op3(__z) { }
  274.   typename _Operation1::result_type
  275.   operator()(const typename _Operation2::argument_type& __x) const {
  276.     return _M_op1(_M_op2(__x), _M_op3(__x));
  277.   }
  278. };
  279.  
  280. template <class _Operation1, class _Operation2, class _Operation3>
  281. inline binary_compose<_Operation1, _Operation2, _Operation3> 
  282. compose2(const _Operation1& __op1, const _Operation2& __op2, 
  283.          const _Operation3& __op3)
  284. {
  285.   return binary_compose<_Operation1,_Operation2,_Operation3>
  286.     (__op1, __op2, __op3);
  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.   const _Tp& operator()(const _Tp& __x) const { return __x; }
  329. };
  330.  
  331. template <class _Tp> struct identity : public _Identity<_Tp> {};
  332.  
  333. // select1st and select2nd are extensions: they are not part of the standard.
  334. template <class _Pair>
  335. struct _Select1st : public unary_function<_Pair, typename _Pair::first_type> {
  336.   const typename _Pair::first_type& operator()(const _Pair& __x) const {
  337.     return __x.first;
  338.   }
  339. };
  340.  
  341. template <class _Pair>
  342. struct _Select2nd : public unary_function<_Pair, typename _Pair::second_type>
  343. {
  344.   const typename _Pair::second_type& operator()(const _Pair& __x) const {
  345.     return __x.second;
  346.   }
  347. };
  348.  
  349. template <class _Pair> struct select1st : public _Select1st<_Pair> {};
  350. template <class _Pair> struct select2nd : public _Select2nd<_Pair> {};
  351.  
  352. // project1st and project2nd are extensions: they are not part of the standard
  353. template <class _Arg1, class _Arg2>
  354. struct _Project1st : public binary_function<_Arg1, _Arg2, _Arg1> {
  355.   _Arg1 operator()(const _Arg1& __x, const _Arg2&) const { return __x; }
  356. };
  357.  
  358. template <class _Arg1, class _Arg2>
  359. struct _Project2nd : public binary_function<_Arg1, _Arg2, _Arg2> {
  360.   _Arg2 operator()(const _Arg1&, const _Arg2& __y) const { return __y; }
  361. };
  362.  
  363. template <class _Arg1, class _Arg2> 
  364. struct project1st : public _Project1st<_Arg1, _Arg2> {};
  365.  
  366. template <class _Arg1, class _Arg2>
  367. struct project2nd : public _Project2nd<_Arg1, _Arg2> {};
  368.  
  369. // constant_void_fun, constant_unary_fun, and constant_binary_fun are
  370. // extensions: they are not part of the standard.  (The same, of course,
  371. // is true of the helper functions constant0, constant1, and constant2.)
  372. template <class _Result>
  373. struct constant_void_fun
  374. {
  375.   typedef _Result result_type;
  376.   result_type __val;
  377.   constant_void_fun(const result_type& __v) : __val(__v) {}
  378.   const result_type& operator()() const { return __val; }
  379. };  
  380.  
  381. #ifndef __STL_LIMITED_DEFAULT_TEMPLATES
  382. template <class _Result, class _Argument = _Result>
  383. #else
  384. template <class _Result, class _Argument>
  385. #endif
  386. struct constant_unary_fun : public unary_function<_Argument, _Result> {
  387.   _Result _M_val;
  388.   constant_unary_fun(const _Result& __v) : _M_val(__v) {}
  389.   const _Result& operator()(const _Argument&) const { return _M_val; }
  390. };
  391.  
  392. #ifndef __STL_LIMITED_DEFAULT_TEMPLATES
  393. template <class _Result, class _Arg1 = _Result, class _Arg2 = _Arg1>
  394. #else
  395. template <class _Result, class _Arg1, class _Arg2>
  396. #endif
  397. struct constant_binary_fun : public binary_function<_Arg1, _Arg2, _Result> {
  398.   _Result _M_val;
  399.   constant_binary_fun(const _Result& __v) : _M_val(__v) {}
  400.   const _Result& operator()(const _Arg1&, const _Arg2&) const {
  401.     return _M_val;
  402.   }
  403. };
  404.  
  405. template <class _Result>
  406. inline constant_void_fun<_Result> constant0(const _Result& __val)
  407. {
  408.   return constant_void_fun<_Result>(__val);
  409. }
  410.  
  411. template <class _Result>
  412. inline constant_unary_fun<_Result,_Result> constant1(const _Result& __val)
  413. {
  414.   return constant_unary_fun<_Result,_Result>(__val);
  415. }
  416.  
  417. template <class _Result>
  418. inline constant_binary_fun<_Result,_Result,_Result> 
  419. constant2(const _Result& __val)
  420. {
  421.   return constant_binary_fun<_Result,_Result,_Result>(__val);
  422. }
  423.  
  424. // subtractive_rng is an extension: it is not part of the standard.
  425. // Note: this code assumes that int is 32 bits.
  426. class subtractive_rng : public unary_function<unsigned int, unsigned int> {
  427. private:
  428.   unsigned int _M_table[55];
  429.   size_t _M_index1;
  430.   size_t _M_index2;
  431. public:
  432.   unsigned int operator()(unsigned int __limit) {
  433.     _M_index1 = (_M_index1 + 1) % 55;
  434.     _M_index2 = (_M_index2 + 1) % 55;
  435.     _M_table[_M_index1] = _M_table[_M_index1] - _M_table[_M_index2];
  436.     return _M_table[_M_index1] % __limit;
  437.   }
  438.  
  439.   void _M_initialize(unsigned int __seed)
  440.   {
  441.     unsigned int __k = 1;
  442.     _M_table[54] = __seed;
  443.     size_t __i;
  444.     for (__i = 0; __i < 54; __i++) {
  445.         size_t __ii = (21 * (__i + 1) % 55) - 1;
  446.         _M_table[__ii] = __k;
  447.         __k = __seed - __k;
  448.         __seed = _M_table[__ii];
  449.     }
  450.     for (int __loop = 0; __loop < 4; __loop++) {
  451.         for (__i = 0; __i < 55; __i++)
  452.             _M_table[__i] = _M_table[__i] - _M_table[(1 + __i + 30) % 55];
  453.     }
  454.     _M_index1 = 0;
  455.     _M_index2 = 31;
  456.   }
  457.  
  458.   subtractive_rng(unsigned int __seed) { _M_initialize(__seed); }
  459.   subtractive_rng() { _M_initialize(161803398u); }
  460. };
  461.  
  462.  
  463. // Adaptor function objects: pointers to member functions.
  464.  
  465. // There are a total of 16 = 2^4 function objects in this family.
  466. //  (1) Member functions taking no arguments vs member functions taking
  467. //       one argument.
  468. //  (2) Call through pointer vs call through reference.
  469. //  (3) Member function with void return type vs member function with
  470. //      non-void return type.
  471. //  (4) Const vs non-const member function.
  472.  
  473. // Note that choice (3) is nothing more than a workaround: according
  474. //  to the draft, compilers should handle void and non-void the same way.
  475. //  This feature is not yet widely implemented, though.  You can only use
  476. //  member functions returning void if your compiler supports partial
  477. //  specialization.
  478.  
  479. // All of this complexity is in the function objects themselves.  You can
  480. //  ignore it by using the helper function mem_fun and mem_fun_ref,
  481. //  which create whichever type of adaptor is appropriate.
  482. //  (mem_fun1 and mem_fun1_ref are no longer part of the C++ standard,
  483. //  but they are provided for backward compatibility.)
  484.  
  485.  
  486. template <class _Ret, class _Tp>
  487. class mem_fun_t : public unary_function<_Tp*,_Ret> {
  488. public:
  489.   explicit mem_fun_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}
  490.   _Ret operator()(_Tp* __p) const { return (__p->*_M_f)(); }
  491. private:
  492.   _Ret (_Tp::*_M_f)();
  493. };
  494.  
  495. template <class _Ret, class _Tp>
  496. class const_mem_fun_t : public unary_function<const _Tp*,_Ret> {
  497. public:
  498.   explicit const_mem_fun_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
  499.   _Ret operator()(const _Tp* __p) const { return (__p->*_M_f)(); }
  500. private:
  501.   _Ret (_Tp::*_M_f)() const;
  502. };
  503.  
  504.  
  505. template <class _Ret, class _Tp>
  506. class mem_fun_ref_t : public unary_function<_Tp,_Ret> {
  507. public:
  508.   explicit mem_fun_ref_t(_Ret (_Tp::*__pf)()) : _M_f(__pf) {}
  509.   _Ret operator()(_Tp& __r) const { return (__r.*_M_f)(); }
  510. private:
  511.   _Ret (_Tp::*_M_f)();
  512. };
  513.  
  514. template <class _Ret, class _Tp>
  515. class const_mem_fun_ref_t : public unary_function<_Tp,_Ret> {
  516. public:
  517.   explicit const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) : _M_f(__pf) {}
  518.   _Ret operator()(const _Tp& __r) const { return (__r.*_M_f)(); }
  519. private:
  520.   _Ret (_Tp::*_M_f)() const;
  521. };
  522.  
  523. template <class _Ret, class _Tp, class _Arg>
  524. class mem_fun1_t : public binary_function<_Tp*,_Arg,_Ret> {
  525. public:
  526.   explicit mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
  527.   _Ret operator()(_Tp* __p, _Arg __x) const { return (__p->*_M_f)(__x); }
  528. private:
  529.   _Ret (_Tp::*_M_f)(_Arg);
  530. };
  531.  
  532. template <class _Ret, class _Tp, class _Arg>
  533. class const_mem_fun1_t : public binary_function<const _Tp*,_Arg,_Ret> {
  534. public:
  535.   explicit const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
  536.   _Ret operator()(const _Tp* __p, _Arg __x) const
  537.     { return (__p->*_M_f)(__x); }
  538. private:
  539.   _Ret (_Tp::*_M_f)(_Arg) const;
  540. };
  541.  
  542. template <class _Ret, class _Tp, class _Arg>
  543. class mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
  544. public:
  545.   explicit mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
  546.   _Ret operator()(_Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
  547. private:
  548.   _Ret (_Tp::*_M_f)(_Arg);
  549. };
  550.  
  551. template <class _Ret, class _Tp, class _Arg>
  552. class const_mem_fun1_ref_t : public binary_function<_Tp,_Arg,_Ret> {
  553. public:
  554.   explicit const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
  555.   _Ret operator()(const _Tp& __r, _Arg __x) const { return (__r.*_M_f)(__x); }
  556. private:
  557.   _Ret (_Tp::*_M_f)(_Arg) const;
  558. };
  559.  
  560. #ifdef __STL_CLASS_PARTIAL_SPECIALIZATION
  561.  
  562. template <class _Tp>
  563. class mem_fun_t<void, _Tp> : public unary_function<_Tp*,void> {
  564. public:
  565.   explicit mem_fun_t(void (_Tp::*__pf)()) : _M_f(__pf) {}
  566.   void operator()(_Tp* __p) const { (__p->*_M_f)(); }
  567. private:
  568.   void (_Tp::*_M_f)();
  569. };
  570.  
  571. template <class _Tp>
  572. class const_mem_fun_t<void, _Tp> : public unary_function<const _Tp*,void> {
  573. public:
  574.   explicit const_mem_fun_t(void (_Tp::*__pf)() const) : _M_f(__pf) {}
  575.   void operator()(const _Tp* __p) const { (__p->*_M_f)(); }
  576. private:
  577.   void (_Tp::*_M_f)() const;
  578. };
  579.  
  580. template <class _Tp>
  581. class mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {
  582. public:
  583.   explicit mem_fun_ref_t(void (_Tp::*__pf)()) : _M_f(__pf) {}
  584.   void operator()(_Tp& __r) const { (__r.*_M_f)(); }
  585. private:
  586.   void (_Tp::*_M_f)();
  587. };
  588.  
  589. template <class _Tp>
  590. class const_mem_fun_ref_t<void, _Tp> : public unary_function<_Tp,void> {
  591. public:
  592.   explicit const_mem_fun_ref_t(void (_Tp::*__pf)() const) : _M_f(__pf) {}
  593.   void operator()(const _Tp& __r) const { (__r.*_M_f)(); }
  594. private:
  595.   void (_Tp::*_M_f)() const;
  596. };
  597.  
  598. template <class _Tp, class _Arg>
  599. class mem_fun1_t<void, _Tp, _Arg> : public binary_function<_Tp*,_Arg,void> {
  600. public:
  601.   explicit mem_fun1_t(void (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
  602.   void operator()(_Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
  603. private:
  604.   void (_Tp::*_M_f)(_Arg);
  605. };
  606.  
  607. template <class _Tp, class _Arg>
  608. class const_mem_fun1_t<void, _Tp, _Arg> 
  609.   : public binary_function<const _Tp*,_Arg,void> {
  610. public:
  611.   explicit const_mem_fun1_t(void (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
  612.   void operator()(const _Tp* __p, _Arg __x) const { (__p->*_M_f)(__x); }
  613. private:
  614.   void (_Tp::*_M_f)(_Arg) const;
  615. };
  616.  
  617. template <class _Tp, class _Arg>
  618. class mem_fun1_ref_t<void, _Tp, _Arg>
  619.   : public binary_function<_Tp,_Arg,void> {
  620. public:
  621.   explicit mem_fun1_ref_t(void (_Tp::*__pf)(_Arg)) : _M_f(__pf) {}
  622.   void operator()(_Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
  623. private:
  624.   void (_Tp::*_M_f)(_Arg);
  625. };
  626.  
  627. template <class _Tp, class _Arg>
  628. class const_mem_fun1_ref_t<void, _Tp, _Arg>
  629.   : public binary_function<_Tp,_Arg,void> {
  630. public:
  631.   explicit const_mem_fun1_ref_t(void (_Tp::*__pf)(_Arg) const) : _M_f(__pf) {}
  632.   void operator()(const _Tp& __r, _Arg __x) const { (__r.*_M_f)(__x); }
  633. private:
  634.   void (_Tp::*_M_f)(_Arg) const;
  635. };
  636.  
  637. #endif /* __STL_CLASS_PARTIAL_SPECIALIZATION */
  638.  
  639. // Mem_fun adaptor helper functions.  There are only two:
  640. //  mem_fun and mem_fun_ref.  (mem_fun1 and mem_fun1_ref 
  641. //  are provided for backward compatibility, but they are no longer
  642. //  part of the C++ standard.)
  643.  
  644. template <class _Ret, class _Tp>
  645. inline mem_fun_t<_Ret,_Tp> mem_fun(_Ret (_Tp::*__f)())
  646.   { return mem_fun_t<_Ret,_Tp>(__f); }
  647.  
  648. template <class _Ret, class _Tp>
  649. inline const_mem_fun_t<_Ret,_Tp> mem_fun(_Ret (_Tp::*__f)() const)
  650.   { return const_mem_fun_t<_Ret,_Tp>(__f); }
  651.  
  652. template <class _Ret, class _Tp>
  653. inline mem_fun_ref_t<_Ret,_Tp> mem_fun_ref(_Ret (_Tp::*__f)()) 
  654.   { return mem_fun_ref_t<_Ret,_Tp>(__f); }
  655.  
  656. template <class _Ret, class _Tp>
  657. inline const_mem_fun_ref_t<_Ret,_Tp> mem_fun_ref(_Ret (_Tp::*__f)() const)
  658.   { return const_mem_fun_ref_t<_Ret,_Tp>(__f); }
  659.  
  660. template <class _Ret, class _Tp, class _Arg>
  661. inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun(_Ret (_Tp::*__f)(_Arg))
  662.   { return mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
  663.  
  664. template <class _Ret, class _Tp, class _Arg>
  665. inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun(_Ret (_Tp::*__f)(_Arg) const)
  666.   { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
  667.  
  668. template <class _Ret, class _Tp, class _Arg>
  669. inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun_ref(_Ret (_Tp::*__f)(_Arg))
  670.   { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
  671.  
  672. template <class _Ret, class _Tp, class _Arg>
  673. inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>
  674. mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const)
  675.   { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
  676.  
  677. template <class _Ret, class _Tp, class _Arg>
  678. inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg))
  679.   { return mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
  680.  
  681. template <class _Ret, class _Tp, class _Arg>
  682. inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg) const)
  683.   { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
  684.  
  685. template <class _Ret, class _Tp, class _Arg>
  686. inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun1_ref(_Ret (_Tp::*__f)(_Arg))
  687.   { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
  688.  
  689. template <class _Ret, class _Tp, class _Arg>
  690. inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>
  691. mem_fun1_ref(_Ret (_Tp::*__f)(_Arg) const)
  692.   { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
  693.  
  694. __STL_END_NAMESPACE
  695.  
  696. #endif /* __SGI_STL_INTERNAL_FUNCTION_H */
  697.  
  698. // Local Variables:
  699. // mode:C++
  700. // End:
  701.