Release 1.51.0

[SVN r80098]

doc/Jamfile.v2

@@ -0,0 +1,42 @@
+# Boost.Algorithm
+#
+# Copyright (c) 2010-2012 Marshall Clow
+#
+# Distributed under the Boost Software License, Version 1.0.
+# (See accompanying file LICENSE_1_0.txt or copy at
+# http://www.boost.org/LICENSE_1_0.txt)
+
+
+# Quickbook
+# -----------------------------------------------------------------------------
+
+import os ;
+
+using quickbook ;
+using doxygen ;
+using boostbook ;
+
+doxygen autodoc 
+    : 
+        [ glob ../../../boost/algorithm/*.hpp ../../../boost/algorithm/searching/*.hpp ]
+    : 
+       <doxygen:param>"PREDEFINED=\"BOOST_ALGORITHM_DOXYGEN=1\""
+       <doxygen:param>WARNINGS=YES # Default NO, but useful to see warnings, especially in a logfile.
+    ; 
+
+
+xml algorithm : algorithm.qbk ;
+
+boostbook standalone
+  :
+    algorithm
+  :
+    <dependency>autodoc 
+    <xsl:param>boost.root=../../../..
+    <xsl:param>"boost.doxygen.reftitle=Boost.Algorithms C++ Reference"
+    <xsl:param>chapter.autolabel=0
+    <xsl:param>chunk.section.depth=8
+    <xsl:param>toc.section.depth=2
+    <xsl:param>toc.max.depth=2
+    <xsl:param>generate.section.toc.level=1
+  ;

doc/algorithm.qbk

@@ -0,0 +1,68 @@
+[library The Boost Algorithm Library
+    [quickbook 1.5]
+    [id algorithm]
+    [dirname algorithm]
+    [purpose Library of useful algorithms]
+    [category algorithms]
+    [authors [Clow, Marshall]]
+    [copyright 2010-2012 Marshall Clow]
+    [source-mode c++]
+    [license
+		Distributed under the Boost Software License, Version 1.0.
+		(See accompanying file LICENSE_1_0.txt or copy at
+		[@http://www.boost.org/LICENSE_1_0.txt])
+    ]
+]
+
+[section Description and Rationale]
+
+Boost.Algorithm is a collection of general purpose algorithms. While Boost contains many libraries of data structures, there is no single library for general purpose algorithms. Even though the algorithms are generally useful, many tend to be thought of as "too small" for Boost.
+
+An implementation of Boyer-Moore searching, for example, might take a developer a week or so to implement, including test cases and documentation. However, scheduling a review to include that code into Boost might take several months, and run into resistance because "it is too small". Nevertheless, a library of tested, reviewed, documented algorithms can make the developer's life much easier, and that is the purpose of this library.
+
+[heading Future plans]
+
+I will be soliciting submissions from other developers, as well as looking through the literature for existing algorithms to include. The Adobe Source Library, for example, contains many useful algorithms that already have documentation and test cases. Knuth's _The Art of Computer Programming_ is chock-full of algorithm descriptions, too. 
+
+My goal is to run regular algorithm reviews, similar to the Boost library review process, but with smaller chunks of code. 
+
+[heading Dependencies]
+
+Boost.Algorithm uses Boost.Range, Boost.Assert, Boost.Array, Boost.TypeTraits, and Boost.StaticAssert.
+
+
+[heading Acknowledgements]
+
+Thanks to all the people who have reviewed this library and made suggestions for improvements. Steven Watanabe and Sean Parent, in particular, have provided a great deal of help.
+
+[endsect]
+
+[/ include toc.qbk]
+
+
+[section:Searching Searching Algorithms]
+[include boyer_moore.qbk]
+[include boyer_moore_horspool.qbk]
+[include knuth_morris_pratt.qbk]
+[endsect]
+
+[section:CXX11 C++11 Algorithms]
+[include all_of.qbk]
+[include any_of.qbk]
+[include none_of.qbk]
+[include one_of.qbk]
+[include ordered-hpp.qbk]
+[include is_partitioned.qbk]
+[include partition_point.qbk]
+[endsect]
+
+[section:Misc Other Algorithms]
+[include clamp-hpp.qbk]
+[include hex.qbk]
+[endsect]
+
+
+
+[xinclude autodoc.xml]
+
+

doc/all_of.qbk

@@ -0,0 +1,89 @@
+[/ File all_of.qbk]
+
+[section:all_of all_of]
+
+[/license
+Copyright (c) 2010-2012 Marshall Clow
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+]
+
+The header file 'boost/algorithm/cxx11/all_of.hpp' contains four variants of a single algorithm, `all_of`. The algorithm tests all the elements of a sequence and returns true if they all share a  property.
+
+The routine `all_of` takes a sequence and a predicate. It will return true if the predicate returns true when applied to every element in the sequence. 
+
+The routine `all_of_equal` takes a sequence and a value. It will return true if every element in the sequence compares equal to the passed in value.
+
+Both routines come in two forms; the first one takes two iterators to define the range. The second form takes a single range parameter, and uses Boost.Range to traverse it.
+
+
+[heading interface]
+
+The function `all_of` returns true if the predicate returns true for every item in the sequence.  There are two versions; one takes two iterators, and the other takes a range.
+
+``
+namespace boost { namespace algorithm {
+template<typename InputIterator, typename Predicate>
+	bool all_of ( InputIterator first, InputIterator last, Predicate p );
+template<typename Range, typename Predicate> 
+	bool all_of ( const Range &r, Predicate p );
+}}
+``
+
+The function `all_of_equal` is similar to `all_of`, but instead of taking a predicate to test the elements of the sequence, it takes a value to compare against.
+
+``
+namespace boost { namespace algorithm {
+template<typename InputIterator, typename V>
+	bool all_of_equal ( InputIterator first, InputIterator last, V const &val );
+template<typename Range, typename V> 
+	bool all_of_equal ( const Range &r, V const &val );
+}}
+``
+
+[heading Examples]
+
+Given the container `c` containing `{ 0, 1, 2, 3, 14, 15 }`, then
+``
+bool isOdd ( int i ) { return i % 2 == 1; }
+bool lessThan10 ( int i ) { return i < 10; }
+
+using boost::algorithm;
+all_of ( c, isOdd ) --> false
+all_of ( c.begin (), c.end (), lessThan10 ) --> false
+all_of ( c.begin (), c.begin () + 3, lessThan10 ) --> true
+all_of ( c.end (), c.end (), isOdd ) --> true  // empty range
+all_of_equal ( c, 3 ) --> false
+all_of_equal ( c.begin () + 3, c.begin () + 4, 3 ) --> true
+all_of_equal ( c.begin (), c.begin (), 99 ) --> true  // empty range
+``
+
+[heading Iterator Requirements]
+
+`all_of` and `all_of_equal` work on all iterators except output iterators.
+
+[heading Complexity]
+
+All of the variants of `all_of` and `all_of_equal` run in ['O(N)] (linear) time; that is, they compare against each element in the list once. If any of the comparisons fail, the algorithm will terminate immediately, without examining the remaining members of the sequence.
+
+[heading Exception Safety]
+
+All of the variants of `all_of` and `all_of_equal` take their parameters by value or const reference, and do not depend upon any global state. Therefore, all the routines in this file provide the strong exception guarantee.
+
+[heading Notes]
+
+* The routine `all_of` is part of the C++11 standard. When compiled using a C++11 implementation, the implementation from the standard library will be used.
+
+* `all_of` and `all_of_equal` both return true for empty ranges, no matter what is passed to test against. When there are no items in the sequence to test, they all satisfy the condition to be tested against.
+
+* The second parameter to `all_of_value` is a template parameter, rather than deduced from the first parameter (`std::iterator_traits<InputIterator>::value_type`) because that allows more flexibility for callers, and takes advantage of built-in comparisons for the type that is pointed to by the iterator.  The function is defined to return true if, for all elements in the sequence, the expression `*iter == val` evaluates to true (where `iter` is an iterator to each element in the sequence)
+
+[endsect]
+
+[/ File all_of.qbk
+Copyright 2011 Marshall Clow
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
+]
+

doc/any_of.qbk

@@ -0,0 +1,89 @@
+[/ File any_of.qbk]
+
+[section:any_of any_of]
+
+[/license
+Copyright (c) 2010-2012 Marshall Clow
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+]
+
+The header file 'boost/algorithm/cxx11/any_of.hpp' contains four variants of a single algorithm, `any_of`. The algorithm tests the elements of a sequence and returns true if any of the elements has a  particular property.
+
+The routine `any_of` takes a sequence and a predicate. It will return true if the predicate returns true for any element in the sequence. 
+
+The routine `any_of_equal` takes a sequence and a value. It will return true if any element in the sequence compares equal to the passed in value.
+
+Both routines come in two forms; the first one takes two iterators to define the range. The second form takes a single range parameter, and uses Boost.Range to traverse it.
+
+
+[heading interface]
+
+The function `any_of` returns true if the predicate returns true any item in the sequence.  There are two versions; one takes two iterators, and the other takes a range.
+
+``
+namespace boost { namespace algorithm {
+template<typename InputIterator, typename Predicate>
+	bool any_of ( InputIterator first, InputIterator last, Predicate p );
+template<typename Range, typename Predicate> 
+	bool any_of ( const Range &r, Predicate p );
+}}
+``
+
+The function `any_of_equal` is similar to `any_of`, but instead of taking a predicate to test the elements of the sequence, it takes a value to compare against.
+
+``
+namespace boost { namespace algorithm {
+template<typename InputIterator, typename V>
+	bool any_of_equal ( InputIterator first, InputIterator last, V const &val );
+template<typename Range, typename V> 
+	bool any_of_equal ( const Range &r, V const &val );
+}}
+``
+
+[heading Examples]
+
+Given the container `c` containing `{ 0, 1, 2, 3, 14, 15 }`, then
+``
+bool isOdd ( int i ) { return i % 2 == 1; }
+bool lessThan10 ( int i ) { return i < 10; }
+
+using boost::algorithm;
+any_of ( c, isOdd ) --> true
+any_of ( c.begin (), c.end (), lessThan10 ) --> true
+any_of ( c.begin () + 4, c.end (), lessThan10 ) --> false
+any_of ( c.end (), c.end (), isOdd ) --> false  // empty range
+any_of_equal ( c, 3 ) --> true
+any_of_equal ( c.begin (), c.begin () + 3, 3 ) --> false
+any_of_equal ( c.begin (), c.begin (), 99 ) --> false  // empty range
+``
+
+[heading Iterator Requirements]
+
+`any_of` and `any_of_equal` work on all iterators except output iterators.
+
+[heading Complexity]
+
+All of the variants of `any_of` and `any_of_equal` run in ['O(N)] (linear) time; that is, they compare against each element in the list once. If any of the comparisons succeed, the algorithm will terminate immediately, without examining the remaining members of the sequence.
+
+[heading Exception Safety]
+
+All of the variants of `any_of` and `any_of_equal` take their parameters by value or const reference, and do not depend upon any global state. Therefore, all the routines in this file provide the strong exception guarantee.
+
+[heading Notes]
+
+* The routine `any_of` is part of the C++11 standard. When compiled using a C++11 implementation, the implementation from the standard library will be used.
+
+* `any_of` and `any_of_equal` both return false for empty ranges, no matter what is passed to test against. 
+
+* The second parameter to `any_of_value` is a template parameter, rather than deduced from the first parameter (`std::iterator_traits<InputIterator>::value_type`) because that allows more flexibility for callers, and takes advantage of built-in comparisons for the type that is pointed to by the iterator.  The function is defined to return true if, for any element in the sequence, the expression `*iter == val` evaluates to true (where `iter` is an iterator to each element in the sequence)
+
+[endsect]
+
+[/ File any_of.qbk
+Copyright 2011 Marshall Clow
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
+]
+

doc/boyer_moore.qbk

@@ -0,0 +1,95 @@
+[/ QuickBook Document version 1.5 ]
+
+[section:BoyerMoore Boyer-Moore Search]
+
+[/license
+
+Copyright (c) 2010-2012 Marshall Clow
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+]
+
+
+[heading Overview]
+
+The header file 'boyer_moore.hpp' contains an an implementation of the Boyer-Moore algorithm for searching sequences of values. 
+
+The Boyer–Moore string search algorithm is a particularly efficient string searching algorithm, and it has been the standard benchmark for the practical string search literature. The Boyer-Moore algorithm was invented by Bob Boyer and J. Strother Moore, and published in the October 1977 issue of the Communications of the ACM , and a copy of that article is available at [@http://www.cs.utexas.edu/~moore/publications/fstrpos.pdf].
+
+The Boyer-Moore algorithm uses two precomputed tables to give better performance than a naive search. These tables depend on the pattern being searched for, and give the Boyer-Moore algorithm larger a memory footprint and startup costs than a simpler algorithm, but these costs are recovered quickly during the searching process, especially if the pattern is longer than a few elements.
+
+However, the Boyer-Moore algorithm cannot be used with comparison predicates like `std::search`.
+
+Nomenclature: I refer to the sequence being searched for as the "pattern", and the sequence being searched in as the "corpus".
+
+[heading Interface]
+
+For flexibility, the Boyer-Moore algorithm has has two interfaces; an object-based interface and a procedural one. The object-based interface builds the tables in the constructor, and uses operator () to perform the search. The procedural interface builds the table and does the search all in one step. If you are going to be searching for the same pattern in multiple corpora, then you should use the object interface, and only build the tables once.
+
+Here is the object interface:
+``
+template <typename patIter>
+class boyer_moore {
+public:
+    boyer_moore ( patIter first, patIter last );
+    ~boyer_moore ();
+    
+    template <typename corpusIter>
+    corpusIter operator () ( corpusIter corpus_first, corpusIter corpus_last );
+    };
+``
+
+and here is the corresponding procedural interface:
+
+``
+template <typename patIter, typename corpusIter>
+corpusIter boyer_moore_search ( 
+        corpusIter corpus_first, corpusIter corpus_last, 
+        patIter pat_first, patIter pat_last );
+``
+
+Each of the functions is passed two pairs of iterators. The first two define the corpus and the second two define the pattern. Note that the two pairs need not be of the same type, but they do need to "point" at the same type. In other words, `patIter::value_type` and `curpusIter::value_type` need to be the same type.
+
+The return value of the function is an iterator pointing to the start of the pattern in the corpus. If the pattern is not found, it returns the end of the corpus (`corpus_last`).
+
+[heading Performance]
+
+The execution time of the Boyer-Moore algorithm, while still linear in the size of the string being searched, can have a significantly lower constant factor than many other search algorithms: it doesn't need to check every character of the string to be searched, but rather skips over some of them. Generally the algorithm gets faster as the pattern being searched for becomes longer. Its efficiency derives from the fact that with each unsuccessful attempt to find a match between the search string and the text it is searching, it uses the information gained from that attempt to rule out as many positions of the text as possible where the string cannot match.
+
+[heading Memory Use]
+
+The algorithm allocates two internal tables. The first one is proportional to the length of the pattern; the second one has one entry for each member of the "alphabet" in the pattern. For (8-bit) character types, this table contains 256 entries.
+
+[heading Complexity]
+
+The worst-case performance to find a pattern in the corpus is ['O(N)] (linear) time; that is, proportional to the length of the corpus being searched. In general, the search is sub-linear; not every entry in the corpus need be checked.
+
+[heading Exception Safety]
+
+Both the object-oriented and procedural versions of the Boyer-Moore algorithm take their parameters by value and do not use any information other than what is passed in. Therefore, both interfaces provide the strong exception guarantee.
+
+[heading Notes]
+
+* When using the object-based interface, the pattern must remain unchanged for during the searches; i.e, from the time the object is constructed until the final call to operator () returns.
+
+* The Boyer-Moore algorithm requires random-access iterators for both the pattern and the corpus.
+
+[heading Customization points] 
+
+The Boyer-Moore object takes a traits template parameter which enables the caller to customize how one of the precomputed tables is stored. This table, called the skip table, contains (logically) one entry for every possible value that the pattern can contain. When searching 8-bit character data, this table contains 256 elements. The traits class defines the table to be used. 
+
+The default traits class uses a `boost::array` for small 'alphabets' and a `tr1::unordered_map` for larger ones.  The array-based skip table gives excellent performance, but could be prohibitively large when the 'alphabet' of elements to be searched grows. The unordered_map based version only grows as the number of unique elements in the pattern, but makes many more heap allocations, and gives slower lookup performance. 
+
+To use a different skip table, you should define your own skip table object and your own traits class, and use them to instantiate the Boyer-Moore object. The interface to these objects is described TBD.
+
+
+[endsect]
+
+[/ File boyer_moore.qbk
+Copyright 2011 Marshall Clow
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
+]
+

doc/boyer_moore_horspool.qbk

@@ -0,0 +1,93 @@
+[/ QuickBook Document version 1.5 ]
+
+[section:BoyerMooreHorspool Boyer-Moore-Horspool Search]
+
+[/license
+
+Copyright (c) 2010-2012 Marshall Clow
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+]
+
+
+[heading Overview]
+
+The header file 'boyer_moore_horspool.hpp' contains an an implementation of the Boyer-Moore-Horspool algorithm for searching sequences of values. 
+
+The Boyer-Moore-Horspool search algorithm was published by Nigel Horspool in 1980. It is a refinement of the Boyer-Moore algorithm that trades space for time. It uses less space for internal tables than Boyer-Moore, and has poorer worst-case performance.
+
+The Boyer-Moore-Horspool algorithm cannot be used with comparison predicates like `std::search`.
+
+[heading Interface]
+
+Nomenclature: I refer to the sequence being searched for as the "pattern", and the sequence being searched in as the "corpus".
+
+For flexibility, the Boyer-Moore-Horspool algorithm has has two interfaces; an object-based interface and a procedural one. The object-based interface builds the tables in the constructor, and uses operator () to perform the search. The procedural interface builds the table and does the search all in one step. If you are going to be searching for the same pattern in multiple corpora, then you should use the object interface, and only build the tables once.
+
+Here is the object interface:
+``
+template <typename patIter>
+class boyer_moore_horspool {
+public:
+    boyer_moore_horspool ( patIter first, patIter last );
+    ~boyer_moore_horspool ();
+    
+    template <typename corpusIter>
+    corpusIter operator () ( corpusIter corpus_first, corpusIter corpus_last );
+    };
+``
+
+and here is the corresponding procedural interface:
+
+``
+template <typename patIter, typename corpusIter>
+corpusIter boyer_moore_horspool_search ( 
+        corpusIter corpus_first, corpusIter corpus_last, 
+        patIter pat_first, patIter pat_last );
+``
+
+Each of the functions is passed two pairs of iterators. The first two define the corpus and the second two define the pattern. Note that the two pairs need not be of the same type, but they do need to "point" at the same type. In other words, `patIter::value_type` and `curpusIter::value_type` need to be the same type.
+
+The return value of the function is an iterator pointing to the start of the pattern in the corpus. If the pattern is not found, it returns the end of the corpus (`corpus_last`).
+
+[heading Performance]
+
+The execution time of the Boyer-Moore-Horspool algorithm is linear in the size of the string being searched; it can have a significantly lower constant factor than many other search algorithms: it doesn't need to check every character of the string to be searched, but rather skips over some of them. Generally the algorithm gets faster as the pattern being searched for becomes longer. Its efficiency derives from the fact that with each unsuccessful attempt to find a match between the search string and the text it is searching, it uses the information gained from that attempt to rule out as many positions of the text as possible where the string cannot match.
+
+[heading Memory Use]
+
+The algorithm an internal table that has one entry for each member of the "alphabet" in the pattern. For (8-bit) character types, this table contains 256 entries.
+
+[heading Complexity]
+
+The worst-case performance is ['O(m x n)], where ['m] is the length of the pattern and ['n] is the length of the corpus. The average time is ['O(n)]. The best case performance is sub-linear, and is, in fact, identical to Boyer-Moore, but the initialization is quicker and the internal loop is simpler than Boyer-Moore.
+
+[heading Exception Safety]
+
+Both the object-oriented and procedural versions of the Boyer-Moore-Horspool algorithm take their parameters by value and do not use any information other than what is passed in. Therefore, both interfaces provide the strong exception guarantee.
+
+[heading Notes]
+
+* When using the object-based interface, the pattern must remain unchanged for during the searches; i.e, from the time the object is constructed until the final call to operator () returns.
+
+* The Boyer-Moore-Horspool algorithm requires random-access iterators for both the pattern and the corpus.
+
+[heading Customization points] 
+
+The Boyer-Moore-Horspool object takes a traits template parameter which enables the caller to customize how the precomputed table is stored. This table, called the skip table, contains (logically) one entry for every possible value that the pattern can contain. When searching 8-bit character data, this table contains 256 elements. The traits class defines the table to be used. 
+
+The default traits class uses a `boost::array` for small 'alphabets' and a `tr1::unordered_map` for larger ones.  The array-based skip table gives excellent performance, but could be prohibitively large when the 'alphabet' of elements to be searched grows. The unordered_map based version only grows as the number of unique elements in the pattern, but makes many more heap allocations, and gives slower lookup performance. 
+
+To use a different skip table, you should define your own skip table object and your own traits class, and use them to instantiate the Boyer-Moore-Horspool object. The interface to these objects is described TBD.
+
+
+[endsect]
+
+[/ File boyer_moore_horspool.qbk
+Copyright 2011 Marshall Clow
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
+]
+

doc/clamp-hpp.qbk

@@ -0,0 +1,73 @@
+[/ QuickBook Document version 1.5 ]
+[section:clamp clamp]
+
+[/license
+
+Copyright (c) 2010-2012 Marshall Clow
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+
+]
+
+
+The header file clamp.hpp contains two functions for "clamping" a value between a pair of boundary values.
+
+[heading clamp]
+
+The function `clamp (v, lo, hi)` returns:
+
+* lo if v < lo
+* hi if hi < v
+* otherwise, v
+
+Note: using `clamp` with floating point numbers may give unexpected results if one of the values is `NaN`.
+
+There is also a version that allows the caller to specify a comparison predicate to use instead of `operator <`.
+
+``
+template<typename V> 
+V clamp ( V val, V lo, V hi );
+
+template<typename V, typename Pred> 
+V clamp ( V val, V lo, V hi, Pred p );
+``
+
+The following code: ``
+   int foo = 23;
+   foo = clamp ( foo, 1, 10 );
+``
+will leave `foo` with a value of 10
+
+Complexity:
+	`clamp` will make either one or two calls to the comparison predicate before returning one of the three parameters.
+
+[heading clamp_range]
+There are also four range-based versions of clamp, that apply clamping to a series of values. You could write them yourself with std::transform and bind, like this: `std::transform ( first, last, out, bind ( clamp ( _1, lo, hi )))`, but they are provided here for your convenience.
+
+``
+template<typename InputIterator, typename OutputIterator> 
+OutputIterator clamp_range ( InputIterator first, InputIterator last, OutputIterator out,
+    typename std::iterator_traits<InputIterator>::value_type lo, 
+    typename std::iterator_traits<InputIterator>::value_type hi );
+
+template<typename Range, typename OutputIterator> 
+OutputIterator clamp_range ( const Range &r, OutputIterator out,
+	typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type lo, 
+	typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type hi );
+
+template<typename InputIterator, typename OutputIterator, typename Pred> 
+OutputIterator clamp_range ( InputIterator first, InputIterator last, OutputIterator out,
+    typename std::iterator_traits<InputIterator>::value_type lo, 
+    typename std::iterator_traits<InputIterator>::value_type hi, Pred p );
+
+template<typename Range, typename OutputIterator, typename Pred> 
+OutputIterator clamp_range ( const Range &r, OutputIterator out,
+	typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type lo, 
+	typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type hi,
+	Pred p );
+``
+
+
+[endsect]

doc/hex.qbk

@@ -0,0 +1,109 @@
+[/ File hex.qbk]
+
+[section:hex hex]
+
+[/license
+Copyright (c) 2011-2012 Marshall Clow
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+]
+
+The header file `'boost/algorithm/hex.hpp'` contains three variants each of two algorithms, `hex` and `unhex`. They are inverse algorithms; that is, one undoes the effort of the other. `hex` takes a sequence of values, and turns them into hexadecimal characters. `unhex` takes a sequence of hexadecimal characters, and outputs a sequence of values.
+
+`hex` and `unhex` come from MySQL, where they are used in database queries and stored procedures.
+
+[heading interface]
+
+The function `hex` takes a sequence of values and writes hexadecimal characters. There are three different interfaces, differing only in how the input sequence is specified.
+
+The first one takes an iterator pair. The second one takes a pointer to the start of a zero-terminated sequence, such as a c string, and the third takes a range as defined by the Boost.Range library.
+
+``
+template <typename InputIterator, typename OutputIterator>
+OutputIterator hex ( InputIterator first, InputIterator last, OutputIterator out );
+
+template <typename T, typename OutputIterator>
+OutputIterator hex ( const T *ptr, OutputIterator out );
+
+template <typename Range, typename OutputIterator>
+OutputIterator hex ( const Range &r, OutputIterator out );
+``
+
+`hex` writes only values in the range '0'..'9' and 'A'..'F', but is not limited to character output. The output iterator could refer to a wstring, or a vector of integers, or any other integral type.
+
+The function `unhex` takes the output of `hex` and turns it back into a sequence of values.
+
+The input parameters for the different variations of `unhex` are the same as `hex`.
+
+``
+template <typename InputIterator, typename OutputIterator>
+OutputIterator unhex ( InputIterator first, InputIterator last, OutputIterator out );
+
+template <typename T, typename OutputIterator>
+OutputIterator unhex ( const T *ptr, OutputIterator out );
+
+template <typename Range, typename OutputIterator>
+OutputIterator unhex ( const Range &r, OutputIterator out );
+``
+
+[heading Error Handling]
+The header 'hex.hpp' defines three exception classes:
+``
+struct hex_decode_error: virtual boost::exception, virtual std::exception {};
+struct not_enough_input : public hex_decode_error;
+struct non_hex_input : public hex_decode_error;
+``
+
+If the input to `unhex` does not contain an "even number" of hex digits, then an exception of type `boost::algorithm::not_enough_input` is thrown.
+
+If the input to `unhex` contains any non-hexadecimal characters, then an exception of type `boost::algorithm::non_hex_input` is thrown.
+
+If you want to catch all the decoding errors, you can catch exceptions of type `boost::algorithm::hex_decode_error`.
+
+[heading Examples]
+
+Assuming that `out` is an iterator that accepts `char` values, and `wout` accepts `wchar_t` values (and that sizeof ( wchar_t ) == 2)
+
+``
+hex ( "abcdef", out )  --> "616263646566"
+hex ( "32", out )     --> "3332"
+hex ( "abcdef", wout ) --> "006100620063006400650066"
+hex ( "32", wout )    --> "00330032"
+
+unhex ( "616263646566", out )  --> "abcdef"
+unhex ( "3332", out )          --> "32"
+unhex ( "616263646566", wout ) --> "\6162\6364\6566"	( i.e, a 3 character string )
+unhex ( "3332", wout )         --> "\3233"				( U+3332, SQUARE HUARADDO )
+
+unhex ( "3", out )            --> Error - not enough input
+unhex ( "32", wout )          --> Error - not enough input
+
+unhex ( "ACEG", out )         --> Error - non-hex input
+
+``
+
+[heading Iterator Requirements]
+
+`hex` and `unhex` work on all iterator types.
+
+[heading Complexity]
+
+All of the variants of `hex` and `unhex` run in ['O(N)] (linear) time; that is, that is, they process each element in the input sequence once.
+
+[heading Exception Safety]
+
+All of the variants of `hex` and `unhex` take their parameters by value or const reference, and do not depend upon any global state. Therefore, all the routines in this file provide the strong exception guarantee. However, when working on input iterators, if an exception is thrown, the input iterators will not be reset to their original values (i.e, the characters read from the iterator cannot be un-read)
+
+[heading Notes]
+
+* `hex` and `unhex` both do nothing when passed empty ranges.
+
+[endsect]
+
+[/ File hex.qbk
+Copyright 2011 Marshall Clow
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
+]
+

doc/is_partitioned.qbk

@@ -0,0 +1,69 @@
+[/ File is_partitioned.qbk]
+
+[section:is_partitioned is_partitioned ]
+
+[/license
+Copyright (c) 2010-2012 Marshall Clow
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+]
+
+The header file 'is_partitioned.hpp' contains two variants of a single algorithm, `is_partitioned`. The algorithm tests to see if a sequence is partitioned according to a predicate; in other words, all the items in the sequence that satisfy the predicate are at the beginning of the sequence.
+
+The routine `is_partitioned` takes a sequence and a predicate. It returns true if the sequence is partitioned according to the predicate.
+
+`is_partitioned` come in two forms; the first one takes two iterators to define the range. The second form takes a single range parameter, and uses Boost.Range to traverse it.
+
+
+[heading interface]
+
+The function `is_partitioned` returns true the items in the sequence are separated according to their ability to satisfy the predicate.  There are two versions; one takes two iterators, and the other takes a range.
+
+``
+template<typename InputIterator, typename Predicate>
+	bool is_partitioned ( InputIterator first, InputIterator last, Predicate p );
+template<typename Range, typename Predicate> 
+	bool is_partitioned ( const Range &r, Predicate p );
+``
+
+[heading Examples]
+
+Given the container `c` containing `{ 0, 1, 2, 3, 14, 15 }`, then
+``
+bool isOdd ( int i ) { return i % 2 == 1; }
+bool lessThan10 ( int i ) { return i < 10; }
+
+is_partitioned ( c, isOdd ) --> false
+is_partitioned ( c, lessThan10 ) --> true
+is_partitioned ( c.begin (), c.end (), lessThan10 ) --> true
+is_partitioned ( c.begin (), c.begin () + 3, lessThan10 ) --> true
+is_partitioned ( c.end (), c.end (), isOdd ) --> true  // empty range
+``
+
+[heading Iterator Requirements]
+
+`is_partitioned` works on all iterators except output iterators.
+
+[heading Complexity]
+
+Both of the variants of `is_partitioned` run in ['O(N)] (linear) time; that is, they compare against each element in the list once. If the sequence is found to be not partitioned at any point, the routine will terminate immediately, without examining the rest of the elements.
+
+[heading Exception Safety]
+
+Both of the variants of `is_partitioned` take their parameters by value or const reference, and do not depend upon any global state. Therefore, all the routines in this file provide the strong exception guarantee.
+
+[heading Notes]
+
+* The iterator-based version of the routine `is_partitioned` is part of the C++11 standard. When compiled using a C++11 implementation, the implementation from the standard library will be used.
+
+* `is_partitioned` returns true for empty ranges, no matter what predicate is passed to test against. 
+
+[endsect]
+
+[/ File is_partitioned.qbk
+Copyright 2011 Marshall Clow
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
+]
+

doc/knuth_morris_pratt.qbk

@@ -0,0 +1,27 @@
+[/ QuickBook Document version 1.5 ]
+
+[section:KnuthMorrisPratt Knuth-Morris-Pratt Search]
+
+[/license
+
+Copyright (c) 2010-2012 Marshall Clow
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+]
+
+
+[heading Overview]
+
+The header file 'knuth_morris_pratt.hpp' contains an an implementation of the Knuth-Morris-Pratt algorithm for searching sequences of values. 
+
+
+[endsect]
+
+[/ File knuth_morris_pratt.qbk
+Copyright 2011 Marshall Clow
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
+]
+

doc/none_of.qbk

@@ -0,0 +1,90 @@
+[/ File none_of.qbk]
+
+[section:none_of none_of]
+
+[/license
+Copyright (c) 2010-2012 Marshall Clow
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+]
+
+The header file 'boost/algorithm/cxx11/none_of.hpp' contains four variants of a single algorithm, `none_of`. The algorithm tests all the elements of a sequence and returns true if they none of them share a property.
+
+The routine `none_of` takes a sequence and a predicate. It will return true if the predicate returns false when applied to every element in the sequence. 
+
+The routine `none_of_equal` takes a sequence and a value. It will return true if none of the elements in the sequence compare equal to the passed in value.
+
+Both routines come in two forms; the first one takes two iterators to define the range. The second form takes a single range parameter, and uses Boost.Range to traverse it.
+
+
+[heading interface]
+
+The function `none_of` returns true if the predicate returns false for every item in the sequence.  There are two versions; one takes two iterators, and the other takes a range.
+
+``
+namespace boost { namespace algorithm {
+template<typename InputIterator, typename Predicate>
+	bool none_of ( InputIterator first, InputIterator last, Predicate p );
+template<typename Range, typename Predicate> 
+	bool none_of ( const Range &r, Predicate p );
+}}
+``
+
+The function `none_of_equal` is similar to `none_of`, but instead of taking a predicate to test the elements of the sequence, it takes a value to compare against.
+
+``
+namespace boost { namespace algorithm {
+template<typename InputIterator, typename V>
+	bool none_of_equal ( InputIterator first, InputIterator last, V const &val );
+template<typename Range, typename V> 
+	bool none_of_equal ( const Range &r, V const &val );
+}}
+``
+
+[heading Examples]
+
+Given the container `c` containing `{ 0, 1, 2, 3, 14, 15 }`, then
+``
+bool isOdd ( int i ) { return i % 2 == 1; }
+bool lessThan10 ( int i ) { return i < 10; }
+
+using boost::algorithm;
+
+none_of ( c, isOdd ) --> false
+none_of ( c.begin (), c.end (), lessThan10 ) --> false
+none_of ( c.begin () + 4, c.end (), lessThan10 ) --> true
+none_of ( c.end (), c.end (), isOdd ) --> true  // empty range
+none_of_equal ( c, 3 ) --> false
+none_of_equal ( c.begin (), c.begin () + 3, 3 ) --> true
+none_of_equal ( c.begin (), c.begin (), 99 ) --> true  // empty range
+``
+
+[heading Iterator Requirements]
+
+`none_of` and `none_of_equal` work on all iterators except output iterators.
+
+[heading Complexity]
+
+All of the variants of `none_of` and `none_of_equal` run in ['O(N)] (linear) time; that is, they compare against each element in the list once. If any of the comparisons succeed, the algorithm will terminate immediately, without examining the remaining members of the sequence.
+
+[heading Exception Safety]
+
+All of the variants of `none_of` and `none_of_equal` take their parameters by value or const reference, and do not depend upon any global state. Therefore, all the routines in this file provide the strong exception guarantee.
+
+[heading Notes]
+
+* The routine `none_of` is part of the C++11 standard. When compiled using a C++11 implementation, the implementation from the standard library will be used.
+
+* `none_of` and `none_of_equal` both return true for empty ranges, no matter what is passed to test against. 
+
+* The second parameter to `none_of_value` is a template parameter, rather than deduced from the first parameter (`std::iterator_traits<InputIterator>::value_type`) because that allows more flexibility for callers, and takes advantage of built-in comparisons for the type that is pointed to by the iterator.  The function is defined to return true if, for all elements in the sequence, the expression `*iter == val` evaluates to false (where `iter` is an iterator to each element in the sequence)
+
+[endsect]
+
+[/ File none_of.qbk
+Copyright 2011 Marshall Clow
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
+]
+

doc/one_of.qbk

@@ -0,0 +1,87 @@
+[/ File one_of.qbk]
+
+[section:one_of one_of]
+
+[/license
+Copyright (c) 2010-2012 Marshall Clow
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+]
+
+The header file 'boost/algorithm/cxx11/one_of.hpp' contains four variants of a single algorithm, `one_of`. The algorithm tests the elements of a sequence and returns true if exactly one of the elements in the sequence has a particular property.
+
+The routine `one_of` takes a sequence and a predicate. It will return true if the predicate returns true for one element in the sequence. 
+
+The routine `one_of_equal` takes a sequence and a value. It will return true if one element in the sequence compares equal to the passed in value.
+
+Both routines come in two forms; the first one takes two iterators to define the range. The second form takes a single range parameter, and uses Boost.Range to traverse it.
+
+
+[heading interface]
+
+The function `one_of` returns true if the predicate returns true for one item in the sequence.  There are two versions; one takes two iterators, and the other takes a range.
+
+``
+namespace boost { namespace algorithm {
+template<typename InputIterator, typename Predicate>
+	bool one_of ( InputIterator first, InputIterator last, Predicate p );
+template<typename Range, typename Predicate> 
+	bool one_of ( const Range &r, Predicate p );
+}}
+``
+
+The function `one_of_equal` is similar to `one_of`, but instead of taking a predicate to test the elements of the sequence, it takes a value to compare against.
+
+``
+namespace boost { namespace algorithm {
+template<typename InputIterator, typename V>
+	bool one_of_equal ( InputIterator first, InputIterator last, V const &val );
+template<typename Range, typename V> 
+	bool one_of_equal ( const Range &r, V const &val );
+}}
+``
+
+[heading Examples]
+
+Given the container `c` containing `{ 0, 1, 2, 3, 14, 15 }`, then
+``
+bool isOdd ( int i ) { return i % 2 == 1; }
+bool lessThan10 ( int i ) { return i < 10; }
+
+using boost::algorithm;
+one_of ( c, isOdd ) --> false
+one_of ( c.begin (), c.end (), lessThan10 ) --> false
+one_of ( c.begin () + 3, c.end (), lessThan10 ) --> true
+one_of ( c.end (), c.end (), isOdd ) --> false  // empty range
+one_of_equal ( c, 3 ) --> true
+one_of_equal ( c.begin (), c.begin () + 3, 3 ) --> false
+one_of_equal ( c.begin (), c.begin (), 99 ) --> false  // empty range
+``
+
+[heading Iterator Requirements]
+
+`one_of` and `one_of_equal` work on all iterators except output iterators.
+
+[heading Complexity]
+
+All of the variants of `one_of` and `one_of_equal` run in ['O(N)] (linear) time; that is, they compare against each element in the list once. If more than one of the elements in the sequence satisfy the condition, then algorithm will return false immediately, without examining the remaining members of the sequence.
+
+[heading Exception Safety]
+
+All of the variants of `one_of` and `one_of_equal` take their parameters by value or const reference, and do not depend upon any global state. Therefore, all the routines in this file provide the strong exception guarantee.
+
+[heading Notes]
+
+* `one_of` and `one_of_equal` both return false for empty ranges, no matter what is passed to test against. 
+
+* The second parameter to `one_of_value` is a template parameter, rather than deduced from the first parameter (`std::iterator_traits<InputIterator>::value_type`) because that allows more flexibility for callers, and takes advantage of built-in comparisons for the type that is pointed to by the iterator.  The function is defined to return true if, for one element in the sequence, the expression `*iter == val` evaluates to true (where `iter` is an iterator to each element in the sequence)
+
+[endsect]
+
+[/ File one_of.qbk
+Copyright 2011 Marshall Clow
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
+]
+

doc/ordered-hpp.qbk

@@ -0,0 +1,130 @@
+[/ QuickBook Document version 1.5 ]
+[section:is_sorted is_sorted ]
+
+[/license
+
+Copyright (c) 2010-2012 Marshall Clow
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at
+http://www.boost.org/LICENSE_1_0.txt)
+
+]
+
+
+The header file `<boost/algorithm/cxx11/is_sorted.hpp>` contains functions for determining if a sequence is ordered.
+
+[heading is_sorted]
+The function `is_sorted(sequence)` determines whether or not a sequence is completely sorted according so some criteria.  If no comparison predicate is specified, then std::less_equal is used (i.e, the test is to see if the sequence is non-decreasing)
+
+``
+namespace boost { namespace algorithm {
+	template <typename Iterator, typename Pred>
+	bool is_sorted ( Iterator first, Iterator last, Pred p );
+	
+	template <typename Iterator>
+	bool is_sorted ( Iterator first, Iterator last );
+	
+	
+	template <typename Range, typename Pred>
+	bool is_sorted ( const Range &r, Pred p );
+	
+	template <typename Range>
+	bool is_sorted ( const Range &r );
+}}
+``
+
+Iterator requirements: The `is_sorted` functions will work on all kinds of iterators (except output iterators). 
+
+[heading is_sorted_until]
+
+If `distance(first, last) < 2`, then `is_sorted ( first, last )` returns `last`. Otherwise, it returns the last iterator i in [first,last] for which the range [first,i) is sorted.
+
+In short, it returns the element in the sequence that is "out of order". If the entire sequence is sorted (according to the predicate), then it will return `last`.
+
+``
+namespace boost { namespace algorithm {
+	template <typename ForwardIterator, typename Pred>
+	FI is_sorted_until ( ForwardIterator first, ForwardIterator last, Pred p );
+	
+	template <typename ForwardIterator>
+	ForwardIterator is_sorted_until ( ForwardIterator first, ForwardIterator last );
+	
+	
+	template <typename Range, typename Pred>
+	typename boost::range_iterator<const R>::type is_sorted_until ( const Range &r, Pred p );
+	
+	template <typename Range>
+	typename boost::range_iterator<const R>::type is_sorted_until ( const Range &r );
+}}
+``
+
+Iterator requirements: The `is_sorted_until` functions will work on forward iterators or better. Since they have to return a place in the input sequence, input iterators will not suffice.
+
+Complexity:
+	`is_sorted_until` will make at most ['N-1] calls to the predicate (given a sequence of length ['N]).
+
+Examples:
+
+Given the sequence `{ 1, 2, 3, 4, 5, 3 }`,   `is_sorted_until ( beg, end, std::less<int>())` would return an iterator pointing at the second `3`.
+
+Given the sequence `{ 1, 2, 3, 4, 5, 9 }`,   `is_sorted_until ( beg, end, std::less<int>())` would return `end`.
+
+
+There are also a set of "wrapper functions" for is_ordered which make it easy to see if an entire sequence is ordered. These functions return a boolean indicating success or failure rather than an iterator to where the out of order items were found.
+
+To test if a sequence is increasing (each element at least as large as the preceeding one):
+``
+namespace boost { namespace algorithm {
+	template <typename Iterator>
+	bool is_increasing ( Iterator first, Iterator last );
+	
+	template <typename R>
+	bool is_increasing ( const R &range );
+}}
+``
+
+To test if a sequence is decreasing (each element no larger than the preceeding one):
+
+``
+namespace boost { namespace algorithm {
+	template <typename Iterator>
+	bool is_decreasing ( Iterator first, Iterator last );
+	
+	template <typename R>
+	bool is_decreasing ( const R &range );
+}}
+``
+
+To test if a sequence is strictly increasing (each element larger than the preceeding one):
+``
+namespace boost { namespace algorithm {
+	template <typename Iterator>
+	bool is_strictly_increasing ( Iterator first, Iterator last );
+	
+	template <typename R>
+	bool is_strictly_increasing ( const R &range );
+}}
+``
+
+To test if a sequence is strictly decreasing (each element smaller than the preceeding one):
+``
+namespace boost { namespace algorithm {
+	template <typename Iterator>
+	bool is_strictly_decreasing ( Iterator first, Iterator last );
+	
+	template <typename R>
+	bool is_strictly_decreasing ( const R &range );
+}}
+``
+
+Complexity:
+	Each of these calls is just a thin wrapper over `is_sorted`, so they have the same complexity as `is_sorted`.
+
+[heading Notes]
+
+* The routines `is_sorted` and `is_sorted_until` are part of the C++11 standard. When compiled using a C++11 implementation, the implementation from the standard library will be used.
+
+* `is_sorted` and `is_sorted_until` both return true for empty ranges and ranges of length one.
+
+[endsect]

doc/partition_point.qbk

@@ -0,0 +1,68 @@
+[/ File partition_point.qbk]
+
+[section:partition_point partition_point ]
+
+[/license
+Copyright (c) 2010-2012 Marshall Clow
+
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+]
+
+The header file 'partition_point.hpp' contains two variants of a single algorithm, `partition_point`. Given a partitioned sequence and a predicate, the algorithm finds the partition point; i.e, the first element in the sequence that does not satisfy the predicate.
+
+The routine `partition_point` takes a partitioned sequence and a predicate. It returns an iterator which 'points to' the first element in the sequence that does not satisfy the predicate. If all the items in the sequence satisfy the predicate, then it returns one past the final element in the sequence.
+
+`partition_point` come in two forms; the first one takes two iterators to define the range. The second form takes a single range parameter, and uses Boost.Range to traverse it.
+
+
+[heading interface]
+
+There are two versions; one takes two iterators, and the other takes a range.
+
+``
+template<typename ForwardIterator, typename Predicate>
+	ForwardIterator partition_point ( ForwardIterator first, ForwardIterator last, Predicate p );
+template<typename Range, typename Predicate> 
+	boost::range_iterator<Range> partition_point ( const Range &r, Predicate p );
+``
+
+[heading Examples]
+
+Given the container `c` containing `{ 0, 1, 2, 3, 14, 15 }`, then
+``
+bool lessThan10 ( int i ) { return i < 10; }
+bool isOdd ( int i ) { return i % 2 == 1; }
+
+partition_point ( c, lessThan10 ) --> c.begin () + 4  (pointing at 14)
+partition_point ( c.begin (), c.end (), lessThan10 ) --> c.begin () + 4  (pointing at 14)
+partition_point ( c.begin (), c.begin () + 3, lessThan10 ) -> c.begin () + 3 (end)
+partition_point ( c.end (), c.end (), isOdd ) --> c.end ()  // empty range
+``
+
+[heading Iterator Requirements]
+
+`partition_point` requires forward iterators or better; it will not work on input iterators or output iterators.
+
+[heading Complexity]
+
+Both of the variants of `partition_point` run in ['O( log (N))] (logarithmic) time; that is, the predicate will be will be applied approximately ['log(N)] times. To do this, however, the algorithm needs to know the size of the sequence. For forward and bidirectional iterators, calculating the size of the sequence is an ['O(N)] operation.
+
+[heading Exception Safety]
+
+Both of the variants of `partition_point` take their parameters by value or const reference, and do not depend upon any global state. Therefore, all the routines in this file provide the strong exception guarantee.
+
+[heading Notes]
+
+* The iterator-based version of the routine `partition_point` is part of the C++11 standard. When compiled using a C++11 implementation, the implementation from the standard library will be used.
+
+* For empty ranges, the partition point is the end of the range.
+
+[endsect]
+
+[/ File partition_point.qbk
+Copyright 2011 Marshall Clow
+Distributed under the Boost Software License, Version 1.0.
+(See accompanying file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
+]
+

include/boost/algorithm/cxx11/all_of.hpp

@@ -12,6 +12,7 @@
 #ifndef 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/end.hpp>
 

include/boost/algorithm/cxx11/any_of.hpp

@@ -14,6 +14,7 @@
 #ifndef 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/end.hpp>
 

include/boost/algorithm/cxx11/copy_if.hpp

@@ -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>
 

include/boost/algorithm/cxx11/iota.hpp

@@ -71,4 +71,4 @@ OutputIterator iota_n ( OutputIterator out, T value, std::size_t n )
 
 }}
 
-#endif  // BOOST_ALGORITHM_IOTA_HPP
+#endif  // BOOST_ALGORITHM_IOTA_HPP

include/boost/algorithm/cxx11/is_partitioned.hpp

@@ -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>
@@ -20,7 +20,7 @@
 namespace boost { namespace algorithm {
 
 #if __cplusplus >= 201103L
-//  Use the C++11 versions of iota if it is available
+//  Use the C++11 versions of is_partitioned if it is available
 using std::is_partitioned;      // Section 25.3.13
 #else
 /// \fn is_partitioned ( InputIterator first, InputIterator last, UnaryPredicate p )
@@ -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
@@ -62,4 +62,4 @@ bool is_partitioned ( const Range &r, UnaryPredicate p )
 
 }}
 
-#endif  // BOOST_ALGORITHM_IS_PARTITIONED_HPP
+#endif  // BOOST_ALGORITHM_IS_PARTITIONED_HPP

include/boost/algorithm/cxx11/is_permutation.hpp

@@ -136,4 +136,4 @@ is_permutation ( const Range &r, ForwardIterator first2, BinaryPredicate pred )
 
 }}
 
-#endif  // BOOST_ALGORITHM_IS_PERMUTATION_HPP
+#endif  // BOOST_ALGORITHM_IS_PERMUTATION_HPP

include/boost/algorithm/cxx11/is_sorted.hpp

@@ -22,11 +22,12 @@
 
 #include <boost/utility/enable_if.hpp>
 #include <boost/type_traits/is_same.hpp>
+#include <boost/mpl/identity.hpp>
 
 namespace boost { namespace algorithm {
 
 #if __cplusplus >= 201103L
-//  Use the C++11 versions of iota if it is available
+//  Use the C++11 versions of is_sorted/is_sorted_until if they are available
 using std::is_sorted_until; // Section 25.4.1.5
 using std::is_sorted;       // Section 25.4.1.5
 #else
@@ -45,7 +46,7 @@ using std::is_sorted;       // Section 25.4.1.5
         ForwardIterator next = first;
         while ( ++next != last )
         {
-            if ( !p ( *first, *next ))
+            if ( p ( *next, *first ))
                 return next;
             first = next;
         }
@@ -62,7 +63,7 @@ using std::is_sorted;       // Section 25.4.1.5
     ForwardIterator is_sorted_until ( ForwardIterator first, ForwardIterator last )
     {
         typedef typename std::iterator_traits<ForwardIterator>::value_type value_type;
-        return boost::algorithm::is_sorted_until ( first, last, std::less_equal<value_type>());
+        return boost::algorithm::is_sorted_until ( first, last, std::less<value_type>());
     }
 
 
@@ -93,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 )
@@ -124,7 +125,6 @@ using std::is_sorted;       // Section 25.4.1.5
         return boost::algorithm::is_sorted_until ( boost::begin ( range ), boost::end ( range ));
     }
 
-
 /// \fn is_sorted ( const R &range, Pred p )
 /// \return whether or not the entire range R is sorted
 ///     (according to the comparison predicate 'p').
@@ -133,7 +133,8 @@ using std::is_sorted;       // Section 25.4.1.5
 /// \param p     A binary predicate that returns true if two elements are ordered.
 ///
     template <typename R, typename Pred>
-    bool is_sorted ( const R &range, Pred p )
+    typename boost::lazy_disable_if_c< boost::is_same<R, Pred>::value, boost::mpl::identity<bool> >::type
+    is_sorted ( const R &range, Pred p )
     {
         return boost::algorithm::is_sorted ( boost::begin ( range ), boost::end ( range ), p );
     }
@@ -144,7 +145,7 @@ using std::is_sorted;       // Section 25.4.1.5
 /// 
 /// \param range The range to be tested.
 ///
-    template <typename R, typename Pred>
+    template <typename R>
     bool is_sorted ( const R &range )
     {
         return boost::algorithm::is_sorted ( boost::begin ( range ), boost::end ( range ));
@@ -152,7 +153,7 @@ using std::is_sorted;       // Section 25.4.1.5
 
 
 ///
-///	-- Range based versions of the C++11 functions
+/// -- Range based versions of the C++11 functions
 ///
 
 /// \fn is_increasing ( ForwardIterator first, ForwardIterator last )
@@ -168,7 +169,7 @@ using std::is_sorted;       // Section 25.4.1.5
     bool is_increasing ( ForwardIterator first, ForwardIterator last )
     {
         typedef typename std::iterator_traits<ForwardIterator>::value_type value_type;
-        return boost::algorithm::is_sorted (first, last, std::less_equal<value_type>());
+        return boost::algorithm::is_sorted (first, last, std::less<value_type>());
     }
 
 
@@ -201,7 +202,7 @@ using std::is_sorted;       // Section 25.4.1.5
     bool is_decreasing ( ForwardIterator first, ForwardIterator last )
     {
         typedef typename std::iterator_traits<ForwardIterator>::value_type value_type;
-        return boost::algorithm::is_sorted (first, last, std::greater_equal<value_type>());
+        return boost::algorithm::is_sorted (first, last, std::greater<value_type>());
     }
 
 /// \fn is_decreasing ( const R &range )
@@ -233,7 +234,7 @@ using std::is_sorted;       // Section 25.4.1.5
     bool is_strictly_increasing ( ForwardIterator first, ForwardIterator last )
     {
         typedef typename std::iterator_traits<ForwardIterator>::value_type value_type;
-        return boost::algorithm::is_sorted (first, last, std::less<value_type>());
+        return boost::algorithm::is_sorted (first, last, std::less_equal<value_type>());
     }
 
 /// \fn is_strictly_increasing ( const R &range )
@@ -264,7 +265,7 @@ using std::is_sorted;       // Section 25.4.1.5
     bool is_strictly_decreasing ( ForwardIterator first, ForwardIterator last )
     {
         typedef typename std::iterator_traits<ForwardIterator>::value_type value_type;
-        return boost::algorithm::is_sorted (first, last, std::greater<value_type>());
+        return boost::algorithm::is_sorted (first, last, std::greater_equal<value_type>());
     }
 
 /// \fn is_strictly_decreasing ( const R &range )

include/boost/algorithm/cxx11/none_of.hpp

@@ -12,6 +12,7 @@
 #ifndef 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/end.hpp>
 

include/boost/algorithm/cxx11/partition_copy.hpp

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

include/boost/algorithm/cxx11/partition_point.hpp

@@ -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>
@@ -20,12 +20,12 @@
 namespace boost { namespace algorithm {
 
 #if __cplusplus >= 201103L
-//  Use the C++11 versions of iota if it is available
+//  Use the C++11 versions of partition_point if it is available
 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
@@ -69,4 +69,4 @@ typename boost::range_iterator<Range> partition_point ( Range &r, Predicate p )
 
 }}
 
-#endif  // BOOST_ALGORITHM_PARTITION_POINT_HPP
+#endif  // BOOST_ALGORITHM_PARTITION_POINT_HPP

include/boost/algorithm/hex.hpp

@@ -0,0 +1,265 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+   
+   Thanks to Nevin for his comments/help.
+*/
+
+/*
+    General problem - turn a sequence of integral types into a sequence of hexadecimal characters.
+    - and back.
+
+TO DO:
+    1. these should really only work on integral types. (see the >> and << operations)
+        -- this is done, I think.
+    2. The 'value_type_or_char' struct is really a hack.
+        -- but it's a better hack now that it works with back_insert_iterators
+*/
+
+/// \file  hex.hpp
+/// \brief Convert sequence of integral types into a sequence of hexadecimal 
+///     characters and back. Based on the MySQL functions HEX and UNHEX
+/// \author Marshall Clow
+
+#ifndef BOOST_ALGORITHM_HEXHPP
+#define BOOST_ALGORITHM_HEXHPP
+
+#include <iterator>     // for std::iterator_traits
+#include <stdexcept>
+
+#include <boost/range/begin.hpp>
+#include <boost/range/end.hpp>
+#include <boost/exception/all.hpp>
+
+#include <boost/utility/enable_if.hpp>
+#include <boost/type_traits/is_integral.hpp>
+
+
+namespace boost { namespace algorithm {
+
+/*! 
+    \struct hex_decode_error 
+    \brief  Base exception class for all hex decoding errors 
+    
+    \struct non_hex_input    
+    \brief  Thrown when a non-hex value (0-9, A-F) encountered when decoding.
+                Contains the offending character
+    
+    \struct not_enough_input 
+    \brief  Thrown when the input sequence unexpectedly ends
+    
+*/
+struct hex_decode_error : virtual boost::exception, virtual std::exception {};
+struct not_enough_input : virtual hex_decode_error {};
+struct non_hex_input    : virtual hex_decode_error {};
+typedef boost::error_info<struct bad_char_,char> bad_char;
+
+namespace detail {
+/// \cond DOXYGEN_HIDE
+
+    template <typename T, typename OutputIterator>
+    OutputIterator encode_one ( T val, OutputIterator out ) {
+        const std::size_t num_hex_digits =  2 * sizeof ( T );
+        char res [ num_hex_digits ];
+        char  *p = res + num_hex_digits;
+        for ( std::size_t i = 0; i < num_hex_digits; ++i, val >>= 4 )
+            *--p = "0123456789ABCDEF" [ val & 0x0F ];
+        return std::copy ( res, res + num_hex_digits, out );
+        }
+
+    unsigned hex_char_to_int ( char c ) {
+        if ( c >= '0' && c <= '9' ) return c - '0';
+        if ( c >= 'A' && c <= 'F' ) return c - 'A' + 10;
+        if ( c >= 'a' && c <= 'f' ) return c - 'a' + 10;
+        BOOST_THROW_EXCEPTION (non_hex_input() << bad_char (c));
+        return 0;   // keep dumb compilers happy
+        }
+    
+
+//  My own iterator_traits class.
+//  It is here so that I can "reach inside" some kinds of output iterators
+//      and get the type to write.
+    template <typename Iterator>
+    struct hex_iterator_traits {
+        typedef typename std::iterator_traits<Iterator>::value_type value_type;
+    };
+
+    template<typename Container>
+    struct hex_iterator_traits< std::back_insert_iterator<Container> > {
+        typedef typename Container::value_type value_type;
+    };
+
+    template<typename Container>
+    struct hex_iterator_traits< std::front_insert_iterator<Container> > {
+        typedef typename Container::value_type value_type;
+    };
+
+    template<typename Container>
+    struct hex_iterator_traits< std::insert_iterator<Container> > {
+        typedef typename Container::value_type value_type;
+    };
+
+//  ostream_iterators have three template parameters.
+//  The first one is the output type, the second one is the character type of
+//  the underlying stream, the third is the character traits.
+//      We only care about the first one.
+  template<typename T, typename charType, typename traits>
+  struct hex_iterator_traits< std::ostream_iterator<T, charType, traits> > {
+      typedef T value_type;
+  };
+
+	template <typename Iterator> 
+	bool iter_end ( Iterator current, Iterator last ) { return current == last; }
+	
+	template <typename T>
+	bool ptr_end ( const T* ptr, const T* /*end*/ ) { return *ptr == '\0'; }
+	
+//  What can we assume here about the inputs?
+//      is std::iterator_traits<InputIterator>::value_type always 'char' ?
+//  Could it be wchar_t, say? Does it matter?
+//      We are assuming ASCII for the values - but what about the storage?
+    template <typename InputIterator, typename OutputIterator, typename EndPred>
+    typename boost::enable_if<boost::is_integral<typename hex_iterator_traits<OutputIterator>::value_type>, OutputIterator>::type
+    decode_one ( InputIterator &first, InputIterator last, OutputIterator out, EndPred pred ) {
+        typedef typename hex_iterator_traits<OutputIterator>::value_type T;
+        T res (0);
+
+    //  Need to make sure that we get can read that many chars here.
+        for ( std::size_t i = 0; i < 2 * sizeof ( T ); ++i, ++first ) {
+            if ( pred ( first, last )) 
+                BOOST_THROW_EXCEPTION (not_enough_input ());
+            res = ( 16 * res ) + hex_char_to_int (static_cast<char> (*first));
+            }
+        
+        *out = res;
+        return ++out;
+        }
+/// \endcond
+    }
+
+
+/// \fn hex ( InputIterator first, InputIterator last, OutputIterator out )
+/// \brief   Converts a sequence of integral types into a hexadecimal sequence of characters.
+/// 
+/// \param first    The start of the input sequence
+/// \param last     One past the end of the input sequence
+/// \param out      An output iterator to the results into
+/// \return         The updated output iterator
+/// \note           Based on the MySQL function of the same name
+template <typename InputIterator, typename OutputIterator>
+typename boost::enable_if<boost::is_integral<typename detail::hex_iterator_traits<InputIterator>::value_type>, OutputIterator>::type
+hex ( InputIterator first, InputIterator last, OutputIterator out ) {
+    for ( ; first != last; ++first )
+        out = detail::encode_one ( *first, out );
+    return out;
+    }
+    
+
+/// \fn hex ( const T *ptr, OutputIterator out )
+/// \brief   Converts a sequence of integral types into a hexadecimal sequence of characters.
+/// 
+/// \param ptr      A pointer to a 0-terminated sequence of data.
+/// \param out      An output iterator to the results into
+/// \return         The updated output iterator
+/// \note           Based on the MySQL function of the same name
+template <typename T, typename OutputIterator>
+typename boost::enable_if<boost::is_integral<T>, OutputIterator>::type
+hex ( const T *ptr, OutputIterator out ) {
+    while ( *ptr )
+        out = detail::encode_one ( *ptr++, out );
+    return out;
+    }
+
+/// \fn hex ( const Range &r, OutputIterator out )
+/// \brief   Converts a sequence of integral types into a hexadecimal sequence of characters.
+/// 
+/// \param r        The input range
+/// \param out      An output iterator to the results into
+/// \return         The updated output iterator
+/// \note           Based on the MySQL function of the same name
+template <typename Range, typename OutputIterator>
+typename boost::enable_if<boost::is_integral<typename detail::hex_iterator_traits<typename Range::iterator>::value_type>, OutputIterator>::type
+hex ( const Range &r, OutputIterator out ) {
+    return hex (boost::begin(r), boost::end(r), out);
+}
+
+
+/// \fn unhex ( InputIterator first, InputIterator last, OutputIterator out )
+/// \brief   Converts a sequence of hexadecimal characters into a sequence of integers.
+/// 
+/// \param first    The start of the input sequence
+/// \param last     One past the end of the input sequence
+/// \param out      An output iterator to the results into
+/// \return         The updated output iterator
+/// \note           Based on the MySQL function of the same name
+template <typename InputIterator, typename OutputIterator>
+OutputIterator unhex ( InputIterator first, InputIterator last, OutputIterator out ) {
+    while ( first != last )
+        out = detail::decode_one ( first, last, out, detail::iter_end<InputIterator> );
+    return out;
+    }
+
+
+/// \fn unhex ( const T *ptr, OutputIterator out )
+/// \brief   Converts a sequence of hexadecimal characters into a sequence of integers.
+/// 
+/// \param ptr      A pointer to a null-terminated input sequence.
+/// \param out      An output iterator to the results into
+/// \return         The updated output iterator
+/// \note           Based on the MySQL function of the same name
+template <typename T, typename OutputIterator>
+OutputIterator unhex ( const T *ptr, OutputIterator out ) {
+    typedef typename detail::hex_iterator_traits<OutputIterator>::value_type OutputType;
+//  If we run into the terminator while decoding, we will throw a
+//      malformed input exception. It would be nicer to throw a 'Not enough input'
+//      exception - but how much extra work would that require?
+    while ( *ptr )
+        out = detail::decode_one ( ptr, (const T *) NULL, out, detail::ptr_end<T> );
+    return out;
+    }
+
+
+/// \fn OutputIterator unhex ( const Range &r, OutputIterator out )
+/// \brief   Converts a sequence of hexadecimal characters into a sequence of integers.
+/// 
+/// \param r        The input range
+/// \param out      An output iterator to the results into
+/// \return         The updated output iterator
+/// \note           Based on the MySQL function of the same name
+template <typename Range, typename OutputIterator>
+OutputIterator unhex ( const Range &r, OutputIterator out ) {
+    return unhex (boost::begin(r), boost::end(r), out);
+    }
+
+
+/// \fn String hex ( const String &input )
+/// \brief   Converts a sequence of integral types into a hexadecimal sequence of characters.
+/// 
+/// \param input    A container to be converted
+/// \return         A container with the encoded text
+template<typename String>
+String hex ( const String &input ) {
+    String output;
+    output.reserve (input.size () * (2 * sizeof (typename String::value_type)));
+    (void) hex (input, std::back_inserter (output));
+    return output;
+    }
+
+/// \fn String unhex ( const String &input )
+/// \brief   Converts a sequence of hexadecimal characters into a sequence of characters.
+/// 
+/// \param input    A container to be converted
+/// \return         A container with the decoded text
+template<typename String>
+String unhex ( const String &input ) {
+    String output;
+    output.reserve (input.size () / (2 * sizeof (typename String::value_type)));
+    (void) unhex (input, std::back_inserter (output));
+    return output;
+    }
+
+}}
+
+#endif // BOOST_ALGORITHM_HEXHPP

include/boost/algorithm/searching/boyer_moore.hpp

@@ -223,7 +223,7 @@ Requirements:
     corpusIter boyer_moore_search ( 
         corpusIter corpus_first, corpusIter corpus_last, const PatternRange &pattern )
     {
-        typedef typename boost::range_iterator<PatternRange> pattern_iterator;
+        typedef typename boost::range_iterator<const PatternRange>::type pattern_iterator;
         boyer_moore<pattern_iterator> bm ( boost::begin(pattern), boost::end (pattern));
         return bm ( corpus_first, corpus_last );
     }
@@ -242,7 +242,7 @@ Requirements:
     typename boost::range_iterator<CorpusRange>::type
     boyer_moore_search ( CorpusRange &corpus, const PatternRange &pattern )
     {
-        typedef typename boost::range_iterator<PatternRange> pattern_iterator;
+        typedef typename boost::range_iterator<const PatternRange>::type pattern_iterator;
         boyer_moore<pattern_iterator> bm ( boost::begin(pattern), boost::end (pattern));
         return bm (boost::begin (corpus), boost::end (corpus));
     }

include/boost/algorithm/searching/boyer_moore_horspool.hpp

@@ -84,6 +84,11 @@ http://www-igm.univ-mlv.fr/%7Elecroq/string/node18.html
             return this->do_search ( corpus_first, corpus_last );
             }
             
