git
/
gcc
mirror of git://gcc.gnu.org/git/gcc.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Makefile.am (install-data-local): Remove pch-install rules. 

2007-08-21  Benjamin Kosnik  <bkoz@montsouris.artheist.org>

	* include/Makefile.am (install-data-local): Remove pch-install rules.
	(host_headers): Add stdc++.h, stdtr1c++.h, extc++.h.
	* include/Makefile.in: Regenerate.
	* config.h.in: Same.

	* scripts/check_compile: Remove space between outputs.	
	* include/ext/throw_allocator.h: Correct doxygen markup.	
	* include/bits/char_traits.h: Correct spacing.
	* include/bits/stl_function.h: Same, for 80 column.
	* include/std/valarray: Same.
	* testsuite/util/testsuite_iterators.h: Same.	
	* testsuite/25_algorithms/headers/algorithm/synopsis.cc: Format.

From-SVN: r127685
This commit is contained in:
Benjamin Kosnik 2007-08-22 01:26:43 +00:00
parent 7e501b00a4
commit 65be6ddd76
11 changed files with 510 additions and 444 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
libstdc++-v3/ChangeLog
View File

@ -1,3 +1,18 @@
2007-08-21 Benjamin Kosnik <bkoz@montsouris.artheist.org>
* include/Makefile.am (install-data-local): Remove pch-install rules.
(host_headers): Add stdc++.h, stdtr1c++.h, extc++.h.
* include/Makefile.in: Regenerate.
* config.h.in: Same.
* scripts/check_compile: Remove space between outputs.
* include/ext/throw_allocator.h: Correct doxygen markup.
* include/bits/char_traits.h: Correct spacing.
* include/bits/stl_function.h: Same, for 80 column.
* include/std/valarray: Same.
* testsuite/util/testsuite_iterators.h: Same.
* testsuite/25_algorithms/headers/algorithm/synopsis.cc: Format.
2007-08-17 Daniel Jacobowitz <dan@codesourcery.com> 2007-08-17 Daniel Jacobowitz <dan@codesourcery.com>
PR testsuite/31884 PR testsuite/31884
@ -24,10 +39,14 @@
testsuite/ext/throw_allocator/check_deallocate_null.cc, testsuite/ext/throw_allocator/check_deallocate_null.cc,
testsuite/ext/throw_allocator/check_new.cc, testsuite/ext/throw_allocator/check_new.cc,
testsuite/ext/throw_allocator/deallocate_local.cc, testsuite/ext/throw_allocator/deallocate_local.cc,
testsuite/tr1/5_numerical_facilities/random/subtract_with_carry_01/cons/gen1.cc, testsuite/tr1/5_numerical_facilities/random/subtract_with_carry_01/
testsuite/tr1/5_numerical_facilities/random/subtract_with_carry/cons/gen1.cc, cons/gen1.cc,
testsuite/tr1/5_numerical_facilities/random/linear_congruential/cons/gen1.cc, testsuite/tr1/5_numerical_facilities/random/subtract_with_carry/cons/
testsuite/tr1/5_numerical_facilities/random/mersenne_twister/cons/gen1.cc, gen1.cc,
testsuite/tr1/5_numerical_facilities/random/linear_congruential/cons/
gen1.cc,
testsuite/tr1/5_numerical_facilities/random/mersenne_twister/cons/
gen1.cc,
testsuite/23_containers/list/modifiers/insert/25288.cc: Use testsuite/23_containers/list/modifiers/insert/25288.cc: Use
dg-require-time. dg-require-time.

3
libstdc++-v3/config.h.in
View File

@ -24,6 +24,9 @@
/* Define to 1 if you have the `atanl' function. */ /* Define to 1 if you have the `atanl' function. */
#undef HAVE_ATANL #undef HAVE_ATANL
/* Define to 1 if the target assembler supports thread-local storage. */
#undef HAVE_CC_TLS
/* Define to 1 if you have the `ceilf' function. */ /* Define to 1 if you have the `ceilf' function. */
#undef HAVE_CEILF #undef HAVE_CEILF

19
libstdc++-v3/include/Makefile.am
View File

