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