+        template <typename Range>
+        typename boost::range_iterator<Range>::type operator () ( Range &r ) const {
+            return (*this) (boost::begin(r), boost::end(r));
+            }
+
     private:
 /// \cond DOXYGEN_HIDE
         patIter pat_first, pat_last;
@@ -119,6 +124,9 @@ http://www-igm.univ-mlv.fr/%7Elecroq/string/node18.html
 // \endcond
         };
 
+/*  Two ranges as inputs gives us four possibilities; with 2,3,3,4 parameters
+    Use a bit of TMP to disambiguate the 3-argument templates */
+
 /// \fn boyer_moore_horspool_search ( corpusIter corpus_first, corpusIter corpus_last, 
 ///       patIter pat_first, patIter pat_last )
 /// \brief Searches the corpus for the pattern.
@@ -130,10 +138,55 @@ http://www-igm.univ-mlv.fr/%7Elecroq/string/node18.html
 ///
     template <typename patIter, typename corpusIter>
     corpusIter boyer_moore_horspool_search ( 
-            corpusIter corpus_first, corpusIter corpus_last, 
-            patIter pat_first, patIter pat_last ) {
+                  corpusIter corpus_first, corpusIter corpus_last, 
+                  patIter pat_first, patIter pat_last )
+    {
         boyer_moore_horspool<patIter> bmh ( pat_first, pat_last );
         return bmh ( corpus_first, corpus_last );
+    }
+
+    template <typename PatternRange, typename corpusIter>
+    corpusIter boyer_moore_horspool_search ( 
+        corpusIter corpus_first, corpusIter corpus_last, const PatternRange &pattern )
+    {
+        typedef typename boost::range_iterator<const PatternRange>::type pattern_iterator;
+        boyer_moore_horspool<pattern_iterator> bmh ( boost::begin(pattern), boost::end (pattern));
+        return bmh ( corpus_first, corpus_last );
+    }
+    
+    template <typename patIter, typename CorpusRange>
+    typename boost::lazy_disable_if_c<
+        boost::is_same<CorpusRange, patIter>::value, typename boost::range_iterator<CorpusRange> >
+    ::type
+    boyer_moore_horspool_search ( CorpusRange &corpus, patIter pat_first, patIter pat_last )
+    {
+        boyer_moore_horspool<patIter> bmh ( pat_first, pat_last );
+        return bm (boost::begin (corpus), boost::end (corpus));
+    }
+    
+    template <typename PatternRange, typename CorpusRange>
+    typename boost::range_iterator<CorpusRange>::type
+    boyer_moore_horspool_search ( CorpusRange &corpus, const PatternRange &pattern )
+    {
+        typedef typename boost::range_iterator<const PatternRange>::type pattern_iterator;
+        boyer_moore_horspool<pattern_iterator> bmh ( boost::begin(pattern), boost::end (pattern));
+        return bmh (boost::begin (corpus), boost::end (corpus));
+    }
+
+
+    //  Creator functions -- take a pattern range, return an object
+    template <typename Range>
+    boost::algorithm::boyer_moore_horspool<typename boost::range_iterator<const Range>::type>
+    make_boyer_moore_horspool ( const Range &r ) {
+        return boost::algorithm::boyer_moore_horspool
+            <typename boost::range_iterator<const Range>::type> (boost::begin(r), boost::end(r));
+        }
+    
+    template <typename Range>
+    boost::algorithm::boyer_moore_horspool<typename boost::range_iterator<Range>::type>
+    make_boyer_moore_horspool ( Range &r ) {
+        return boost::algorithm::boyer_moore_horspool
+            <typename boost::range_iterator<Range>::type> (boost::begin(r), boost::end(r));
         }
 
 }}

