libstdc++

ext/functional
Go to the documentation of this file.
1 // Functional extensions -*- C++ -*-
2
3 // Copyright (C) 2002-2013 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
63 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
64 {
65 _GLIBCXX_BEGIN_NAMESPACE_VERSION
66
67 using std::size_t;
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
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.
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
106 * compose2 takes f, g1, and g2, and constructs the @c binary_compose
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>
185 struct identity
186 : 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
201 : public std::_Select1st<_Pair> {};
202
203 /// An \link SGIextensions SGI extension \endlink.
204 template <class _Pair>
205 struct select2nd
206 : public std::_Select2nd<_Pair> {};
207
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
295 * @c constant2 each take a @a result argument and construct variables of
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>
354 {
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;
369 }
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++)
387 _M_table[__i] = _M_table[__i] - _M_table[(1 + __i + 30) % 55];
388 }
389 _M_index1 = 0;
390 _M_index2 = 31;
391 }
392
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); }
425
426 _GLIBCXX_END_NAMESPACE_VERSION
427 } // namespace
428
429 #endif
430