# functional

Go to the documentation of this file.

    00001 // Functional extensions -*- C++ -*-
    00002
    00003 // Copyright (C) 2002 Free Software Foundation, Inc.
    00004 //
    00005 // This file is part of the GNU ISO C++ Library.  This library is free
    00006 // software; you can redistribute it and/or modify it under the
    00007 // terms of the GNU General Public License as published by the
    00008 // Free Software Foundation; either version 2, or (at your option)
    00009 // any later version.
    00010
    00011 // This library is distributed in the hope that it will be useful,
    00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
    00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    00014 // GNU General Public License for more details.
    00015
    00016 // You should have received a copy of the GNU General Public License along
    00017 // with this library; see the file COPYING.  If not, write to the Free
    00018 // Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307,
    00019 // USA.
    00020
    00021 // As a special exception, you may use this file as part of a free software
    00022 // library without restriction.  Specifically, if other files instantiate
    00023 // templates or use macros or inline functions from this file, or you compile
    00024 // this file and link it with other files to produce an executable, this
    00025 // file does not by itself cause the resulting executable to be covered by
    00026 // the GNU General Public License.  This exception does not however
    00027 // invalidate any other reasons why the executable file might be covered by
    00028 // the GNU General Public License.
    00029
    00030 /*
    00031  *
    00032  * Copyright (c) 1994
    00033  * Hewlett-Packard Company
    00034  *
    00035  * Permission to use, copy, modify, distribute and sell this software
    00036  * and its documentation for any purpose is hereby granted without fee,
    00037  * provided that the above copyright notice appear in all copies and
    00038  * that both that copyright notice and this permission notice appear
    00039  * in supporting documentation.  Hewlett-Packard Company makes no
    00040  * representations about the suitability of this software for any
    00041  * purpose.  It is provided "as is" without express or implied warranty.
    00042  *
    00043  *
    00044  * Copyright (c) 1996
    00045  * Silicon Graphics Computer Systems, Inc.
    00046  *
    00047  * Permission to use, copy, modify, distribute and sell this software
    00048  * and its documentation for any purpose is hereby granted without fee,
    00049  * provided that the above copyright notice appear in all copies and
    00050  * that both that copyright notice and this permission notice appear
    00051  * in supporting documentation.  Silicon Graphics makes no
    00052  * representations about the suitability of this software for any
    00053  * purpose.  It is provided "as is" without express or implied warranty.
    00054  */
    00055
    00062 #ifndef _EXT_FUNCTIONAL
    00063 #define _EXT_FUNCTIONAL
    00064
    00065 #pragma GCC system_header
    00066 #include <functional>
    00067
    00068 namespace __gnu_cxx
    00069 {
    00070 using std::unary_function;
    00071 using std::binary_function;
    00072 using std::mem_fun1_t;
    00073 using std::const_mem_fun1_t;
    00074 using std::mem_fun1_ref_t;
    00075 using std::const_mem_fun1_ref_t;
    00076
    00086
    00087 template <class _Tp> inline _Tp identity_element(std::plus<_Tp>) {
    00088   return _Tp(0);
    00089 }
    00091 template <class _Tp> inline _Tp identity_element(std::multiplies<_Tp>) {
    00092   return _Tp(1);
    00093 }
    00122
    00123 template <class _Operation1, class _Operation2>
    00124 class unary_compose
    00125   : public unary_function<typename _Operation2::argument_type,
    00126                typename _Operation1::result_type>
    00127 {
    00128 protected:
    00129   _Operation1 _M_fn1;
    00130   _Operation2 _M_fn2;
    00131 public:
    00132   unary_compose(const _Operation1& __x, const _Operation2& __y)
    00133     : _M_fn1(__x), _M_fn2(__y) {}
    00134   typename _Operation1::result_type
    00135   operator()(const typename _Operation2::argument_type& __x) const {
    00136     return _M_fn1(_M_fn2(__x));
    00137   }
    00138 };
    00139
    00141 template <class _Operation1, class _Operation2>
    00142 inline unary_compose<_Operation1,_Operation2>
    00143 compose1(const _Operation1& __fn1, const _Operation2& __fn2)
    00144 {
    00145   return unary_compose<_Operation1,_Operation2>(__fn1, __fn2);
    00146 }
    00147
    00149 template <class _Operation1, class _Operation2, class _Operation3>
    00150 class binary_compose
    00151   : public unary_function<typename _Operation2::argument_type,
    00152                           typename _Operation1::result_type> {
    00153 protected:
    00154   _Operation1 _M_fn1;
    00155   _Operation2 _M_fn2;
    00156   _Operation3 _M_fn3;
    00157 public:
    00158   binary_compose(const _Operation1& __x, const _Operation2& __y,
    00159                  const _Operation3& __z)
    00160     : _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { }
    00161   typename _Operation1::result_type
    00162   operator()(const typename _Operation2::argument_type& __x) const {
    00163     return _M_fn1(_M_fn2(__x), _M_fn3(__x));
    00164   }
    00165 };
    00166
    00168 template <class _Operation1, class _Operation2, class _Operation3>
    00169 inline binary_compose<_Operation1, _Operation2, _Operation3>
    00170 compose2(const _Operation1& __fn1, const _Operation2& __fn2,
    00171          const _Operation3& __fn3)
    00172 {
    00173   return binary_compose<_Operation1,_Operation2,_Operation3>
    00174     (__fn1, __fn2, __fn3);
    00175 }
    00184 template <class _Tp> struct identity : public std::_Identity<_Tp> {};
    00185
    00196
    00197 template <class _Pair> struct select1st : public std::_Select1st<_Pair> {};
    00199 template <class _Pair> struct select2nd : public std::_Select2nd<_Pair> {};
    00202 // extension documented next
    00203 template <class _Arg1, class _Arg2>
    00204 struct _Project1st : public binary_function<_Arg1, _Arg2, _Arg1> {
    00205   _Arg1 operator()(const _Arg1& __x, const _Arg2&) const { return __x; }
    00206 };
    00207
    00208 template <class _Arg1, class _Arg2>
    00209 struct _Project2nd : public binary_function<_Arg1, _Arg2, _Arg2> {
    00210   _Arg2 operator()(const _Arg1&, const _Arg2& __y) const { return __y; }
    00211 };
    00212
    00221
    00222 template <class _Arg1, class _Arg2>
    00223 struct project1st : public _Project1st<_Arg1, _Arg2> {};
    00224
    00226 template <class _Arg1, class _Arg2>
    00227 struct project2nd : public _Project2nd<_Arg1, _Arg2> {};
    00230 // extension documented next
    00231 template <class _Result>
    00232 struct _Constant_void_fun {
    00233   typedef _Result result_type;
    00234   result_type _M_val;
    00235
    00236   _Constant_void_fun(const result_type& __v) : _M_val(__v) {}
    00237   const result_type& operator()() const { return _M_val; }
    00238 };
    00239
    00240 template <class _Result, class _Argument>
    00241 struct _Constant_unary_fun {
    00242   typedef _Argument argument_type;
    00243   typedef  _Result  result_type;
    00244   result_type _M_val;
    00245
    00246   _Constant_unary_fun(const result_type& __v) : _M_val(__v) {}
    00247   const result_type& operator()(const _Argument&) const { return _M_val; }
    00248 };
    00249
    00250 template <class _Result, class _Arg1, class _Arg2>
    00251 struct _Constant_binary_fun {
    00252   typedef  _Arg1   first_argument_type;
    00253   typedef  _Arg2   second_argument_type;
    00254   typedef  _Result result_type;
    00255   _Result _M_val;
    00256
    00257   _Constant_binary_fun(const _Result& __v) : _M_val(__v) {}
    00258   const result_type& operator()(const _Arg1&, const _Arg2&) const {
    00259     return _M_val;
    00260   }
    00261 };
    00262
    00277
    00278 template <class _Result>
    00279 struct constant_void_fun : public _Constant_void_fun<_Result> {
    00280   constant_void_fun(const _Result& __v) : _Constant_void_fun<_Result>(__v) {}
    00281 };
    00282
    00284 template <class _Result,
    00285           class _Argument = _Result>
    00286 struct constant_unary_fun : public _Constant_unary_fun<_Result, _Argument>
    00287 {
    00288   constant_unary_fun(const _Result& __v)
    00289     : _Constant_unary_fun<_Result, _Argument>(__v) {}
    00290 };
    00291
    00293 template <class _Result,
    00294           class _Arg1 = _Result,
    00295           class _Arg2 = _Arg1>
    00296 struct constant_binary_fun
    00297   : public _Constant_binary_fun<_Result, _Arg1, _Arg2>
    00298 {
    00299   constant_binary_fun(const _Result& __v)
    00300     : _Constant_binary_fun<_Result, _Arg1, _Arg2>(__v) {}
    00301 };
    00302
    00304 template <class _Result>
    00305 inline constant_void_fun<_Result> constant0(const _Result& __val)
    00306 {
    00307   return constant_void_fun<_Result>(__val);
    00308 }
    00309
    00311 template <class _Result>
    00312 inline constant_unary_fun<_Result,_Result> constant1(const _Result& __val)
    00313 {
    00314   return constant_unary_fun<_Result,_Result>(__val);
    00315 }
    00316
    00318 template <class _Result>
    00319 inline constant_binary_fun<_Result,_Result,_Result>
    00320 constant2(const _Result& __val)
    00321 {
    00322   return constant_binary_fun<_Result,_Result,_Result>(__val);
    00323 }
    00332 class subtractive_rng : public unary_function<unsigned int, unsigned int> {
    00333 private:
    00334   unsigned int _M_table[55];
    00335   size_t _M_index1;
    00336   size_t _M_index2;
    00337 public:
    00339   unsigned int operator()(unsigned int __limit) {
    00340     _M_index1 = (_M_index1 + 1) % 55;
    00341     _M_index2 = (_M_index2 + 1) % 55;
    00342     _M_table[_M_index1] = _M_table[_M_index1] - _M_table[_M_index2];
    00343     return _M_table[_M_index1] % __limit;
    00344   }
    00345
    00346   void _M_initialize(unsigned int __seed)
    00347   {
    00348     unsigned int __k = 1;
    00349     _M_table[54] = __seed;
    00350     size_t __i;
    00351     for (__i = 0; __i < 54; __i++) {
    00352         size_t __ii = (21 * (__i + 1) % 55) - 1;
    00353         _M_table[__ii] = __k;
    00354         __k = __seed - __k;
    00355         __seed = _M_table[__ii];
    00356     }
    00357     for (int __loop = 0; __loop < 4; __loop++) {
    00358         for (__i = 0; __i < 55; __i++)
    00359             _M_table[__i] = _M_table[__i] - _M_table[(1 + __i + 30) % 55];
    00360     }
    00361     _M_index1 = 0;
    00362     _M_index2 = 31;
    00363   }
    00364
    00366   subtractive_rng(unsigned int __seed) { _M_initialize(__seed); }
    00368   subtractive_rng() { _M_initialize(161803398u); }
    00369 };
    00370
    00371 // Mem_fun adaptor helper functions mem_fun1 and mem_fun1_ref,
    00372 // provided for backward compatibility, they are no longer part of
    00373 // the C++ standard.
    00374
    00375 template <class _Ret, class _Tp, class _Arg>
    00376 inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg))
    00377   { return mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
    00378
    00379 template <class _Ret, class _Tp, class _Arg>
    00380 inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg) const)
    00381   { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); }
    00382
    00383 template <class _Ret, class _Tp, class _Arg>
    00384 inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun1_ref(_Ret (_Tp::*__f)(_Arg))
    00385   { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
    00386
    00387 template <class _Ret, class _Tp, class _Arg>
    00388 inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg>
    00389 mem_fun1_ref(_Ret (_Tp::*__f)(_Arg) const)
    00390   { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); }
    00391
    00392 } // namespace __gnu_cxx
    00393
    00394 #endif /* _EXT_FUNCTIONAL */
    00395