include/boost/algorithm/searching/knuth_morris_pratt.hpp

@@ -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
 */
 
@@ -79,6 +79,11 @@ namespace boost { namespace algorithm {
             return do_search   ( corpus_first, corpus_last, k_corpus_length );
             }
     
+        template <typename Range>
+        typename boost::range_iterator<Range>::type operator () ( Range &r ) const {
+            return (*this) (boost::begin(r), boost::end(r));
+            }
+
     private:
 /// \cond DOXYGEN_HIDE
         patIter pat_first, pat_last;
@@ -179,6 +184,9 @@ namespace boost { namespace algorithm {
         };
 
 
+/*  Two ranges as inputs gives us four possibilities; with 2,3,3,4 parameters
+    Use a bit of TMP to disambiguate the 3-argument templates */
+
 /// \fn knuth_morris_pratt_search ( corpusIter corpus_first, corpusIter corpus_last, 
 ///       patIter pat_first, patIter pat_last )
 /// \brief Searches the corpus for the pattern.
@@ -190,10 +198,55 @@ namespace boost { namespace algorithm {
 ///
     template <typename patIter, typename corpusIter>
     corpusIter knuth_morris_pratt_search ( 
-            corpusIter corpus_first, corpusIter corpus_last, 
-            patIter pat_first, patIter pat_last ) {
+                  corpusIter corpus_first, corpusIter corpus_last, 
+                  patIter pat_first, patIter pat_last )
+    {
         knuth_morris_pratt<patIter> kmp ( pat_first, pat_last );
         return kmp ( corpus_first, corpus_last );
+    }
+
+    template <typename PatternRange, typename corpusIter>
+    corpusIter knuth_morris_pratt_search ( 
+        corpusIter corpus_first, corpusIter corpus_last, const PatternRange &pattern )
+    {
+        typedef typename boost::range_iterator<const PatternRange>::type pattern_iterator;
+        knuth_morris_pratt<pattern_iterator> kmp ( boost::begin(pattern), boost::end (pattern));
+        return kmp ( corpus_first, corpus_last );
+    }
+    
+    template <typename patIter, typename CorpusRange>
+    typename boost::lazy_disable_if_c<
+        boost::is_same<CorpusRange, patIter>::value, typename boost::range_iterator<CorpusRange> >
+    ::type
+    knuth_morris_pratt_search ( CorpusRange &corpus, patIter pat_first, patIter pat_last )
+    {
+        knuth_morris_pratt<patIter> kmp ( pat_first, pat_last );
+        return kmp (boost::begin (corpus), boost::end (corpus));
+    }
+    
+    template <typename PatternRange, typename CorpusRange>
+    typename boost::range_iterator<CorpusRange>::type
+    knuth_morris_pratt_search ( CorpusRange &corpus, const PatternRange &pattern )
+    {
+        typedef typename boost::range_iterator<const PatternRange>::type pattern_iterator;
+        knuth_morris_pratt<pattern_iterator> kmp ( boost::begin(pattern), boost::end (pattern));
+        return kmp (boost::begin (corpus), boost::end (corpus));
+    }
+
+
+    //  Creator functions -- take a pattern range, return an object
+    template <typename Range>
+    boost::algorithm::knuth_morris_pratt<typename boost::range_iterator<const Range>::type>
+    make_knuth_morris_pratt ( const Range &r ) {
+        return boost::algorithm::knuth_morris_pratt
+            <typename boost::range_iterator<const Range>::type> (boost::begin(r), boost::end(r));
+        }
+    
+    template <typename Range>
+    boost::algorithm::knuth_morris_pratt<typename boost::range_iterator<Range>::type>
+    make_knuth_morris_pratt ( Range &r ) {
+        return boost::algorithm::knuth_morris_pratt
+            <typename boost::range_iterator<Range>::type> (boost::begin(r), boost::end(r));
         }
 }}
 

include/boost/algorithm/string/find.hpp

@@ -228,13 +228,13 @@ namespace boost {
         //! Find head algorithm
         /*!
             Get the head of the input. Head is a prefix of the string of the 
-            given size. If the input is shorter then required, whole input if considered 
+            given size. If the input is shorter then required, whole input is considered 
             to be the head.
 
             \param Input An input string
             \param N Length of the head
                 For N>=0, at most N characters are extracted.
-                For N<0, size(Input)-|N| characters are extracted.
+                For N<0, at most size(Input)-|N| characters are extracted.
             \return 
                 An \c iterator_range delimiting the match. 
                 Returned iterator is either \c Range1T::iterator or 
@@ -258,13 +258,13 @@ namespace boost {
         //! Find tail algorithm
         /*!
             Get the tail of the input. Tail is a suffix of the string of the 
-            given size. If the input is shorter then required, whole input if considered 
+            given size. If the input is shorter then required, whole input is considered 
             to be the tail.
 
             \param Input An input string
             \param N Length of the tail. 
                 For N>=0, at most N characters are extracted.
-                For N<0, size(Input)-|N| characters are extracted.
+                For N<0, at most size(Input)-|N| characters are extracted.
             \return 
                 An \c iterator_range delimiting the match. 
                 Returned iterator is either \c RangeT::iterator or 

include/boost/algorithm/string/iter_find.hpp

@@ -60,7 +60,7 @@ namespace boost {
                 a match).
             \param Input A container which will be searched.
             \param Finder A Finder object used for searching
-            \return A reference the result
+            \return A reference to the result
 
             \note Prior content of the result will be overwritten.
         */
@@ -122,7 +122,7 @@ namespace boost {
             Each match is used as a separator of segments. These segments are then
             returned in the result.
 
-            \param Result A 'container container' to container the result of search.
+            \param Result A 'container container' to contain the result of search.
                 Both outer and inner container must have constructor taking a pair
                 of iterators as an argument.
                 Typical type of the result is 
@@ -131,7 +131,7 @@ namespace boost {
                 a match).
             \param Input A container which will be searched.
             \param Finder A finder object used for searching
-            \return A reference the result
+            \return A reference to the result
 
             \note Prior content of the result will be overwritten.
         */

index.html

@@ -0,0 +1,13 @@
+<html>
+<head>
+<meta http-equiv="refresh" content="0; URL=doc/html/index.html">
+</head>
+<body>
+Automatic redirection failed, please go to
+<a href="doc/html/index.html">doc/html/index.html</a> &nbsp;<hr>
+<p>© Copyright Marshall Clow, 2012</p>
+<p>Distributed under the Boost Software License, Version 1.0. (See accompanying 
+file <a href="../../LICENSE_1_0.txt">LICENSE_1_0.txt</a> or copy 
+at <a href="http://www.boost.org/LICENSE_1_0.txt">www.boost.org/LICENSE_1_0.txt</a>)</p>
+</body>
+</html>

string/doc/usage.xml

@@ -130,17 +130,17 @@
     string str1("command.com");
     cout 
         << str1
-        << (is_executable("command.com")? "is": "is not") 
+        << (is_executable(str1)? "is": "is not") 
         << "an executable" 
         << endl; // prints "command.com is an executable"
     
     //..
-    char text1[]="hello world!";
+    char text1[]="hello";
     cout 
         << text1 
-        << (all( text1, is_lower() )? "is": "is not")
+        << (all( text1, is_lower() )? " is": " is not")
         << " written in the lower case" 
-        << endl; // prints "hello world! is written in the lower case"
+        << endl; // prints "hello is written in the lower case"
         </programlisting>
         <para>
             The predicates determine whether if a substring is contained in the input string
@@ -149,6 +149,11 @@
             simply contains the substring or if both strings are equal. See the reference for 
             <headername>boost/algorithm/string/predicate.hpp</headername> for more details. 
         </para>
+        <para>  
+            Note that if we had used "hello world" as the input to the test, it would have
+            output "hello world is not written in the lower case" because the space in the
+            input string is not a lower case letter.
+        </para>
         <para>  
             In addition the algorithm <functionname>all()</functionname> checks
             all elements of a container to satisfy a condition specified by a predicate. 
@@ -163,7 +168,7 @@
         <title>Trimming</title>
         
         <para>
-            When parsing the input from a user, strings usually have unwanted leading or trailing 
+            When parsing the input from a user, strings often have unwanted leading or trailing 
             characters. To get rid of them, we need trim functions:
         </para>
         <programlisting>

test/Jamfile.v2

@@ -16,6 +16,7 @@ import testing ;
      [ run search_test1.cpp          : : : : search_test1 ]
      [ run search_test2.cpp          : : : : search_test2 ]
      [ run search_test3.cpp          : : : : search_test3 ]
+     [ run search_test4.cpp          : : : : search_test4 ]
      [ compile-fail search_fail1.cpp : : : : ]
      [ compile-fail search_fail2.cpp : : : : ]
      [ compile-fail search_fail3.cpp : : : : ]
@@ -39,6 +40,12 @@ import testing ;
      [ run is_partitioned_test1.cpp        : : : : is_partitioned_test1 ]
      [ run partition_copy_test1.cpp        : : : : partition_copy_test1 ]
 
+# Hex tests
+     [ run hex_test1.cpp        : : : : hex_test1 ]
+     [ run hex_test2.cpp        : : : : hex_test2 ]
+     [ run hex_test3.cpp        : : : : hex_test3 ]
+     [ run hex_test4.cpp        : : : : hex_test4 ]
+	 [ compile-fail hex_fail1.cpp ]
    ;
 }
 

test/copy_n_test1.cpp

@@ -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;
-	
-//	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 );
+    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 );
 
-	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 ());
+    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 ());
 
