From 01b0d4b85a401d257d9fe091e6647800b2ccbf00 Mon Sep 17 00:00:00 2001 From: Paolo Carlini Date: Thu, 3 Jan 2002 20:02:18 +0100 Subject: [PATCH] stl_numeric.h (power + helpers, iota): Move to... 2002-01-02 Paolo Carlini * include/bits/stl_numeric.h (power + helpers, iota): Move to... * include/ext/numeric: ...here, new file. * include/bits/stl_function.h (identity_element, unary_compose, binary_compose, compose1, compose2, identity, select1st, select2nd, project1st + helper, project2nd + helper, constant_void_fun + helper, constant_unary_fun + helper, costant_binary_fun + helper, constant0, constant1, constant2, subtractive_rng, mem_fun1, mem_fun1_ref): Move to... * include/ext/functional: ...here, new file. * include/Makefile.am (ext_headers): Add new files. * include/Makefile.in: Regenerate. * testsuite/ext/headers.cc: Include and . * include/backward/algo.h: Include , tweak. * include/backward/function.h: Include , tweak. * include/ext/ropeimpl.h: Include . From-SVN: r48519 --- libstdc++-v3/ChangeLog | 19 ++ libstdc++-v3/include/Makefile.am | 2 + libstdc++-v3/include/Makefile.in | 2 + libstdc++-v3/include/backward/algo.h | 7 +- libstdc++-v3/include/backward/function.h | 41 +-- libstdc++-v3/include/bits/stl_function.h | 317 +----------------- libstdc++-v3/include/bits/stl_numeric.h | 61 ---- libstdc++-v3/include/ext/functional | 389 +++++++++++++++++++++++ libstdc++-v3/include/ext/numeric | 130 ++++++++ libstdc++-v3/include/ext/ropeimpl.h | 1 + libstdc++-v3/testsuite/ext/headers.cc | 2 + 11 files changed, 573 insertions(+), 398 deletions(-) create mode 100644 libstdc++-v3/include/ext/functional create mode 100644 libstdc++-v3/include/ext/numeric diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog index f1f970d4740..bead9f702cf 100644 --- a/libstdc++-v3/ChangeLog +++ b/libstdc++-v3/ChangeLog @@ -1,3 +1,22 @@ +2002-01-03 Paolo Carlini + + * include/bits/stl_numeric.h (power + helpers, iota): Move to... + * include/ext/numeric: ...here, new file. + * include/bits/stl_function.h (identity_element, unary_compose, + binary_compose, compose1, compose2, identity, select1st, + select2nd, project1st + helper, project2nd + helper, + constant_void_fun + helper, constant_unary_fun + helper, + costant_binary_fun + helper, constant0, constant1, constant2, + subtractive_rng, mem_fun1, mem_fun1_ref): Move to... + * include/ext/functional: ...here, new file. + * include/Makefile.am (ext_headers): Add new files. + * include/Makefile.in: Regenerate. + * testsuite/ext/headers.cc: Include and + . + * include/backward/algo.h: Include , tweak. + * include/backward/function.h: Include , tweak. + * include/ext/ropeimpl.h: Include . + Thu Jan 3 11:05:41 2002 Jeffrey A Law (law@redhat.com) * config/os/hpux/bits/os_defines.h: Prefix __strtoll and diff --git a/libstdc++-v3/include/Makefile.am b/libstdc++-v3/include/Makefile.am index 42119305c36..a4a4e44c87e 100644 --- a/libstdc++-v3/include/Makefile.am +++ b/libstdc++-v3/include/Makefile.am @@ -173,10 +173,12 @@ ext_srcdir = ${glibcpp_srcdir}/include/ext ext_builddir = ./ext ext_headers = \ ${ext_srcdir}/algorithm \ + ${ext_srcdir}/functional \ ${ext_srcdir}/hash_map \ ${ext_srcdir}/hash_set \ ${ext_srcdir}/iterator \ ${ext_srcdir}/memory \ + ${ext_srcdir}/numeric \ ${ext_srcdir}/rope \ ${ext_srcdir}/ropeimpl.h \ ${ext_srcdir}/slist \ diff --git a/libstdc++-v3/include/Makefile.in b/libstdc++-v3/include/Makefile.in index abde46d4687..46d1093e67a 100644 --- a/libstdc++-v3/include/Makefile.in +++ b/libstdc++-v3/include/Makefile.in @@ -303,10 +303,12 @@ ext_srcdir = ${glibcpp_srcdir}/include/ext ext_builddir = ./ext ext_headers = \ ${ext_srcdir}/algorithm \ + ${ext_srcdir}/functional \ ${ext_srcdir}/hash_map \ ${ext_srcdir}/hash_set \ ${ext_srcdir}/iterator \ ${ext_srcdir}/memory \ + ${ext_srcdir}/numeric \ ${ext_srcdir}/rope \ ${ext_srcdir}/ropeimpl.h \ ${ext_srcdir}/slist \ diff --git a/libstdc++-v3/include/backward/algo.h b/libstdc++-v3/include/backward/algo.h index 185ab7811c3..a3554a8f8d0 100644 --- a/libstdc++-v3/include/backward/algo.h +++ b/libstdc++-v3/include/backward/algo.h @@ -63,6 +63,7 @@ #include #include #include +#include // Names from using std::for_each; @@ -128,8 +129,6 @@ using std::accumulate; using std::inner_product; using std::partial_sum; using std::adjacent_difference; -using std::power; -using std::iota; // Names from ext/algorithm using __gnu_cxx::random_sample; @@ -139,6 +138,10 @@ using __gnu_cxx::is_heap; using __gnu_cxx::count; // Extension returning void using __gnu_cxx::count_if; // Extension returning void +// Names from ext/numeric +using __gnu_cxx::power; +using __gnu_cxx::iota; + #endif /* _CPP_BACKWARD_ALGO_H */ // Local Variables: diff --git a/libstdc++-v3/include/backward/function.h b/libstdc++-v3/include/backward/function.h index 219126d8825..bc96f49ffab 100644 --- a/libstdc++-v3/include/backward/function.h +++ b/libstdc++-v3/include/backward/function.h @@ -60,6 +60,7 @@ #include #include #include +#include // Names from stl_function.h using std::unary_function; @@ -68,7 +69,6 @@ using std::plus; using std::minus; using std::multiplies; using std::divides; -using std::identity_element; using std::modulus; using std::negate; using std::equal_to; @@ -88,25 +88,9 @@ using std::binder1st; using std::binder2nd; using std::bind1st; using std::bind2nd; -using std::unary_compose; -using std::binary_compose; -using std::compose1; -using std::compose2; using std::pointer_to_unary_function; using std::pointer_to_binary_function; using std::ptr_fun; -using std::identity; -using std::select1st; -using std::select2nd; -using std::project1st; -using std::project2nd; -using std::constant_void_fun; -using std::constant_unary_fun; -using std::constant_binary_fun; -using std::constant0; -using std::constant1; -using std::constant2; -using std::subtractive_rng; using std::mem_fun_t; using std::const_mem_fun_t; using std::mem_fun_ref_t; @@ -117,8 +101,27 @@ using std::mem_fun1_ref_t; using std::const_mem_fun1_ref_t; using std::mem_fun; using std::mem_fun_ref; -using std::mem_fun1; -using std::mem_fun1_ref; + +// Names from ext/functional +using __gnu_cxx::identity_element; +using __gnu_cxx::unary_compose; +using __gnu_cxx::binary_compose; +using __gnu_cxx::compose1; +using __gnu_cxx::compose2; +using __gnu_cxx::identity; +using __gnu_cxx::select1st; +using __gnu_cxx::select2nd; +using __gnu_cxx::project1st; +using __gnu_cxx::project2nd; +using __gnu_cxx::constant_void_fun; +using __gnu_cxx::constant_unary_fun; +using __gnu_cxx::constant_binary_fun; +using __gnu_cxx::constant0; +using __gnu_cxx::constant1; +using __gnu_cxx::constant2; +using __gnu_cxx::subtractive_rng; +using __gnu_cxx::mem_fun1; +using __gnu_cxx::mem_fun1_ref; #endif /* _CPP_BACKWARD_FUNCTION_H */ diff --git a/libstdc++-v3/include/bits/stl_function.h b/libstdc++-v3/include/bits/stl_function.h index d2a53685630..a017189d493 100644 --- a/libstdc++-v3/include/bits/stl_function.h +++ b/libstdc++-v3/include/bits/stl_function.h @@ -162,25 +162,6 @@ struct negate : public unary_function<_Tp,_Tp> }; /** @} */ -/** The @c identity_element functions are not part of the C++ standard; SGI - * provided them as an extension. Its argument is an operation, and its - * return value is the identity element for that operation. It is overloaded - * for addition and multiplication, and you can overload it for your own - * nefarious operations. - * - * @addtogroup SGIextensions - * @{ -*/ -/// An \link SGIextensions SGI extension \endlink. -template inline _Tp identity_element(plus<_Tp>) { - return _Tp(0); -} -/// An \link SGIextensions SGI extension \endlink. -template inline _Tp identity_element(multiplies<_Tp>) { - return _Tp(1); -} -/** @} */ - // 20.3.3 comparisons /** @defgroup s20_3_3_comparisons Comparison Classes * The library provides six wrapper functors for all the basic comparisons @@ -433,88 +414,6 @@ bind2nd(const _Operation& __fn, const _Tp& __x) } /** @} */ -/** As an extension to the binders, SGI provided composition functors and - * wrapper functions to aid in their creation. The @c unary_compose - * functor is constructed from two functions/functors, @c f and @c g. - * Calling @c operator() with a single argument @c x returns @c f(g(x)). - * The function @c compose1 takes the two functions and constructs a - * @c unary_compose variable for you. - * - * @c binary_compose is constructed from three functors, @c f, @c g1, - * and @c g2. Its @c operator() returns @c f(g1(x),g2(x)). The function - * @compose2 takes f, g1, and g2, and constructs the @c binary_compose - * instance for you. For example, if @c f returns an int, then - * \code - * int answer = (compose2(f,g1,g2))(x); - * \endcode - * is equivalent to - * \code - * int temp1 = g1(x); - * int temp2 = g2(x); - * int answer = f(temp1,temp2); - * \endcode - * But the first form is more compact, and can be passed around as a - * functor to other algorithms. - * - * @addtogroup SGIextensions - * @{ -*/ -/// An \link SGIextensions SGI extension \endlink. -template -class unary_compose - : public unary_function -{ -protected: - _Operation1 _M_fn1; - _Operation2 _M_fn2; -public: - unary_compose(const _Operation1& __x, const _Operation2& __y) - : _M_fn1(__x), _M_fn2(__y) {} - typename _Operation1::result_type - operator()(const typename _Operation2::argument_type& __x) const { - return _M_fn1(_M_fn2(__x)); - } -}; - -/// An \link SGIextensions SGI extension \endlink. -template -inline unary_compose<_Operation1,_Operation2> -compose1(const _Operation1& __fn1, const _Operation2& __fn2) -{ - return unary_compose<_Operation1,_Operation2>(__fn1, __fn2); -} - -/// An \link SGIextensions SGI extension \endlink. -template -class binary_compose - : public unary_function { -protected: - _Operation1 _M_fn1; - _Operation2 _M_fn2; - _Operation3 _M_fn3; -public: - binary_compose(const _Operation1& __x, const _Operation2& __y, - const _Operation3& __z) - : _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { } - typename _Operation1::result_type - operator()(const typename _Operation2::argument_type& __x) const { - return _M_fn1(_M_fn2(__x), _M_fn3(__x)); - } -}; - -/// An \link SGIextensions SGI extension \endlink. -template -inline binary_compose<_Operation1, _Operation2, _Operation3> -compose2(const _Operation1& __fn1, const _Operation2& __fn2, - const _Operation3& __fn3) -{ - return binary_compose<_Operation1,_Operation2,_Operation3> - (__fn1, __fn2, __fn3); -} -/** @} */ - // 20.3.7 adaptors pointers functions /** @defgroup s20_3_7_adaptors Adaptors for pointers to functions * The advantage of function objects over pointers to functions is that @@ -576,23 +475,12 @@ ptr_fun(_Result (*__x)(_Arg1, _Arg2)) { } /** @} */ - -// extension documented next template struct _Identity : public unary_function<_Tp,_Tp> { _Tp& operator()(_Tp& __x) const { return __x; } const _Tp& operator()(const _Tp& __x) const { return __x; } }; -/** As an extension, SGI provided a functor called @c identity. When a - * functor is required but no operations are desired, this can be used as a - * pass-through. Its @c operator() returns its argument unchanged. - * - * @addtogroup SGIextensions -*/ -template struct identity : public _Identity<_Tp> {}; - -// extension documented next template struct _Select1st : public unary_function<_Pair, typename _Pair::first_type> { typename _Pair::first_type& operator()(_Pair& __x) const { @@ -614,191 +502,6 @@ struct _Select2nd : public unary_function<_Pair, typename _Pair::second_type> } }; -/** @c select1st and @c select2nd are extensions provided by SGI. Their - * @c operator()s - * take a @c std::pair as an argument, and return either the first member - * or the second member, respectively. They can be used (especially with - * the composition functors) to "strip" data from a sequence before - * performing the remainder of an algorithm. - * - * @addtogroup SGIextensions - * @{ -*/ -/// An \link SGIextensions SGI extension \endlink. -template struct select1st : public _Select1st<_Pair> {}; -/// An \link SGIextensions SGI extension \endlink. -template struct select2nd : public _Select2nd<_Pair> {}; -/** @} */ - -// extension documented next -template -struct _Project1st : public binary_function<_Arg1, _Arg2, _Arg1> { - _Arg1 operator()(const _Arg1& __x, const _Arg2&) const { return __x; } -}; - -template -struct _Project2nd : public binary_function<_Arg1, _Arg2, _Arg2> { - _Arg2 operator()(const _Arg1&, const _Arg2& __y) const { return __y; } -}; - -/** The @c operator() of the @c project1st functor takes two arbitrary - * arguments and returns the first one, while @c project2nd returns the - * second one. They are extensions provided by SGI. - * - * @addtogroup SGIextensions - * @{ -*/ -/// An \link SGIextensions SGI extension \endlink. -template -struct project1st : public _Project1st<_Arg1, _Arg2> {}; - -/// An \link SGIextensions SGI extension \endlink. -template -struct project2nd : public _Project2nd<_Arg1, _Arg2> {}; -/** @} */ - -// extension documented next -template -struct _Constant_void_fun { - typedef _Result result_type; - result_type _M_val; - - _Constant_void_fun(const result_type& __v) : _M_val(__v) {} - const result_type& operator()() const { return _M_val; } -}; - -template -struct _Constant_unary_fun { - typedef _Argument argument_type; - typedef _Result result_type; - result_type _M_val; - - _Constant_unary_fun(const result_type& __v) : _M_val(__v) {} - const result_type& operator()(const _Argument&) const { return _M_val; } -}; - -template -struct _Constant_binary_fun { - typedef _Arg1 first_argument_type; - typedef _Arg2 second_argument_type; - typedef _Result result_type; - _Result _M_val; - - _Constant_binary_fun(const _Result& __v) : _M_val(__v) {} - const result_type& operator()(const _Arg1&, const _Arg2&) const { - return _M_val; - } -}; - -/** These three functors are each constructed from a single arbitrary - * variable/value. Later, their @c operator()s completely ignore any - * arguments passed, and return the stored value. - * - @c constant_void_fun's @c operator() takes no arguments - * - @c constant_unary_fun's @c operator() takes one argument (ignored) - * - @c constant_binary_fun's @c operator() takes two arguments (ignored) - * - * The helper creator functions @c constant0, @c constant1, and - * @c constant2 each take a "result" argument and construct variables of - * the appropriate functor type. - * - * @addtogroup SGIextensions - * @{ -*/ -/// An \link SGIextensions SGI extension \endlink. -template -struct constant_void_fun : public _Constant_void_fun<_Result> { - constant_void_fun(const _Result& __v) : _Constant_void_fun<_Result>(__v) {} -}; - -/// An \link SGIextensions SGI extension \endlink. -template -struct constant_unary_fun : public _Constant_unary_fun<_Result, _Argument> -{ - constant_unary_fun(const _Result& __v) - : _Constant_unary_fun<_Result, _Argument>(__v) {} -}; - -/// An \link SGIextensions SGI extension \endlink. -template -struct constant_binary_fun - : public _Constant_binary_fun<_Result, _Arg1, _Arg2> -{ - constant_binary_fun(const _Result& __v) - : _Constant_binary_fun<_Result, _Arg1, _Arg2>(__v) {} -}; - -/// An \link SGIextensions SGI extension \endlink. -template -inline constant_void_fun<_Result> constant0(const _Result& __val) -{ - return constant_void_fun<_Result>(__val); -} - -/// An \link SGIextensions SGI extension \endlink. -template -inline constant_unary_fun<_Result,_Result> constant1(const _Result& __val) -{ - return constant_unary_fun<_Result,_Result>(__val); -} - -/// An \link SGIextensions SGI extension \endlink. -template -inline constant_binary_fun<_Result,_Result,_Result> -constant2(const _Result& __val) -{ - return constant_binary_fun<_Result,_Result,_Result>(__val); -} -/** @} */ - -/** The @c subtractive_rng class is documented on - * SGI's site. - * Note that this code assumes that @c int is 32 bits. - * - * @ingroup SGIextensions -*/ -class subtractive_rng : public unary_function { -private: - unsigned int _M_table[55]; - size_t _M_index1; - size_t _M_index2; -public: - /// Returns a number less than the argument. - unsigned int operator()(unsigned int __limit) { - _M_index1 = (_M_index1 + 1) % 55; - _M_index2 = (_M_index2 + 1) % 55; - _M_table[_M_index1] = _M_table[_M_index1] - _M_table[_M_index2]; - return _M_table[_M_index1] % __limit; - } - - void _M_initialize(unsigned int __seed) - { - unsigned int __k = 1; - _M_table[54] = __seed; - size_t __i; - for (__i = 0; __i < 54; __i++) { - size_t __ii = (21 * (__i + 1) % 55) - 1; - _M_table[__ii] = __k; - __k = __seed - __k; - __seed = _M_table[__ii]; - } - for (int __loop = 0; __loop < 4; __loop++) { - for (__i = 0; __i < 55; __i++) - _M_table[__i] = _M_table[__i] - _M_table[(1 + __i + 30) % 55]; - } - _M_index1 = 0; - _M_index2 = 31; - } - - /// Ctor allowing you to initialize the seed. - subtractive_rng(unsigned int __seed) { _M_initialize(__seed); } - /// Default ctor; initializes its state with some number you don't see. - subtractive_rng() { _M_initialize(161803398u); } -}; - - // 20.3.8 adaptors pointers members /** @defgroup s20_3_8_memadaptors Adaptors for pointers to members * There are a total of 16 = 2^4 function objects in this family. @@ -989,9 +692,7 @@ private: // Mem_fun adaptor helper functions. There are only two: -// mem_fun and mem_fun_ref. (mem_fun1 and mem_fun1_ref -// are provided for backward compatibility, but they are no longer -// part of the C++ standard.) +// mem_fun and mem_fun_ref. template inline mem_fun_t<_Ret,_Tp> mem_fun(_Ret (_Tp::*__f)()) @@ -1026,22 +727,6 @@ inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); } -template -inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg)) - { return mem_fun1_t<_Ret,_Tp,_Arg>(__f); } - -template -inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg) const) - { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); } - -template -inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun1_ref(_Ret (_Tp::*__f)(_Arg)) - { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); } - -template -inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg> -mem_fun1_ref(_Ret (_Tp::*__f)(_Arg) const) - { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); } /** @} */ } // namespace std diff --git a/libstdc++-v3/include/bits/stl_numeric.h b/libstdc++-v3/include/bits/stl_numeric.h index 9bceee0a750..23f2bcc4512 100644 --- a/libstdc++-v3/include/bits/stl_numeric.h +++ b/libstdc++-v3/include/bits/stl_numeric.h @@ -206,67 +206,6 @@ namespace std return ++__result; } - // Returns __x ** __n, where __n >= 0. _Note that "multiplication" - // is required to be associative, but not necessarily commutative. - - - template - _Tp - __power(_Tp __x, _Integer __n, _MonoidOperation __monoid_op) - { - if (__n == 0) - return identity_element(__monoid_op); - else { - while ((__n & 1) == 0) { - __n >>= 1; - __x = __monoid_op(__x, __x); - } - - _Tp __result = __x; - __n >>= 1; - while (__n != 0) { - __x = __monoid_op(__x, __x); - if ((__n & 1) != 0) - __result = __monoid_op(__result, __x); - __n >>= 1; - } - return __result; - } - } - - template - inline _Tp - __power(_Tp __x, _Integer __n) - { return __power(__x, __n, multiplies<_Tp>()); } - - // Alias for the internal name __power. Note that power is an extension, - // not part of the C++ standard. - - template - inline _Tp - power(_Tp __x, _Integer __n, _MonoidOperation __monoid_op) - { return __power(__x, __n, __monoid_op); } - - template - inline _Tp - power(_Tp __x, _Integer __n) - { return __power(__x, __n); } - - // iota is not part of the C++ standard. It is an extension. - - template - void - iota(_ForwardIter __first, _ForwardIter __last, _Tp __value) - { - // concept requirements - __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>) - __glibcpp_function_requires(_ConvertibleConcept<_Tp, - typename iterator_traits<_ForwardIter>::value_type>) - - while (__first != __last) - *__first++ = __value++; - } - } // namespace std #endif /* _CPP_BITS_STL_NUMERIC_H */ diff --git a/libstdc++-v3/include/ext/functional b/libstdc++-v3/include/ext/functional new file mode 100644 index 00000000000..8a171615553 --- /dev/null +++ b/libstdc++-v3/include/ext/functional @@ -0,0 +1,389 @@ +// Functional extensions -*- C++ -*- + +// Copyright (C) 2002 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +#ifndef _EXT_FUNCTIONAL +#define _EXT_FUNCTIONAL + +#pragma GCC system_header +#include + +namespace __gnu_cxx +{ +using std::unary_function; +using std::binary_function; +using std::mem_fun1_t; +using std::const_mem_fun1_t; +using std::mem_fun1_ref_t; +using std::const_mem_fun1_ref_t; + +/** The @c identity_element functions are not part of the C++ standard; SGI + * provided them as an extension. Its argument is an operation, and its + * return value is the identity element for that operation. It is overloaded + * for addition and multiplication, and you can overload it for your own + * nefarious operations. + * + * @addtogroup SGIextensions + * @{ +*/ +/// An \link SGIextensions SGI extension \endlink. +template inline _Tp identity_element(std::plus<_Tp>) { + return _Tp(0); +} +/// An \link SGIextensions SGI extension \endlink. +template inline _Tp identity_element(std::multiplies<_Tp>) { + return _Tp(1); +} +/** @} */ + +/** As an extension to the binders, SGI provided composition functors and + * wrapper functions to aid in their creation. The @c unary_compose + * functor is constructed from two functions/functors, @c f and @c g. + * Calling @c operator() with a single argument @c x returns @c f(g(x)). + * The function @c compose1 takes the two functions and constructs a + * @c unary_compose variable for you. + * + * @c binary_compose is constructed from three functors, @c f, @c g1, + * and @c g2. Its @c operator() returns @c f(g1(x),g2(x)). The function + * @compose2 takes f, g1, and g2, and constructs the @c binary_compose + * instance for you. For example, if @c f returns an int, then + * \code + * int answer = (compose2(f,g1,g2))(x); + * \endcode + * is equivalent to + * \code + * int temp1 = g1(x); + * int temp2 = g2(x); + * int answer = f(temp1,temp2); + * \endcode + * But the first form is more compact, and can be passed around as a + * functor to other algorithms. + * + * @addtogroup SGIextensions + * @{ +*/ +/// An \link SGIextensions SGI extension \endlink. +template +class unary_compose + : public unary_function +{ +protected: + _Operation1 _M_fn1; + _Operation2 _M_fn2; +public: + unary_compose(const _Operation1& __x, const _Operation2& __y) + : _M_fn1(__x), _M_fn2(__y) {} + typename _Operation1::result_type + operator()(const typename _Operation2::argument_type& __x) const { + return _M_fn1(_M_fn2(__x)); + } +}; + +/// An \link SGIextensions SGI extension \endlink. +template +inline unary_compose<_Operation1,_Operation2> +compose1(const _Operation1& __fn1, const _Operation2& __fn2) +{ + return unary_compose<_Operation1,_Operation2>(__fn1, __fn2); +} + +/// An \link SGIextensions SGI extension \endlink. +template +class binary_compose + : public unary_function { +protected: + _Operation1 _M_fn1; + _Operation2 _M_fn2; + _Operation3 _M_fn3; +public: + binary_compose(const _Operation1& __x, const _Operation2& __y, + const _Operation3& __z) + : _M_fn1(__x), _M_fn2(__y), _M_fn3(__z) { } + typename _Operation1::result_type + operator()(const typename _Operation2::argument_type& __x) const { + return _M_fn1(_M_fn2(__x), _M_fn3(__x)); + } +}; + +/// An \link SGIextensions SGI extension \endlink. +template +inline binary_compose<_Operation1, _Operation2, _Operation3> +compose2(const _Operation1& __fn1, const _Operation2& __fn2, + const _Operation3& __fn3) +{ + return binary_compose<_Operation1,_Operation2,_Operation3> + (__fn1, __fn2, __fn3); +} +/** @} */ + +/** As an extension, SGI provided a functor called @c identity. When a + * functor is required but no operations are desired, this can be used as a + * pass-through. Its @c operator() returns its argument unchanged. + * + * @addtogroup SGIextensions +*/ +template struct identity : public std::_Identity<_Tp> {}; + +/** @c select1st and @c select2nd are extensions provided by SGI. Their + * @c operator()s + * take a @c std::pair as an argument, and return either the first member + * or the second member, respectively. They can be used (especially with + * the composition functors) to "strip" data from a sequence before + * performing the remainder of an algorithm. + * + * @addtogroup SGIextensions + * @{ +*/ +/// An \link SGIextensions SGI extension \endlink. +template struct select1st : public std::_Select1st<_Pair> {}; +/// An \link SGIextensions SGI extension \endlink. +template struct select2nd : public std::_Select2nd<_Pair> {}; +/** @} */ + +// extension documented next +template +struct _Project1st : public binary_function<_Arg1, _Arg2, _Arg1> { + _Arg1 operator()(const _Arg1& __x, const _Arg2&) const { return __x; } +}; + +template +struct _Project2nd : public binary_function<_Arg1, _Arg2, _Arg2> { + _Arg2 operator()(const _Arg1&, const _Arg2& __y) const { return __y; } +}; + +/** The @c operator() of the @c project1st functor takes two arbitrary + * arguments and returns the first one, while @c project2nd returns the + * second one. They are extensions provided by SGI. + * + * @addtogroup SGIextensions + * @{ +*/ + +/// An \link SGIextensions SGI extension \endlink. +template +struct project1st : public _Project1st<_Arg1, _Arg2> {}; + +/// An \link SGIextensions SGI extension \endlink. +template +struct project2nd : public _Project2nd<_Arg1, _Arg2> {}; +/** @} */ + +// extension documented next +template +struct _Constant_void_fun { + typedef _Result result_type; + result_type _M_val; + + _Constant_void_fun(const result_type& __v) : _M_val(__v) {} + const result_type& operator()() const { return _M_val; } +}; + +template +struct _Constant_unary_fun { + typedef _Argument argument_type; + typedef _Result result_type; + result_type _M_val; + + _Constant_unary_fun(const result_type& __v) : _M_val(__v) {} + const result_type& operator()(const _Argument&) const { return _M_val; } +}; + +template +struct _Constant_binary_fun { + typedef _Arg1 first_argument_type; + typedef _Arg2 second_argument_type; + typedef _Result result_type; + _Result _M_val; + + _Constant_binary_fun(const _Result& __v) : _M_val(__v) {} + const result_type& operator()(const _Arg1&, const _Arg2&) const { + return _M_val; + } +}; + +/** These three functors are each constructed from a single arbitrary + * variable/value. Later, their @c operator()s completely ignore any + * arguments passed, and return the stored value. + * - @c constant_void_fun's @c operator() takes no arguments + * - @c constant_unary_fun's @c operator() takes one argument (ignored) + * - @c constant_binary_fun's @c operator() takes two arguments (ignored) + * + * The helper creator functions @c constant0, @c constant1, and + * @c constant2 each take a "result" argument and construct variables of + * the appropriate functor type. + * + * @addtogroup SGIextensions + * @{ +*/ +/// An \link SGIextensions SGI extension \endlink. +template +struct constant_void_fun : public _Constant_void_fun<_Result> { + constant_void_fun(const _Result& __v) : _Constant_void_fun<_Result>(__v) {} +}; + +/// An \link SGIextensions SGI extension \endlink. +template +struct constant_unary_fun : public _Constant_unary_fun<_Result, _Argument> +{ + constant_unary_fun(const _Result& __v) + : _Constant_unary_fun<_Result, _Argument>(__v) {} +}; + +/// An \link SGIextensions SGI extension \endlink. +template +struct constant_binary_fun + : public _Constant_binary_fun<_Result, _Arg1, _Arg2> +{ + constant_binary_fun(const _Result& __v) + : _Constant_binary_fun<_Result, _Arg1, _Arg2>(__v) {} +}; + +/// An \link SGIextensions SGI extension \endlink. +template +inline constant_void_fun<_Result> constant0(const _Result& __val) +{ + return constant_void_fun<_Result>(__val); +} + +/// An \link SGIextensions SGI extension \endlink. +template +inline constant_unary_fun<_Result,_Result> constant1(const _Result& __val) +{ + return constant_unary_fun<_Result,_Result>(__val); +} + +/// An \link SGIextensions SGI extension \endlink. +template +inline constant_binary_fun<_Result,_Result,_Result> +constant2(const _Result& __val) +{ + return constant_binary_fun<_Result,_Result,_Result>(__val); +} +/** @} */ + +/** The @c subtractive_rng class is documented on + * SGI's site. + * Note that this code assumes that @c int is 32 bits. + * + * @ingroup SGIextensions +*/ +class subtractive_rng : public unary_function { +private: + unsigned int _M_table[55]; + size_t _M_index1; + size_t _M_index2; +public: + /// Returns a number less than the argument. + unsigned int operator()(unsigned int __limit) { + _M_index1 = (_M_index1 + 1) % 55; + _M_index2 = (_M_index2 + 1) % 55; + _M_table[_M_index1] = _M_table[_M_index1] - _M_table[_M_index2]; + return _M_table[_M_index1] % __limit; + } + + void _M_initialize(unsigned int __seed) + { + unsigned int __k = 1; + _M_table[54] = __seed; + size_t __i; + for (__i = 0; __i < 54; __i++) { + size_t __ii = (21 * (__i + 1) % 55) - 1; + _M_table[__ii] = __k; + __k = __seed - __k; + __seed = _M_table[__ii]; + } + for (int __loop = 0; __loop < 4; __loop++) { + for (__i = 0; __i < 55; __i++) + _M_table[__i] = _M_table[__i] - _M_table[(1 + __i + 30) % 55]; + } + _M_index1 = 0; + _M_index2 = 31; + } + + /// Ctor allowing you to initialize the seed. + subtractive_rng(unsigned int __seed) { _M_initialize(__seed); } + /// Default ctor; initializes its state with some number you don't see. + subtractive_rng() { _M_initialize(161803398u); } +}; + +// Mem_fun adaptor helper functions mem_fun1 and mem_fun1_ref, +// provided for backward compatibility, they are no longer part of +// the C++ standard. + +template +inline mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg)) + { return mem_fun1_t<_Ret,_Tp,_Arg>(__f); } + +template +inline const_mem_fun1_t<_Ret,_Tp,_Arg> mem_fun1(_Ret (_Tp::*__f)(_Arg) const) + { return const_mem_fun1_t<_Ret,_Tp,_Arg>(__f); } + +template +inline mem_fun1_ref_t<_Ret,_Tp,_Arg> mem_fun1_ref(_Ret (_Tp::*__f)(_Arg)) + { return mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); } + +template +inline const_mem_fun1_ref_t<_Ret,_Tp,_Arg> +mem_fun1_ref(_Ret (_Tp::*__f)(_Arg) const) + { return const_mem_fun1_ref_t<_Ret,_Tp,_Arg>(__f); } + +} // namespace __gnu_cxx + +#endif /* _EXT_FUNCTIONAL */ + diff --git a/libstdc++-v3/include/ext/numeric b/libstdc++-v3/include/ext/numeric new file mode 100644 index 00000000000..93364678d48 --- /dev/null +++ b/libstdc++-v3/include/ext/numeric @@ -0,0 +1,130 @@ +// Numeric extensions -*- C++ -*- + +// Copyright (C) 2002 Free Software Foundation, Inc. +// +// This file is part of the GNU ISO C++ Library. This library is free +// software; you can redistribute it and/or modify it under the +// terms of the GNU General Public License as published by the +// Free Software Foundation; either version 2, or (at your option) +// any later version. + +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License along +// with this library; see the file COPYING. If not, write to the Free +// Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, +// USA. + +// As a special exception, you may use this file as part of a free software +// library without restriction. Specifically, if other files instantiate +// templates or use macros or inline functions from this file, or you compile +// this file and link it with other files to produce an executable, this +// file does not by itself cause the resulting executable to be covered by +// the GNU General Public License. This exception does not however +// invalidate any other reasons why the executable file might be covered by +// the GNU General Public License. + +/* + * + * Copyright (c) 1994 + * Hewlett-Packard Company + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Hewlett-Packard Company makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + * + * + * Copyright (c) 1996 + * Silicon Graphics Computer Systems, Inc. + * + * Permission to use, copy, modify, distribute and sell this software + * and its documentation for any purpose is hereby granted without fee, + * provided that the above copyright notice appear in all copies and + * that both that copyright notice and this permission notice appear + * in supporting documentation. Silicon Graphics makes no + * representations about the suitability of this software for any + * purpose. It is provided "as is" without express or implied warranty. + */ + +#ifndef _EXT_NUMERIC +#define _EXT_NUMERIC + +#pragma GCC system_header +#include +#include + +#include // For identity_element + +namespace __gnu_cxx +{ + // Returns __x ** __n, where __n >= 0. _Note that "multiplication" + // is required to be associative, but not necessarily commutative. + + template + _Tp + __power(_Tp __x, _Integer __n, _MonoidOperation __monoid_op) + { + if (__n == 0) + return identity_element(__monoid_op); + else { + while ((__n & 1) == 0) { + __n >>= 1; + __x = __monoid_op(__x, __x); + } + + _Tp __result = __x; + __n >>= 1; + while (__n != 0) { + __x = __monoid_op(__x, __x); + if ((__n & 1) != 0) + __result = __monoid_op(__result, __x); + __n >>= 1; + } + return __result; + } + } + + template + inline _Tp + __power(_Tp __x, _Integer __n) + { return __power(__x, __n, std::multiplies<_Tp>()); } + + // Alias for the internal name __power. Note that power is an extension, + // not part of the C++ standard. + + template + inline _Tp + power(_Tp __x, _Integer __n, _MonoidOperation __monoid_op) + { return __power(__x, __n, __monoid_op); } + + template + inline _Tp + power(_Tp __x, _Integer __n) + { return __power(__x, __n); } + + // iota is not part of the C++ standard. It is an extension. + + template + void + iota(_ForwardIter __first, _ForwardIter __last, _Tp __value) + { + // concept requirements + __glibcpp_function_requires(_Mutable_ForwardIteratorConcept<_ForwardIter>) + __glibcpp_function_requires(_ConvertibleConcept<_Tp, + typename std::iterator_traits<_ForwardIter>::value_type>) + + while (__first != __last) + *__first++ = __value++; + } + +} // namespace __gnu_cxx + +#endif /* _EXT_NUMERIC */ + diff --git a/libstdc++-v3/include/ext/ropeimpl.h b/libstdc++-v3/include/ext/ropeimpl.h index 61324943b43..b3e694cf15a 100644 --- a/libstdc++-v3/include/ext/ropeimpl.h +++ b/libstdc++-v3/include/ext/ropeimpl.h @@ -51,6 +51,7 @@ #include // For copy_n and lexicographical_compare_3way #include // For uninitialized_copy_n +#include // For power namespace __gnu_cxx { diff --git a/libstdc++-v3/testsuite/ext/headers.cc b/libstdc++-v3/testsuite/ext/headers.cc index bc7f8b21f8b..f63b4ab11f6 100644 --- a/libstdc++-v3/testsuite/ext/headers.cc +++ b/libstdc++-v3/testsuite/ext/headers.cc @@ -24,10 +24,12 @@ // subdirectory that are meant to be directly included. #include +#include #include #include #include #include +#include #include #include