| Home | Libraries | People | FAQ | More

## Reference

### Header <boost/algorithm/algorithm.hpp>

Misc Algorithms.

Marshall Clow

    namespace boost {
      namespace algorithm {
        template<typename T> T identity_operation(std::multiplies< T >);
        template<typename T> T identity_operation(std::plus< T >);
        template<typename T, typename Integer>
          boost::enable_if< boost::is_integral< Integer >, T >::type
          power(T, Integer);
        template<typename T, typename Integer, typename Operation>
          boost::enable_if< boost::is_integral< Integer >, T >::type
          power(T, Integer, Operation);
      }
    }

### Header <boost/algorithm/clamp.hpp>

Clamp algorithm.

Marshall Clow

Suggested by olafvdspek in https://svn.boost.org/trac/boost/ticket/3215

    namespace boost {
      namespace algorithm {
        template<typename T, typename Pred>
          T const & clamp(T const &,
                          typename boost::mpl::identity< T >::type const &,
                          typename boost::mpl::identity< T >::type const &, Pred);
        template<typename T>
          T const & clamp(const T &,
                          typename boost::mpl::identity< T >::type const &,
                          typename boost::mpl::identity< T >::type const &);
        template<typename InputIterator, typename OutputIterator>
          OutputIterator
          clamp_range(InputIterator first, InputIterator last, OutputIterator out,
                      typename std::iterator_traits< InputIterator >::value_type const & lo,
                      typename std::iterator_traits< InputIterator >::value_type const & hi);
        template<typename Range, typename OutputIterator>
          boost::disable_if_c< boost::is_same< Range, OutputIterator >::value, OutputIterator >::type
          clamp_range(const Range &, OutputIterator,
                      typename std::iterator_traits< typename boost::range_iterator< const Range >::type >::value_type const &,
                      typename std::iterator_traits< typename boost::range_iterator< const Range >::type >::value_type const &);
        template<typename InputIterator, typename OutputIterator, typename Pred>
          OutputIterator
          clamp_range(InputIterator first, InputIterator last, OutputIterator out,
                      typename std::iterator_traits< InputIterator >::value_type const & lo,
                      typename std::iterator_traits< InputIterator >::value_type const & hi,
                      Pred p);
        template<typename Range, typename OutputIterator, typename Pred>
          boost::disable_if_c< boost::is_same< Range, OutputIterator >::value, OutputIterator >::type
          clamp_range(const Range &, OutputIterator,
                      typename std::iterator_traits< typename boost::range_iterator< const Range >::type >::value_type const &,
                      typename std::iterator_traits< typename boost::range_iterator< const Range >::type >::value_type const &,
                      Pred);
      }
    }

### Header <boost/algorithm/cxx11/all_of.hpp>

Test ranges to see if all elements match a value or predicate.

Marshall Clow

    namespace boost {
      namespace algorithm {
        template<typename InputIterator, typename Predicate>
          bool all_of(InputIterator, InputIterator, Predicate);
        template<typename Range, typename Predicate>
          bool all_of(const Range &, Predicate);
        template<typename InputIterator, typename T>
          bool all_of_equal(InputIterator, InputIterator, const T &);
        template<typename Range, typename T>
          bool all_of_equal(const Range &, const T &);
      }
    }

### Header <boost/algorithm/cxx11/any_of.hpp>

Test ranges to see if any elements match a value or predicate.

Marshall Clow

    namespace boost {
      namespace algorithm {
        template<typename InputIterator, typename Predicate>
          bool any_of(InputIterator, InputIterator, Predicate);
        template<typename Range, typename Predicate>
          bool any_of(const Range &, Predicate);
        template<typename InputIterator, typename V>
          bool any_of_equal(InputIterator, InputIterator, const V &);
        template<typename Range, typename V>
          bool any_of_equal(const Range &, const V &);
      }
    }

### Header <boost/algorithm/cxx11/copy_if.hpp>

Copy a subset of a sequence to a new sequence.