-	//	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 ()));
-	
-	//	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 ()));
-		}
-	}
+    //  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 ()));
+        }
+    }
 
 
 void test_sequence1 () {
-	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::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 );   
+    }
 
 
 int test_main( int , char* [] )

test/find_if_not_test1.cpp

@@ -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;
-	
-	if ( offset >= 0 ) {
-		retval = v.begin ();
-		std::advance ( retval, offset );
-		}
-	else {
-		retval = v.end ();
-		std::advance ( retval, offset + 1 );
-		}
-	return 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;
+    }
 
 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 );

test/hex_fail1.cpp

@@ -0,0 +1,25 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/hex.hpp>
+#include <boost/test/included/test_exec_monitor.hpp>
+
+#include <string>
+#include <iostream>
+#include <vector>
+
+//  should not compile: vector is not an integral type
+int test_main( int , char* [] )
+{
+  std::vector<float> v;
+  std::string out;
+  boost::algorithm::unhex ( out, std::back_inserter(v));
+  return 0;
+}

test/hex_test1.cpp

@@ -0,0 +1,154 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    For more information, see http://www.boost.org
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/hex.hpp>
+#include <boost/test/included/test_exec_monitor.hpp>
+
+#include <string>
+#include <iostream>
+
+
+template<typename String>
+void test_to_hex ( const typename String::value_type ** tests ) {
+    for ( const typename String::value_type **p = tests; *p; p++ ) {
+        String arg, argh, one, two, three, four;
+        arg.assign ( *p );
+        boost::algorithm::hex ( *p, std::back_inserter ( one ));
+        boost::algorithm::hex ( arg, std::back_inserter ( two ));
+        boost::algorithm::hex ( arg.begin (), arg.end (), std::back_inserter ( three ));
+        four = boost::algorithm::hex ( arg );
+        BOOST_CHECK ( one == two );
+        BOOST_CHECK ( one == three );
+        BOOST_CHECK ( one == four );
+        argh = one;
+        one.clear (); two.clear (); three.clear (); four.clear ();
+        boost::algorithm::unhex ( argh.c_str (), std::back_inserter ( one ));
+        boost::algorithm::unhex ( argh, std::back_inserter ( two ));
+        boost::algorithm::unhex ( argh.begin (), argh.end (), std::back_inserter ( three ));
+        four = boost::algorithm::unhex ( argh );
+        BOOST_CHECK ( one == two );
+        BOOST_CHECK ( one == three );
+        BOOST_CHECK ( one == four );
+        BOOST_CHECK ( one == arg );
+        }
+    }
+
+
+template<typename String>
+void test_from_hex_success ( const typename String::value_type ** tests ) {
+    for ( const typename String::value_type **p = tests; *p; p++ ) {
+        String arg, argh, one, two, three, four;
+        arg.assign ( *p );
+        boost::algorithm::unhex ( *p, std::back_inserter ( one ));
+        boost::algorithm::unhex ( arg, std::back_inserter ( two ));
+        boost::algorithm::unhex ( arg.begin (), arg.end (), std::back_inserter ( three ));
+        four = boost::algorithm::unhex ( arg );
+        BOOST_CHECK ( one == two );
+        BOOST_CHECK ( one == three );
+        BOOST_CHECK ( one == four );
+        argh = one;
+        one.clear (); two.clear (); three.clear (); four.clear ();
+        boost::algorithm::hex ( argh.c_str (), std::back_inserter ( one ));
+        boost::algorithm::hex ( argh, std::back_inserter ( two ));
+        boost::algorithm::hex ( argh.begin (), argh.end (), std::back_inserter ( three ));
+        four = boost::algorithm::hex ( argh );
+        BOOST_CHECK ( one == two );
+        BOOST_CHECK ( one == three );
+        BOOST_CHECK ( one == four );
+        BOOST_CHECK ( one == arg );
+        }
+    }
+
+template<typename String>
+void test_from_hex_failure ( const typename String::value_type ** tests ) {
+    int num_catches;
+    for ( const typename String::value_type **p = tests; *p; p++ ) {
+        String arg, one;
+        arg.assign ( *p );
+        num_catches = 0;
+
+        try { boost::algorithm::unhex ( *p, std::back_inserter ( one )); }
+        catch ( const boost::algorithm::hex_decode_error & /*ex*/ ) { num_catches++; }
+        try { boost::algorithm::unhex ( arg, std::back_inserter ( one )); }
+        catch ( const boost::algorithm::hex_decode_error & /*ex*/ ) { num_catches++; }
+        try { boost::algorithm::unhex ( arg.begin (), arg.end (), std::back_inserter ( one )); }
+        catch ( const boost::algorithm::hex_decode_error & /*ex*/ ) { num_catches++; }
+        BOOST_CHECK ( num_catches == 3 );
+        }
+    }
+
+
+
+const char *tohex [] = {
+    "",
+    "a",
+    "\001",
+    "12",
+    "asdfadsfsad",
+    "01234567890ABCDEF",
+    NULL        // End of the list
+    };
+
+
+const wchar_t *tohex_w [] = {
+    L"",
+    L"a",
+    L"\001",
+    L"12",
+    L"asdfadsfsad",
+    L"01234567890ABCDEF",
+    NULL        // End of the list
+    };
+
+
+const char *fromhex [] = {
+    "20",
+    "2122234556FF",
+    NULL        // End of the list
+    };
+
+
+const wchar_t *fromhex_w [] = {
+    L"00101020",
+    L"2122234556FF3456",
+    NULL        // End of the list
+    };
+
+
+const char *fromhex_fail [] = {
+    "2",
+    "H",
+    "234",
+    "21222G4556FF",
+    NULL        // End of the list
+    };
+
+
+const wchar_t *fromhex_fail_w [] = {
+    L"2",
+    L"12",
+    L"H",
+    L"234",
+    L"21222G4556FF",
+    NULL        // End of the list
+    };
+
+
+int test_main( int , char* [] )
+{
+  test_to_hex<std::string> ( tohex );
+  test_from_hex_success<std::string> ( fromhex );
+  test_from_hex_failure<std::string> ( fromhex_fail );
+
+  test_to_hex<std::wstring> ( tohex_w );
+  test_from_hex_success<std::wstring> ( fromhex_w );
+  test_from_hex_failure<std::wstring> ( fromhex_fail_w );
+  return 0;
+}