@ -754,7 +754,10 @@ host_headers = \
${host_srcdir}/os_defines.h \ ${host_srcdir}/os_defines.h \
${glibcxx_srcdir}/$(ATOMIC_WORD_SRCDIR)/atomic_word.h \ ${glibcxx_srcdir}/$(ATOMIC_WORD_SRCDIR)/atomic_word.h \
${glibcxx_srcdir}/$(ABI_TWEAKS_SRCDIR)/cxxabi_tweaks.h \ ${glibcxx_srcdir}/$(ABI_TWEAKS_SRCDIR)/cxxabi_tweaks.h \
${glibcxx_srcdir}/$(CPU_DEFINES_SRCDIR)/cpu_defines.h ${glibcxx_srcdir}/$(CPU_DEFINES_SRCDIR)/cpu_defines.h \
${glibcxx_srcdir}/include/precompiled/stdc++.h \
${glibcxx_srcdir}/include/precompiled/stdtr1c++.h \
${glibcxx_srcdir}/include/precompiled/extc++.h
# Non-installed host_header files. # Non-installed host_header files.
COMPATIBILITY_H = config/abi/compatibility.h COMPATIBILITY_H = config/abi/compatibility.h
@ -809,10 +812,8 @@ pch_output_anchors = \
PCHFLAGS=-Winvalid-pch -Wno-deprecated -x c++-header $(CXXFLAGS) PCHFLAGS=-Winvalid-pch -Wno-deprecated -x c++-header $(CXXFLAGS)
if GLIBCXX_BUILD_PCH if GLIBCXX_BUILD_PCH
pch_build = ${pch_output} pch_build = ${pch_output}
pch_install = install-pch
else else
pch_build = pch_build =
pch_install =
endif endif
# List of all timestamp files. By keeping only one copy of this list, both # List of all timestamp files. By keeping only one copy of this list, both
@ -1129,7 +1130,7 @@ ${pch3_output}: ${pch3_source} ${pch2_output}
# the rest are taken from the original source tree. # the rest are taken from the original source tree.
if GLIBCXX_HOSTED if GLIBCXX_HOSTED
install-data-local: install-headers ${pch_install} install-data-local: install-headers
else else
install-data-local: install-freestanding-headers install-data-local: install-freestanding-headers
endif endif
@ -1219,16 +1220,6 @@ install-headers:
${thread_host_headers}; do \ ${thread_host_headers}; do \
$(INSTALL_DATA) $${file} $(DESTDIR)${host_installdir}; done $(INSTALL_DATA) $${file} $(DESTDIR)${host_installdir}; done
install-pch:
$(mkinstalldirs) $(DESTDIR)${pch1_output_installdir}
for file in ${pch1_output_builddir}/*; do \
$(INSTALL_DATA) $$file $(DESTDIR)${pch1_output_installdir}; done
$(mkinstalldirs) $(DESTDIR)${pch2_output_installdir}
for file in ${pch2_output_builddir}/*; do \
$(INSTALL_DATA) $$file $(DESTDIR)${pch2_output_installdir}; done
$(INSTALL_DATA) ${pch1_output_anchor} $(DESTDIR)${host_installdir}
$(INSTALL_DATA) ${pch2_output_anchor} $(DESTDIR)${host_installdir}
# By adding these files here, automake will remove them for 'make clean' # By adding these files here, automake will remove them for 'make clean'
CLEANFILES = ${pch_output} ${pch_output_anchors} CLEANFILES = ${pch_output} ${pch_output_anchors}

19
libstdc++-v3/include/Makefile.in
View File

@ -981,7 +981,10 @@ host_headers = \
${host_srcdir}/os_defines.h \ ${host_srcdir}/os_defines.h \
${glibcxx_srcdir}/$(ATOMIC_WORD_SRCDIR)/atomic_word.h \ ${glibcxx_srcdir}/$(ATOMIC_WORD_SRCDIR)/atomic_word.h \
${glibcxx_srcdir}/$(ABI_TWEAKS_SRCDIR)/cxxabi_tweaks.h \ ${glibcxx_srcdir}/$(ABI_TWEAKS_SRCDIR)/cxxabi_tweaks.h \
${glibcxx_srcdir}/$(CPU_DEFINES_SRCDIR)/cpu_defines.h ${glibcxx_srcdir}/$(CPU_DEFINES_SRCDIR)/cpu_defines.h \
${glibcxx_srcdir}/include/precompiled/stdc++.h \
${glibcxx_srcdir}/include/precompiled/stdtr1c++.h \
${glibcxx_srcdir}/include/precompiled/extc++.h
# Non-installed host_header files. # Non-installed host_header files.
@ -1035,8 +1038,6 @@ pch_output_anchors = \
PCHFLAGS = -Winvalid-pch -Wno-deprecated -x c++-header $(CXXFLAGS) PCHFLAGS = -Winvalid-pch -Wno-deprecated -x c++-header $(CXXFLAGS)
@GLIBCXX_BUILD_PCH_FALSE@pch_build = @GLIBCXX_BUILD_PCH_FALSE@pch_build =
@GLIBCXX_BUILD_PCH_TRUE@pch_build = ${pch_output} @GLIBCXX_BUILD_PCH_TRUE@pch_build = ${pch_output}
@GLIBCXX_BUILD_PCH_FALSE@pch_install =
@GLIBCXX_BUILD_PCH_TRUE@pch_install = install-pch
# List of all timestamp files. By keeping only one copy of this list, both # List of all timestamp files. By keeping only one copy of this list, both
# CLEANFILES and all-local are kept up-to-date. # CLEANFILES and all-local are kept up-to-date.
@ -1512,7 +1513,7 @@ ${pch3_output}: ${pch3_source} ${pch2_output}
# host_headers_extra are taken out of the build tree staging area; # host_headers_extra are taken out of the build tree staging area;
# the rest are taken from the original source tree. # the rest are taken from the original source tree.
@GLIBCXX_HOSTED_TRUE@install-data-local: install-headers ${pch_install} @GLIBCXX_HOSTED_TRUE@install-data-local: install-headers
@GLIBCXX_HOSTED_FALSE@install-data-local: install-freestanding-headers @GLIBCXX_HOSTED_FALSE@install-data-local: install-freestanding-headers
# This is a subset of the full install-headers rule. We only need <cstddef>, # This is a subset of the full install-headers rule. We only need <cstddef>,
@ -1600,16 +1601,6 @@ install-headers:
${thread_host_headers}; do \ ${thread_host_headers}; do \
$(INSTALL_DATA) $${file} $(DESTDIR)${host_installdir}; done $(INSTALL_DATA) $${file} $(DESTDIR)${host_installdir}; done
install-pch:
$(mkinstalldirs) $(DESTDIR)${pch1_output_installdir}
for file in ${pch1_output_builddir}/*; do \
$(INSTALL_DATA) $$file $(DESTDIR)${pch1_output_installdir}; done
$(mkinstalldirs) $(DESTDIR)${pch2_output_installdir}
for file in ${pch2_output_builddir}/*; do \
$(INSTALL_DATA) $$file $(DESTDIR)${pch2_output_installdir}; done
$(INSTALL_DATA) ${pch1_output_anchor} $(DESTDIR)${host_installdir}
$(INSTALL_DATA) ${pch2_output_anchor} $(DESTDIR)${host_installdir}
# To remove directories. # To remove directories.
clean-local: clean-local:
rm -rf ${pch_output_dirs} rm -rf ${pch_output_dirs}

2
libstdc++-v3/include/bits/char_traits.h
View File

@ -60,7 +60,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx)
* types, but who don't need to change the definitions of any function * types, but who don't need to change the definitions of any function
* defined in char_traits, can specialize __gnu_cxx::_Char_types * defined in char_traits, can specialize __gnu_cxx::_Char_types
* while leaving __gnu_cxx::char_traits alone. */ * while leaving __gnu_cxx::char_traits alone. */
template <class _CharT> template<typename _CharT>
struct _Char_types struct _Char_types
{ {
typedef unsigned long int_type; typedef unsigned long int_type;

42
libstdc++-v3/include/bits/stl_function.h
View File

@ -124,9 +124,11 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
// 20.3.2 arithmetic // 20.3.2 arithmetic
/** @defgroup s20_3_2_arithmetic Arithmetic Classes /** @defgroup s20_3_2_arithmetic Arithmetic Classes
* Because basic math often needs to be done during an algorithm, the library
* provides functors for those operations. See the documentation for * Because basic math often needs to be done during an algorithm,
* @link s20_3_1_base the base classes@endlink for examples of their use. * the library provides functors for those operations. See the
* documentation for @link s20_3_1_base the base classes@endlink
* for examples of their use.
* *
* @{ * @{
*/ */
@ -249,7 +251,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
// 20.3.4 logical operations // 20.3.4 logical operations
/** @defgroup s20_3_4_logical Boolean Operations Classes /** @defgroup s20_3_4_logical Boolean Operations Classes
* Here are wrapper functors for Boolean operations: @c &&, @c ||, and @c !. * Here are wrapper functors for Boolean operations: @c &&, @c ||,
* and @c !.
* *
* @{ * @{
*/ */
@ -360,15 +363,14 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
template <class _Predicate> template <class _Predicate>
class binary_negate class binary_negate
: public binary_function<typename _Predicate::first_argument_type, : public binary_function<typename _Predicate::first_argument_type,
typename _Predicate::second_argument_type, typename _Predicate::second_argument_type, bool>
bool>
{ {
protected: protected:
_Predicate _M_pred; _Predicate _M_pred;
public: public:
explicit explicit
binary_negate(const _Predicate& __x) binary_negate(const _Predicate& __x) : _M_pred(__x) { }
: _M_pred(__x) { }
bool bool
operator()(const typename _Predicate::first_argument_type& __x, operator()(const typename _Predicate::first_argument_type& __x,
@ -605,7 +607,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
* *
* @{ * @{
*/ */
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink. /// One of the @link s20_3_8_memadaptors adaptors for member
/// pointers@endlink.
template <class _Ret, class _Tp> template <class _Ret, class _Tp>
class mem_fun_t : public unary_function<_Tp*, _Ret> class mem_fun_t : public unary_function<_Tp*, _Ret>
{ {
@ -621,7 +624,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
_Ret (_Tp::*_M_f)(); _Ret (_Tp::*_M_f)();
}; };
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink. /// One of the @link s20_3_8_memadaptors adaptors for member
/// pointers@endlink.
template <class _Ret, class _Tp> template <class _Ret, class _Tp>
class const_mem_fun_t : public unary_function<const _Tp*, _Ret> class const_mem_fun_t : public unary_function<const _Tp*, _Ret>
{ {
@ -637,7 +641,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
_Ret (_Tp::*_M_f)() const; _Ret (_Tp::*_M_f)() const;
}; };
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink. /// One of the @link s20_3_8_memadaptors adaptors for member
/// pointers@endlink.
template <class _Ret, class _Tp> template <class _Ret, class _Tp>
class mem_fun_ref_t : public unary_function<_Tp, _Ret> class mem_fun_ref_t : public unary_function<_Tp, _Ret>
{ {
@ -653,7 +658,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
_Ret (_Tp::*_M_f)(); _Ret (_Tp::*_M_f)();
}; };
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink. /// One of the @link s20_3_8_memadaptors adaptors for member
/// pointers@endlink.
template <class _Ret, class _Tp> template <class _Ret, class _Tp>
class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> class const_mem_fun_ref_t : public unary_function<_Tp, _Ret>
{ {
@ -669,7 +675,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
_Ret (_Tp::*_M_f)() const; _Ret (_Tp::*_M_f)() const;
}; };
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink. /// One of the @link s20_3_8_memadaptors adaptors for member
/// pointers@endlink.
template <class _Ret, class _Tp, class _Arg> template <class _Ret, class _Tp, class _Arg>
class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret> class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret>
{ {
@ -685,7 +692,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
_Ret (_Tp::*_M_f)(_Arg); _Ret (_Tp::*_M_f)(_Arg);
}; };
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink. /// One of the @link s20_3_8_memadaptors adaptors for member
/// pointers@endlink.
template <class _Ret, class _Tp, class _Arg> template <class _Ret, class _Tp, class _Arg>
class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret> class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret>
{ {
@ -701,7 +709,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
_Ret (_Tp::*_M_f)(_Arg) const; _Ret (_Tp::*_M_f)(_Arg) const;
}; };
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink. /// One of the @link s20_3_8_memadaptors adaptors for member
/// pointers@endlink.
template <class _Ret, class _Tp, class _Arg> template <class _Ret, class _Tp, class _Arg>
class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
{ {
@ -717,7 +726,8 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
_Ret (_Tp::*_M_f)(_Arg); _Ret (_Tp::*_M_f)(_Arg);
}; };
/// One of the @link s20_3_8_memadaptors adaptors for member pointers@endlink. /// One of the @link s20_3_8_memadaptors adaptors for member
/// pointers@endlink.
template <class _Ret, class _Tp, class _Arg> template <class _Ret, class _Tp, class _Arg>
class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret>
{ {

6
libstdc++-v3/include/ext/throw_allocator.h
View File

@ -39,7 +39,7 @@
// purpose. It is provided "as is" without express or implied // purpose. It is provided "as is" without express or implied
// warranty. // warranty.
/** @file ext/vstring.h /** @file ext/throw_allocator.h
* This file is a GNU extension to the Standard C++ Library. * This file is a GNU extension to the Standard C++ Library.
* *
* Contains an exception-throwing allocator, useful for testing * Contains an exception-throwing allocator, useful for testing
@ -47,10 +47,6 @@
* sanity checked. * sanity checked.
*/ */
/**
* @file throw_allocator.h
*/
#ifndef _THROW_ALLOCATOR_H #ifndef _THROW_ALLOCATOR_H
#define _THROW_ALLOCATOR_H 1 #define _THROW_ALLOCATOR_H 1

4
libstdc++-v3/include/std/valarray
View File

@ -881,7 +881,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
valarray<_Tp>::min() const valarray<_Tp>::min() const
{ {
_GLIBCXX_DEBUG_ASSERT(_M_size > 0); _GLIBCXX_DEBUG_ASSERT(_M_size > 0);
return *std::min_element(_M_data, _M_data+_M_size); return *std::min_element(_M_data, _M_data + _M_size);
} }
template<typename _Tp> template<typename _Tp>
@ -889,7 +889,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std)
valarray<_Tp>::max() const valarray<_Tp>::max() const
{ {
_GLIBCXX_DEBUG_ASSERT(_M_size > 0); _GLIBCXX_DEBUG_ASSERT(_M_size > 0);
return *std::max_element(_M_data, _M_data+_M_size); return *std::max_element(_M_data, _M_data + _M_size);
} }
template<class _Tp> template<class _Tp>

3
libstdc++-v3/scripts/check_compile
View File

@ -28,7 +28,7 @@ PCH_FLAGS=`$flags_script --cxxpchflags`
FLAGS=`$flags_script --cxxflags` FLAGS=`$flags_script --cxxflags`
TEST_FLAGS="-S" TEST_FLAGS="-S"
COMPILER=`$flags_script --build-cxx` COMPILER=`$flags_script --build-cxx`
CXX="$COMPILER $INCLUDES $PCH_FLAGS $FLAGS $TEST_FLAGS" CXX="$COMPILER $INCLUDES $PCH_FLAGS $FLAGS -Wfatal-errors $TEST_FLAGS"
echo "compile line is:" echo "compile line is:"
echo $CXX echo $CXX
@ -49,7 +49,6 @@ do
# mv $OUTPUT_NAME binaries # mv $OUTPUT_NAME binaries
rm $OUTPUT_NAME rm $OUTPUT_NAME
fi fi
echo ""
let UNIQUE_ID+=1 let UNIQUE_ID+=1
fi fi
done done

789
libstdc++-v3/testsuite/25_algorithms/headers/algorithm/synopsis.cc
View File

@ -20,385 +20,442 @@
#include <algorithm> #include <algorithm>
namespace std { namespace std
{
// 25.1, non-modifying sequence operations: // 25.1, non-modifying sequence operations:
template<class InputIterator, class Function> template<typename _IIter, typename _Funct>
Function for_each(InputIterator first, InputIterator last, Function f); _Funct
template<class InputIterator, class T> for_each(_IIter, _IIter, _Funct);
InputIterator find(InputIterator first, InputIterator last,
const T& value);
template<class InputIterator, class Predicate>
InputIterator find_if(InputIterator first, InputIterator last,
Predicate pred);
template<class ForwardIterator1, class ForwardIterator2>
ForwardIterator1
find_end(ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2);
template<class ForwardIterator1, class ForwardIterator2,
class BinaryPredicate>
ForwardIterator1
find_end(ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2,
BinaryPredicate pred);
template<class ForwardIterator1, class ForwardIterator2>
ForwardIterator1
find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2);
template<class ForwardIterator1, class ForwardIterator2,
class BinaryPredicate>
ForwardIterator1
find_first_of(ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2,
BinaryPredicate pred);
template<class ForwardIterator> template<typename _IIter, typename _Tp>
ForwardIterator adjacent_find(ForwardIterator first, _IIter
ForwardIterator last); find(_IIter, _IIter, const _Tp&);
template<class ForwardIterator, class BinaryPredicate> template<typename _IIter, typename _Predicate>
ForwardIterator adjacent_find(ForwardIterator first, _IIter
ForwardIterator last, BinaryPredicate pred); find_if(_IIter, _IIter, _Predicate);
template<class InputIterator, class T> template<typename _FIter1, typename _FIter2>
typename iterator_traits<InputIterator>::difference_type _FIter1
count(InputIterator first, InputIterator last, const T& value); find_end(_FIter1, _FIter1, _FIter2, _FIter2);
template<class InputIterator, class Predicate> template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
typename iterator_traits<InputIterator>::difference_type _FIter1
count_if(InputIterator first, InputIterator last, Predicate pred); find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
template<class InputIterator1, class InputIterator2>
pair<InputIterator1, InputIterator2>
mismatch(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2);
template
<class InputIterator1, class InputIterator2, class BinaryPredicate>
pair<InputIterator1, InputIterator2>
mismatch(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, BinaryPredicate pred);
template<class InputIterator1, class InputIterator2>
bool equal(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2);
template
<class InputIterator1, class InputIterator2, class BinaryPredicate>
bool equal(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, BinaryPredicate pred);
template<class ForwardIterator1, class ForwardIterator2> template<typename _FIter1, typename _FIter2>
ForwardIterator1 search _FIter1
(ForwardIterator1 first1, ForwardIterator1 last1, find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
ForwardIterator2 first2, ForwardIterator2 last2);
template<class ForwardIterator1, class ForwardIterator2, template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
class BinaryPredicate> _FIter1
ForwardIterator1 search find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
(ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2,
BinaryPredicate pred);
template<class ForwardIterator, class Size, class T> template<typename _FIter>
ForwardIterator search_n(ForwardIterator first, ForwardIterator last, _FIter
Size count, const T& value); adjacent_find(_FIter, _FIter);
template <class ForwardIterator, class Size, class T, class BinaryPredicate> template<typename _FIter, typename _BinaryPredicate>
ForwardIterator search_n(ForwardIterator first, ForwardIterator last, _FIter
Size count, const T& value, adjacent_find(_FIter, _FIter, _BinaryPredicate);
BinaryPredicate pred);
// 25.2, modifying sequence operations: template<typename _IIter, typename _Tp>
// 25.2.1, copy: typename iterator_traits<_IIter>::difference_type
template<class InputIterator, class OutputIterator> count(_IIter, _IIter, const _Tp&);
OutputIterator copy(InputIterator first, InputIterator last,
OutputIterator result);
template<class BidirectionalIterator1, class BidirectionalIterator2>
BidirectionalIterator2
copy_backward
(BidirectionalIterator1 first, BidirectionalIterator1 last,
BidirectionalIterator2 result);
// 25.2.2, swap:
template<class T> void swap(T& a, T& b);
template<class ForwardIterator1, class ForwardIterator2>
ForwardIterator2 swap_ranges(ForwardIterator1 first1,
ForwardIterator1 last1, ForwardIterator2 first2);
template<class ForwardIterator1, class ForwardIterator2>
void iter_swap(ForwardIterator1 a, ForwardIterator2 b);
template<class InputIterator, class OutputIterator, class UnaryOperation>
OutputIterator transform(InputIterator first, InputIterator last,
OutputIterator result, UnaryOperation op);
template<class InputIterator1, class InputIterator2, class OutputIterator,
class BinaryOperation>
OutputIterator transform(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, OutputIterator result,
BinaryOperation binary_op);
template<class ForwardIterator, class T>
void replace(ForwardIterator first, ForwardIterator last,
const T& old_value, const T& new_value);
template<class ForwardIterator, class Predicate, class T>
void replace_if(ForwardIterator first, ForwardIterator last,
Predicate pred, const T& new_value);
template<class InputIterator, class OutputIterator, class T>
OutputIterator replace_copy(InputIterator first, InputIterator last,
OutputIterator result,
const T& old_value, const T& new_value);
template<class Iterator, class OutputIterator, class Predicate, class T>
OutputIterator replace_copy_if(Iterator first, Iterator last,
OutputIterator result,
Predicate pred, const T& new_value);
template<class ForwardIterator, class T>
void fill(ForwardIterator first, ForwardIterator last, const T& value);
template<class OutputIterator, class Size, class T>
void fill_n(OutputIterator first, Size n, const T& value);
template<class ForwardIterator, class Generator>
void generate(ForwardIterator first, ForwardIterator last,
Generator gen);
template<class OutputIterator, class Size, class Generator>
void generate_n(OutputIterator first, Size n, Generator gen);
template<class ForwardIterator, class T> template<typename _IIter, typename _Predicate>
ForwardIterator remove(ForwardIterator first, ForwardIterator last, typename iterator_traits<_IIter>::difference_type
const T& value); count_if(_IIter, _IIter, _Predicate);
template<class ForwardIterator, class Predicate>
ForwardIterator remove_if(ForwardIterator first, ForwardIterator last, template<typename _IIter1, typename _IIter2>
Predicate pred); pair<_IIter1, _IIter2>
template<class InputIterator, class OutputIterator, class T> mismatch(_IIter1, _IIter1, _IIter2);
OutputIterator remove_copy(InputIterator first, InputIterator last,
OutputIterator result, const T& value); template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
template<class InputIterator, class OutputIterator, class Predicate> pair<_IIter1, _IIter2>
OutputIterator remove_copy_if(InputIterator first, InputIterator last, mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
OutputIterator result, Predicate pred);
template<class ForwardIterator> template<typename _IIter1, typename _IIter2>
ForwardIterator unique(ForwardIterator first, ForwardIterator last); bool
template<class ForwardIterator, class BinaryPredicate> equal(_IIter1, _IIter1, _IIter2);
ForwardIterator unique(ForwardIterator first, ForwardIterator last,
BinaryPredicate pred); template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
template<class InputIterator, class OutputIterator> bool
OutputIterator unique_copy(InputIterator first, InputIterator last, equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
OutputIterator result);
template<class InputIterator, class OutputIterator, class BinaryPredicate> template<typename _FIter1, typename _FIter2>
OutputIterator unique_copy(InputIterator first, InputIterator last, _FIter1
OutputIterator result, BinaryPredicate pred); search(_FIter1, _FIter1, _FIter2, _FIter2);
template<class BidirectionalIterator>
void reverse(BidirectionalIterator first, BidirectionalIterator last); template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
template<class BidirectionalIterator, class OutputIterator> _FIter1
OutputIterator reverse_copy(BidirectionalIterator first, search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
BidirectionalIterator last,
OutputIterator result); template<typename _FIter, typename _Size, typename _Tp>
template<class ForwardIterator> _FIter
void rotate(ForwardIterator first, ForwardIterator middle, search_n(_FIter, _FIter, _Size, const _Tp&);
ForwardIterator last);
template<class ForwardIterator, class OutputIterator> template<typename _FIter, typename _Size, typename _Tp,
OutputIterator rotate_copy typename _BinaryPredicate>
(ForwardIterator first, ForwardIterator middle, _FIter
ForwardIterator last, OutputIterator result); search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
template<class RandomAccessIterator>
void random_shuffle(RandomAccessIterator first, // 25.2, modifying sequence operations:
RandomAccessIterator last); // 25.2.1, copy:
template<class RandomAccessIterator, class RandomNumberGenerator> template<typename _IIter, typename _OIter>
void random_shuffle(RandomAccessIterator first, _OIter
RandomAccessIterator last, copy(_IIter, _IIter, _OIter);
RandomNumberGenerator& rand);
// 25.2.12, partitions: template<typename _BIter1, typename _BIter2>
template<class BidirectionalIterator, class Predicate> _BIter2
BidirectionalIterator partition(BidirectionalIterator first, copy_backward (_BIter1, _BIter1, _BIter2);
BidirectionalIterator last,
Predicate pred); // 25.2.2, swap:
template<class BidirectionalIterator, class Predicate> template<typename _Tp>
BidirectionalIterator stable_partition(BidirectionalIterator first, void
BidirectionalIterator last, swap(_Tp&, _Tp& b);
Predicate pred);
// 25.3, sorting and related operations: template<typename _FIter1, typename _FIter2>
// 25.3.1, sorting: _FIter2
template<class RandomAccessIterator> swap_ranges(_FIter1 first1, _FIter1, _FIter2);
void sort(RandomAccessIterator first, RandomAccessIterator last);
template<class RandomAccessIterator, class Compare> template<typename _FIter1, typename _FIter2>
void sort(RandomAccessIterator first, RandomAccessIterator last, void
Compare comp); iter_swap(_FIter1, _FIter2 b);
template<class RandomAccessIterator>
void stable_sort(RandomAccessIterator first, RandomAccessIterator last); template<typename _IIter, typename _OIter, typename _UnaryOperation>
template<class RandomAccessIterator, class Compare> _OIter
void stable_sort(RandomAccessIterator first, RandomAccessIterator last, transform(_IIter, _IIter, _OIter, _UnaryOperation op);
Compare comp);
template<class RandomAccessIterator> template<typename _IIter1, typename _IIter2, typename _OIter,
void partial_sort(RandomAccessIterator first, typename _BinaryOperation>
RandomAccessIterator middle, _OIter
RandomAccessIterator last); transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
template<class RandomAccessIterator, class Compare>
void partial_sort(RandomAccessIterator first, template<typename _FIter, typename _Tp>
RandomAccessIterator middle, void
RandomAccessIterator last, Compare comp); replace(_FIter, _FIter, const _Tp&, const _Tp&);
template<class InputIterator, class RandomAccessIterator>
RandomAccessIterator template<typename _FIter, typename _Predicate, typename _Tp>
partial_sort_copy(InputIterator first, InputIterator last, void
RandomAccessIterator result_first, replace_if(_FIter, _FIter, _Predicate, const _Tp&);
RandomAccessIterator result_last);
template<class InputIterator, class RandomAccessIterator, class Compare> template<typename _IIter, typename _OIter, typename _Tp>
RandomAccessIterator _OIter
partial_sort_copy(InputIterator first, InputIterator last, replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
RandomAccessIterator result_first,
RandomAccessIterator result_last, template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
Compare comp); _OIter
template<class RandomAccessIterator> replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
RandomAccessIterator last); template<typename _FIter, typename _Tp>
template<class RandomAccessIterator, class Compare> void
void nth_element(RandomAccessIterator first, RandomAccessIterator nth, fill(_FIter, _FIter, const _Tp&);
RandomAccessIterator last, Compare comp);
// 25.3.3, binary search: template<typename _OIter, typename _Size, typename _Tp>
template<class ForwardIterator, class T> void
ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last, fill_n(_OIter, _Size n, const _Tp&);
const T& value);
template<class ForwardIterator, class T, class Compare> template<typename _FIter, typename _Generator>
ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last, void
const T& value, Compare comp); generate(_FIter, _FIter, _Generator);
template<class ForwardIterator, class T>
ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last, template<typename _OIter, typename _Size, typename _Generator>
const T& value); void
template<class ForwardIterator, class T, class Compare> generate_n(_OIter, _Size, _Generator);
ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
const T& value, Compare comp); template<typename _FIter, typename _Tp>
template<class ForwardIterator, class T> _FIter
pair<ForwardIterator, ForwardIterator> remove(_FIter, _FIter, const _Tp&);
equal_range(ForwardIterator first, ForwardIterator last,
const T& value); template<typename _FIter, typename _Predicate>
template<class ForwardIterator, class T, class Compare> _FIter
pair<ForwardIterator, ForwardIterator> remove_if(_FIter, _FIter, _Predicate);
equal_range(ForwardIterator first, ForwardIterator last,
const T& value, Compare comp); template<typename _IIter, typename _OIter, typename _Tp>
template<class ForwardIterator, class T> _OIter
bool binary_search(ForwardIterator first, ForwardIterator last, remove_copy(_IIter, _IIter, _OIter, const _Tp&);
const T& value);
template<class ForwardIterator, class T, class Compare> template<typename _IIter, typename _OIter, typename _Predicate>
bool binary_search(ForwardIterator first, ForwardIterator last, _OIter
const T& value, Compare comp); remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
// 25.3.4, merge:
template<class InputIterator1, class InputIterator2, class OutputIterator> template<typename _FIter>
OutputIterator merge(InputIterator1 first1, InputIterator1 last1, _FIter
InputIterator2 first2, InputIterator2 last2, unique(_FIter, _FIter);
OutputIterator result);
template<class InputIterator1, class InputIterator2, class OutputIterator, template<typename _FIter, typename _BinaryPredicate>
class Compare> _FIter
OutputIterator merge(InputIterator1 first1, InputIterator1 last1, unique(_FIter, _FIter, _BinaryPredicate);
InputIterator2 first2, InputIterator2 last2,
OutputIterator result, Compare comp); template<typename _IIter, typename _OIter>
template<class BidirectionalIterator> _OIter
void inplace_merge(BidirectionalIterator first, unique_copy(_IIter, _IIter, _OIter);
BidirectionalIterator middle,
BidirectionalIterator last); template<typename _IIter, typename _OIter, typename _BinaryPredicate>
template<class BidirectionalIterator, class Compare> _OIter
void inplace_merge(BidirectionalIterator first, unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
BidirectionalIterator middle,
BidirectionalIterator last, Compare comp); template<typename _BIter>
// 25.3.5, set operations: void
template<class InputIterator1, class InputIterator2> reverse(_BIter, _BIter);
bool includes(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2); template<typename _BIter, typename _OIter>
template<class InputIterator1, class InputIterator2, class Compare> _OIter
bool includes reverse_copy(_BIter, _BIter, _OIter);
(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, Compare comp); template<typename _FIter>
template<class InputIterator1, class InputIterator2, class OutputIterator> void
OutputIterator set_union(InputIterator1 first1, InputIterator1 last1, rotate(_FIter, _FIter, _FIter);
InputIterator2 first2, InputIterator2 last2,
OutputIterator result); template<typename _FIter, typename _OIter>
template<class InputIterator1, class InputIterator2, class OutputIterator, _OIter
class Compare> rotate_copy (_FIter, _FIter, _FIter, _OIter);
OutputIterator set_union(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, template<typename _RAIter>
OutputIterator result, Compare comp); void
template<class InputIterator1, class InputIterator2, class OutputIterator> random_shuffle(_RAIter, _RAIter);
OutputIterator set_intersection
(InputIterator1 first1, InputIterator1 last1, template<typename _RAIter, typename _Generator>
InputIterator2 first2, InputIterator2 last2, void
OutputIterator result); random_shuffle(_RAIter, _RAIter, _Generator&);
template<class InputIterator1, class InputIterator2, class OutputIterator,
class Compare> // 25.2.12, partitions:
OutputIterator set_intersection template<typename _BIter, typename _Predicate>
(InputIterator1 first1, InputIterator1 last1, _BIter
InputIterator2 first2, InputIterator2 last2, partition(_BIter, _BIter, _Predicate);
OutputIterator result, Compare comp);
template<class InputIterator1, class InputIterator2, class OutputIterator> template<typename _BIter, typename _Predicate>
OutputIterator set_difference _BIter
(InputIterator1 first1, InputIterator1 last1, stable_partition(_BIter, _BIter, _Predicate);
InputIterator2 first2, InputIterator2 last2,
OutputIterator result); // 25.3, sorting and related operations:
template<class InputIterator1, class InputIterator2, class OutputIterator, // 25.3.1, sorting:
class Compare> template<typename _RAIter>
OutputIterator set_difference void
(InputIterator1 first1, InputIterator1 last1, sort(_RAIter, _RAIter);
InputIterator2 first2, InputIterator2 last2,
OutputIterator result, Compare comp); template<typename _RAIter, typename _Compare>
template<class InputIterator1, class InputIterator2, class OutputIterator> void
OutputIterator sort(_RAIter, _RAIter, _Compare);
set_symmetric_difference(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, template<typename _RAIter>
OutputIterator result); void
template<class InputIterator1, class InputIterator2, class OutputIterator, stable_sort(_RAIter, _RAIter);
class Compare>
OutputIterator template<typename _RAIter, typename _Compare>
set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, void
InputIterator2 first2, InputIterator2 last2, stable_sort(_RAIter, _RAIter, _Compare);
OutputIterator result, Compare comp);
// 25.3.6, heap operations: template<typename _RAIter>
template<class RandomAccessIterator> void
void push_heap(RandomAccessIterator first, RandomAccessIterator last); partial_sort(_RAIter, _RAIter, _RAIter);
template<class RandomAccessIterator, class Compare>
void push_heap(RandomAccessIterator first, RandomAccessIterator last, template<typename _RAIter, typename _Compare>
Compare comp); void
template<class RandomAccessIterator> partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
void pop_heap(RandomAccessIterator first, RandomAccessIterator last);
template<class RandomAccessIterator, class Compare> template<typename _IIter, typename _RAIter>
void pop_heap(RandomAccessIterator first, RandomAccessIterator last, _RAIter
Compare comp); partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
template<class RandomAccessIterator>
void make_heap(RandomAccessIterator first, RandomAccessIterator last); template<typename _IIter, typename _RAIter, typename _Compare>
template<class RandomAccessIterator, class Compare> _RAIter
void make_heap(RandomAccessIterator first, RandomAccessIterator last, partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
Compare comp);
template<class RandomAccessIterator> template<typename _RAIter>
void sort_heap(RandomAccessIterator first, RandomAccessIterator last); void
template<class RandomAccessIterator, class Compare> nth_element(_RAIter, _RAIter, _RAIter);
void sort_heap(RandomAccessIterator first, RandomAccessIterator last,
Compare comp); template<typename _RAIter, typename _Compare>
void
nth_element(_RAIter, _RAIter, _RAIter, _Compare);
// 25.3.3, binary search:
template<typename _FIter, typename _Tp>
_FIter
lower_bound(_FIter, _FIter, const _Tp&);
template<typename _FIter, typename _Tp, typename _Compare>
_FIter
lower_bound(_FIter, _FIter, const _Tp&, _Compare);
template<typename _FIter, typename _Tp>
_FIter
upper_bound(_FIter, _FIter, const _Tp&);
template<typename _FIter, typename _Tp, typename _Compare>
_FIter
upper_bound(_FIter, _FIter, const _Tp&, _Compare);
template<typename _FIter, typename _Tp>
pair<_FIter, _FIter>
equal_range(_FIter, _FIter, const _Tp&);
template<typename _FIter, typename _Tp, typename _Compare>
pair<_FIter, _FIter>
equal_range(_FIter, _FIter, const _Tp&, _Compare);
template<typename _FIter, typename _Tp>
bool
binary_search(_FIter, _FIter, const _Tp&);
template<typename _FIter, typename _Tp, typename _Compare>
bool
binary_search(_FIter, _FIter, const _Tp&, _Compare);
// 25.3.4, merge:
template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter
merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Compare>
_OIter
merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
template<typename _BIter>
void
inplace_merge(_BIter, _BIter, _BIter);
template<typename _BIter, typename _Compare>
void
inplace_merge(_BIter, _BIter, _BIter, _Compare);
// 25.3.5, set operations:
template<typename _IIter1, typename _IIter2>
bool
includes(_IIter1, _IIter1, _IIter2, _IIter2);
template<typename _IIter1, typename _IIter2, typename _Compare>
bool
includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter
set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Compare>
_OIter
set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter
set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Compare>
_OIter
set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter
set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Compare>
_OIter
set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
template<typename _IIter1, typename _IIter2, typename _OIter>
_OIter
set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
template<typename _IIter1, typename _IIter2, typename _OIter,
typename _Compare>
_OIter
set_symmetric_difference(_IIter1, _IIter1, _IIter2, _IIter2,
_OIter, _Compare);
// 25.3.6, heap operations:
template<typename _RAIter>
void
push_heap(_RAIter, _RAIter);
template<typename _RAIter, typename _Compare>
void
push_heap(_RAIter, _RAIter, _Compare);
template<typename _RAIter>
void
pop_heap(_RAIter, _RAIter);
template<typename _RAIter, typename _Compare>
void
pop_heap(_RAIter, _RAIter, _Compare);
template<typename _RAIter>
void
make_heap(_RAIter, _RAIter);
template<typename _RAIter, typename _Compare>
void
make_heap(_RAIter, _RAIter, _Compare);
template<typename _RAIter>
void
sort_heap(_RAIter, _RAIter);
template<typename _RAIter, typename _Compare>
void
sort_heap(_RAIter, _RAIter, _Compare);
// 25.3.7, minimum and maximum: // 25.3.7, minimum and maximum:
template<class T> const T& min(const T& a, const T& b); template<typename _Tp>
template<class T, class Compare> const _Tp&
const T& min(const T& a, const T& b, Compare comp); min(const _Tp&, const _Tp&);
template<class T> const T& max(const T& a, const T& b);
template<class T, class Compare> template<typename _Tp, typename _Compare>
const T& max(const T& a, const T& b, Compare comp); const _Tp&
template<class ForwardIterator> min(const _Tp&, const _Tp&, _Compare);
ForwardIterator min_element
(ForwardIterator first, ForwardIterator last); template<typename _Tp>
template<class ForwardIterator, class Compare> const _Tp&
ForwardIterator min_element(ForwardIterator first, ForwardIterator last, max(const _Tp&, const _Tp&);
Compare comp);
template<class ForwardIterator> template<typename _Tp, typename _Compare>
ForwardIterator max_element const _Tp&
(ForwardIterator first, ForwardIterator last); max(const _Tp&, const _Tp&, _Compare);
template<class ForwardIterator, class Compare>
ForwardIterator max_element(ForwardIterator first, ForwardIterator last, template<typename _FIter>
Compare comp); _FIter
template<class InputIterator1, class InputIterator2> min_element(_FIter, _FIter);
bool lexicographical_compare
(InputIterator1 first1, InputIterator1 last1, template<typename _FIter, typename _Compare>
InputIterator2 first2, InputIterator2 last2); _FIter
template<class InputIterator1, class InputIterator2, class Compare> min_element(_FIter, _FIter, _Compare);
bool lexicographical_compare
(InputIterator1 first1, InputIterator1 last1, template<typename _FIter>
InputIterator2 first2, InputIterator2 last2, _FIter
Compare comp); max_element(_FIter, _FIter);
template<typename _FIter, typename _Compare>
_FIter
max_element(_FIter, _FIter, _Compare);
template<typename _IIter1, typename _IIter2>
bool
lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2);
template<typename _IIter1, typename _IIter2, typename _Compare>
bool
lexicographical_compare(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
// 25.3.9, permutations // 25.3.9, permutations
template<class BidirectionalIterator> template<typename _BIter>
bool next_permutation(BidirectionalIterator first, bool
BidirectionalIterator last); next_permutation(_BIter, _BIter);
template<class BidirectionalIterator, class Compare>
bool next_permutation(BidirectionalIterator first, template<typename _BIter, typename _Compare>
BidirectionalIterator last, Compare comp); bool
template<class BidirectionalIterator> next_permutation(_BIter, _BIter, _Compare);
bool prev_permutation(BidirectionalIterator first,
BidirectionalIterator last); template<typename _BIter>
template<class BidirectionalIterator, class Compare> bool
bool prev_permutation(BidirectionalIterator first, prev_permutation(_BIter, _BIter);
BidirectionalIterator last, Compare comp);
template<typename _BIter, typename _Compare>
bool
prev_permutation(_BIter, _BIter, _Compare);
} }

40
libstdc++-v3/testsuite/util/testsuite_iterators.h
View File

@ -61,8 +61,7 @@ namespace __gnu_test
{ {
T* first; T* first;
T* last; T* last;
BoundsContainer(T* _first, T* _last) BoundsContainer(T* _first, T* _last) : first(_first), last(_last)
: first(_first), last(_last)
{ } { }
}; };
@ -73,7 +72,7 @@ namespace __gnu_test
T* incrementedto; T* incrementedto;
bool* writtento; bool* writtento;
OutputContainer(T* _first, T* _last) OutputContainer(T* _first, T* _last)
: BoundsContainer<T>(_first, _last), incrementedto(_first) : BoundsContainer<T>(_first, _last), incrementedto(_first)
{ {
writtento = new bool[this->last - this->first]; writtento = new bool[this->last - this->first];
for(int i = 0; i < this->last - this->first; i++) for(int i = 0; i < this->last - this->first; i++)
@ -114,21 +113,21 @@ namespace __gnu_test
* instansiated directly, but generated from a test_container * instansiated directly, but generated from a test_container
*/ */
template<class T> template<class T>
struct output_iterator_wrapper: public std::iterator struct output_iterator_wrapper
<std::output_iterator_tag, T, ptrdiff_t, T*, T&> : public std::iterator<std::output_iterator_tag, T, ptrdiff_t, T*, T&>
{ {
typedef OutputContainer<T> ContainerType; typedef OutputContainer<T> ContainerType;
T* ptr; T* ptr;
ContainerType* SharedInfo; ContainerType* SharedInfo;
output_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in) output_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in)
:ptr(_ptr), SharedInfo(SharedInfo_in) : ptr(_ptr), SharedInfo(SharedInfo_in)
{ {
ITERATOR_VERIFY(ptr >= SharedInfo->first && ptr <= SharedInfo->last); ITERATOR_VERIFY(ptr >= SharedInfo->first && ptr <= SharedInfo->last);
} }
output_iterator_wrapper(const output_iterator_wrapper& in) output_iterator_wrapper(const output_iterator_wrapper& in)
:ptr(in.ptr), SharedInfo(in.SharedInfo) : ptr(in.ptr), SharedInfo(in.SharedInfo)
{ } { }
WritableObject<T> WritableObject<T>
@ -175,8 +174,8 @@ namespace __gnu_test
* instansiated directly, but generated from a test_container * instansiated directly, but generated from a test_container
*/ */
template<class T> template<class T>
class input_iterator_wrapper:public std::iterator class input_iterator_wrapper
<std::input_iterator_tag, T, ptrdiff_t, T*, T&> : public std::iterator<std::input_iterator_tag, T, ptrdiff_t, T*, T&>
{ {
protected: protected:
input_iterator_wrapper() input_iterator_wrapper()
@ -188,11 +187,11 @@ namespace __gnu_test
ContainerType* SharedInfo; ContainerType* SharedInfo;
input_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in) input_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in)
: ptr(_ptr), SharedInfo(SharedInfo_in) : ptr(_ptr), SharedInfo(SharedInfo_in)
{ ITERATOR_VERIFY(ptr >= SharedInfo->first && ptr <= SharedInfo->last); } { ITERATOR_VERIFY(ptr >= SharedInfo->first && ptr <= SharedInfo->last); }
input_iterator_wrapper(const input_iterator_wrapper& in) input_iterator_wrapper(const input_iterator_wrapper& in)
: ptr(in.ptr), SharedInfo(in.SharedInfo) : ptr(in.ptr), SharedInfo(in.SharedInfo)
{ } { }
bool bool
@ -257,16 +256,16 @@ namespace __gnu_test
* instansiated directly, but generated from a test_container * instansiated directly, but generated from a test_container
*/ */
template<class T> template<class T>
struct forward_iterator_wrapper:public input_iterator_wrapper<T> struct forward_iterator_wrapper : public input_iterator_wrapper<T>
{ {
typedef BoundsContainer<T> ContainerType; typedef BoundsContainer<T> ContainerType;
typedef std::forward_iterator_tag iterator_category; typedef std::forward_iterator_tag iterator_category;
forward_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in) forward_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in)
:input_iterator_wrapper<T>(_ptr, SharedInfo_in) : input_iterator_wrapper<T>(_ptr, SharedInfo_in)
{ } { }
forward_iterator_wrapper(const forward_iterator_wrapper& in) forward_iterator_wrapper(const forward_iterator_wrapper& in)
:input_iterator_wrapper<T>(in) : input_iterator_wrapper<T>(in)
{ } { }
forward_iterator_wrapper() forward_iterator_wrapper()
@ -311,16 +310,16 @@ namespace __gnu_test
* instansiated directly, but generated from a test_container * instansiated directly, but generated from a test_container
*/ */
template<class T> template<class T>
struct bidirectional_iterator_wrapper:public forward_iterator_wrapper<T> struct bidirectional_iterator_wrapper : public forward_iterator_wrapper<T>
{ {
typedef BoundsContainer<T> ContainerType; typedef BoundsContainer<T> ContainerType;
typedef std::bidirectional_iterator_tag iterator_category; typedef std::bidirectional_iterator_tag iterator_category;
bidirectional_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in) bidirectional_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in)
:forward_iterator_wrapper<T>(_ptr, SharedInfo_in) : forward_iterator_wrapper<T>(_ptr, SharedInfo_in)
{ } { }
bidirectional_iterator_wrapper(const bidirectional_iterator_wrapper& in) bidirectional_iterator_wrapper(const bidirectional_iterator_wrapper& in)
:forward_iterator_wrapper<T>(in) : forward_iterator_wrapper<T>(in)
{ } { }
bidirectional_iterator_wrapper(): forward_iterator_wrapper<T>() bidirectional_iterator_wrapper(): forward_iterator_wrapper<T>()
@ -375,16 +374,17 @@ namespace __gnu_test
* instansiated directly, but generated from a test_container * instansiated directly, but generated from a test_container
*/ */
template<class T> template<class T>
struct random_access_iterator_wrapper:public bidirectional_iterator_wrapper<T> struct random_access_iterator_wrapper
: public bidirectional_iterator_wrapper<T>
{ {
typedef BoundsContainer<T> ContainerType; typedef BoundsContainer<T> ContainerType;
typedef std::random_access_iterator_tag iterator_category; typedef std::random_access_iterator_tag iterator_category;
random_access_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in) random_access_iterator_wrapper(T* _ptr, ContainerType* SharedInfo_in)
: bidirectional_iterator_wrapper<T>(_ptr, SharedInfo_in) : bidirectional_iterator_wrapper<T>(_ptr, SharedInfo_in)
{ } { }
random_access_iterator_wrapper(const random_access_iterator_wrapper<T>& in) random_access_iterator_wrapper(const random_access_iterator_wrapper<T>& in)
: bidirectional_iterator_wrapper<T>(in) : bidirectional_iterator_wrapper<T>(in)
{ } { }
random_access_iterator_wrapper():bidirectional_iterator_wrapper<T>() random_access_iterator_wrapper():bidirectional_iterator_wrapper<T>()