boostorg/algorithm
1
0
Fork 1
mirror of https://github.com/boostorg/algorithm.git synced 2025-07-01 15:00:59 +02:00
Code Issues Packages Projects Releases Wiki Activity

Merge Boost.Algorithm inspection report changes to release. No functionality change

Browse Source 
[SVN r78689]
This commit is contained in:
Marshall Clow
2012-05-27 15:45:18 +00:00
parent 563fe27a59
commit 96d4708367
20 changed files with 166 additions and 166 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

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

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

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

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

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

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

@ -12,7 +12,7 @@
#ifndef BOOST_ALGORITHM_IS_PARTITIONED_HPP
#define BOOST_ALGORITHM_IS_PARTITIONED_HPP
#include <algorithm> // for std::is_partitioned, if available
#include <algorithm> // for std::is_partitioned, if available
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
@ -35,14 +35,14 @@ using std::is_partitioned; // Section 25.3.13
template <typename InputIterator, typename UnaryPredicate>
bool is_partitioned ( InputIterator first, InputIterator last, UnaryPredicate p )
{
// Run through the part that satisfy the predicate
// Run through the part that satisfy the predicate
for ( ; first != last; ++first )
if ( !p (*first))
break;
// Now the part that does not satisfy the predicate
break;
// Now the part that does not satisfy the predicate
for ( ; first != last; ++first )
if ( p (*first))
return false;
return false;
return true;
}
#endif

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