test/hex_test2.cpp

@@ -0,0 +1,137 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    For more information, see http://www.boost.org
+
+Test non-string cases; vector and list
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/hex.hpp>
+#include <boost/test/included/test_exec_monitor.hpp>
+
+#include <string>
+#include <iostream>
+#include <deque>
+#include <list>
+
+
+const char *tohex [] = {
+    "",
+    "a",
+    "\001",
+    "12",
+    "asdfadsfsad",
+    "01234567890ABCDEF",
+    NULL        // End of the list
+    };
+
+void test_to_hex () {
+    for ( const char **p = tohex; *p; p++ ) {
+        std::deque<char> arg, argh;
+        std::list<char> one, two, three;
+        arg.assign ( *p, *p + strlen (*p));
+        boost::algorithm::hex ( *p,                       std::back_inserter ( one ));
+        boost::algorithm::hex ( arg,                      std::back_inserter ( two ));
+        boost::algorithm::hex ( arg.begin (), arg.end (), std::back_inserter ( three ));
+        BOOST_CHECK ( std::equal ( one.begin (), one.end (), two.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), three.begin ()));
+
+        std::copy ( one.begin (), one.end (), std::back_inserter ( argh ));
+        one.clear (); two.clear (); three.clear ();
+
+//      boost::algorithm::unhex ( argh.c_str (),              std::back_inserter ( one ));
+        boost::algorithm::unhex ( argh,                       std::back_inserter ( two ));
+        boost::algorithm::unhex ( argh.begin (), argh.end (), std::back_inserter ( three ));
+//      BOOST_CHECK ( std::equal ( one.begin (), one.end (), two.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), three.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), arg.begin ()));
+        }
+
+//  Again, with a front_inserter
+    for ( const char **p = tohex; *p; p++ ) {
+        std::deque<char> arg, argh;
+        std::list<char> one, two, three;
+        arg.assign ( *p, *p + strlen (*p));
+        boost::algorithm::hex ( *p,                       std::front_inserter ( one ));
+        boost::algorithm::hex ( arg,                      std::front_inserter ( two ));
+        boost::algorithm::hex ( arg.begin (), arg.end (), std::front_inserter ( three ));
+        BOOST_CHECK ( std::equal ( one.begin (), one.end (), two.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), three.begin ()));
+
+    //  Copy, reversing
+        std::copy ( one.begin (), one.end (), std::front_inserter ( argh ));
+        one.clear (); two.clear (); three.clear ();
+
+//      boost::algorithm::unhex ( argh.c_str (),              std::front_inserter ( one ));
+        boost::algorithm::unhex ( argh,                       std::front_inserter ( two ));
+        boost::algorithm::unhex ( argh.begin (), argh.end (), std::front_inserter ( three ));
+//      BOOST_CHECK ( std::equal ( one.begin (), one.end (), two.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), three.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), arg.rbegin ()));   // reverse
+        }
+    }
+
+const char *fromhex [] = {
+    "20",
+    "2122234556FF",
+    NULL        // End of the list
+    };
+
+
+void test_from_hex_success () {
+    for ( const char **p = fromhex; *p; p++ ) {
+        std::deque<char> arg, argh;
+        std::list<char> one, two, three;
+        arg.assign ( *p, *p + strlen (*p));
+        boost::algorithm::unhex ( *p,                       std::back_inserter ( one ));
+        boost::algorithm::unhex ( arg,                      std::back_inserter ( two ));
+        boost::algorithm::unhex ( arg.begin (), arg.end (), std::back_inserter ( three ));
+        BOOST_CHECK ( std::equal ( one.begin (), one.end (), two.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), three.begin ()));
+
+        std::copy ( one.begin (), one.end (), std::back_inserter ( argh ));
+        one.clear (); two.clear (); three.clear ();
+
+//      boost::algorithm::hex ( argh.c_str (),              std::back_inserter ( one ));
+        boost::algorithm::hex ( argh,                       std::back_inserter ( two ));
+        boost::algorithm::hex ( argh.begin (), argh.end (), std::back_inserter ( three ));
+//      BOOST_CHECK ( std::equal ( one.begin (), one.end (), two.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), three.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), arg.begin ()));
+        }
+
+//  Again, with a front_inserter
+    for ( const char **p = fromhex; *p; p++ ) {
+        std::deque<char> arg, argh;
+        std::list<char> one, two, three;
+        arg.assign ( *p, *p + strlen (*p));
+        boost::algorithm::unhex ( *p,                       std::front_inserter ( one ));
+        boost::algorithm::unhex ( arg,                      std::front_inserter ( two ));
+        boost::algorithm::unhex ( arg.begin (), arg.end (), std::front_inserter ( three ));
+        BOOST_CHECK ( std::equal ( one.begin (), one.end (), two.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), three.begin ()));
+
+    //  Copy, reversing
+        std::copy ( one.begin (), one.end (), std::front_inserter ( argh ));
+        one.clear (); two.clear (); three.clear ();
+
+//      boost::algorithm::hex ( argh.c_str (),              std::front_inserter ( one ));
+        boost::algorithm::hex ( argh,                       std::front_inserter ( two ));
+        boost::algorithm::hex ( argh.begin (), argh.end (), std::front_inserter ( three ));
+//      BOOST_CHECK ( std::equal ( one.begin (), one.end (), two.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), three.begin ()));
+        BOOST_CHECK ( std::equal ( two.begin (), two.end (), arg.rbegin ()));   // reversed
+        }
+    }
+
+
+int test_main( int , char* [] )
+{
+  test_to_hex ();
+  test_from_hex_success ();
+  return 0;
+}