Marshall Clow

    namespace boost {
      namespace algorithm {
        template<typename InputIterator, typename OutputIterator,
                 typename Predicate>
          OutputIterator
          copy_if(InputIterator, InputIterator, OutputIterator, Predicate);
        template<typename Range, typename OutputIterator, typename Predicate>
          OutputIterator copy_if(const Range &, OutputIterator, Predicate);
        template<typename InputIterator, typename OutputIterator,
                 typename Predicate>
          std::pair< InputIterator, OutputIterator >
          copy_while(InputIterator, InputIterator, OutputIterator, Predicate);
        template<typename Range, typename OutputIterator, typename Predicate>
          std::pair< typename boost::range_iterator< const Range >::type, OutputIterator >
          copy_while(const Range &, OutputIterator, Predicate);
        template<typename InputIterator, typename OutputIterator,
                 typename Predicate>
          std::pair< InputIterator, OutputIterator >
          copy_until(InputIterator, InputIterator, OutputIterator, Predicate);
        template<typename Range, typename OutputIterator, typename Predicate>
          std::pair< typename boost::range_iterator< const Range >::type, OutputIterator >
          copy_until(const Range &, OutputIterator, Predicate);
      }
    }

### Header <boost/algorithm/cxx11/copy_n.hpp>

Copy n items from one sequence to another.

Marshall Clow

    namespace boost {
      namespace algorithm {
        template<typename InputIterator, typename Size, typename OutputIterator>
          OutputIterator copy_n(InputIterator, Size, OutputIterator);
      }
    }

### Header <boost/algorithm/cxx11/find_if_not.hpp>

Find the first element in a sequence that does not satisfy a predicate.

Marshall Clow

    namespace boost {
      namespace algorithm {
        template<typename InputIterator, typename Predicate>
          InputIterator find_if_not(InputIterator, InputIterator, Predicate);
        template<typename Range, typename Predicate>
          boost::range_iterator< const Range >::type
          find_if_not(const Range &, Predicate);
      }
    }

### Header <boost/algorithm/cxx11/iota.hpp>

Generate an increasing series.

Marshall Clow

    namespace boost {
      namespace algorithm {
        template<typename ForwardIterator, typename T>
          void iota(ForwardIterator, ForwardIterator, T);
        template<typename Range, typename T> void iota(Range &, T);
        template<typename OutputIterator, typename T>
          OutputIterator iota_n(OutputIterator, T, std::size_t);
      }
    }

### Header <boost/algorithm/cxx11/is_partitioned.hpp>

Tell if a sequence is partitioned.

Marshall Clow

    namespace boost {
      namespace algorithm {
        template<typename InputIterator, typename UnaryPredicate>
          bool is_partitioned(InputIterator, InputIterator, UnaryPredicate);
        template<typename Range, typename UnaryPredicate>
          bool is_partitioned(const Range &, UnaryPredicate);
      }
    }

### Header <boost/algorithm/cxx11/is_permutation.hpp>

    namespace boost {
      namespace algorithm {
        template<typename ForwardIterator1, typename ForwardIterator2,
                 typename BinaryPredicate>
          bool is_permutation(ForwardIterator1, ForwardIterator1,
                              ForwardIterator2, BinaryPredicate);
        template<typename ForwardIterator1, typename ForwardIterator2>
          bool is_permutation(ForwardIterator1, ForwardIterator1,
                              ForwardIterator2);
        template<typename Range, typename ForwardIterator>
          bool is_permutation(const Range &, ForwardIterator);
        template<typename Range, typename ForwardIterator,
                 typename BinaryPredicate>
          boost::disable_if_c< boost::is_same< Range, ForwardIterator >::value, bool >::type
          is_permutation(const Range &, ForwardIterator, BinaryPredicate);
      }
    }

### Header <boost/algorithm/cxx14/is_permutation.hpp>

    namespace boost {
      namespace algorithm {
        template<typename ForwardIterator1, typename ForwardIterator2>
          bool is_permutation(ForwardIterator1, ForwardIterator1,
                              ForwardIterator2, ForwardIterator2);
        template<typename ForwardIterator1, typename ForwardIterator2,
                 typename BinaryPredicate>
          bool is_permutation(ForwardIterator1, ForwardIterator1,
                              ForwardIterator2, ForwardIterator2,
                              BinaryPredicate);
      }
    }