@ -94,7 +94,7 @@ using std::is_sorted; // Section 25.4.1.5
#endif
///
/// -- Range based versions of the C++11 functions
/// -- Range based versions of the C++11 functions
///
/// \fn is_sorted_until ( const R &range, Pred p )
@ -126,7 +126,7 @@ using std::is_sorted; // Section 25.4.1.5
}
namespace detail {
typedef struct { typedef bool type; } bool_;
typedef struct { typedef bool type; } bool_;
};
/// \fn is_sorted ( const R &range, Pred p )
@ -157,7 +157,7 @@ namespace detail {
///
/// -- Range based versions of the C++11 functions
/// -- Range based versions of the C++11 functions
///
/// \fn is_increasing ( ForwardIterator first, ForwardIterator last )

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

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

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

@ -12,7 +12,7 @@
#ifndef BOOST_ALGORITHM_PARTITION_COPY_HPP
#define BOOST_ALGORITHM_PARTITION_COPY_HPP
#include <algorithm> // for std::partition_copy, if available
#include <algorithm> // for std::partition_copy, if available
#include <utility> // for make_pair
#include <boost/range/begin.hpp>

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

@ -12,7 +12,7 @@
#ifndef BOOST_ALGORITHM_PARTITION_POINT_HPP
#define BOOST_ALGORITHM_PARTITION_POINT_HPP
#include <algorithm> // for std::partition_point, if available
#include <algorithm> // for std::partition_point, if available
#include <boost/range/begin.hpp>
#include <boost/range/end.hpp>
@ -25,7 +25,7 @@ using std::partition_point; // Section 25.3.13
#else
/// \fn partition_point ( ForwardIterator first, ForwardIterator last, Predicate p )
/// \brief Given a partitioned range, returns the partition point, i.e, the first element
/// that does not satisfy p
/// that does not satisfy p
///
/// \param first The start of the input sequence
/// \param last One past the end of the input sequence

2
include/boost/algorithm/hex.hpp
View File

@ -45,7 +45,7 @@ namespace boost { namespace algorithm {
\struct non_hex_input
\brief Thrown when a non-hex value (0-9, A-F) encountered when decoding.
Contains the offending character
Contains the offending character
\struct not_enough_input
\brief Thrown when the input sequence unexpectedly ends

2
include/boost/algorithm/searching/knuth_morris_pratt.hpp
View File

@ -32,7 +32,7 @@ namespace boost { namespace algorithm {
* Random-access iterators
* The two iterator types (I1 and I2) must "point to" the same underlying type.
http://en.wikipedia.org/wiki/Knuth–Morris–Pratt_algorithm
http://en.wikipedia.org/wiki/Knuth-Morris-Pratt_algorithm
http://www.inf.fh-flensburg.de/lang/algorithmen/pattern/kmpen.htm
*/

88
test/copy_n_test1.cpp
View File

@ -22,60 +22,60 @@ namespace ba = boost::algorithm;
template <typename Container>
void test_sequence ( Container const &c ) {
typedef typename Container::value_type value_type;
std::vector<value_type> v;
typedef typename Container::value_type value_type;
std::vector<value_type> v;
// Copy zero elements
v.clear ();
ba::copy_n ( c.begin (), 0, back_inserter ( v ));
BOOST_CHECK ( v.size () == 0 );
ba::copy_n ( c.begin (), 0U, back_inserter ( v ));
BOOST_CHECK ( v.size () == 0 );
// Copy zero elements
v.clear ();
ba::copy_n ( c.begin (), 0, back_inserter ( v ));
BOOST_CHECK ( v.size () == 0 );
ba::copy_n ( c.begin (), 0U, back_inserter ( v ));
BOOST_CHECK ( v.size () == 0 );
if ( c.size () > 0 ) {
// Just one element
v.clear ();
ba::copy_n ( c.begin (), 1, back_inserter ( v ));
BOOST_CHECK ( v.size () == 1 );
BOOST_CHECK ( v[0] == *c.begin ());
if ( c.size () > 0 ) {
// Just one element
v.clear ();
ba::copy_n ( c.begin (), 1, back_inserter ( v ));
BOOST_CHECK ( v.size () == 1 );
BOOST_CHECK ( v[0] == *c.begin ());
v.clear ();
ba::copy_n ( c.begin (), 1U, back_inserter ( v ));
BOOST_CHECK ( v.size () == 1 );
BOOST_CHECK ( v[0] == *c.begin ());
v.clear ();
ba::copy_n ( c.begin (), 1U, back_inserter ( v ));
BOOST_CHECK ( v.size () == 1 );
BOOST_CHECK ( v[0] == *c.begin ());
// Half the elements
v.clear ();
ba::copy_n ( c.begin (), c.size () / 2, back_inserter ( v ));
BOOST_CHECK ( v.size () == c.size () / 2);
BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
// Half the elements
v.clear ();
ba::copy_n ( c.begin (), c.size () / 2, back_inserter ( v ));
BOOST_CHECK ( v.size () == c.size () / 2);
BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
// Half the elements + 1
v.clear ();
ba::copy_n ( c.begin (), c.size () / 2 + 1, back_inserter ( v ));
BOOST_CHECK ( v.size () == c.size () / 2 + 1 );
BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
// Half the elements + 1
v.clear ();
ba::copy_n ( c.begin (), c.size () / 2 + 1, back_inserter ( v ));
BOOST_CHECK ( v.size () == c.size () / 2 + 1 );
BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
// All the elements
v.clear ();
ba::copy_n ( c.begin (), c.size (), back_inserter ( v ));
BOOST_CHECK ( v.size () == c.size ());
BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
}
}
// All the elements
v.clear ();
ba::copy_n ( c.begin (), c.size (), back_inserter ( v ));
BOOST_CHECK ( v.size () == c.size ());
BOOST_CHECK ( std::equal ( v.begin (), v.end (), c.begin ()));
}
}
void test_sequence1 () {
std::vector<int> v;
for ( int i = 5; i < 15; ++i )
v.push_back ( i );
test_sequence ( v );
std::vector<int> v;
for ( int i = 5; i < 15; ++i )
v.push_back ( i );
test_sequence ( v );
std::list<int> l;
for ( int i = 25; i > 15; --i )
l.push_back ( i );
test_sequence ( l );
}
std::list<int> l;
for ( int i = 25; i > 15; --i )
l.push_back ( i );
test_sequence ( l );
}
int test_main( int , char* [] )

24
test/find_if_not_test1.cpp
View File

@ -22,18 +22,18 @@ namespace ba = boost::algorithm;
template <typename Container>
typename Container::iterator offset_to_iter ( Container &v, int offset ) {
typename Container::iterator retval;
typename Container::iterator retval;
if ( offset >= 0 ) {
retval = v.begin ();
std::advance ( retval, offset );
}
else {
retval = v.end ();
std::advance ( retval, offset + 1 );
}
return retval;
}
if ( offset >= 0 ) {
retval = v.begin ();
std::advance ( retval, offset );
}
else {
retval = v.end ();
std::advance ( retval, offset + 1 );
}
return retval;
}
template <typename Container, typename Predicate>
void test_sequence ( Container &v, Predicate comp, int expected ) {
@ -71,7 +71,7 @@ void test_sequence1 () {
test_sequence ( v, less_than<int>(10), 5 );
test_sequence ( v, less_than<int>(99), -1 ); // all elements satisfy
// With bidirectional iterators.
// With bidirectional iterators.
std::list<int> l;
for ( int i = 5; i < 15; ++i )
l.push_back ( i );

2
test/hex_fail1.cpp
View File

@ -15,7 +15,7 @@
#include <iostream>
#include <vector>
// should not compile: vector is not an integral type
// should not compile: vector is not an integral type
int test_main( int , char* [] )
{
std::vector<float> v;

16
test/hex_test3.cpp
View File

@ -21,12 +21,12 @@ Try ostream_iterators
template <typename char_type>
void test_to_hex ( const char_type ** tests ) {
typedef std::basic_string<char_type> String;
typedef std::basic_ostringstream<char_type> Stream;
typedef std::ostream_iterator<char_type, char_type> Iter;
typedef std::basic_string<char_type> String;
typedef std::basic_ostringstream<char_type> Stream;
typedef std::ostream_iterator<char_type, char_type> Iter;
for ( const char_type **p = tests; *p; p++ ) {
String arg, argh;
String arg, argh;
Stream one, two, three;
arg.assign ( *p );
boost::algorithm::hex ( *p, Iter ( one ));
@ -49,12 +49,12 @@ void test_to_hex ( const char_type ** tests ) {
template <typename char_type>
void test_from_hex_success ( const char_type ** tests ) {
typedef std::basic_string<char_type> String;
typedef std::basic_ostringstream<char_type> Stream;
typedef std::ostream_iterator<char_type, char_type> Iter;
typedef std::basic_string<char_type> String;
typedef std::basic_ostringstream<char_type> Stream;
typedef std::ostream_iterator<char_type, char_type> Iter;
for ( const char_type **p = tests; *p; p++ ) {
String arg, argh;
String arg, argh;
Stream one, two, three;
arg.assign ( *p );
boost::algorithm::unhex ( *p, Iter ( one ));

72
test/iota_test1.cpp
View File

@ -16,60 +16,60 @@
#include <vector>
#include <list>
// Test to make sure a sequence is "correctly formed"; i.e, ascending by one
// Test to make sure a sequence is "correctly formed"; i.e, ascending by one
template <typename Iterator, typename T>
bool test_iota_results ( Iterator first, Iterator last, T initial_value ) {
if ( first == last ) return true;
if ( initial_value != *first ) return false;
Iterator prev = first;
while ( ++first != last ) {
if (( *first - *prev ) != 1 )
return false;
prev = first;
}
return true;
}
if ( first == last ) return true;
if ( initial_value != *first ) return false;
Iterator prev = first;
while ( ++first != last ) {
if (( *first - *prev ) != 1 )
return false;
prev = first;
}
return true;
}
template <typename Range, typename T>
bool test_iota_results ( const Range &r, T initial_value ) {
return test_iota_results (boost::begin (r), boost::end (r), initial_value );
return test_iota_results (boost::begin (r), boost::end (r), initial_value );
}
void test_ints () {
std::vector<int> v;
std::list<int> l;
std::vector<int> v;
std::list<int> l;
v.clear (); v.reserve ( 10 );
boost::algorithm::iota ( v.begin (), v.end (), 23 );
BOOST_CHECK ( test_iota_results ( v.begin (), v.end (), 23 ));
v.clear (); v.reserve ( 10 );
boost::algorithm::iota ( v.begin (), v.end (), 23 );
BOOST_CHECK ( test_iota_results ( v.begin (), v.end (), 23 ));
v.clear (); v.reserve ( 19 );
boost::algorithm::iota ( v, 18 );
BOOST_CHECK ( test_iota_results ( v, 18 ));
v.clear (); v.reserve ( 19 );
boost::algorithm::iota ( v, 18 );
BOOST_CHECK ( test_iota_results ( v, 18 ));
v.clear ();
boost::algorithm::iota_n ( std::back_inserter(v), 99, 20 );
BOOST_CHECK ( test_iota_results ( v, 99 ));
v.clear ();
boost::algorithm::iota_n ( std::back_inserter(v), 99, 20 );
BOOST_CHECK ( test_iota_results ( v, 99 ));
/*
l.clear (); l.reserve ( 5 );
boost::algorithm::iota ( l.begin (), l.end (), 123 );
BOOST_CHECK ( test_iota_results ( l.begin (), l.end (), 123 ));
l.clear (); l.reserve ( 5 );
boost::algorithm::iota ( l.begin (), l.end (), 123 );
BOOST_CHECK ( test_iota_results ( l.begin (), l.end (), 123 ));
l.clear (); l.reserve ( 9 );
boost::algorithm::iota ( l.begin (), l.end (), 87 );
BOOST_CHECK ( test_iota_results ( l.begin (), l.end (), 87 ));
l.clear (); l.reserve ( 9 );
boost::algorithm::iota ( l.begin (), l.end (), 87 );
BOOST_CHECK ( test_iota_results ( l.begin (), l.end (), 87 ));
*/
l.clear ();
boost::algorithm::iota_n ( std::back_inserter(l), 99, 20 );
BOOST_CHECK ( test_iota_results ( l, 99 ));
l.clear ();
boost::algorithm::iota_n ( std::back_inserter(l), 99, 20 );
BOOST_CHECK ( test_iota_results ( l, 99 ));
l.clear ();
boost::algorithm::iota_n ( std::front_inserter(l), 123, 20 );
BOOST_CHECK ( test_iota_results ( l.rbegin (), l.rend (), 123 ));
}
l.clear ();
boost::algorithm::iota_n ( std::front_inserter(l), 123, 20 );
BOOST_CHECK ( test_iota_results ( l.rbegin (), l.rend (), 123 ));
}
int test_main( int , char* [] )

18
test/is_partitioned_test1.cpp
View File

@ -40,19 +40,19 @@ void test_sequence1 () {
v.clear ();
for ( int i = 5; i < 15; ++i )
v.push_back ( i );
BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(3))); // no elements
BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(6))); // only the first element
BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(10))); // in the middle somewhere
BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(99))); // all elements satisfy
BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(3))); // no elements
BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(6))); // only the first element
BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(10))); // in the middle somewhere
BOOST_CHECK ( ba::is_partitioned ( v, less_than<int>(99))); // all elements satisfy
// With bidirectional iterators.
// With bidirectional iterators.
std::list<int> l;
for ( int i = 5; i < 15; ++i )
l.push_back ( i );
BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(3))); // no elements
BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(6))); // only the first element
BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(10))); // in the middle somewhere
BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(99))); // all elements satisfy
BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(3))); // no elements
BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(6))); // only the first element
BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(10))); // in the middle somewhere
BOOST_CHECK ( ba::is_partitioned ( l.begin (), l.end (), less_than<int>(99))); // all elements satisfy
}