test/hex_test3.cpp

@@ -0,0 +1,123 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    For more information, see http://www.boost.org
+
+Try ostream_iterators
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/hex.hpp>
+#include <boost/test/included/test_exec_monitor.hpp>
+
+#include <string>
+#include <iostream>
+#include <deque>
+#include <list>
+
+
+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;
+
+    for ( const char_type **p = tests; *p; p++ ) {
+        String arg, argh;
+        Stream one, two, three;
+        arg.assign ( *p );
+        boost::algorithm::hex ( *p, Iter ( one ));
+        boost::algorithm::hex ( arg, Iter ( two ));
+        boost::algorithm::hex ( arg.begin (), arg.end (), Iter ( three ));
+        boost::algorithm::hex ( arg );
+        BOOST_CHECK ( one.str () == two.str ());
+        BOOST_CHECK ( one.str () == three.str ());
+        argh = one.str ();
+        one.str (String()); two.str (String()); three.str (String());
+        boost::algorithm::unhex ( argh.c_str (), Iter ( one ));
+        boost::algorithm::unhex ( argh, Iter ( two ));
+        boost::algorithm::unhex ( argh.begin (), argh.end (), Iter ( three ));
+        BOOST_CHECK ( one.str () == two.str ());
+        BOOST_CHECK ( one.str () == three.str ());
+        BOOST_CHECK ( one.str () == arg );
+        }
+    }
+
+
+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;
+
+    for ( const char_type **p = tests; *p; p++ ) {
+        String arg, argh;
+        Stream one, two, three;
+        arg.assign ( *p );
+        boost::algorithm::unhex ( *p,                       Iter ( one ));
+        boost::algorithm::unhex ( arg,                      Iter ( two ));
+        boost::algorithm::unhex ( arg.begin (), arg.end (), Iter ( three ));
+        
+        BOOST_CHECK ( one.str () == two.str ());
+        BOOST_CHECK ( one.str () == three.str ());
+
+        argh = one.str ();
+        one.str (String()); two.str (String()); three.str (String());
+
+        boost::algorithm::hex ( argh.c_str (),              Iter ( one ));
+        boost::algorithm::hex ( argh,                       Iter ( two ));
+        boost::algorithm::hex ( argh.begin (), argh.end (), Iter ( three ));
+
+        BOOST_CHECK ( one.str () == two.str ());
+        BOOST_CHECK ( one.str () == three.str ());
+        BOOST_CHECK ( one.str () == arg );
+        }
+
+    }
+
+const char *tohex [] = {
+    "",
+    "a",
+    "\001",
+    "12",
+    "asdfadsfsad",
+    "01234567890ABCDEF",
+    NULL        // End of the list
+    };
+
+const wchar_t *tohex_w [] = {
+    L"",
+    L"a",
+    L"\001",
+    L"12",
+    L"asdfadsfsad",
+    L"01234567890ABCDEF",
+    NULL        // End of the list
+    };
+
+
+const char *fromhex [] = {
+    "20",
+    "2122234556FF",
+    NULL        // End of the list
+    };
+
+const wchar_t *fromhex_w [] = {
+    L"11223320",
+    L"21222345010256FF",
+    NULL        // End of the list
+    };
+
+
+
+int test_main( int , char* [] )
+{
+  test_to_hex ( tohex );
+  test_to_hex ( tohex_w );
+  test_from_hex_success ( fromhex );
+  test_from_hex_success ( fromhex_w );
+  return 0;
+}

