Skip to content

R
riscv-gcc-1
Commit 65be6ddd by Benjamin Kosnik
Options

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
parent 7e501b00
Showing with 520 additions and 454 deletions
libstdc++-v3/ChangeLog
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 @@ ...@@ -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.
......
libstdc++-v3/config.h.in
...@@ -24,6 +24,9 @@ ...@@ -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
......
libstdc++-v3/include/Makefile.am
...@@ -754,7 +754,10 @@ host_headers = \ ...@@ -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 = \ ...@@ -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} ...@@ -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: ...@@ -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}
......
libstdc++-v3/include/Makefile.in
...@@ -981,7 +981,10 @@ host_headers = \ ...@@ -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 = \ ...@@ -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} ...@@ -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: ...@@ -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}
......
libstdc++-v3/include/bits/char_traits.h
...@@ -60,7 +60,7 @@ _GLIBCXX_BEGIN_NAMESPACE(__gnu_cxx) ...@@ -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;
......
libstdc++-v3/include/bits/stl_function.h
...@@ -124,9 +124,11 @@ _GLIBCXX_BEGIN_NAMESPACE(std) ...@@ -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) ...@@ -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) ...@@ -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) ...@@ -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) ...@@ -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) ...@@ -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) ...@@ -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) ...@@ -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) ...@@ -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) ...@@ -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) ...@@ -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>
{ {
......
libstdc++-v3/include/ext/throw_allocator.h
...@@ -39,7 +39,7 @@ ...@@ -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 @@ ...@@ -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
......
libstdc++-v3/include/std/valarray
...@@ -881,7 +881,7 @@ _GLIBCXX_BEGIN_NAMESPACE(std) ...@@ -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) ...@@ -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>
......
libstdc++-v3/scripts/check_compile
...@@ -28,7 +28,7 @@ PCH_FLAGS=`$flags_script --cxxpchflags` ...@@ -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 ...@@ -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
......
libstdc++-v3/testsuite/25_algorithms/headers/algorithm/synopsis.cc
...@@ -20,385 +20,442 @@ ...@@ -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<typename _IIter, typename _Tp>
template<class InputIterator, class Predicate> _IIter
InputIterator find_if(InputIterator first, InputIterator last, find(_IIter, _IIter, const _Tp&);
Predicate pred);
template<class ForwardIterator1, class ForwardIterator2> template<typename _IIter, typename _Predicate>
ForwardIterator1 _IIter
find_end(ForwardIterator1 first1, ForwardIterator1 last1, find_if(_IIter, _IIter, _Predicate);
ForwardIterator2 first2, ForwardIterator2 last2);
template<class ForwardIterator1, class ForwardIterator2, template<typename _FIter1, typename _FIter2>
class BinaryPredicate> _FIter1
ForwardIterator1 find_end(_FIter1, _FIter1, _FIter2, _FIter2);
find_end(ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2, template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
BinaryPredicate pred); _FIter1
template<class ForwardIterator1, class ForwardIterator2> find_end(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
ForwardIterator1
find_first_of(ForwardIterator1 first1, ForwardIterator1 last1, template<typename _FIter1, typename _FIter2>
ForwardIterator2 first2, ForwardIterator2 last2); _FIter1
template<class ForwardIterator1, class ForwardIterator2, find_first_of(_FIter1, _FIter1, _FIter2, _FIter2);
class BinaryPredicate>
ForwardIterator1 template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
find_first_of(ForwardIterator1 first1, ForwardIterator1 last1, _FIter1
ForwardIterator2 first2, ForwardIterator2 last2, find_first_of(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
BinaryPredicate pred);
template<typename _FIter>
template<class ForwardIterator> _FIter
ForwardIterator adjacent_find(ForwardIterator first, adjacent_find(_FIter, _FIter);
ForwardIterator last);
template<typename _FIter, typename _BinaryPredicate>
template<class ForwardIterator, class BinaryPredicate> _FIter
ForwardIterator adjacent_find(ForwardIterator first, adjacent_find(_FIter, _FIter, _BinaryPredicate);
ForwardIterator last, BinaryPredicate pred);
template<typename _IIter, typename _Tp>
template<class InputIterator, class T> typename iterator_traits<_IIter>::difference_type
typename iterator_traits<InputIterator>::difference_type count(_IIter, _IIter, const _Tp&);
count(InputIterator first, InputIterator last, const T& value);
template<typename _IIter, typename _Predicate>
template<class InputIterator, class Predicate> typename iterator_traits<_IIter>::difference_type
typename iterator_traits<InputIterator>::difference_type count_if(_IIter, _IIter, _Predicate);
count_if(InputIterator first, InputIterator last, Predicate pred);
template<class InputIterator1, class InputIterator2> template<typename _IIter1, typename _IIter2>
pair<InputIterator1, InputIterator2> pair<_IIter1, _IIter2>
mismatch(InputIterator1 first1, InputIterator1 last1, mismatch(_IIter1, _IIter1, _IIter2);
InputIterator2 first2);
template template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
<class InputIterator1, class InputIterator2, class BinaryPredicate> pair<_IIter1, _IIter2>
pair<InputIterator1, InputIterator2> mismatch(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
mismatch(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, BinaryPredicate pred); template<typename _IIter1, typename _IIter2>
template<class InputIterator1, class InputIterator2> bool
bool equal(InputIterator1 first1, InputIterator1 last1, equal(_IIter1, _IIter1, _IIter2);
InputIterator2 first2);
template template<typename _IIter1, typename _IIter2, typename _BinaryPredicate>
<class InputIterator1, class InputIterator2, class BinaryPredicate> bool
bool equal(InputIterator1 first1, InputIterator1 last1, equal(_IIter1, _IIter1, _IIter2, _BinaryPredicate);
InputIterator2 first2, BinaryPredicate pred);
template<typename _FIter1, typename _FIter2>
template<class ForwardIterator1, class ForwardIterator2> _FIter1
ForwardIterator1 search search(_FIter1, _FIter1, _FIter2, _FIter2);
(ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, ForwardIterator2 last2); template<typename _FIter1, typename _FIter2, typename _BinaryPredicate>
_FIter1
template<class ForwardIterator1, class ForwardIterator2, search(_FIter1, _FIter1, _FIter2, _FIter2, _BinaryPredicate);
class BinaryPredicate>
ForwardIterator1 search template<typename _FIter, typename _Size, typename _Tp>
(ForwardIterator1 first1, ForwardIterator1 last1, _FIter
ForwardIterator2 first2, ForwardIterator2 last2, search_n(_FIter, _FIter, _Size, const _Tp&);
BinaryPredicate pred);
template<typename _FIter, typename _Size, typename _Tp,
template<class ForwardIterator, class Size, class T> typename _BinaryPredicate>
ForwardIterator search_n(ForwardIterator first, ForwardIterator last, _FIter
Size count, const T& value); search_n(_FIter, _FIter, _Size, const _Tp&, _BinaryPredicate);
template <class ForwardIterator, class Size, class T, class BinaryPredicate> // 25.2, modifying sequence operations:
ForwardIterator search_n(ForwardIterator first, ForwardIterator last, // 25.2.1, copy:
Size count, const T& value, template<typename _IIter, typename _OIter>
BinaryPredicate pred); _OIter
copy(_IIter, _IIter, _OIter);
// 25.2, modifying sequence operations:
// 25.2.1, copy: template<typename _BIter1, typename _BIter2>
template<class InputIterator, class OutputIterator> _BIter2
OutputIterator copy(InputIterator first, InputIterator last, copy_backward (_BIter1, _BIter1, _BIter2);
OutputIterator result);
template<class BidirectionalIterator1, class BidirectionalIterator2> // 25.2.2, swap:
BidirectionalIterator2 template<typename _Tp>
copy_backward void
(BidirectionalIterator1 first, BidirectionalIterator1 last, swap(_Tp&, _Tp& b);
BidirectionalIterator2 result);
// 25.2.2, swap: template<typename _FIter1, typename _FIter2>
template<class T> void swap(T& a, T& b); _FIter2
template<class ForwardIterator1, class ForwardIterator2> swap_ranges(_FIter1 first1, _FIter1, _FIter2);
ForwardIterator2 swap_ranges(ForwardIterator1 first1,
ForwardIterator1 last1, ForwardIterator2 first2); template<typename _FIter1, typename _FIter2>
template<class ForwardIterator1, class ForwardIterator2> void
void iter_swap(ForwardIterator1 a, ForwardIterator2 b); iter_swap(_FIter1, _FIter2 b);
template<class InputIterator, class OutputIterator, class UnaryOperation>
OutputIterator transform(InputIterator first, InputIterator last, template<typename _IIter, typename _OIter, typename _UnaryOperation>
OutputIterator result, UnaryOperation op); _OIter
template<class InputIterator1, class InputIterator2, class OutputIterator, transform(_IIter, _IIter, _OIter, _UnaryOperation op);
class BinaryOperation>
OutputIterator transform(InputIterator1 first1, InputIterator1 last1, template<typename _IIter1, typename _IIter2, typename _OIter,
InputIterator2 first2, OutputIterator result, typename _BinaryOperation>
BinaryOperation binary_op); _OIter
template<class ForwardIterator, class T> transform(_IIter1, _IIter1, _IIter2, _OIter, _BinaryOperation);
void replace(ForwardIterator first, ForwardIterator last,
const T& old_value, const T& new_value); template<typename _FIter, typename _Tp>
template<class ForwardIterator, class Predicate, class T> void
void replace_if(ForwardIterator first, ForwardIterator last, replace(_FIter, _FIter, const _Tp&, const _Tp&);
Predicate pred, const T& new_value);
template<class InputIterator, class OutputIterator, class T> template<typename _FIter, typename _Predicate, typename _Tp>
OutputIterator replace_copy(InputIterator first, InputIterator last, void
OutputIterator result, replace_if(_FIter, _FIter, _Predicate, const _Tp&);
const T& old_value, const T& new_value);
template<class Iterator, class OutputIterator, class Predicate, class T> template<typename _IIter, typename _OIter, typename _Tp>
OutputIterator replace_copy_if(Iterator first, Iterator last, _OIter
OutputIterator result, replace_copy(_IIter, _IIter, _OIter, const _Tp&, const _Tp&);
Predicate pred, const T& new_value);
template<class ForwardIterator, class T> template<typename _Iter, typename _OIter, typename _Predicate, typename _Tp>
void fill(ForwardIterator first, ForwardIterator last, const T& value); _OIter
template<class OutputIterator, class Size, class T> replace_copy_if(_Iter, _Iter, _OIter, _Predicate, const _Tp&);
void fill_n(OutputIterator first, Size n, const T& value);
template<class ForwardIterator, class Generator> template<typename _FIter, typename _Tp>
void generate(ForwardIterator first, ForwardIterator last, void
Generator gen); fill(_FIter, _FIter, const _Tp&);
template<class OutputIterator, class Size, class Generator>
void generate_n(OutputIterator first, Size n, Generator gen); template<typename _OIter, typename _Size, typename _Tp>
void
template<class ForwardIterator, class T> fill_n(_OIter, _Size n, const _Tp&);
ForwardIterator remove(ForwardIterator first, ForwardIterator last,
const T& value); template<typename _FIter, typename _Generator>
template<class ForwardIterator, class Predicate> void
ForwardIterator remove_if(ForwardIterator first, ForwardIterator last, generate(_FIter, _FIter, _Generator);
Predicate pred);
template<class InputIterator, class OutputIterator, class T> template<typename _OIter, typename _Size, typename _Generator>
OutputIterator remove_copy(InputIterator first, InputIterator last, void
OutputIterator result, const T& value); generate_n(_OIter, _Size, _Generator);
template<class InputIterator, class OutputIterator, class Predicate>
OutputIterator remove_copy_if(InputIterator first, InputIterator last, template<typename _FIter, typename _Tp>
OutputIterator result, Predicate pred); _FIter
template<class ForwardIterator> remove(_FIter, _FIter, const _Tp&);
ForwardIterator unique(ForwardIterator first, ForwardIterator last);
template<class ForwardIterator, class BinaryPredicate> template<typename _FIter, typename _Predicate>
ForwardIterator unique(ForwardIterator first, ForwardIterator last, _FIter
BinaryPredicate pred); remove_if(_FIter, _FIter, _Predicate);
template<class InputIterator, class OutputIterator>
OutputIterator unique_copy(InputIterator first, InputIterator last, template<typename _IIter, typename _OIter, typename _Tp>
OutputIterator result); _OIter
template<class InputIterator, class OutputIterator, class BinaryPredicate> remove_copy(_IIter, _IIter, _OIter, const _Tp&);
OutputIterator unique_copy(InputIterator first, InputIterator last,
OutputIterator result, BinaryPredicate pred); template<typename _IIter, typename _OIter, typename _Predicate>
template<class BidirectionalIterator> _OIter
void reverse(BidirectionalIterator first, BidirectionalIterator last); remove_copy_if(_IIter, _IIter, _OIter, _Predicate);
template<class BidirectionalIterator, class OutputIterator>
OutputIterator reverse_copy(BidirectionalIterator first, template<typename _FIter>
BidirectionalIterator last, _FIter
OutputIterator result); unique(_FIter, _FIter);
template<class ForwardIterator>
void rotate(ForwardIterator first, ForwardIterator middle, template<typename _FIter, typename _BinaryPredicate>
ForwardIterator last); _FIter
template<class ForwardIterator, class OutputIterator> unique(_FIter, _FIter, _BinaryPredicate);
OutputIterator rotate_copy
(ForwardIterator first, ForwardIterator middle, template<typename _IIter, typename _OIter>
ForwardIterator last, OutputIterator result); _OIter
template<class RandomAccessIterator> unique_copy(_IIter, _IIter, _OIter);
void random_shuffle(RandomAccessIterator first,
RandomAccessIterator last); template<typename _IIter, typename _OIter, typename _BinaryPredicate>
template<class RandomAccessIterator, class RandomNumberGenerator> _OIter
void random_shuffle(RandomAccessIterator first, unique_copy(_IIter, _IIter, _OIter, _BinaryPredicate);
RandomAccessIterator last,
RandomNumberGenerator& rand); template<typename _BIter>
// 25.2.12, partitions: void
template<class BidirectionalIterator, class Predicate> reverse(_BIter, _BIter);
BidirectionalIterator partition(BidirectionalIterator first,
BidirectionalIterator last, template<typename _BIter, typename _OIter>
Predicate pred); _OIter
template<class BidirectionalIterator, class Predicate> reverse_copy(_BIter, _BIter, _OIter);
BidirectionalIterator stable_partition(BidirectionalIterator first,
BidirectionalIterator last, template<typename _FIter>
Predicate pred); void
// 25.3, sorting and related operations: rotate(_FIter, _FIter, _FIter);
// 25.3.1, sorting:
template<class RandomAccessIterator> template<typename _FIter, typename _OIter>
void sort(RandomAccessIterator first, RandomAccessIterator last); _OIter
template<class RandomAccessIterator, class Compare> rotate_copy (_FIter, _FIter, _FIter, _OIter);
void sort(RandomAccessIterator first, RandomAccessIterator last,
Compare comp); template<typename _RAIter>
template<class RandomAccessIterator> void
void stable_sort(RandomAccessIterator first, RandomAccessIterator last); random_shuffle(_RAIter, _RAIter);
template<class RandomAccessIterator, class Compare>
void stable_sort(RandomAccessIterator first, RandomAccessIterator last, template<typename _RAIter, typename _Generator>
Compare comp); void
template<class RandomAccessIterator> random_shuffle(_RAIter, _RAIter, _Generator&);
void partial_sort(RandomAccessIterator first,
RandomAccessIterator middle, // 25.2.12, partitions:
RandomAccessIterator last); template<typename _BIter, typename _Predicate>
template<class RandomAccessIterator, class Compare> _BIter
void partial_sort(RandomAccessIterator first, partition(_BIter, _BIter, _Predicate);
RandomAccessIterator middle,
RandomAccessIterator last, Compare comp); template<typename _BIter, typename _Predicate>
template<class InputIterator, class RandomAccessIterator> _BIter
RandomAccessIterator stable_partition(_BIter, _BIter, _Predicate);
partial_sort_copy(InputIterator first, InputIterator last,
RandomAccessIterator result_first, // 25.3, sorting and related operations:
RandomAccessIterator result_last); // 25.3.1, sorting:
template<class InputIterator, class RandomAccessIterator, class Compare> template<typename _RAIter>
RandomAccessIterator void
partial_sort_copy(InputIterator first, InputIterator last, sort(_RAIter, _RAIter);
RandomAccessIterator result_first,
RandomAccessIterator result_last, template<typename _RAIter, typename _Compare>
Compare comp); void
template<class RandomAccessIterator> sort(_RAIter, _RAIter, _Compare);
void nth_element(RandomAccessIterator first, RandomAccessIterator nth,
RandomAccessIterator last); template<typename _RAIter>
template<class RandomAccessIterator, class Compare> void
void nth_element(RandomAccessIterator first, RandomAccessIterator nth, stable_sort(_RAIter, _RAIter);
RandomAccessIterator last, Compare comp);
// 25.3.3, binary search: template<typename _RAIter, typename _Compare>
template<class ForwardIterator, class T> void
ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last, stable_sort(_RAIter, _RAIter, _Compare);
const T& value);
template<class ForwardIterator, class T, class Compare> template<typename _RAIter>
ForwardIterator lower_bound(ForwardIterator first, ForwardIterator last, void
const T& value, Compare comp); partial_sort(_RAIter, _RAIter, _RAIter);
template<class ForwardIterator, class T>
ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last, template<typename _RAIter, typename _Compare>
const T& value); void
template<class ForwardIterator, class T, class Compare> partial_sort(_RAIter, _RAIter, _RAIter, _Compare);
ForwardIterator upper_bound(ForwardIterator first, ForwardIterator last,
const T& value, Compare comp); template<typename _IIter, typename _RAIter>
template<class ForwardIterator, class T> _RAIter
pair<ForwardIterator, ForwardIterator> partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter);
equal_range(ForwardIterator first, ForwardIterator last,
const T& value); template<typename _IIter, typename _RAIter, typename _Compare>
template<class ForwardIterator, class T, class Compare> _RAIter
pair<ForwardIterator, ForwardIterator> partial_sort_copy(_IIter, _IIter, _RAIter, _RAIter, _Compare);
equal_range(ForwardIterator first, ForwardIterator last,
const T& value, Compare comp); template<typename _RAIter>
template<class ForwardIterator, class T> void
bool binary_search(ForwardIterator first, ForwardIterator last, nth_element(_RAIter, _RAIter, _RAIter);
const T& value);
template<class ForwardIterator, class T, class Compare> template<typename _RAIter, typename _Compare>
bool binary_search(ForwardIterator first, ForwardIterator last, void
const T& value, Compare comp); nth_element(_RAIter, _RAIter, _RAIter, _Compare);
// 25.3.4, merge:
template<class InputIterator1, class InputIterator2, class OutputIterator> // 25.3.3, binary search:
OutputIterator merge(InputIterator1 first1, InputIterator1 last1, template<typename _FIter, typename _Tp>
InputIterator2 first2, InputIterator2 last2, _FIter
OutputIterator result); lower_bound(_FIter, _FIter, const _Tp&);
template<class InputIterator1, class InputIterator2, class OutputIterator,
class Compare> template<typename _FIter, typename _Tp, typename _Compare>
OutputIterator merge(InputIterator1 first1, InputIterator1 last1, _FIter
InputIterator2 first2, InputIterator2 last2, lower_bound(_FIter, _FIter, const _Tp&, _Compare);
OutputIterator result, Compare comp);
template<class BidirectionalIterator> template<typename _FIter, typename _Tp>
void inplace_merge(BidirectionalIterator first, _FIter
BidirectionalIterator middle, upper_bound(_FIter, _FIter, const _Tp&);
BidirectionalIterator last);
template<class BidirectionalIterator, class Compare> template<typename _FIter, typename _Tp, typename _Compare>
void inplace_merge(BidirectionalIterator first, _FIter
BidirectionalIterator middle, upper_bound(_FIter, _FIter, const _Tp&, _Compare);
BidirectionalIterator last, Compare comp);
// 25.3.5, set operations: template<typename _FIter, typename _Tp>
template<class InputIterator1, class InputIterator2> pair<_FIter, _FIter>
bool includes(InputIterator1 first1, InputIterator1 last1, equal_range(_FIter, _FIter, const _Tp&);
InputIterator2 first2, InputIterator2 last2);
template<class InputIterator1, class InputIterator2, class Compare> template<typename _FIter, typename _Tp, typename _Compare>
bool includes pair<_FIter, _FIter>
(InputIterator1 first1, InputIterator1 last1, equal_range(_FIter, _FIter, const _Tp&, _Compare);
InputIterator2 first2, InputIterator2 last2, Compare comp);
template<class InputIterator1, class InputIterator2, class OutputIterator> template<typename _FIter, typename _Tp>
OutputIterator set_union(InputIterator1 first1, InputIterator1 last1, bool
InputIterator2 first2, InputIterator2 last2, binary_search(_FIter, _FIter, const _Tp&);
OutputIterator result);
template<class InputIterator1, class InputIterator2, class OutputIterator, template<typename _FIter, typename _Tp, typename _Compare>
class Compare> bool
OutputIterator set_union(InputIterator1 first1, InputIterator1 last1, binary_search(_FIter, _FIter, const _Tp&, _Compare);
InputIterator2 first2, InputIterator2 last2,
OutputIterator result, Compare comp); // 25.3.4, merge:
template<class InputIterator1, class InputIterator2, class OutputIterator> template<typename _IIter1, typename _IIter2, typename _OIter>
OutputIterator set_intersection _OIter
(InputIterator1 first1, InputIterator1 last1, merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
InputIterator2 first2, InputIterator2 last2,
OutputIterator result); template<typename _IIter1, typename _IIter2, typename _OIter,
template<class InputIterator1, class InputIterator2, class OutputIterator, typename _Compare>
class Compare> _OIter
OutputIterator set_intersection merge(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
(InputIterator1 first1, InputIterator1 last1,
InputIterator2 first2, InputIterator2 last2, template<typename _BIter>
OutputIterator result, Compare comp); void
template<class InputIterator1, class InputIterator2, class OutputIterator> inplace_merge(_BIter, _BIter, _BIter);
OutputIterator set_difference
(InputIterator1 first1, InputIterator1 last1, template<typename _BIter, typename _Compare>
InputIterator2 first2, InputIterator2 last2, void
OutputIterator result); inplace_merge(_BIter, _BIter, _BIter, _Compare);
template<class InputIterator1, class InputIterator2, class OutputIterator,
class Compare> // 25.3.5, set operations:
OutputIterator set_difference template<typename _IIter1, typename _IIter2>
(InputIterator1 first1, InputIterator1 last1, bool
InputIterator2 first2, InputIterator2 last2, includes(_IIter1, _IIter1, _IIter2, _IIter2);
OutputIterator result, Compare comp);
template<class InputIterator1, class InputIterator2, class OutputIterator> template<typename _IIter1, typename _IIter2, typename _Compare>
OutputIterator bool
set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, includes(_IIter1, _IIter1, _IIter2, _IIter2, _Compare);
InputIterator2 first2, InputIterator2 last2,
OutputIterator result); template<typename _IIter1, typename _IIter2, typename _OIter>
template<class InputIterator1, class InputIterator2, class OutputIterator, _OIter
class Compare> set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
OutputIterator
set_symmetric_difference(InputIterator1 first1, InputIterator1 last1, template<typename _IIter1, typename _IIter2, typename _OIter,
InputIterator2 first2, InputIterator2 last2, typename _Compare>
OutputIterator result, Compare comp); _OIter
// 25.3.6, heap operations: set_union(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
template<class RandomAccessIterator>
void push_heap(RandomAccessIterator first, RandomAccessIterator last); template<typename _IIter1, typename _IIter2, typename _OIter>
template<class RandomAccessIterator, class Compare> _OIter
void push_heap(RandomAccessIterator first, RandomAccessIterator last, set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
Compare comp);
template<class RandomAccessIterator> template<typename _IIter1, typename _IIter2, typename _OIter,
void pop_heap(RandomAccessIterator first, RandomAccessIterator last); typename _Compare>
template<class RandomAccessIterator, class Compare> _OIter
void pop_heap(RandomAccessIterator first, RandomAccessIterator last, set_intersection(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
Compare comp);
template<class RandomAccessIterator> template<typename _IIter1, typename _IIter2, typename _OIter>
void make_heap(RandomAccessIterator first, RandomAccessIterator last); _OIter
template<class RandomAccessIterator, class Compare> set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter);
void make_heap(RandomAccessIterator first, RandomAccessIterator last,
Compare comp); template<typename _IIter1, typename _IIter2, typename _OIter,
template<class RandomAccessIterator> typename _Compare>
void sort_heap(RandomAccessIterator first, RandomAccessIterator last); _OIter
template<class RandomAccessIterator, class Compare> set_difference(_IIter1, _IIter1, _IIter2, _IIter2, _OIter, _Compare);
void sort_heap(RandomAccessIterator first, RandomAccessIterator last,
Compare comp); 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);
} }
libstdc++-v3/testsuite/util/testsuite_iterators.h
...@@ -61,8 +61,7 @@ namespace __gnu_test ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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 ...@@ -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>()
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment