libstdc++
ext/functional
Go to the documentation of this file.
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;
71  using std::mem_fun1_t;
73  using std::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>
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>
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>
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>
173  compose2(const _Operation1& __fn1, const _Operation2& __fn2,
174  const _Operation3& __fn3)
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>
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>
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>
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)
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  */
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.
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 
subtractive_rng()
Default ctor; initializes its state with some number you don't see.
Definition: ext/functional:395
One of the adaptors for member pointers.
Definition: stl_function.h:632
An SGI extension .
Definition: ext/functional:126
An SGI extension .
Definition: ext/functional:204
One of the math functors.
Definition: stl_function.h:141
subtractive_rng(unsigned int __seed)
Ctor allowing you to initialize the seed.
Definition: ext/functional:391
An SGI extension .
Definition: ext/functional:238
One of the adaptors for member pointers.
Definition: stl_function.h:668
One of the adaptors for member pointers.
Definition: stl_function.h:614
One of the math functors.
Definition: stl_function.h:159
constant_unary_fun< _Result, _Result > constant1(const _Result &__val)
An SGI extension .
Definition: ext/functional:333
An SGI extension .
Definition: ext/functional:200
unsigned int operator()(unsigned int __limit)
Returns a number less than the argument.
Definition: ext/functional:360
constant_binary_fun< _Result, _Result, _Result > constant2(const _Result &__val)
An SGI extension .
Definition: ext/functional:339
binary_compose< _Operation1, _Operation2, _Operation3 > compose2(const _Operation1 &__fn1, const _Operation2 &__fn2, const _Operation3 &__fn3)
An SGI extension .
Definition: ext/functional:173
An SGI extension .
Definition: ext/functional:300
An SGI extension .
Definition: ext/functional:234
An SGI extension .
Definition: ext/functional:151
One of the adaptors for member pointers.
Definition: stl_function.h:650
unary_compose< _Operation1, _Operation2 > compose1(const _Operation1 &__fn1, const _Operation2 &__fn2)
An SGI extension .
Definition: ext/functional:146
constant_void_fun< _Result > constant0(const _Result &__val)
An SGI extension .
Definition: ext/functional:327