### Header <boost/algorithm/cxx11/is_sorted.hpp>

    namespace boost {
      namespace algorithm {
        template<typename ForwardIterator, typename Pred>
          ForwardIterator is_sorted_until(ForwardIterator, ForwardIterator, Pred);
        template<typename ForwardIterator>
          ForwardIterator is_sorted_until(ForwardIterator, ForwardIterator);
        template<typename ForwardIterator, typename Pred>
          bool is_sorted(ForwardIterator, ForwardIterator, Pred);
        template<typename ForwardIterator>
          bool is_sorted(ForwardIterator, ForwardIterator);
        template<typename R, typename Pred>
          boost::lazy_disable_if_c< boost::is_same< R, Pred >::value, typename boost::range_iterator< const R > >::type
          is_sorted_until(const R &, Pred);
        template<typename R>
          boost::range_iterator< const R >::type is_sorted_until(const R &);
        template<typename R, typename Pred>
          boost::lazy_disable_if_c< boost::is_same< R, Pred >::value, boost::mpl::identity< bool > >::type
          is_sorted(const R &, Pred);
        template<typename R> bool is_sorted(const R &);
        template<typename ForwardIterator>
          bool is_increasing(ForwardIterator, ForwardIterator);
        template<typename R> bool is_increasing(const R &);
        template<typename ForwardIterator>
          bool is_decreasing(ForwardIterator, ForwardIterator);
        template<typename R> bool is_decreasing(const R &);
        template<typename ForwardIterator>
          bool is_strictly_increasing(ForwardIterator, ForwardIterator);
        template<typename R> bool is_strictly_increasing(const R &);
        template<typename ForwardIterator>
          bool is_strictly_decreasing(ForwardIterator, ForwardIterator);
        template<typename R> bool is_strictly_decreasing(const R &);
      }
    }

### Header <boost/algorithm/cxx11/none_of.hpp>

Test ranges to see if no elements match a value or predicate.

Marshall Clow

    namespace boost {
      namespace algorithm {
        template<typename InputIterator, typename Predicate>
          bool none_of(InputIterator, InputIterator, Predicate);
        template<typename Range, typename Predicate>
          bool none_of(const Range &, Predicate);
        template<typename InputIterator, typename V>
          bool none_of_equal(InputIterator, InputIterator, const V &);
        template<typename Range, typename V>
          bool none_of_equal(const Range &, const V &);
      }
    }

### Header <boost/algorithm/cxx11/one_of.hpp>

Test ranges to see if only one element matches a value or predicate.

Marshall Clow

    namespace boost {
      namespace algorithm {
        template<typename InputIterator, typename Predicate>
          bool one_of(InputIterator, InputIterator, Predicate);
        template<typename Range, typename Predicate>
          bool one_of(const Range &, Predicate);
        template<typename InputIterator, typename V>
          bool one_of_equal(InputIterator, InputIterator, const V &);
        template<typename Range, typename V>
          bool one_of_equal(const Range &, const V &);
      }
    }

### Header <boost/algorithm/cxx11/partition_copy.hpp>

Copy a subset of a sequence to a new sequence.

Marshall Clow

    namespace boost {
      namespace algorithm {
        template<typename InputIterator, typename OutputIterator1,
                 typename OutputIterator2, typename UnaryPredicate>
          std::pair< OutputIterator1, OutputIterator2 >
          partition_copy(InputIterator, InputIterator, OutputIterator1,
                         OutputIterator2, UnaryPredicate);
        template<typename Range, typename OutputIterator1,
                 typename OutputIterator2, typename UnaryPredicate>
          std::pair< OutputIterator1, OutputIterator2 >
          partition_copy(const Range &, OutputIterator1, OutputIterator2,
                         UnaryPredicate);
      }
    }

### Header <boost/algorithm/cxx11/partition_point.hpp>

Find the partition point in a sequence.

Marshall Clow

    namespace boost {
      namespace algorithm {
        template<typename ForwardIterator, typename Predicate>
          ForwardIterator
          partition_point(ForwardIterator, ForwardIterator, Predicate);
        template<typename Range, typename Predicate>
          boost::range_iterator< Range >::type partition_point(Range &, Predicate);
      }
    }

### Header <boost/algorithm/cxx14/equal.hpp>

Test ranges to if they are equal.

Marshall Clow

    namespace boost {
      namespace algorithm {
        template<typename InputIterator1, typename InputIterator2,
                 typename BinaryPredicate>
          bool equal(InputIterator1, InputIterator1, InputIterator2,
                     InputIterator2, BinaryPredicate);
        template<typename InputIterator1, typename InputIterator2>
          bool equal(InputIterator1, InputIterator1, InputIterator2,
                     InputIterator2);
      }
    }

