functional revision 97403
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 68namespace __gnu_cxx 69{ 70using std::unary_function; 71using std::binary_function; 72using std::mem_fun1_t; 73using std::const_mem_fun1_t; 74using std::mem_fun1_ref_t; 75using 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. 87template <class _Tp> inline _Tp identity_element(std::plus<_Tp>) { 88 return _Tp(0); 89} 90/// An \link SGIextensions SGI extension \endlink. 91template <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. 123template <class _Operation1, class _Operation2> 124class unary_compose 125 : public unary_function<typename _Operation2::argument_type, 126 typename _Operation1::result_type> 127{ 128protected: 129 _Operation1 _M_fn1; 130 _Operation2 _M_fn2; 131public: 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. 141template <class _Operation1, class _Operation2> 142inline unary_compose<_Operation1,_Operation2> 143compose1(const _Operation1& __fn1, const _Operation2& __fn2) 144{ 145 return unary_compose<_Operation1,_Operation2>(__fn1, __fn2); 146} 147 148/// An \link SGIextensions SGI extension \endlink. 149template <class _Operation1, class _Operation2, class _Operation3> 150class binary_compose 151 : public unary_function<typename _Operation2::argument_type, 152 typename _Operation1::result_type> { 153protected: 154 _Operation1 _M_fn1; 155 _Operation2 _M_fn2; 156 _Operation3 _M_fn3; 157public: 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. 168template <class _Operation1, class _Operation2, class _Operation3> 169inline binary_compose<_Operation1, _Operation2, _Operation3> 170compose2(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*/ 184template <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. 197template <class _Pair> struct select1st : public std::_Select1st<_Pair> {}; 198/// An \link SGIextensions SGI extension \endlink. 199template <class _Pair> struct select2nd : public std::_Select2nd<_Pair> {}; 200/** @} */ 201 202// extension documented next 203template <class _Arg1, class _Arg2> 204struct _Project1st : public binary_function<_Arg1, _Arg2, _Arg1> { 205 _Arg1 operator()(const _Arg1& __x, const _Arg2&) const { return __x; } 206}; 207 208template <class _Arg1, class _Arg2> 209struct _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. 222template <class _Arg1, class _Arg2> 223struct project1st : public _Project1st<_Arg1, _Arg2> {}; 224 225/// An \link SGIextensions SGI extension \endlink. 226template <class _Arg1, class _Arg2> 227struct project2nd : public _Project2nd<_Arg1, _Arg2> {}; 228/** @} */ 229 230// extension documented next 231template <class _Result> 232struct _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 240template <class _Result, class _Argument> 241struct _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 250template <class _Result, class _Arg1, class _Arg2> 251struct _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. 278template <class _Result> 279struct 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. 284template <class _Result, 285 class _Argument = _Result> 286struct 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. 293template <class _Result, 294 class _Arg1 = _Result, 295 class _Arg2 = _Arg1> 296struct 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. 304template <class _Result> 305inline 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. 311template <class _Result> 312inline 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. 318template <class _Result> 319inline constant_binary_fun<_Result,_Result,_Result> 320constant2(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*/ 332class subtractive_rng : public unary_function<unsigned int, unsigned int> { 333private: 334 unsigned int _M_table[55]; 335 size_t _M_index1; 336 size_t _M_index2; 337public: 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 375template <class _Ret, class _Tp, class _Arg> 376inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg)) 377 { return mem_fun1_t<_Ret,_Tp,_Arg>(__f); } 378 379template <class _Ret, class _Tp, class _Arg> 380inline 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 383template <class _Ret, class _Tp, class _Arg> 384inline 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 387template <class _Ret, class _Tp, class _Arg> 388inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg> 389mem_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