home *** CD-ROM | disk | FTP | other *** search
/ H4CK3R 14 / hacker14.iso / programacao / cwin / c.exe / $INSTDIR / include / c++ / ext / functional < prev    next >
Encoding:
Text File  |  2003-12-15  |  13.5 KB  |  396 lines
  1. // Functional extensions -*- C++ -*-
  2.  
  3. // Copyright (C) 2002 Free Software Foundation, Inc.
  4. //
  5. // This file is part of the GNU ISO C++ Library.  This library is free
  6. // software; you can redistribute it and/or modify it under the
  7. // terms of the GNU General Public License as published by the
  8. // Free Software Foundation; either version 2, or (at your option)
  9. // any later version.
  10.  
  11. // This library is distributed in the hope that it will be useful,
  12. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  13. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14. // GNU General Public License for more details.
  15.  
  16. // You should have received a copy of the GNU General Public License along
  17. // with this library; see the file COPYING.  If not, write to the Free
  18. // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
  19. // USA.
  20.  
  21. // As a special exception, you may use this file as part of a free software
  22. // library without restriction.  Specifically, if other files instantiate
  23. // templates or use macros or inline functions from this file, or you compile
  24. // this file and link it with other files to produce an executable, this
  25. // file does not by itself cause the resulting executable to be covered by
  26. // the GNU General Public License.  This exception does not however
  27. // invalidate any other reasons why the executable file might be covered by
  28. // the GNU General Public License.
  29.  
  30. /*
  31.  *
  32.  * Copyright (c) 1994
  33.  * Hewlett-Packard Company
  34.  *
  35.  * Permission to use, copy, modify, distribute and sell this software
  36.  * and its documentation for any purpose is hereby granted without fee,
  37.  * provided that the above copyright notice appear in all copies and
  38.  * that both that copyright notice and this permission notice appear
  39.  * in supporting documentation.  Hewlett-Packard Company makes no
  40.  * representations about the suitability of this software for any
  41.  * purpose.  It is provided "as is" without express or implied warranty.
  42.  *
  43.  *
  44.  * Copyright (c) 1996
  45.  * Silicon Graphics Computer Systems, Inc.
  46.  *
  47.  * Permission to use, copy, modify, distribute and sell this software
  48.  * and its documentation for any purpose is hereby granted without fee,
  49.  * provided that the above copyright notice appear in all copies and
  50.  * that both that copyright notice and this permission notice appear
  51.  * in supporting documentation.  Silicon Graphics makes no
  52.  * representations about the suitability of this software for any
  53.  * purpose.  It is provided "as is" without express or implied warranty.
  54.  */
  55.  
  56. /** @file ext/functional
  57.  *  This file is a GNU extension to the Standard C++ Library (possibly
  58.  *  containing extensions from the HP/SGI STL subset).  You should only
  59.  *  include this header if you are using GCC 3 or later.
  60.  */
  61.  
  62. #ifndef _EXT_FUNCTIONAL
  63. #define _EXT_FUNCTIONAL
  64.  
  65. #pragma GCC system_header
  66. #include <functional>
  67.  
  68. namespace __gnu_cxx
  69. {
  70. using std::unary_function;
  71. using std::binary_function;
  72. using std::mem_fun1_t;
  73. using std::const_mem_fun1_t;
  74. using std::mem_fun1_ref_t;
  75. using std::const_mem_fun1_ref_t;
  76.  
  77. /** The @c identity_element functions are not part of the C++ standard; SGI
  78.  *  provided them as an extension.  Its argument is an operation, and its
  79.  *  return value is the identity element for that operation.  It is overloaded
  80.  *  for addition and multiplication, and you can overload it for your own
  81.  *  nefarious operations.
  82.  *
  83.  *  @addtogroup SGIextensions
  84.  *  @{
  85. */
  86. /// An \link SGIextensions SGI extension \endlink.
  87. template <class _Tp> inline _Tp identity_element(std::plus<_Tp>) {
  88.   return _Tp(0);
  89. }
  90. /// An \link SGIextensions SGI extension \endlink.
  91. template <class _Tp> inline _Tp identity_element(std::multiplies<_Tp>) {
  92.   return _Tp(1);
  93. }
  94. /** @}  */
  95.  
  96. /** As an extension to the binders, SGI provided composition functors and
  97.  *  wrapper functions to aid in their creation.  The @c unary_compose
  98.  *  functor is constructed from two functions/functors, @c f and @c g.
  99.  *  Calling @c operator() with a single argument @c x returns @c f(g(x)).
  100.  *  The function @c compose1 takes the two functions and constructs a
  101.  *  @c unary_compose variable for you.
  102.  *  
  103.  *  @c binary_compose is constructed from three functors, @c f, @c g1,
  104.  *  and @c g2.  Its @c operator() returns @c f(g1(x),g2(x)).  The function
  105.  *  @compose2 takes f, g1, and g2, and constructs the @c binary_compose
  106.  *  instance for you.  For example, if @c f returns an int, then
  107.  *  \code
  108.  *  int answer = (compose2(f,g1,g2))(x);
  109.  *  \endcode
  110.  *  is equivalent to
  111.  *  \code
  112.  *  int temp1 = g1(x);
  113.  *  int temp2 = g2(x);
  114.  *  int answer = f(temp1,temp2);
  115.  *  \endcode
  116.  *  But the first form is more compact, and can be passed around as a
  117.  *  functor to other algorithms.
  118.  *
  119.  *  @addtogroup SGIextensions
  120.  *  @{
  121. */
  122. /// An \link SGIextensions SGI extension \endlink.
  123. template <class _Operation1, class _Operation2>
  124. class unary_compose
  125.   : public unary_function<typename _Operation2::argument_type,
  126.                typename _Operation1::result_type> 
  127. {
  128. protected:
  129.   _Operation1 _M_fn1;
  130.   _Operation2 _M_fn2;
  131. public:
  132.   unary_compose(const _Operation1& __x, const _Operation2& __y) 
  133.     : _M_fn1(__x), _M_fn2(__y) {}
  134.   typename _Operation1::result_type
  135.   operator()(const typename _Operation2::argument_type& __x) const {
  136.     return _M_fn1(_M_fn2(__x));
  137.   }
  138. };
  139.  
  140. /// An \link SGIextensions SGI extension \endlink.
  141. template <class _Operation1, class _Operation2>
  142. inline unary_compose<_Operation1,_Operation2> 
  143. compose1(const _Operation1& __fn1, const _Operation2& __fn2)
  144. {
  145.   return unary_compose<_Operation1,_Operation2>(__fn1, __fn2);
  146. }
  147.  
  148. /// An \link SGIextensions SGI extension \endlink.
  149. template <class _Operation1, class _Operation2, class _Operation3>
  150. class binary_compose
  151.   : public unary_function<typename _Operation2::argument_type,
  152.                           typename _Operation1::result_type> {
  153. protected:
  154.   _Operation1 _M_fn1;
  155.   _Operation2 _M_fn2;
  156.   _Operation3 _M_fn3;
  157. public:
  158.   binary_compose(const _Operation1& __x, const _Operation2& __y, 
  159.                  const _Operation3& __z) 
  160.     : _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { }
  161.   typename _Operation1::result_type
  162.   operator()(const typename _Operation2::argument_type& __x) const {
  163.     return _M_fn1(_M_fn2(__x), _M_fn3(__x));
  164.   }
  165. };
  166.  
  167. /// An \link SGIextensions SGI extension \endlink.
  168. template <class _Operation1, class _Operation2, class _Operation3>
  169. inline binary_compose<_Operation1, _Operation2, _Operation3> 
  170. compose2(const _Operation1& __fn1, const _Operation2& __fn2, 
  171.          const _Operation3& __fn3)
  172. {
  173.   return binary_compose<_Operation1,_Operation2,_Operation3>
  174.     (__fn1, __fn2, __fn3);
  175. }
  176. /** @}  */
  177.  
  178. /** As an extension, SGI provided a functor called @c identity.  When a
  179.  *  functor is required but no operations are desired, this can be used as a
  180.  *  pass-through.  Its @c operator() returns its argument unchanged.
  181.  *
  182.  *  @addtogroup SGIextensions
  183. */
  184. template <class _Tp> struct identity : public std::_Identity<_Tp> {};
  185.  
  186. /** @c select1st and @c select2nd are extensions provided by SGI.  Their
  187.  *  @c operator()s
  188.  *  take a @c std::pair as an argument, and return either the first member
  189.  *  or the second member, respectively.  They can be used (especially with
  190.  *  the composition functors) to "strip" data from a sequence before
  191.  *  performing the remainder of an algorithm.
  192.  *
  193.  *  @addtogroup SGIextensions
  194.  *  @{
  195. */
  196. /// An \link SGIextensions SGI extension \endlink.
  197. template <class _Pair> struct select1st : public std::_Select1st<_Pair> {};
  198. /// An \link SGIextensions SGI extension \endlink.
  199. template <class _Pair> struct select2nd : public std::_Select2nd<_Pair> {};
  200. /** @}  */
  201.  
  202. // extension documented next
  203. template <class _Arg1, class _Arg2>
  204. struct _Project1st : public binary_function<_Arg1, _Arg2, _Arg1> {
  205.   _Arg1 operator()(const _Arg1& __x, const _Arg2&) const { return __x; }
  206. };
  207.  
  208. template <class _Arg1, class _Arg2>
  209. struct _Project2nd : public binary_function<_Arg1, _Arg2, _Arg2> {
  210.   _Arg2 operator()(const _Arg1&, const _Arg2& __y) const { return __y; }
  211. };
  212.  
  213. /** The @c operator() of the @c project1st functor takes two arbitrary
  214.  *  arguments and returns the first one, while @c project2nd returns the
  215.  *  second one.  They are extensions provided by SGI.
  216.  *
  217.  *  @addtogroup SGIextensions
  218.  *  @{
  219. */
  220.  
  221. /// An \link SGIextensions SGI extension \endlink.
  222. template <class _Arg1, class _Arg2> 
  223. struct project1st : public _Project1st<_Arg1, _Arg2> {};
  224.  
  225. /// An \link SGIextensions SGI extension \endlink.
  226. template <class _Arg1, class _Arg2>
  227. struct project2nd : public _Project2nd<_Arg1, _Arg2> {};
  228. /** @}  */
  229.  
  230. // extension documented next
  231. template <class _Result>
  232. struct _Constant_void_fun {
  233.   typedef _Result result_type;
  234.   result_type _M_val;
  235.  
  236.   _Constant_void_fun(const result_type& __v) : _M_val(__v) {}
  237.   const result_type& operator()() const { return _M_val; }
  238. };  
  239.  
  240. template <class _Result, class _Argument>
  241. struct _Constant_unary_fun {
  242.   typedef _Argument argument_type;
  243.   typedef  _Result  result_type;
  244.   result_type _M_val;
  245.  
  246.   _Constant_unary_fun(const result_type& __v) : _M_val(__v) {}
  247.   const result_type& operator()(const _Argument&) const { return _M_val; }
  248. };
  249.  
  250. template <class _Result, class _Arg1, class _Arg2>
  251. struct _Constant_binary_fun {
  252.   typedef  _Arg1   first_argument_type;
  253.   typedef  _Arg2   second_argument_type;
  254.   typedef  _Result result_type;
  255.   _Result _M_val;
  256.  
  257.   _Constant_binary_fun(const _Result& __v) : _M_val(__v) {}
  258.   const result_type& operator()(const _Arg1&, const _Arg2&) const {
  259.     return _M_val;
  260.   }
  261. };
  262.  
  263. /** These three functors are each constructed from a single arbitrary
  264.  *  variable/value.  Later, their @c operator()s completely ignore any
  265.  *  arguments passed, and return the stored value.
  266.  *  - @c constant_void_fun's @c operator() takes no arguments
  267.  *  - @c constant_unary_fun's @c operator() takes one argument (ignored)
  268.  *  - @c constant_binary_fun's @c operator() takes two arguments (ignored)
  269.  *
  270.  *  The helper creator functions @c constant0, @c constant1, and
  271.  *  @c constant2 each take a "result" argument and construct variables of
  272.  *  the appropriate functor type.
  273.  *
  274.  *  @addtogroup SGIextensions
  275.  *  @{
  276. */
  277. /// An \link SGIextensions SGI extension \endlink.
  278. template <class _Result>
  279. struct constant_void_fun : public _Constant_void_fun<_Result> {
  280.   constant_void_fun(const _Result& __v) : _Constant_void_fun<_Result>(__v) {}
  281. };  
  282.  
  283. /// An \link SGIextensions SGI extension \endlink.
  284. template <class _Result,
  285.           class _Argument = _Result>
  286. struct constant_unary_fun : public _Constant_unary_fun<_Result, _Argument>
  287. {
  288.   constant_unary_fun(const _Result& __v)
  289.     : _Constant_unary_fun<_Result, _Argument>(__v) {}
  290. };
  291.  
  292. /// An \link SGIextensions SGI extension \endlink.
  293. template <class _Result,
  294.           class _Arg1 = _Result,
  295.           class _Arg2 = _Arg1>
  296. struct constant_binary_fun
  297.   : public _Constant_binary_fun<_Result, _Arg1, _Arg2>
  298. {
  299.   constant_binary_fun(const _Result& __v)
  300.     : _Constant_binary_fun<_Result, _Arg1, _Arg2>(__v) {}
  301. };
  302.  
  303. /// An \link SGIextensions SGI extension \endlink.
  304. template <class _Result>
  305. inline constant_void_fun<_Result> constant0(const _Result& __val)
  306. {
  307.   return constant_void_fun<_Result>(__val);
  308. }
  309.  
  310. /// An \link SGIextensions SGI extension \endlink.
  311. template <class _Result>
  312. inline constant_unary_fun<_Result,_Result> constant1(const _Result& __val)
  313. {
  314.   return constant_unary_fun<_Result,_Result>(__val);
  315. }
  316.  
  317. /// An \link SGIextensions SGI extension \endlink.
  318. template <class _Result>
  319. inline constant_binary_fun<_Result,_Result,_Result> 
  320. constant2(const _Result& __val)
  321. {
  322.   return constant_binary_fun<_Result,_Result,_Result>(__val);
  323. }
  324. /** @}  */
  325.  
  326. /** The @c subtractive_rng class is documented on
  327.  *  <a href="http://www.sgi.com/tech/stl/">SGI's site</a>.
  328.  *  Note that this code assumes that @c int is 32 bits.
  329.  *
  330.  *  @ingroup SGIextensions
  331. */
  332. class subtractive_rng : public unary_function<unsigned int, unsigned int> {
  333. private:
  334.   unsigned int _M_table[55];
  335.   size_t _M_index1;
  336.   size_t _M_index2;
  337. public:
  338.   /// Returns a number less than the argument.
  339.   unsigned int operator()(unsigned int __limit) {
  340.     _M_index1 = (_M_index1 + 1) % 55;
  341.     _M_index2 = (_M_index2 + 1) % 55;
  342.     _M_table[_M_index1] = _M_table[_M_index1] - _M_table[_M_index2];
  343.     return _M_table[_M_index1] % __limit;
  344.   }
  345.  
  346.   void _M_initialize(unsigned int __seed)
  347.   {
  348.     unsigned int __k = 1;
  349.     _M_table[54] = __seed;
  350.     size_t __i;
  351.     for (__i = 0; __i < 54; __i++) {
  352.         size_t __ii = (21 * (__i + 1) % 55) - 1;
  353.         _M_table[__ii] = __k;
  354.         __k = __seed - __k;
  355.         __seed = _M_table[__ii];
  356.     }
  357.     for (int __loop = 0; __loop < 4; __loop++) {
  358.         for (__i = 0; __i < 55; __i++)
  359.             _M_table[__i] = _M_table[__i] - _M_table[(1 + __i + 30) % 55];
  360.     }
  361.     _M_index1 = 0;
  362.     _M_index2 = 31;
  363.   }
  364.  
  365.   /// Ctor allowing you to initialize the seed.
  366.   subtractive_rng(unsigned int __seed) { _M_initialize(__seed); }
  367.   /// Default ctor; initializes its state with some number you don't see.
  368.   subtractive_rng() { _M_initialize(161803398u); }
  369. };
  370.  
  371. // Mem_fun adaptor helper functions mem_fun1 and mem_fun1_ref, 
  372. // provided for backward compatibility, they are no longer part of
  373. // the C++ standard.
  374.  
  375. template <class _Ret, class _Tp, class _Arg>
  376. inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg))
  377.   { return mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
  378.  
  379. template <class _Ret, class _Tp, class _Arg>
  380. inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg) const)
  381.   { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
  382.  
  383. template <class _Ret, class _Tp, class _Arg>
  384. inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun1_ref(_Ret (_Tp::*__f)(_Arg))
  385.   { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
  386.  
  387. template <class _Ret, class _Tp, class _Arg>
  388. inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>
  389. mem_fun1_ref(_Ret (_Tp::*__f)(_Arg) const)
  390.   { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
  391.  
  392. } // namespace __gnu_cxx
  393.  
  394. #endif /* _EXT_FUNCTIONAL */
  395.  
  396.