### Header <boost/algorithm/cxx14/mismatch.hpp>

Find the first mismatched element in a sequence.

Marshall Clow

    namespace boost {
      namespace algorithm {
        template<typename InputIterator1, typename InputIterator2,
                 typename BinaryPredicate>
          std::pair< InputIterator1, InputIterator2 >
          mismatch(InputIterator1, InputIterator1, InputIterator2, InputIterator2,
                   BinaryPredicate);
        template<typename InputIterator1, typename InputIterator2>
          std::pair< InputIterator1, InputIterator2 >
          mismatch(InputIterator1, InputIterator1, InputIterator2, InputIterator2);
      }
    }

### Header <boost/algorithm/gather.hpp>

    namespace boost {
      namespace algorithm {

        // iterator-based gather implementation
        template<typename BidirectionalIterator, typename Pred>
          std::pair< BidirectionalIterator, BidirectionalIterator >
          gather(BidirectionalIterator first, BidirectionalIterator last,
                 BidirectionalIterator pivot, Pred pred);

        // range-based gather implementation
        template<typename BidirectionalRange, typename Pred>
          std::pair< typename boost::range_iterator< const BidirectionalRange >::type, typename boost::range_iterator< const BidirectionalRange >::type >
          gather(const BidirectionalRange & range,
                 typename boost::range_iterator< const BidirectionalRange >::type pivot,
                 Pred pred);
      }
    }

### Header <boost/algorithm/hex.hpp>

Convert sequence of integral types into a sequence of hexadecimal characters and back. Based on the MySQL functions HEX and UNHEX.

Marshall Clow

    namespace boost {
      namespace algorithm {
        struct hex_decode_error;
        struct not_enough_input;
        struct non_hex_input;

        typedef boost::error_info< struct bad_char_, char > bad_char;
        template<typename InputIterator, typename OutputIterator>
          unspecified hex(InputIterator, InputIterator, OutputIterator);
        template<typename InputIterator, typename OutputIterator>
          unspecified hex_lower(InputIterator, InputIterator, OutputIterator);
        template<typename T, typename OutputIterator>
          boost::enable_if< boost::is_integral< T >, OutputIterator >::type
          hex(const T *, OutputIterator);
        template<typename T, typename OutputIterator>
          boost::enable_if< boost::is_integral< T >, OutputIterator >::type
          hex_lower(const T *, OutputIterator);
        template<typename Range, typename OutputIterator>
          unspecified hex(const Range &, OutputIterator);
        template<typename Range, typename OutputIterator>
          unspecified hex_lower(const Range &, OutputIterator);
        template<typename InputIterator, typename OutputIterator>
          OutputIterator unhex(InputIterator, InputIterator, OutputIterator);
        template<typename T, typename OutputIterator>
          OutputIterator unhex(const T *, OutputIterator);
        template<typename Range, typename OutputIterator>
          OutputIterator unhex(const Range &, OutputIterator);
        template<typename String> String hex(const String &);
        template<typename String> String hex_lower(const String &);
        template<typename String> String unhex(const String &);
      }
    }

### Header <boost/algorithm/is_palindrome.hpp>

Checks the input sequence on palindrome.

Alexander Zaitsev

    namespace boost {
      namespace algorithm {
        template<typename BidirectionalIterator, typename Predicate>
          bool is_palindrome(BidirectionalIterator, BidirectionalIterator,
                             Predicate);
        template<typename BidirectionalIterator>
          bool is_palindrome(BidirectionalIterator, BidirectionalIterator);
        template<typename R> bool is_palindrome(const R &);
        template<typename R, typename Predicate>
          bool is_palindrome(const R &, Predicate);
        bool is_palindrome(const char *);
        template<typename Predicate> bool is_palindrome(const char *, Predicate);
      }
    }

### Header <boost/algorithm/minmax.hpp>

    namespace boost {
      template<typename T>
        tuple< T const &, T const & > minmax(T const & a, T const & b);
      template<typename T, typename BinaryPredicate>
        tuple< T const &, T const & >
        minmax(T const & a, T const & b, BinaryPredicate comp);
    }

