feedc0de/boost_algorithm
1
0
Fork 0
forked from boostorg/algorithm
Code Pull Requests Activity

Remove unnecessary #include <algorithm> and correct some comments

Browse Source
This commit is contained in:
Kolya Matteo
2016-04-29 15:37:09 -04:00
parent 795c6c69e5
commit 1da90fcc4a
12 changed files with 5 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
include/boost/algorithm/cxx11/all_of.hpp
View File

@ -12,7 +12,6 @@
#ifndef BOOST_ALGORITHM_ALL_OF_HPP #ifndef BOOST_ALGORITHM_ALL_OF_HPP
#define BOOST_ALGORITHM_ALL_OF_HPP #define BOOST_ALGORITHM_ALL_OF_HPP
#include <algorithm> // for std::all_of, if available
#include <boost/range/begin.hpp> #include <boost/range/begin.hpp>
#include <boost/range/end.hpp> #include <boost/range/end.hpp>
@ -27,8 +26,6 @@ namespace boost { namespace algorithm {
/// \param p A predicate for testing the elements of the sequence /// \param p A predicate for testing the elements of the sequence
/// ///
/// \note This function is part of the C++2011 standard library. /// \note This function is part of the C++2011 standard library.
/// We will use the standard one if it is available,
/// otherwise we have our own implementation.
template<typename InputIterator, typename Predicate> template<typename InputIterator, typename Predicate>
bool all_of ( InputIterator first, InputIterator last, Predicate p ) bool all_of ( InputIterator first, InputIterator last, Predicate p )
{ {

1
include/boost/algorithm/cxx11/any_of.hpp
View File

@ -14,7 +14,6 @@
#ifndef BOOST_ALGORITHM_ANY_OF_HPP #ifndef BOOST_ALGORITHM_ANY_OF_HPP
#define BOOST_ALGORITHM_ANY_OF_HPP #define BOOST_ALGORITHM_ANY_OF_HPP
#include <algorithm> // for std::any_of, if available
#include <boost/range/begin.hpp> #include <boost/range/begin.hpp>
#include <boost/range/end.hpp> #include <boost/range/end.hpp>

4
include/boost/algorithm/cxx11/copy_if.hpp
View File

@ -12,7 +12,7 @@
#ifndef BOOST_ALGORITHM_COPY_IF_HPP #ifndef BOOST_ALGORITHM_COPY_IF_HPP
#define BOOST_ALGORITHM_COPY_IF_HPP #define BOOST_ALGORITHM_COPY_IF_HPP
#include <algorithm> // for std::copy_if, if available #include <utility> // for std::pair, std::make_pair
#include <boost/range/begin.hpp> #include <boost/range/begin.hpp>
#include <boost/range/end.hpp> #include <boost/range/end.hpp>
@ -28,8 +28,6 @@ namespace boost { namespace algorithm {
/// \param result An output iterator to write the results into /// \param result An output iterator to write the results into
/// \param p A predicate for testing the elements of the range /// \param p A predicate for testing the elements of the range
/// \note This function is part of the C++2011 standard library. /// \note This function is part of the C++2011 standard library.
/// We will use the standard one if it is available,
/// otherwise we have our own implementation.
template<typename InputIterator, typename OutputIterator, typename Predicate> template<typename InputIterator, typename OutputIterator, typename Predicate>
OutputIterator copy_if ( InputIterator first, InputIterator last, OutputIterator result, Predicate p ) OutputIterator copy_if ( InputIterator first, InputIterator last, OutputIterator result, Predicate p )
{ {

4
include/boost/algorithm/cxx11/copy_n.hpp
View File

@ -12,8 +12,6 @@
#ifndef BOOST_ALGORITHM_COPY_N_HPP #ifndef BOOST_ALGORITHM_COPY_N_HPP
#define BOOST_ALGORITHM_COPY_N_HPP #define BOOST_ALGORITHM_COPY_N_HPP
#include <algorithm> // for std::copy_n, if available
namespace boost { namespace algorithm { namespace boost { namespace algorithm {
/// \fn copy_n ( InputIterator first, Size n, OutputIterator result ) /// \fn copy_n ( InputIterator first, Size n, OutputIterator result )
@ -25,8 +23,6 @@ namespace boost { namespace algorithm {
/// \param n The number of elements to copy /// \param n The number of elements to copy
/// \param result An output iterator to write the results into /// \param result An output iterator to write the results into
/// \note This function is part of the C++2011 standard library. /// \note This function is part of the C++2011 standard library.
/// We will use the standard one if it is available,
/// otherwise we have our own implementation.
template <typename InputIterator, typename Size, typename OutputIterator> template <typename InputIterator, typename Size, typename OutputIterator>
OutputIterator copy_n ( InputIterator first, Size n, OutputIterator result ) OutputIterator copy_n ( InputIterator first, Size n, OutputIterator result )
{ {

4
include/boost/algorithm/cxx11/find_if_not.hpp
View File

@ -12,8 +12,6 @@
#ifndef BOOST_ALGORITHM_FIND_IF_NOT_HPP #ifndef BOOST_ALGORITHM_FIND_IF_NOT_HPP
#define BOOST_ALGORITHM_FIND_IF_NOT_HPP #define BOOST_ALGORITHM_FIND_IF_NOT_HPP
#include <algorithm> // for std::find_if_not, if it exists
#include <boost/range/begin.hpp> #include <boost/range/begin.hpp>
#include <boost/range/end.hpp> #include <boost/range/end.hpp>
@ -27,8 +25,6 @@ namespace boost { namespace algorithm {
/// \param last One past the end of the input sequence /// \param last One past the end of the input sequence
/// \param p A predicate for testing the elements of the range /// \param p A predicate for testing the elements of the range
/// \note This function is part of the C++2011 standard library. /// \note This function is part of the C++2011 standard library.
/// We will use the standard one if it is available,
/// otherwise we have our own implementation.
template<typename InputIterator, typename Predicate> template<typename InputIterator, typename Predicate>
InputIterator find_if_not ( InputIterator first, InputIterator last, Predicate p ) InputIterator find_if_not ( InputIterator first, InputIterator last, Predicate p )
{ {

4
include/boost/algorithm/cxx11/iota.hpp
View File

@ -12,8 +12,6 @@
#ifndef BOOST_ALGORITHM_IOTA_HPP #ifndef BOOST_ALGORITHM_IOTA_HPP
#define BOOST_ALGORITHM_IOTA_HPP #define BOOST_ALGORITHM_IOTA_HPP
#include <numeric>
#include <boost/range/begin.hpp> #include <boost/range/begin.hpp>
#include <boost/range/end.hpp> #include <boost/range/end.hpp>
@ -26,8 +24,6 @@ namespace boost { namespace algorithm {
/// \param last One past the end of the input sequence /// \param last One past the end of the input sequence
/// \param value The initial value of the sequence to be generated /// \param value The initial value of the sequence to be generated
/// \note This function is part of the C++2011 standard library. /// \note This function is part of the C++2011 standard library.
/// We will use the standard one if it is available,
/// otherwise we have our own implementation.
template <typename ForwardIterator, typename T> template <typename ForwardIterator, typename T>
void iota ( ForwardIterator first, ForwardIterator last, T value ) void iota ( ForwardIterator first, ForwardIterator last, T value )
{ {

4
include/boost/algorithm/cxx11/is_partitioned.hpp
View File

@ -12,8 +12,6 @@
#ifndef BOOST_ALGORITHM_IS_PARTITIONED_HPP #ifndef BOOST_ALGORITHM_IS_PARTITIONED_HPP
#define BOOST_ALGORITHM_IS_PARTITIONED_HPP #define BOOST_ALGORITHM_IS_PARTITIONED_HPP
#include <algorithm> // for std::is_partitioned, if available
#include <boost/range/begin.hpp> #include <boost/range/begin.hpp>
#include <boost/range/end.hpp> #include <boost/range/end.hpp>
@ -26,8 +24,6 @@ namespace boost { namespace algorithm {
/// \param last One past the end of the input sequence /// \param last One past the end of the input sequence
/// \param p The predicate to test the values with /// \param p The predicate to test the values with
/// \note This function is part of the C++2011 standard library. /// \note This function is part of the C++2011 standard library.
/// We will use the standard one if it is available,
/// otherwise we have our own implementation.
template <typename InputIterator, typename UnaryPredicate> template <typename InputIterator, typename UnaryPredicate>
bool is_partitioned ( InputIterator first, InputIterator last, UnaryPredicate p ) bool is_partitioned ( InputIterator first, InputIterator last, UnaryPredicate p )
{ {

8
include/boost/algorithm/cxx11/is_permutation.hpp
View File

@ -12,8 +12,8 @@
#ifndef BOOST_ALGORITHM_IS_PERMUTATION11_HPP #ifndef BOOST_ALGORITHM_IS_PERMUTATION11_HPP
#define BOOST_ALGORITHM_IS_PERMUTATION11_HPP #define BOOST_ALGORITHM_IS_PERMUTATION11_HPP
#include <algorithm> // for std::less, tie, mismatch and is_permutation (if available) #include <algorithm> // for std::find_if, count_if, mismatch
#include <utility> // for std::make_pair #include <utility> // for std::pair
#include <functional> // for std::equal_to #include <functional> // for std::equal_to
#include <iterator> #include <iterator>
@ -108,8 +108,6 @@ namespace detail {
/// \param p The predicate to compare elements with /// \param p The predicate to compare elements with
/// ///
/// \note This function is part of the C++2011 standard library. /// \note This function is part of the C++2011 standard library.
/// We will use the standard one if it is available,
/// otherwise we have our own implementation.
template< class ForwardIterator1, class ForwardIterator2, class BinaryPredicate > template< class ForwardIterator1, class ForwardIterator2, class BinaryPredicate >
bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1, bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1,
ForwardIterator2 first2, BinaryPredicate p ) ForwardIterator2 first2, BinaryPredicate p )
@ -135,8 +133,6 @@ bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1,
/// \param last2 One past the end of the input sequence /// \param last2 One past the end of the input sequence
/// \param first2 The start of the second sequence /// \param first2 The start of the second sequence
/// \note This function is part of the C++2011 standard library. /// \note This function is part of the C++2011 standard library.
/// We will use the standard one if it is available,
/// otherwise we have our own implementation.
template< class ForwardIterator1, class ForwardIterator2 > template< class ForwardIterator1, class ForwardIterator2 >
bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2 ) bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2 )
{ {

1
include/boost/algorithm/cxx11/is_sorted.hpp
View File

@ -13,7 +13,6 @@
#ifndef BOOST_ALGORITHM_ORDERED_HPP #ifndef BOOST_ALGORITHM_ORDERED_HPP
#define BOOST_ALGORITHM_ORDERED_HPP #define BOOST_ALGORITHM_ORDERED_HPP
#include <algorithm>
#include <functional> #include <functional>
#include <iterator> #include <iterator>

1
include/boost/algorithm/cxx11/none_of.hpp
View File

@ -12,7 +12,6 @@
#ifndef BOOST_ALGORITHM_NONE_OF_HPP #ifndef BOOST_ALGORITHM_NONE_OF_HPP
#define BOOST_ALGORITHM_NONE_OF_HPP #define BOOST_ALGORITHM_NONE_OF_HPP
#include <algorithm> // for std::none_of, if available
#include <boost/range/begin.hpp> #include <boost/range/begin.hpp>
#include <boost/range/end.hpp> #include <boost/range/end.hpp>

5
include/boost/algorithm/cxx11/partition_copy.hpp
View File

@ -12,8 +12,7 @@
#ifndef BOOST_ALGORITHM_PARTITION_COPY_HPP #ifndef BOOST_ALGORITHM_PARTITION_COPY_HPP
#define BOOST_ALGORITHM_PARTITION_COPY_HPP #define BOOST_ALGORITHM_PARTITION_COPY_HPP
#include <algorithm> // for std::partition_copy, if available #include <utility> // for std::pair
#include <utility> // for make_pair
#include <boost/range/begin.hpp> #include <boost/range/begin.hpp>
#include <boost/range/end.hpp> #include <boost/range/end.hpp>
@ -34,8 +33,6 @@ namespace boost { namespace algorithm {
/// \param p A predicate for dividing the elements of the input sequence. /// \param p A predicate for dividing the elements of the input sequence.
/// ///
/// \note This function is part of the C++2011 standard library. /// \note This function is part of the C++2011 standard library.
/// We will use the standard one if it is available,
/// otherwise we have our own implementation.
template <typename InputIterator, template <typename InputIterator,
typename OutputIterator1, typename OutputIterator2, typename UnaryPredicate> typename OutputIterator1, typename OutputIterator2, typename UnaryPredicate>
std::pair<OutputIterator1, OutputIterator2> std::pair<OutputIterator1, OutputIterator2>

4
include/boost/algorithm/cxx11/partition_point.hpp
View File

@ -12,7 +12,7 @@
#ifndef BOOST_ALGORITHM_PARTITION_POINT_HPP #ifndef BOOST_ALGORITHM_PARTITION_POINT_HPP
#define BOOST_ALGORITHM_PARTITION_POINT_HPP #define BOOST_ALGORITHM_PARTITION_POINT_HPP
#include <algorithm> // for std::partition_point, if available #include <iterator> // for std::distance, advance
#include <boost/range/begin.hpp> #include <boost/range/begin.hpp>
#include <boost/range/end.hpp> #include <boost/range/end.hpp>
@ -27,8 +27,6 @@ namespace boost { namespace algorithm {
/// \param last One past the end of the input sequence /// \param last One past the end of the input sequence
/// \param p The predicate to test the values with /// \param p The predicate to test the values with
/// \note This function is part of the C++2011 standard library. /// \note This function is part of the C++2011 standard library.
/// We will use the standard one if it is available,
/// otherwise we have our own implementation.
template <typename ForwardIterator, typename Predicate> template <typename ForwardIterator, typename Predicate>
ForwardIterator partition_point ( ForwardIterator first, ForwardIterator last, Predicate p ) ForwardIterator partition_point ( ForwardIterator first, ForwardIterator last, Predicate p )
{ {