test/hex_test4.cpp

@@ -0,0 +1,145 @@
+/* 
+   Copyright (c) Marshall Clow 2011-2012.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    For more information, see http://www.boost.org
+
+Try ostream_iterators
+*/
+
+#include <boost/config.hpp>
+#include <boost/algorithm/hex.hpp>
+#include <boost/test/included/test_exec_monitor.hpp>
+
+#include <string>
+#include <iostream>
+
+namespace ba = boost::algorithm;
+
+void test_short_input1 () {
+    std::string s;
+    
+    try { ba::unhex ( std::string ( "A" ), std::back_inserter(s)); }
+    catch ( const std::exception &ex ) { return; }
+    BOOST_TEST_MESSAGE ( "Failed to catch std::exception in test_short_input1" );
+    BOOST_CHECK ( false );
+    }
+
+void test_short_input2 () {
+    std::string s;
+    
+    try { ba::unhex ( std::string ( "A" ), std::back_inserter(s)); }
+    catch ( const ba::hex_decode_error &ex ) { return; }
+    BOOST_TEST_MESSAGE ( "Failed to catch ba::hex_decode_error in test_short_input2" );
+    BOOST_CHECK ( false );
+    }
+    
+void test_short_input3 () {
+    std::string s;
+    
+    try { ba::unhex ( std::string ( "A" ), std::back_inserter(s)); }
+    catch ( const ba::not_enough_input &ex ) { return; }
+    BOOST_TEST_MESSAGE ( "Failed to catch ba::not_enough_input in test_short_input3" );
+    BOOST_CHECK ( false );
+    }
+    
+//  Make sure that the right thing is thrown
+void test_short_input4 () {
+    std::string s;
+    
+    try { ba::unhex ( std::string ( "A" ), std::back_inserter(s)); }
+    catch ( const ba::non_hex_input &ex ) { BOOST_CHECK ( false ); }
+    catch ( const ba::not_enough_input &ex ) { return; }
+    catch ( ... ) { BOOST_CHECK ( false ); }
+    BOOST_CHECK ( false );
+    }
+
+//  Make sure that the right thing is thrown
+void test_short_input5 () {
+    std::string s;
+    
+    try { ba::unhex ( "A", std::back_inserter(s)); }
+    catch ( const ba::non_hex_input &ex ) { BOOST_CHECK ( false ); }
+    catch ( const ba::not_enough_input &ex ) { return; }
+    catch ( ... ) { BOOST_CHECK ( false ); }
+    BOOST_CHECK ( false );
+    }
+
+
+void test_short_input () {
+//  BOOST_TEST_MESSAGE ( "Short input tests for boost::algorithm::unhex" );
+    test_short_input1 ();
+    test_short_input2 ();
+    test_short_input3 ();
+    test_short_input4 ();
+    test_short_input5 ();
+    }
+
+
+void test_nonhex_input1 () {
+    std::string s;
+    
+    try { ba::unhex ( "01234FG1234", std::back_inserter(s)); }
+    catch ( const std::exception &ex ) {
+        BOOST_CHECK ( 'G' == *boost::get_error_info<ba::bad_char>(ex));
+        return;
+        }
+    catch ( ... ) {}
+    BOOST_TEST_MESSAGE ( "Failed to catch std::exception in test_nonhex_input1" );
+    BOOST_CHECK ( false );
+    }
+
+void test_nonhex_input2 () {
+    std::string s;
+    
+    try { ba::unhex ( "012Z4FA1234", std::back_inserter(s)); }
+    catch ( const ba::hex_decode_error &ex ) {
+        BOOST_CHECK ( 'Z' == *boost::get_error_info<ba::bad_char>(ex));
+        return;
+        }
+    catch ( ... ) {}
+    BOOST_TEST_MESSAGE ( "Failed to catch ba::hex_decode_error in test_nonhex_input2" );
+    BOOST_CHECK ( false );
+    }
+    
+void test_nonhex_input3 () {
+    std::string s;
+    
+    try { ba::unhex ( "01234FA12Q4", std::back_inserter(s)); }
+    catch ( const ba::non_hex_input &ex ) {
+        BOOST_CHECK ( 'Q' == *boost::get_error_info<ba::bad_char>(ex));
+        return;
+        }
+    catch ( ... ) {}
+    BOOST_TEST_MESSAGE ( "Failed to catch ba::non_hex_input in test_nonhex_input3" );
+    BOOST_CHECK ( false );
+    }
+    
+//  Make sure that the right thing is thrown
+void test_nonhex_input4 () {
+    std::string s;
+    
+    try { ba::unhex ( "P1234FA1234", std::back_inserter(s)); }
+    catch ( const ba::not_enough_input &ex ) { BOOST_CHECK ( false ); }
+    catch ( const ba::non_hex_input &ex ) { return; }
+    catch ( ... ) { BOOST_CHECK ( false ); }
+    BOOST_CHECK ( false );
+    }
+
+void test_nonhex_input () {
+//  BOOST_TEST_MESSAGE ( "Non hex input tests for for boost::algorithm::unhex" );
+    test_nonhex_input1 ();
+    test_nonhex_input2 ();
+    test_nonhex_input3 ();
+    test_nonhex_input4 ();
+    }
+
+int test_main( int , char* [] )
+{
+    test_short_input ();
+    test_nonhex_input ();
+    
+  return 0;
+}