### Header <boost/algorithm/minmax_element.hpp>

    namespace boost {
      template<typename ForwardIter>
        std::pair< ForwardIter, ForwardIter >
        minmax_element(ForwardIter first, ForwardIter last);
      template<typename ForwardIter, typename BinaryPredicate>
        std::pair< ForwardIter, ForwardIter >
        minmax_element(ForwardIter first, ForwardIter last, BinaryPredicate comp);
      template<typename ForwardIter>
        ForwardIter first_min_element(ForwardIter first, ForwardIter last);
      template<typename ForwardIter, typename BinaryPredicate>
        ForwardIter first_min_element(ForwardIter first, ForwardIter last,
                                      BinaryPredicate comp);
      template<typename ForwardIter>
        ForwardIter last_min_element(ForwardIter first, ForwardIter last);
      template<typename ForwardIter, typename BinaryPredicate>
        ForwardIter last_min_element(ForwardIter first, ForwardIter last,
                                     BinaryPredicate comp);
      template<typename ForwardIter>
        ForwardIter first_max_element(ForwardIter first, ForwardIter last);
      template<typename ForwardIter, typename BinaryPredicate>
        ForwardIter first_max_element(ForwardIter first, ForwardIter last,
                                      BinaryPredicate comp);
      template<typename ForwardIter>
        ForwardIter last_max_element(ForwardIter first, ForwardIter last);
      template<typename ForwardIter, typename BinaryPredicate>
        ForwardIter last_max_element(ForwardIter first, ForwardIter last,
                                     BinaryPredicate comp);
      template<typename ForwardIter>
        std::pair< ForwardIter, ForwardIter >
        first_min_first_max_element(ForwardIter first, ForwardIter last);
      template<typename ForwardIter, typename BinaryPredicate>
        std::pair< ForwardIter, ForwardIter >
        first_min_first_max_element(ForwardIter first, ForwardIter last,
                                    BinaryPredicate comp);
      template<typename ForwardIter>
        std::pair< ForwardIter, ForwardIter >
        first_min_last_max_element(ForwardIter first, ForwardIter last);
      template<typename ForwardIter, typename BinaryPredicate>
        std::pair< ForwardIter, ForwardIter >
        first_min_last_max_element(ForwardIter first, ForwardIter last,
                                   BinaryPredicate comp);
      template<typename ForwardIter>
        std::pair< ForwardIter, ForwardIter >
        last_min_first_max_element(ForwardIter first, ForwardIter last);
      template<typename ForwardIter, typename BinaryPredicate>
        std::pair< ForwardIter, ForwardIter >
        last_min_first_max_element(ForwardIter first, ForwardIter last,
                                   BinaryPredicate comp);
      template<typename ForwardIter>
        std::pair< ForwardIter, ForwardIter >
        last_min_last_max_element(ForwardIter first, ForwardIter last);
      template<typename ForwardIter, typename BinaryPredicate>
        std::pair< ForwardIter, ForwardIter >
        last_min_last_max_element(ForwardIter first, ForwardIter last,
                                  BinaryPredicate comp);
    }

### Header <boost/algorithm/searching/boyer_moore.hpp>

    namespace boost {
      namespace algorithm {
        template<typename patIter, typename traits = detail::BM_traits<patIter> >
          class boyer_moore;
        template<typename patIter, typename corpusIter>
          std::pair< corpusIter, corpusIter >
          boyer_moore_search(corpusIter, corpusIter, patIter, patIter);
        template<typename PatternRange, typename corpusIter>
          std::pair< corpusIter, corpusIter >
          boyer_moore_search(corpusIter corpus_first, corpusIter corpus_last,
                             const PatternRange & pattern);
        template<typename patIter, typename CorpusRange>
          boost::disable_if_c< boost::is_same< CorpusRange, patIter >::value, std::pair< typename boost::range_iterator< CorpusRange >::type, typename boost::range_iterator< CorpusRange >::type > >::type
          boyer_moore_search(CorpusRange & corpus, patIter pat_first,
                             patIter pat_last);
        template<typename PatternRange, typename CorpusRange>
          std::pair< typename boost::range_iterator< CorpusRange >::type, typename boost::range_iterator< CorpusRange >::type >
          boyer_moore_search(CorpusRange & corpus, const PatternRange & pattern);
        template<typename Range>
          boost::algorithm::boyer_moore< typename boost::range_iterator< const Range >::type >
          make_boyer_moore(const Range & r);
        template<typename Range>
          boost::algorithm::boyer_moore< typename boost::range_iterator< Range >::type >
          make_boyer_moore(Range & r);
      }
    }

