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