libstdc++
ext/functional
Go to the documentation of this file.
1 // Functional extensions -*- C++ -*-
2 
3 // Copyright (C) 2002-2024 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 <bits/requires_hosted.h> // GNU extensions are currently omitted
62 
63 #include <functional>
64 
65 namespace __gnu_cxx _GLIBCXX_VISIBILITY(default)
66 {
67 _GLIBCXX_BEGIN_NAMESPACE_VERSION
68 
69 #pragma GCC diagnostic push
70 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
71 
72  /** The @c identity_element functions are not part of the C++
73  * standard; SGI provided them as an extension. Its argument is an
74  * operation, and its return value is the identity element for that
75  * operation. It is overloaded for addition and multiplication,
76  * and you can overload it for your own nefarious operations.
77  *
78  * @addtogroup SGIextensions
79  * @{
80  */
81  /// An \link SGIextensions SGI extension \endlink.
82  template <class _Tp>
83  inline _Tp
84  identity_element(std::plus<_Tp>)
85  { return _Tp(0); }
86 
87  /// An \link SGIextensions SGI extension \endlink.
88  template <class _Tp>
89  inline _Tp
90  identity_element(std::multiplies<_Tp>)
91  { return _Tp(1); }
92  /** @} */
93 
94  /** As an extension to the binders, SGI provided composition functors and
95  * wrapper functions to aid in their creation. The @c unary_compose
96  * functor is constructed from two functions/functors, @c f and @c g.
97  * Calling @c operator() with a single argument @c x returns @c f(g(x)).
98  * The function @c compose1 takes the two functions and constructs a
99  * @c unary_compose variable for you.
100  *
101  * @c binary_compose is constructed from three functors, @c f, @c g1,
102  * and @c g2. Its @c operator() returns @c f(g1(x),g2(x)). The function
103  * compose2 takes f, g1, and g2, and constructs the @c binary_compose
104  * instance for you. For example, if @c f returns an int, then
105  * \code
106  * int answer = (compose2(f,g1,g2))(x);
107  * \endcode
108  * is equivalent to
109  * \code
110  * int temp1 = g1(x);
111  * int temp2 = g2(x);
112  * int answer = f(temp1,temp2);
113  * \endcode
114  * But the first form is more compact, and can be passed around as a
115  * functor to other algorithms.
116  *
117  * @addtogroup SGIextensions
118  * @{
119  */
120  /// An \link SGIextensions SGI extension \endlink.
121  template <class _Operation1, class _Operation2>
122  class unary_compose
123  : public std::unary_function<typename _Operation2::argument_type,
124  typename _Operation1::result_type>
125  {
126  protected:
127  _Operation1 _M_fn1;
128  _Operation2 _M_fn2;
129 
130  public:
131  unary_compose(const _Operation1& __x, const _Operation2& __y)
132  : _M_fn1(__x), _M_fn2(__y) {}
133 
134  typename _Operation1::result_type
135  operator()(const typename _Operation2::argument_type& __x) const
136  { return _M_fn1(_M_fn2(__x)); }
137  };
138 
139  /// An \link SGIextensions SGI extension \endlink.
140  template <class _Operation1, class _Operation2>
141  inline unary_compose<_Operation1, _Operation2>
142  compose1(const _Operation1& __fn1, const _Operation2& __fn2)
143  { return unary_compose<_Operation1,_Operation2>(__fn1, __fn2); }
144 
145  /// An \link SGIextensions SGI extension \endlink.
146  template <class _Operation1, class _Operation2, class _Operation3>
147  class binary_compose
148  : public std::unary_function<typename _Operation2::argument_type,
149  typename _Operation1::result_type>
150  {
151  protected:
152  _Operation1 _M_fn1;
153  _Operation2 _M_fn2;
154  _Operation3 _M_fn3;
155 
156  public:
157  binary_compose(const _Operation1& __x, const _Operation2& __y,
158  const _Operation3& __z)
159  : _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { }
160 
161  typename _Operation1::result_type
162  operator()(const typename _Operation2::argument_type& __x) const
163  { return _M_fn1(_M_fn2(__x), _M_fn3(__x)); }
164  };
165 
166  /// An \link SGIextensions SGI extension \endlink.
167  template <class _Operation1, class _Operation2, class _Operation3>
168  inline binary_compose<_Operation1, _Operation2, _Operation3>
169  compose2(const _Operation1& __fn1, const _Operation2& __fn2,
170  const _Operation3& __fn3)
171  { return binary_compose<_Operation1, _Operation2, _Operation3>
172  (__fn1, __fn2, __fn3); }
173  /** @} */
174 
175  /** As an extension, SGI provided a functor called @c identity. When a
176  * functor is required but no operations are desired, this can be used as a
177  * pass-through. Its @c operator() returns its argument unchanged.
178  *
179  * @addtogroup SGIextensions
180  */
181  template <class _Tp>
182  struct identity
183  : public std::_Identity<_Tp> {};
184 
185  /** @c select1st and @c select2nd are extensions provided by SGI. Their
186  * @c operator()s
187  * take a @c std::pair as an argument, and return either the first member
188  * or the second member, respectively. They can be used (especially with
189  * the composition functors) to @a strip data from a sequence before
190  * performing the remainder of an algorithm.
191  *
192  * @addtogroup SGIextensions
193  * @{
194  */
195  /// An \link SGIextensions SGI extension \endlink.
196  template <class _Pair>
197  struct select1st
198  : public std::_Select1st<_Pair> {};
199 
200  /// An \link SGIextensions SGI extension \endlink.
201  template <class _Pair>
202  struct select2nd
203  : public std::_Select2nd<_Pair> {};
204 
205  /** @} */
206 
207  // extension documented next
208  template <class _Arg1, class _Arg2>
209  struct _Project1st : public std::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 std::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 std::unary_function<unsigned int, unsigned int>
351  {
352  private:
353  unsigned int _M_table[55];
354  std::size_t _M_index1;
355  std::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  std::size_t __i;
374  for (__i = 0; __i < 54; __i++)
375  {
376  std::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 std::mem_fun1_t<_Ret, _Tp, _Arg>
405  mem_fun1(_Ret (_Tp::*__f)(_Arg))
406  { return std::mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
407 
408  template <class _Ret, class _Tp, class _Arg>
409  inline std::const_mem_fun1_t<_Ret, _Tp, _Arg>
410  mem_fun1(_Ret (_Tp::*__f)(_Arg) const)
411  { return std::const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); }
412 
413  template <class _Ret, class _Tp, class _Arg>
414  inline std::mem_fun1_ref_t<_Ret, _Tp, _Arg>
415  mem_fun1_ref(_Ret (_Tp::*__f)(_Arg))
416  { return std::mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
417 
418  template <class _Ret, class _Tp, class _Arg>
419  inline std::const_mem_fun1_ref_t<_Ret, _Tp, _Arg>
420  mem_fun1_ref(_Ret (_Tp::*__f)(_Arg) const)
421  { return std::const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); }
422 
423 #pragma GCC diagnostic pop
424 
425 _GLIBCXX_END_NAMESPACE_VERSION
426 } // namespace
427 
428 #endif
429