### Header <boost/algorithm/searching/boyer_moore_horspool.hpp>

    namespace boost {
      namespace algorithm {
        template<typename patIter, typename traits = detail::BM_traits<patIter> >
          class boyer_moore_horspool;
        template<typename patIter, typename corpusIter>
          std::pair< corpusIter, corpusIter >
          boyer_moore_horspool_search(corpusIter, corpusIter, patIter, patIter);
        template<typename PatternRange, typename corpusIter>
          std::pair< corpusIter, corpusIter >
          boyer_moore_horspool_search(corpusIter corpus_first,
                                      corpusIter corpus_last,
                                      const PatternRange & pattern);
        template<typename patIter, typename CorpusRange>
          boost::disable_if_c< boost::is_same< CorpusRange, patIter >::value, std::pair< typename boost::range_iterator< CorpusRange >::type, typename boost::range_iterator< CorpusRange >::type > >::type
          boyer_moore_horspool_search(CorpusRange & corpus, patIter pat_first,
                                      patIter pat_last);
        template<typename PatternRange, typename CorpusRange>
          std::pair< typename boost::range_iterator< CorpusRange >::type, typename boost::range_iterator< CorpusRange >::type >
          boyer_moore_horspool_search(CorpusRange & corpus,
                                      const PatternRange & pattern);
        template<typename Range>
          boost::algorithm::boyer_moore_horspool< typename boost::range_iterator< const Range >::type >
          make_boyer_moore_horspool(const Range & r);
        template<typename Range>
          boost::algorithm::boyer_moore_horspool< typename boost::range_iterator< Range >::type >
          make_boyer_moore_horspool(Range & r);
      }
    }

### Header <boost/algorithm/searching/knuth_morris_pratt.hpp>

    namespace boost {
      namespace algorithm {
        template<typename patIter> class knuth_morris_pratt;
        template<typename patIter, typename corpusIter>
          std::pair< corpusIter, corpusIter >
          knuth_morris_pratt_search(corpusIter, corpusIter, patIter, patIter);
        template<typename PatternRange, typename corpusIter>
          std::pair< corpusIter, corpusIter >
          knuth_morris_pratt_search(corpusIter corpus_first,
                                    corpusIter corpus_last,
                                    const PatternRange & pattern);
        template<typename patIter, typename CorpusRange>
          boost::disable_if_c< boost::is_same< CorpusRange, patIter >::value, std::pair< typename boost::range_iterator< CorpusRange >::type, typename boost::range_iterator< CorpusRange >::type > >::type
          knuth_morris_pratt_search(CorpusRange & corpus, patIter pat_first,
                                    patIter pat_last);
        template<typename PatternRange, typename CorpusRange>
          std::pair< typename boost::range_iterator< CorpusRange >::type, typename boost::range_iterator< CorpusRange >::type >
          knuth_morris_pratt_search(CorpusRange & corpus,
                                    const PatternRange & pattern);
        template<typename Range>
          boost::algorithm::knuth_morris_pratt< typename boost::range_iterator< const Range >::type >
          make_knuth_morris_pratt(const Range & r);
        template<typename Range>
          boost::algorithm::knuth_morris_pratt< typename boost::range_iterator< Range >::type >
          make_knuth_morris_pratt(Range & r);
      }
    }

### Header <boost/algorithm/sort_subrange.hpp>

Sort a subrange.

Marshall Clow

Suggested by Sean Parent in his CppCon 2015 keynote

    namespace boost {
      namespace algorithm {
        template<typename Iterator, typename Pred>
          void sort_subrange(Iterator first, Iterator last, Iterator sub_first,
                             Iterator sub_last, Pred p);
        template<typename Iterator>
          void sort_subrange(Iterator first, Iterator last, Iterator sub_first,
                             Iterator sub_last);
        template<typename Iterator, typename Pred>
          void partition_subrange(Iterator first, Iterator last,
                                  Iterator sub_first, Iterator sub_last, Pred p);
        template<typename Iterator>
          void partition_subrange(Iterator first, Iterator last,
                                  Iterator sub_first, Iterator sub_last);
      }
    }

### Header <boost/algorithm/string.hpp>

Cumulative include for string_algo library

### Header <boost/algorithm/string_regex.hpp>

Cumulative include for string_algo library. In addition to string.hpp contains also regex-related stuff.