test/iota_test1.cpp

@@ -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 ( 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 (); 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 ();
+    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 ( 9 );
-	boost::algorithm::iota ( l.begin (), l.end (), 87 );
-	BOOST_CHECK ( test_iota_results ( l.begin (), l.end (), 87 ));
+    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 ();
-	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::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 ));
+    }
 
 
 int test_main( int , char* [] )

test/is_partitioned_test1.cpp

@@ -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 
     }
 
 

test/ordered_test.cpp

@@ -12,7 +12,7 @@
 #include <algorithm>
 #include <iostream>
 
-#include <boost/algorithm/cxx11/ordered.hpp>
+#include <boost/algorithm/cxx11/is_sorted.hpp>
 #include <boost/test/included/test_exec_monitor.hpp>
 
 using namespace boost;
@@ -29,6 +29,54 @@ namespace ba = boost::algorithm;
 
 static void
 test_ordered(void)
+{
+    const int strictlyIncreasingValues[] = { 1, 2, 3, 4, 5 };
+    const int randomValues[] = { 3, 6, 1, 2, 7 };
+    const int constantValues[] = { 1, 2, 2, 2, 5 };
+          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>()));
+
+//  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
+    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));
+    BOOST_CHECK ( ba::is_sorted_until ( a_range(nonConstantArray), std::less<int>()) == boost::end(nonConstantArray));
+
+    BOOST_CHECK ( ba::is_sorted_until ( b_e(randomValues),     std::less<int>()) == &randomValues[2] );
+    BOOST_CHECK ( ba::is_sorted_until ( b_e(randomValues))                       == &randomValues[2] );
+    BOOST_CHECK ( ba::is_sorted_until ( a_range(randomValues), std::less<int>()) == &randomValues[2] );
+    BOOST_CHECK ( ba::is_sorted_until ( a_range(randomValues))                   == &randomValues[2] );
+
+    BOOST_CHECK ( ba::is_sorted_until ( a_range(inOrderUntilTheEnd), std::less<int>()) == &inOrderUntilTheEnd[8] );
+    BOOST_CHECK ( ba::is_sorted_until ( a_range(inOrderUntilTheEnd))                   == &inOrderUntilTheEnd[8] );
+
+//  For zero and one element collections, the comparison predicate should never be called
+    BOOST_CHECK ( ba::is_sorted_until ( a_begin(randomValues), a_begin(randomValues),     std::equal_to<int>()) == a_begin(randomValues));
+    BOOST_CHECK ( ba::is_sorted_until ( a_begin(randomValues), a_begin(randomValues))                           == a_begin(randomValues));
+    BOOST_CHECK ( ba::is_sorted_until ( a_begin(randomValues), a_begin(randomValues) + 1, std::equal_to<int>()) == a_begin(randomValues) + 1);
+    BOOST_CHECK ( ba::is_sorted_until ( a_begin(randomValues), a_begin(randomValues) + 1 )                      == a_begin(randomValues) + 1);
+}
+
+
+static void
+test_increasing_decreasing(void)
 {
     const int strictlyIncreasingValues[] = { 1, 2, 3, 4, 5 };
     const int strictlyDecreasingValues[] = { 9, 8, 7, 6, 5 };
@@ -36,8 +84,6 @@ test_ordered(void)
     const int decreasingValues[] = { 9, 7, 7, 7, 5 };
     const int randomValues[] = { 3, 6, 1, 2, 7 };
     const int constantValues[] = { 7, 7, 7, 7, 7 };
-          int nonConstantArray[] = { 7, 7, 7, 7, 7 };
-    const int inOrderUntilTheEnd [] = { 0, 1, 2, 3, 4, 5, 6, 7, 6 };
 
     // Test a strictly increasing sequence
     BOOST_CHECK (  ba::is_strictly_increasing (b_e(strictlyIncreasingValues)));
@@ -98,30 +144,11 @@ test_ordered(void)
     BOOST_CHECK ( !ba::is_strictly_decreasing (strictlyIncreasingValues, strictlyIncreasingValues+2));
     BOOST_CHECK ( !ba::is_decreasing          (strictlyIncreasingValues, strictlyIncreasingValues+2));
     
-    // Test underlying routines
-    BOOST_CHECK (  ba::is_sorted_until ( b_e(strictlyIncreasingValues),     std::less<int>()) ==      a_end(strictlyIncreasingValues));
-    BOOST_CHECK (  ba::is_sorted_until ( a_range(strictlyIncreasingValues), std::less<int>()) == boost::end(strictlyIncreasingValues));
-
-    BOOST_CHECK ( ba::is_sorted_until ( b_e(nonConstantArray),     std::less<int>()) !=      a_end(nonConstantArray));
-    BOOST_CHECK ( ba::is_sorted_until ( a_range(nonConstantArray), std::less<int>()) != boost::end(nonConstantArray));
-
-    BOOST_CHECK ( ba::is_sorted_until ( b_e(randomValues),     std::less<int>()) == &randomValues[2] );
-    BOOST_CHECK ( ba::is_sorted_until ( a_range(randomValues), std::less<int>()) == &randomValues[2] );
-
-    BOOST_CHECK ( ba::is_sorted_until ( b_e(randomValues),     std::less<int>()) == &randomValues[2] );
-    BOOST_CHECK ( ba::is_sorted_until ( a_range(randomValues), std::less<int>()) == &randomValues[2] );
-
-    BOOST_CHECK ( ba::is_sorted_until ( a_range(inOrderUntilTheEnd), std::less<int>()) == &inOrderUntilTheEnd[8] );
-
-//  For zero and one element collections, the comparison predicate should never be called
-    BOOST_CHECK ( ba::is_sorted_until ( a_begin(randomValues), a_begin(randomValues),     std::equal_to<int>()) == a_begin(randomValues));
-    BOOST_CHECK ( ba::is_sorted_until ( a_begin(randomValues), a_begin(randomValues) + 1, std::equal_to<int>()) == a_begin(randomValues) + 1);
-
 }
 
 int test_main( int, char * [] )
 {
     test_ordered ();
-
+    test_increasing_decreasing ();
     return 0;
 }

test/partition_point_test1.cpp

@@ -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;
-	
-	if ( offset >= 0 ) {
-		retval = v.begin ();
-		std::advance ( retval, offset );
-		}
-	else {
-		retval = v.end ();
-		std::advance ( retval, offset + 1 );
-		}
-	return 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;
+    }
 
 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 );

test/search_test4.cpp

@@ -0,0 +1,116 @@
+/* 
+   Copyright (c) Marshall Clow 2010-2012.
+
+   Distributed under the Boost Software License, Version 1.0. (See accompanying
+   file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
+
+    For more information, see http://www.boost.org
+
+    Testing the range-based interfaces
+*/
+
+#include <boost/algorithm/searching/boyer_moore.hpp>
+#include <boost/algorithm/searching/boyer_moore_horspool.hpp>
+#include <boost/algorithm/searching/knuth_morris_pratt.hpp>
+
+#include <boost/test/included/test_exec_monitor.hpp>
+
+#include <iostream>
+#include <algorithm>
+#include <vector>
+#include <string>
+
+typedef std::vector<std::string> vec;
+#define NUM_TRIES   100
+
+#define runOne(call, refDiff)   { \
+    res = boost::algorithm::call ( haystack, needle );  \
+    if ( res != exp ) {                                 \
+        std::cout << "Expected "                        \
+            << exp - haystack.begin () << " got "       \
+            << res - haystack.begin () << std::endl;    \
+        throw std::runtime_error                        \
+            ( "Unexpected result from " #call );        \
+        }                                               \
+    }
+    
+#define runObject(obj, refDiff) { \
+    boost::algorithm::obj <vec::const_iterator> s_o =   \
+      boost::algorithm::make_##obj  ( needle );         \
+    res = s_o ( haystack );                             \
+    if ( res != exp ) {                                 \
+        std::cout << "Expected "                        \
+        << exp - haystack.begin () << " got "           \
+        << res - haystack.begin () << std::endl;        \
+        throw std::runtime_error                        \
+        ( "Unexpected result from " #obj " object" );   \
+        }                                               \
+    }
+
+namespace {
+
+    vec ReadFromFile ( const char *name ) {
+        std::ifstream in ( name, std::ios_base::binary | std::ios_base::in );
+        std::string temp;
+        vec retVal;
+        while ( std::getline ( in, temp ))
+            retVal.push_back ( temp );
+        
+        return retVal;
+        }
+    
+    void check_one ( const vec &haystack, const vec &needle, int expected ) {
+        
+        vec::const_iterator res;
+        vec::const_iterator exp;        // the expected result
+        
+        if ( expected >= 0 )
+            exp = haystack.begin () + expected;
+        else if ( expected == -1 )
+            exp = haystack.end ();      // we didn't find it1
+        else if ( expected == -2 )
+            exp = std::search ( haystack.begin (), haystack.end (), needle.begin (), needle.end ());
+        else    
+            throw std::logic_error ( "Expected must be -2, -1, or >= 0" );
+
+        std::cout << "Pattern is " << needle.size ()   << " entries long" << std::endl;
+        std::cout << "Corpus  is " << haystack.size () << " entries long" << std::endl;
+
+    //  First, the std library search
+        res = std::search ( haystack.begin (), haystack.end (), needle.begin (), needle.end ());
+        if ( res != exp ) {
+            std::cout << "Expected " << exp - haystack.begin () << " got " << res - haystack.begin () << std::endl;
+            throw std::runtime_error ( "Unexpected result from std::search" );
+            }
+
+        runOne    ( boyer_moore_search,          stdDiff );
+        runObject ( boyer_moore,                 stdDiff );
+        runOne    ( boyer_moore_horspool_search, stdDiff );
+        runObject ( boyer_moore_horspool,        stdDiff );
+        runOne    ( knuth_morris_pratt_search,   stdDiff );
+        runObject ( knuth_morris_pratt,          stdDiff );
+        }
+        
+    }
+
+int test_main( int , char* [] )
+{
+    vec c1  = ReadFromFile ( "search_test_data/0001.corpus" );
+    vec p1b = ReadFromFile ( "search_test_data/0002b.pat" );
+    vec p1e = ReadFromFile ( "search_test_data/0002e.pat" );
+    vec p1n = ReadFromFile ( "search_test_data/0002n.pat" );
+    vec p1f = ReadFromFile ( "search_test_data/0002f.pat" );
+
+    std::cout << std::ios::fixed << std::setprecision(4);
+//  std::cout << "Corpus is " << c1.size () << " entries long\n";
+    std::cout << "--- Beginning ---" << std::endl;
+    check_one ( c1, p1b, 0 );       //  Find it at position zero
+    std::cout << "---- Middle -----" << std::endl;
+    check_one ( c1, p1f, -2 );      //  Don't know answer
+    std::cout << "------ End ------" << std::endl;
+    check_one ( c1, p1e, c1.size() - p1e.size ());  
+    std::cout << "--- Not found ---" << std::endl;
+    check_one ( c1, p1n, -1 );      //  Not found
+    
+    return 0;
+    }