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