24
test/ordered_test.cpp
View File

@ -36,24 +36,24 @@ test_ordered(void)
int nonConstantArray[] = { 1, 2, 2, 2, 5 };
const int inOrderUntilTheEnd [] = { 0, 1, 2, 3, 4, 5, 6, 7, 6 };
// Begin/end checks
BOOST_CHECK ( ba::is_sorted (b_e(strictlyIncreasingValues)));
BOOST_CHECK ( !ba::is_sorted (b_e(randomValues)));
BOOST_CHECK ( ba::is_sorted (b_e(strictlyIncreasingValues), std::less<int>()));
BOOST_CHECK ( !ba::is_sorted (b_e(strictlyIncreasingValues), std::greater<int>()));
// Begin/end checks
BOOST_CHECK ( ba::is_sorted (b_e(strictlyIncreasingValues)));
BOOST_CHECK ( !ba::is_sorted (b_e(randomValues)));
BOOST_CHECK ( ba::is_sorted (b_e(strictlyIncreasingValues), std::less<int>()));
BOOST_CHECK ( !ba::is_sorted (b_e(strictlyIncreasingValues), std::greater<int>()));
// Range checks
BOOST_CHECK ( ba::is_sorted (a_range(strictlyIncreasingValues)));
BOOST_CHECK ( !ba::is_sorted (a_range(randomValues)));
BOOST_CHECK ( ba::is_sorted (a_range(strictlyIncreasingValues), std::less<int>()));
BOOST_CHECK ( !ba::is_sorted (a_range(strictlyIncreasingValues), std::greater<int>()));
// Range checks
BOOST_CHECK ( ba::is_sorted (a_range(strictlyIncreasingValues)));
BOOST_CHECK ( !ba::is_sorted (a_range(randomValues)));
BOOST_CHECK ( ba::is_sorted (a_range(strictlyIncreasingValues), std::less<int>()));
BOOST_CHECK ( !ba::is_sorted (a_range(strictlyIncreasingValues), std::greater<int>()));
BOOST_CHECK ( ba::is_sorted_until ( b_e(strictlyIncreasingValues)) == a_end(strictlyIncreasingValues));
BOOST_CHECK ( ba::is_sorted_until ( b_e(strictlyIncreasingValues), std::less<int>()) == a_end(strictlyIncreasingValues));
BOOST_CHECK ( ba::is_sorted_until ( a_range(strictlyIncreasingValues)) == boost::end(strictlyIncreasingValues));
BOOST_CHECK ( ba::is_sorted_until ( a_range(strictlyIncreasingValues), std::less<int>()) == boost::end(strictlyIncreasingValues));
// Check for const and non-const arrays
// Check for const and non-const arrays
BOOST_CHECK ( ba::is_sorted_until ( b_e(constantValues), std::less<int>()) != a_end(constantValues));
BOOST_CHECK ( ba::is_sorted_until ( a_range(constantValues), std::less<int>()) != boost::end(constantValues));
BOOST_CHECK ( ba::is_sorted_until ( b_e(nonConstantArray), std::less<int>()) != a_end(nonConstantArray));
@ -149,6 +149,6 @@ test_increasing_decreasing(void)
int test_main( int, char * [] )
{
test_ordered ();
test_increasing_decreasing ();
test_increasing_decreasing ();
return 0;
}

24
test/partition_point_test1.cpp
View File

@ -22,18 +22,18 @@ namespace ba = boost::algorithm;
template <typename Container>
typename Container::iterator offset_to_iter ( Container &v, int offset ) {
typename Container::iterator retval;
typename Container::iterator retval;
if ( offset >= 0 ) {
retval = v.begin ();
std::advance ( retval, offset );
}
else {
retval = v.end ();
std::advance ( retval, offset + 1 );
}
return retval;
}
if ( offset >= 0 ) {
retval = v.begin ();
std::advance ( retval, offset );
}
else {
retval = v.end ();
std::advance ( retval, offset + 1 );
}
return retval;
}
template <typename Container, typename Predicate>
void test_sequence ( Container &v, Predicate comp, int expected ) {
@ -79,7 +79,7 @@ void test_sequence1 () {
test_sequence ( v, less_than<int>(10), 5 );
test_sequence ( v, less_than<int>(99), -1 ); // all elements satisfy
// With bidirectional iterators.
// With bidirectional iterators.
std::list<int> l;
for ( int i = 5; i < 15; ++i )
l.push_back ( i );