?????????? ?????????

?????????? ????????? - ??????????????? - /home/agenciai/public_html/cd38d8/algorithm.zip

???????
PK��M�[e?��is_palindrome.hppnu��[��/* Copyright (c) Alexander Zaitsev <zamazan4ik@gmail.com>, 2016 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) See http://www.boost.org/ for latest version. / /// \file is_palindrome.hpp /// \brief Checks the input sequence on palindrome. /// \author Alexander Zaitsev #ifndef BOOST_ALGORITHM_IS_PALINDROME_HPP #define BOOST_ALGORITHM_IS_PALINDROME_HPP #include <iterator> #include <functional> #include <cstring> #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> namespace boost { namespace algorithm { /// \fn is_palindrome ( BidirectionalIterator begin, BidirectionalIterator end, Predicate p ) /// \return true if the entire sequence is palindrome /// /// \param begin The start of the input sequence /// \param end One past the end of the input sequence /// \param p A predicate used to compare the values. /// /// \note This function will return true for empty sequences and for palindromes. /// For other sequences function will return false. /// Complexity: O(N). template <typename BidirectionalIterator, typename Predicate> bool is_palindrome(BidirectionalIterator begin, BidirectionalIterator end, Predicate p) { if(begin == end) { return true; } --end; while(begin != end) { if(!p(begin, end)) { return false; } ++begin; if(begin == end) { break; } --end; } return true; } /// \fn is_palindrome ( BidirectionalIterator begin, BidirectionalIterator end ) /// \return true if the entire sequence is palindrome /// /// \param begin The start of the input sequence /// \param end One past the end of the input sequence /// /// \note This function will return true for empty sequences and for palindromes. /// For other sequences function will return false. /// Complexity: O(N). template <typename BidirectionalIterator> bool is_palindrome(BidirectionalIterator begin, BidirectionalIterator end) { return is_palindrome(begin, end, std::equal_to<typename std::iterator_traits<BidirectionalIterator>::value_type> ()); } /// \fn is_palindrome ( const R& range ) /// \return true if the entire sequence is palindrome /// /// \param range The range to be tested. /// /// \note This function will return true for empty sequences and for palindromes. /// For other sequences function will return false. /// Complexity: O(N). template <typename R> bool is_palindrome(const R& range) { return is_palindrome(boost::begin(range), boost::end(range)); } /// \fn is_palindrome ( const R& range, Predicate p ) /// \return true if the entire sequence is palindrome /// /// \param range The range to be tested. /// \param p A predicate used to compare the values. /// /// \note This function will return true for empty sequences and for palindromes. /// For other sequences function will return false. /// Complexity: O(N). template <typename R, typename Predicate> bool is_palindrome(const R& range, Predicate p) { return is_palindrome(boost::begin(range), boost::end(range), p); } /// \fn is_palindrome ( const char str ) /// \return true if the entire sequence is palindrome /// /// \param str C-string to be tested. /// /// \note This function will return true for empty sequences and for palindromes. /// For other sequences function will return false. /// Complexity: O(N). bool is_palindrome(const char* str) { if(!str) return true; return is_palindrome(str, str + strlen(str)); } /// \fn is_palindrome ( const char* str, Predicate p ) /// \return true if the entire sequence is palindrome /// /// \param str C-string to be tested. /// \param p A predicate used to compare the values. /// /// \note This function will return true for empty sequences and for palindromes. /// For other sequences function will return false. /// Complexity: O(N). template<typename Predicate> bool is_palindrome(const char* str, Predicate p) { if(!str) return true; return is_palindrome(str, str + strlen(str), p); } }} #endif // BOOST_ALGORITHM_IS_PALINDROME_HPP PK��M�[�3� �� is_partitioned_until.hppnu��[��/* Copyright (c) Alexander Zaitsev <zamazan4ik@gmail.by>, 2017. 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) / /// \file is_partitioned_until.hpp /// \brief Tell if a sequence is partitioned /// \author Alexander Zaitsev #ifndef BOOST_ALGORITHM_IS_PARTITIONED_UNTIL_HPP #define BOOST_ALGORITHM_IS_PARTITIONED_UNTIL_HPP #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> namespace boost { namespace algorithm { /// \fn is_partitioned_until ( InputIterator first, InputIterator last, UnaryPredicate p ) /// \brief 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. /// /// \param first The start of the input sequence /// \param last One past the end of the input sequence /// \param p The predicate to test the values with /// /// \note Returns the first iterator 'it' in the sequence [first, last) for which is_partitioned(first, it, p) is false. /// Returns last if the entire sequence is partitioned. /// Complexity: O(N). template <typename InputIterator, typename UnaryPredicate> InputIterator is_partitioned_until ( InputIterator first, InputIterator last, UnaryPredicate p ) { // 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 for ( ; first != last; ++first ) if ( p (first)) return first; return last; } /// \fn is_partitioned_until ( const Range &r, UnaryPredicate p ) /// \brief 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. /// /// \param r The input range /// \param p The predicate to test the values with /// /// \note Returns the first iterator 'it' in the sequence [first, last) for which is_partitioned(first, it, p) is false. /// Returns last if the entire sequence is partitioned. /// Complexity: O(N). template <typename Range, typename UnaryPredicate> typename boost::range_iterator<const Range>::type is_partitioned_until ( const Range &r, UnaryPredicate p ) { return boost::algorithm::is_partitioned_until (boost::begin(r), boost::end(r), p); } }} #endif // BOOST_ALGORITHM_IS_PARTITIONED_UNTIL_HPP PK��M�[%�R�PD��PD��minmax_element.hppnu��[��// (C) Copyright Herve Bronnimann 2004. // // 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) / Revision history: 1 July 2004 Split the code into two headers to lessen dependence on Boost.tuple. (Herve) 26 June 2004 Added the code for the boost minmax library. (Herve) / #ifndef BOOST_ALGORITHM_MINMAX_ELEMENT_HPP #define BOOST_ALGORITHM_MINMAX_ELEMENT_HPP / PROPOSED STANDARD EXTENSIONS: * * minmax_element(first, last) * Effect: std::make_pair( std::min_element(first, last), * std::max_element(first, last) ); * * minmax_element(first, last, comp) * Effect: std::make_pair( std::min_element(first, last, comp), * std::max_element(first, last, comp) ); / #include <utility> // for std::pair and std::make_pair #include <boost/config.hpp> namespace boost { namespace detail { // for obtaining a uniform version of minmax_element // that compiles with VC++ 6.0 -- avoid the iterator_traits by // having comparison object over iterator, not over dereferenced value template <typename Iterator> struct less_over_iter { bool operator()(Iterator const& it1, Iterator const& it2) const { return it1 < it2; } }; template <typename Iterator, class BinaryPredicate> struct binary_pred_over_iter { explicit binary_pred_over_iter(BinaryPredicate const& p ) : m_p( p ) {} bool operator()(Iterator const& it1, Iterator const& it2) const { return m_p(it1, it2); } private: BinaryPredicate m_p; }; // common base for the two minmax_element overloads template <typename ForwardIter, class Compare > std::pair<ForwardIter,ForwardIter> basic_minmax_element(ForwardIter first, ForwardIter last, Compare comp) { if (first == last) return std::make_pair(last,last); ForwardIter min_result = first; ForwardIter max_result = first; // if only one element ForwardIter second = first; ++second; if (second == last) return std::make_pair(min_result, max_result); // treat first pair separately (only one comparison for first two elements) ForwardIter potential_min_result = last; if (comp(first, second)) max_result = second; else { min_result = second; potential_min_result = first; } // then each element by pairs, with at most 3 comparisons per pair first = ++second; if (first != last) ++second; while (second != last) { if (comp(first, second)) { if (comp(first, min_result)) { min_result = first; potential_min_result = last; } if (comp(max_result, second)) max_result = second; } else { if (comp(second, min_result)) { min_result = second; potential_min_result = first; } if (comp(max_result, first)) max_result = first; } first = ++second; if (first != last) ++second; } // if odd number of elements, treat last element if (first != last) { // odd number of elements if (comp(first, min_result)) { min_result = first; potential_min_result = last; } else if (comp(max_result, first)) max_result = first; } // resolve min_result being incorrect with one extra comparison // (in which case potential_min_result is necessarily the correct result) if (potential_min_result != last && !comp(min_result, potential_min_result)) min_result = potential_min_result; return std::make_pair(min_result,max_result); } } // namespace detail template <typename ForwardIter> std::pair<ForwardIter,ForwardIter> minmax_element(ForwardIter first, ForwardIter last) { return detail::basic_minmax_element(first, last, detail::less_over_iter<ForwardIter>() ); } template <typename ForwardIter, class BinaryPredicate> std::pair<ForwardIter,ForwardIter> minmax_element(ForwardIter first, ForwardIter last, BinaryPredicate comp) { return detail::basic_minmax_element(first, last, detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) ); } } / PROPOSED BOOST EXTENSIONS * In the description below, [rfirst,rlast) denotes the reversed range * of [first,last). Even though the iterator type of first and last may * be only a Forward Iterator, it is possible to explain the semantics * by assuming that it is a Bidirectional Iterator. In the sequel, * reverse(ForwardIterator&) returns the reverse_iterator adaptor. * This is not how the functions would be implemented! * * first_min_element(first, last) * Effect: std::min_element(first, last); * * first_min_element(first, last, comp) * Effect: std::min_element(first, last, comp); * * last_min_element(first, last) * Effect: reverse( std::min_element(reverse(last), reverse(first)) ); * * last_min_element(first, last, comp) * Effect: reverse( std::min_element(reverse(last), reverse(first), comp) ); * * first_max_element(first, last) * Effect: std::max_element(first, last); * * first_max_element(first, last, comp) * Effect: max_element(first, last); * * last_max_element(first, last) * Effect: reverse( std::max_element(reverse(last), reverse(first)) ); * * last_max_element(first, last, comp) * Effect: reverse( std::max_element(reverse(last), reverse(first), comp) ); * * first_min_first_max_element(first, last) * Effect: std::make_pair( first_min_element(first, last), * first_max_element(first, last) ); * * first_min_first_max_element(first, last, comp) * Effect: std::make_pair( first_min_element(first, last, comp), * first_max_element(first, last, comp) ); * * first_min_last_max_element(first, last) * Effect: std::make_pair( first_min_element(first, last), * last_max_element(first, last) ); * * first_min_last_max_element(first, last, comp) * Effect: std::make_pair( first_min_element(first, last, comp), * last_max_element(first, last, comp) ); * * last_min_first_max_element(first, last) * Effect: std::make_pair( last_min_element(first, last), * first_max_element(first, last) ); * * last_min_first_max_element(first, last, comp) * Effect: std::make_pair( last_min_element(first, last, comp), * first_max_element(first, last, comp) ); * * last_min_last_max_element(first, last) * Effect: std::make_pair( last_min_element(first, last), * last_max_element(first, last) ); * * last_min_last_max_element(first, last, comp) * Effect: std::make_pair( last_min_element(first, last, comp), * last_max_element(first, last, comp) ); / namespace boost { // Min_element and max_element variants namespace detail { // common base for the overloads template <typename ForwardIter, class BinaryPredicate> ForwardIter basic_first_min_element(ForwardIter first, ForwardIter last, BinaryPredicate comp) { if (first == last) return last; ForwardIter min_result = first; while (++first != last) if (comp(first, min_result)) min_result = first; return min_result; } template <typename ForwardIter, class BinaryPredicate> ForwardIter basic_last_min_element(ForwardIter first, ForwardIter last, BinaryPredicate comp) { if (first == last) return last; ForwardIter min_result = first; while (++first != last) if (!comp(min_result, first)) min_result = first; return min_result; } template <typename ForwardIter, class BinaryPredicate> ForwardIter basic_first_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp) { if (first == last) return last; ForwardIter max_result = first; while (++first != last) if (comp(max_result, first)) max_result = first; return max_result; } template <typename ForwardIter, class BinaryPredicate> ForwardIter basic_last_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp) { if (first == last) return last; ForwardIter max_result = first; while (++first != last) if (!comp(first, max_result)) max_result = first; return max_result; } } // namespace detail template <typename ForwardIter> ForwardIter first_min_element(ForwardIter first, ForwardIter last) { return detail::basic_first_min_element(first, last, detail::less_over_iter<ForwardIter>() ); } template <typename ForwardIter, class BinaryPredicate> ForwardIter first_min_element(ForwardIter first, ForwardIter last, BinaryPredicate comp) { return detail::basic_first_min_element(first, last, detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) ); } template <typename ForwardIter> ForwardIter last_min_element(ForwardIter first, ForwardIter last) { return detail::basic_last_min_element(first, last, detail::less_over_iter<ForwardIter>() ); } template <typename ForwardIter, class BinaryPredicate> ForwardIter last_min_element(ForwardIter first, ForwardIter last, BinaryPredicate comp) { return detail::basic_last_min_element(first, last, detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) ); } template <typename ForwardIter> ForwardIter first_max_element(ForwardIter first, ForwardIter last) { return detail::basic_first_max_element(first, last, detail::less_over_iter<ForwardIter>() ); } template <typename ForwardIter, class BinaryPredicate> ForwardIter first_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp) { return detail::basic_first_max_element(first, last, detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) ); } template <typename ForwardIter> ForwardIter last_max_element(ForwardIter first, ForwardIter last) { return detail::basic_last_max_element(first, last, detail::less_over_iter<ForwardIter>() ); } template <typename ForwardIter, class BinaryPredicate> ForwardIter last_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp) { return detail::basic_last_max_element(first, last, detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) ); } // Minmax_element variants -- comments removed namespace detail { template <typename ForwardIter, class BinaryPredicate> std::pair<ForwardIter,ForwardIter> basic_first_min_last_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp) { if (first == last) return std::make_pair(last,last); ForwardIter min_result = first; ForwardIter max_result = first; ForwardIter second = ++first; if (second == last) return std::make_pair(min_result, max_result); if (comp(second, min_result)) min_result = second; else max_result = second; first = ++second; if (first != last) ++second; while (second != last) { if (!comp(second, first)) { if (comp(first, min_result)) min_result = first; if (!comp(second, max_result)) max_result = second; } else { if (comp(second, min_result)) min_result = second; if (!comp(first, max_result)) max_result = first; } first = ++second; if (first != last) ++second; } if (first != last) { if (comp(first, min_result)) min_result = first; else if (!comp(first, max_result)) max_result = first; } return std::make_pair(min_result, max_result); } template <typename ForwardIter, class BinaryPredicate> std::pair<ForwardIter,ForwardIter> basic_last_min_first_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp) { if (first == last) return std::make_pair(last,last); ForwardIter min_result = first; ForwardIter max_result = first; ForwardIter second = ++first; if (second == last) return std::make_pair(min_result, max_result); if (comp(max_result, second)) max_result = second; else min_result = second; first = ++second; if (first != last) ++second; while (second != last) { if (comp(first, second)) { if (!comp(min_result, first)) min_result = first; if (comp(max_result, second)) max_result = second; } else { if (!comp(min_result, second)) min_result = second; if (comp(max_result, first)) max_result = first; } first = ++second; if (first != last) ++second; } if (first != last) { if (!comp(min_result, first)) min_result = first; else if (comp(max_result, first)) max_result = first; } return std::make_pair(min_result, max_result); } template <typename ForwardIter, class BinaryPredicate> std::pair<ForwardIter,ForwardIter> basic_last_min_last_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp) { if (first == last) return std::make_pair(last,last); ForwardIter min_result = first; ForwardIter max_result = first; ForwardIter second = first; ++second; if (second == last) return std::make_pair(min_result,max_result); ForwardIter potential_max_result = last; if (comp(first, second)) max_result = second; else { min_result = second; potential_max_result = second; } first = ++second; if (first != last) ++second; while (second != last) { if (comp(first, second)) { if (!comp(min_result, first)) min_result = first; if (!comp(second, max_result)) { max_result = second; potential_max_result = last; } } else { if (!comp(min_result, second)) min_result = second; if (!comp(first, max_result)) { max_result = first; potential_max_result = second; } } first = ++second; if (first != last) ++second; } if (first != last) { if (!comp(min_result, first)) min_result = first; if (!comp(first, max_result)) { max_result = first; potential_max_result = last; } } if (potential_max_result != last && !comp(potential_max_result, max_result)) max_result = potential_max_result; return std::make_pair(min_result,max_result); } } // namespace detail template <typename ForwardIter> inline std::pair<ForwardIter,ForwardIter> first_min_first_max_element(ForwardIter first, ForwardIter last) { return minmax_element(first, last); } template <typename ForwardIter, class BinaryPredicate> inline std::pair<ForwardIter,ForwardIter> first_min_first_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp) { return minmax_element(first, last, comp); } template <typename ForwardIter> std::pair<ForwardIter,ForwardIter> first_min_last_max_element(ForwardIter first, ForwardIter last) { return detail::basic_first_min_last_max_element(first, last, detail::less_over_iter<ForwardIter>() ); } template <typename ForwardIter, class BinaryPredicate> inline std::pair<ForwardIter,ForwardIter> first_min_last_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp) { return detail::basic_first_min_last_max_element(first, last, detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) ); } template <typename ForwardIter> std::pair<ForwardIter,ForwardIter> last_min_first_max_element(ForwardIter first, ForwardIter last) { return detail::basic_last_min_first_max_element(first, last, detail::less_over_iter<ForwardIter>() ); } template <typename ForwardIter, class BinaryPredicate> inline std::pair<ForwardIter,ForwardIter> last_min_first_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp) { return detail::basic_last_min_first_max_element(first, last, detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) ); } template <typename ForwardIter> std::pair<ForwardIter,ForwardIter> last_min_last_max_element(ForwardIter first, ForwardIter last) { return detail::basic_last_min_last_max_element(first, last, detail::less_over_iter<ForwardIter>() ); } template <typename ForwardIter, class BinaryPredicate> inline std::pair<ForwardIter,ForwardIter> last_min_last_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp) { return detail::basic_last_min_last_max_element(first, last, detail::binary_pred_over_iter<ForwardIter,BinaryPredicate>(comp) ); } } // namespace boost #endif // BOOST_ALGORITHM_MINMAX_ELEMENT_HPP PK��M�[�#AZ �� string/trim_all.hppnu��[��// Boost string_algo library trim.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_TRIM_ALL_HPP #define BOOST_STRING_TRIM_ALL_HPP #include <boost/algorithm/string/config.hpp> #include <boost/algorithm/string/trim.hpp> #include <boost/algorithm/string/classification.hpp> #include <boost/algorithm/string/find_format.hpp> #include <boost/algorithm/string/formatter.hpp> #include <boost/algorithm/string/finder.hpp> #include <locale> /! \file Defines trim_all algorithms. Just like \c trim, \c trim_all removes all trailing and leading spaces from a sequence (string). In addition, spaces in the middle of the sequence are truncated to just one character. Space is recognized using given locales. \c trim_fill acts as trim_all, but the spaces in the middle are replaces with a user-define sequence of character. Parametric (\c _if) variants use a predicate (functor) to select which characters are to be trimmed.. Functions take a selection predicate as a parameter, which is used to determine whether a character is a space. Common predicates are provided in classification.hpp header. / namespace boost { namespace algorithm { // multi line trim ----------------------------------------------- // //! Trim All - parametric /! Remove all leading and trailing spaces from the input and compress all other spaces to a single character. The result is a trimmed copy of the input \param Input An input sequence \param IsSpace A unary predicate identifying spaces \return A trimmed copy of the input / template<typename SequenceT, typename PredicateT> inline SequenceT trim_all_copy_if(const SequenceT& Input, PredicateT IsSpace) { return ::boost::find_format_all_copy( ::boost::trim_copy_if(Input, IsSpace), ::boost::token_finder(IsSpace, ::boost::token_compress_on), ::boost::dissect_formatter(::boost::head_finder(1))); } //! Trim All /! Remove all leading and trailing spaces from the input and compress all other spaces to a single character. The input sequence is modified in-place. \param Input An input sequence \param IsSpace A unary predicate identifying spaces / template<typename SequenceT, typename PredicateT> inline void trim_all_if(SequenceT& Input, PredicateT IsSpace) { ::boost::trim_if(Input, IsSpace); ::boost::find_format_all( Input, ::boost::token_finder(IsSpace, ::boost::token_compress_on), ::boost::dissect_formatter(::boost::head_finder(1))); } //! Trim All /! Remove all leading and trailing spaces from the input and compress all other spaces to a single character. The result is a trimmed copy of the input \param Input An input sequence \param Loc A locale used for 'space' classification \return A trimmed copy of the input / template<typename SequenceT> inline SequenceT trim_all_copy(const SequenceT& Input, const std::locale& Loc =std::locale()) { return trim_all_copy_if(Input, ::boost::is_space(Loc)); } //! Trim All /! Remove all leading and trailing spaces from the input and compress all other spaces to a single character. The input sequence is modified in-place. \param Input An input sequence \param Loc A locale used for 'space' classification \return A trimmed copy of the input / template<typename SequenceT> inline void trim_all(SequenceT& Input, const std::locale& Loc =std::locale()) { trim_all_if(Input, ::boost::is_space(Loc)); } //! Trim Fill - parametric /! Remove all leading and trailing spaces from the input and replace all every block of consecutive spaces with a fill string defined by user. The result is a trimmed copy of the input \param Input An input sequence \param Fill A string used to fill the inner spaces \param IsSpace A unary predicate identifying spaces \return A trimmed copy of the input / template<typename SequenceT, typename RangeT, typename PredicateT> inline SequenceT trim_fill_copy_if(const SequenceT& Input, const RangeT& Fill, PredicateT IsSpace) { return ::boost::find_format_all_copy( ::boost::trim_copy_if(Input, IsSpace), ::boost::token_finder(IsSpace, ::boost::token_compress_on), ::boost::const_formatter(::boost::as_literal(Fill))); } //! Trim Fill /! Remove all leading and trailing spaces from the input and replace all every block of consecutive spaces with a fill string defined by user. The input sequence is modified in-place. \param Input An input sequence \param Fill A string used to fill the inner spaces \param IsSpace A unary predicate identifying spaces / template<typename SequenceT, typename RangeT, typename PredicateT> inline void trim_fill_if(SequenceT& Input, const RangeT& Fill, PredicateT IsSpace) { ::boost::trim_if(Input, IsSpace); ::boost::find_format_all( Input, ::boost::token_finder(IsSpace, ::boost::token_compress_on), ::boost::const_formatter(::boost::as_literal(Fill))); } //! Trim Fill /! Remove all leading and trailing spaces from the input and replace all every block of consecutive spaces with a fill string defined by user. The result is a trimmed copy of the input \param Input An input sequence \param Fill A string used to fill the inner spaces \param Loc A locale used for 'space' classification \return A trimmed copy of the input / template<typename SequenceT, typename RangeT> inline SequenceT trim_fill_copy(const SequenceT& Input, const RangeT& Fill, const std::locale& Loc =std::locale()) { return trim_fill_copy_if(Input, Fill, ::boost::is_space(Loc)); } //! Trim Fill /! Remove all leading and trailing spaces from the input and replace all every block of consecutive spaces with a fill string defined by user. The input sequence is modified in-place. \param Input An input sequence \param Fill A string used to fill the inner spaces \param Loc A locale used for 'space' classification \return A trimmed copy of the input / template<typename SequenceT, typename RangeT> inline void trim_fill(SequenceT& Input, const RangeT& Fill, const std::locale& Loc =std::locale()) { trim_fill_if(Input, Fill, ::boost::is_space(Loc)); } } // namespace algorithm // pull names to the boost namespace using algorithm::trim_all; using algorithm::trim_all_if; using algorithm::trim_all_copy; using algorithm::trim_all_copy_if; using algorithm::trim_fill; using algorithm::trim_fill_if; using algorithm::trim_fill_copy; using algorithm::trim_fill_copy_if; } // namespace boost #endif // BOOST_STRING_TRIM_ALL_HPP PK��M�[HX1϶��string/split.hppnu��[��// Boost string_algo library split.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2006. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_SPLIT_HPP #define BOOST_STRING_SPLIT_HPP #include <boost/algorithm/string/config.hpp> #include <boost/algorithm/string/iter_find.hpp> #include <boost/algorithm/string/finder.hpp> #include <boost/algorithm/string/compare.hpp> /! \file Defines basic split algorithms. Split algorithms can be used to divide a string into several parts according to given criteria. Each part is copied and added as a new element to the output container. Thus the result container must be able to hold copies of the matches (in a compatible structure like std::string) or a reference to it (e.g. using the iterator range class). Examples of such a container are \c std::vector<std::string> or \c std::list<boost::iterator_range<std::string::iterator>> / namespace boost { namespace algorithm { // find_all ------------------------------------------------------------// //! Find all algorithm /! This algorithm finds all occurrences of the search string in the input. Each part is copied and added as a new element to the output container. Thus the result container must be able to hold copies of the matches (in a compatible structure like std::string) or a reference to it (e.g. using the iterator range class). Examples of such a container are \c std::vector<std::string> or \c std::list<boost::iterator_range<std::string::iterator>> \param Result A container that can hold copies of references to the substrings \param Input A container which will be searched. \param Search A substring to be searched for. \return A reference the result \note Prior content of the result will be overwritten. \note This function provides the strong exception-safety guarantee / template< typename SequenceSequenceT, typename Range1T, typename Range2T > inline SequenceSequenceT& find_all( SequenceSequenceT& Result, #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) Range1T&& Input, #else Range1T& Input, #endif const Range2T& Search) { return ::boost::algorithm::iter_find( Result, Input, ::boost::algorithm::first_finder(Search) ); } //! Find all algorithm ( case insensitive ) /! This algorithm finds all occurrences of the search string in the input. Each part is copied and added as a new element to the output container. Thus the result container must be able to hold copies of the matches (in a compatible structure like std::string) or a reference to it (e.g. using the iterator range class). Examples of such a container are \c std::vector<std::string> or \c std::list<boost::iterator_range<std::string::iterator>> Searching is case insensitive. \param Result A container that can hold copies of references to the substrings \param Input A container which will be searched. \param Search A substring to be searched for. \param Loc A locale used for case insensitive comparison \return A reference the result \note Prior content of the result will be overwritten. \note This function provides the strong exception-safety guarantee / template< typename SequenceSequenceT, typename Range1T, typename Range2T > inline SequenceSequenceT& ifind_all( SequenceSequenceT& Result, #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) Range1T&& Input, #else Range1T& Input, #endif const Range2T& Search, const std::locale& Loc=std::locale() ) { return ::boost::algorithm::iter_find( Result, Input, ::boost::algorithm::first_finder(Search, is_iequal(Loc) ) ); } // tokenize -------------------------------------------------------------// //! Split algorithm /! Tokenize expression. This function is equivalent to C strtok. Input sequence is split into tokens, separated by separators. Separators are given by means of the predicate. Each part is copied and added as a new element to the output container. Thus the result container must be able to hold copies of the matches (in a compatible structure like std::string) or a reference to it (e.g. using the iterator range class). Examples of such a container are \c std::vector<std::string> or \c std::list<boost::iterator_range<std::string::iterator>> \param Result A container that can hold copies of references to the substrings \param Input A container which will be searched. \param Pred A predicate to identify separators. This predicate is supposed to return true if a given element is a separator. \param eCompress If eCompress argument is set to token_compress_on, adjacent separators are merged together. Otherwise, every two separators delimit a token. \return A reference the result \note Prior content of the result will be overwritten. \note This function provides the strong exception-safety guarantee / template< typename SequenceSequenceT, typename RangeT, typename PredicateT > inline SequenceSequenceT& split( SequenceSequenceT& Result, #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) RangeT&& Input, #else RangeT& Input, #endif PredicateT Pred, token_compress_mode_type eCompress=token_compress_off ) { return ::boost::algorithm::iter_split( Result, Input, ::boost::algorithm::token_finder( Pred, eCompress ) ); } } // namespace algorithm // pull names to the boost namespace using algorithm::find_all; using algorithm::ifind_all; using algorithm::split; } // namespace boost #endif // BOOST_STRING_SPLIT_HPP PK��M�[�Rγ4��4��string/sequence_traits.hppnu��[��// Boost string_algo library sequence_traits.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_SEQUENCE_TRAITS_HPP #define BOOST_STRING_SEQUENCE_TRAITS_HPP #include <boost/config.hpp> #include <boost/mpl/bool.hpp> #include <boost/algorithm/string/yes_no_type.hpp> /! \file Traits defined in this header are used by various algorithms to achieve better performance for specific containers. Traits provide fail-safe defaults. If a container supports some of these features, it is possible to specialize the specific trait for this container. For lacking compilers, it is possible of define an override for a specific tester function. Due to a language restriction, it is not currently possible to define specializations for stl containers without including the corresponding header. To decrease the overhead needed by this inclusion, user can selectively include a specialization header for a specific container. They are located in boost/algorithm/string/stl directory. Alternatively she can include boost/algorithm/string/std_collection_traits.hpp header which contains specializations for all stl containers. / namespace boost { namespace algorithm { // sequence traits -----------------------------------------------// //! Native replace trait /! This trait specifies that the sequence has \c std::string like replace method / template< typename T > class has_native_replace { public: # if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) enum { value = false }; # else BOOST_STATIC_CONSTANT(bool, value=false); # endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) typedef mpl::bool_<has_native_replace<T>::value> type; }; //! Stable iterators trait /! This trait specifies that the sequence has stable iterators. It means that operations like insert/erase/replace do not invalidate iterators. / template< typename T > class has_stable_iterators { public: # if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) enum { value = false }; # else BOOST_STATIC_CONSTANT(bool, value=false); # endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) typedef mpl::bool_<has_stable_iterators<T>::value> type; }; //! Const time insert trait /! This trait specifies that the sequence's insert method has constant time complexity. / template< typename T > class has_const_time_insert { public: # if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) enum { value = false }; # else BOOST_STATIC_CONSTANT(bool, value=false); # endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) typedef mpl::bool_<has_const_time_insert<T>::value> type; }; //! Const time erase trait /! This trait specifies that the sequence's erase method has constant time complexity. / template< typename T > class has_const_time_erase { public: # if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) enum { value = false }; # else BOOST_STATIC_CONSTANT(bool, value=false); # endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) typedef mpl::bool_<has_const_time_erase<T>::value> type; }; } // namespace algorithm } // namespace boost #endif // BOOST_STRING_SEQUENCE_TRAITS_HPP PK��M�[��string/yes_no_type.hppnu��[��// Boost string_algo library yes_no_type.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_YES_NO_TYPE_DETAIL_HPP #define BOOST_STRING_YES_NO_TYPE_DETAIL_HPP namespace boost { namespace algorithm { // taken from boost mailing-list // when yes_no_type will become officially // a part of boost distribution, this header // will be deprecated template<int I> struct size_descriptor { typedef char (& type)[I]; }; typedef size_descriptor<1>::type yes_type; typedef size_descriptor<2>::type no_type; } // namespace algorithm } // namespace boost #endif // BOOST_STRING_YES_NO_TYPE_DETAIL_HPP PK��M�[�C�D��D�� string/std_containers_traits.hppnu��[��// Boost string_algo library std_containers_traits.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_STD_CONTAINERS_TRAITS_HPP #define BOOST_STRING_STD_CONTAINERS_TRAITS_HPP /!\file This file includes sequence traits for stl containers. / #include <boost/config.hpp> #include <boost/algorithm/string/std/string_traits.hpp> #include <boost/algorithm/string/std/list_traits.hpp> #ifdef BOOST_HAS_SLIST # include <boost/algorithm/string/std/slist_traits.hpp> #endif #endif // BOOST_STRING_STD_CONTAINERS_TRAITS_HPP PK��M�[ި��string/formatter.hppnu��[��// Boost string_algo library formatter.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_FORMATTER_HPP #define BOOST_STRING_FORMATTER_HPP #include <boost/range/value_type.hpp> #include <boost/range/iterator_range_core.hpp> #include <boost/range/as_literal.hpp> #include <boost/algorithm/string/detail/formatter.hpp> /! \file Defines Formatter generators. Formatter is a functor which formats a string according to given parameters. A Formatter works in conjunction with a Finder. A Finder can provide additional information for a specific Formatter. An example of such a cooperation is regex_finder and regex_formatter. Formatters are used as pluggable components for replace facilities. This header contains generator functions for the Formatters provided in this library. / namespace boost { namespace algorithm { // generic formatters ---------------------------------------------------------------// //! Constant formatter /! Constructs a \c const_formatter. Const formatter always returns the same value, regardless of the parameter. \param Format A predefined value used as a result for formatting \return An instance of the \c const_formatter object. / template<typename RangeT> inline detail::const_formatF< iterator_range< BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> > const_formatter(const RangeT& Format) { return detail::const_formatF< iterator_range< BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >(::boost::as_literal(Format)); } //! Identity formatter /! Constructs an \c identity_formatter. Identity formatter always returns the parameter. \return An instance of the \c identity_formatter object. / template<typename RangeT> inline detail::identity_formatF< iterator_range< BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> > identity_formatter() { return detail::identity_formatF< iterator_range< BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >(); } //! Empty formatter /! Constructs an \c empty_formatter. Empty formatter always returns an empty sequence. \param Input container used to select a correct value_type for the resulting empty_container<>. \return An instance of the \c empty_formatter object. / template<typename RangeT> inline detail::empty_formatF< BOOST_STRING_TYPENAME range_value<RangeT>::type> empty_formatter(const RangeT&) { return detail::empty_formatF< BOOST_STRING_TYPENAME range_value<RangeT>::type>(); } //! Empty formatter /! Constructs a \c dissect_formatter. Dissect formatter uses a specified finder to extract a portion of the formatted sequence. The first finder's match is returned as a result \param Finder a finder used to select a portion of the formatted sequence \return An instance of the \c dissect_formatter object. / template<typename FinderT> inline detail::dissect_formatF< FinderT > dissect_formatter(const FinderT& Finder) { return detail::dissect_formatF<FinderT>(Finder); } } // namespace algorithm // pull the names to the boost namespace using algorithm::const_formatter; using algorithm::identity_formatter; using algorithm::empty_formatter; using algorithm::dissect_formatter; } // namespace boost #endif // BOOST_FORMATTER_HPP PK��M�[� ��string/config.hppnu��[��// Boost string_algo library config.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_CONFIG_HPP #define BOOST_STRING_CONFIG_HPP #include <boost/config.hpp> #include <boost/detail/workaround.hpp> #ifdef BOOST_STRING_DEDUCED_TYPENAME # error "macro already defined!" #endif #define BOOST_STRING_TYPENAME BOOST_DEDUCED_TYPENAME // Metrowerks workaround #if BOOST_WORKAROUND(__MWERKS__, <= 0x3003) // 8.x #pragma parse_func_templ off #endif #endif // BOOST_STRING_CONFIG_HPP PK��M�[�]�( ��( ��string/concept.hppnu��[��// Boost string_algo library concept.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_CONCEPT_HPP #define BOOST_STRING_CONCEPT_HPP #include <boost/concept_check.hpp> #include <boost/range/iterator_range_core.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> /! \file Defines concepts used in string_algo library / namespace boost { namespace algorithm { //! Finder concept /! Defines the Finder concept. Finder is a functor which selects an arbitrary part of a string. Search is performed on the range specified by starting and ending iterators. Result of the find operation must be convertible to iterator_range. / template<typename FinderT, typename IteratorT> struct FinderConcept { private: typedef iterator_range<IteratorT> range; public: void constraints() { // Operation r=(pF)(i,i); } private: range r; IteratorT i; FinderT* pF; }; // Finder_concept //! Formatter concept /! Defines the Formatter concept. Formatter is a functor, which takes a result from a finder operation and transforms it in a specific way. Result must be a container supported by container_traits, or a reference to it. / template<typename FormatterT, typename FinderT, typename IteratorT> struct FormatterConcept { public: void constraints() { // Operation ::boost::begin((pFo)( (pF)(i,i) )); ::boost::end((pFo)( (pF)(i,i) )); } private: IteratorT i; FinderT* pF; FormatterT pFo; }; // FormatterConcept; } // namespace algorithm } // namespace boost #endif // BOOST_STRING_CONCEPT_HPP PK��M�[%ޯ��string/case_conv.hppnu��[��// Boost string_algo library case_conv.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_CASE_CONV_HPP #define BOOST_STRING_CASE_CONV_HPP #include <boost/algorithm/string/config.hpp> #include <algorithm> #include <locale> #include <boost/iterator/transform_iterator.hpp> #include <boost/range/as_literal.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/value_type.hpp> #include <boost/algorithm/string/detail/case_conv.hpp> /! \file Defines sequence case-conversion algorithms. Algorithms convert each element in the input sequence to the desired case using provided locales. / namespace boost { namespace algorithm { // to_lower -----------------------------------------------// //! Convert to lower case /! Each element of the input sequence is converted to lower case. The result is a copy of the input converted to lower case. It is returned as a sequence or copied to the output iterator. \param Output An output iterator to which the result will be copied \param Input An input range \param Loc A locale used for conversion \return An output iterator pointing just after the last inserted character or a copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template<typename OutputIteratorT, typename RangeT> inline OutputIteratorT to_lower_copy( OutputIteratorT Output, const RangeT& Input, const std::locale& Loc=std::locale()) { return ::boost::algorithm::detail::transform_range_copy( Output, ::boost::as_literal(Input), ::boost::algorithm::detail::to_lowerF< typename range_value<RangeT>::type >(Loc)); } //! Convert to lower case /! \overload / template<typename SequenceT> inline SequenceT to_lower_copy( const SequenceT& Input, const std::locale& Loc=std::locale()) { return ::boost::algorithm::detail::transform_range_copy<SequenceT>( Input, ::boost::algorithm::detail::to_lowerF< typename range_value<SequenceT>::type >(Loc)); } //! Convert to lower case /! Each element of the input sequence is converted to lower case. The input sequence is modified in-place. \param Input A range \param Loc a locale used for conversion / template<typename WritableRangeT> inline void to_lower( WritableRangeT& Input, const std::locale& Loc=std::locale()) { ::boost::algorithm::detail::transform_range( ::boost::as_literal(Input), ::boost::algorithm::detail::to_lowerF< typename range_value<WritableRangeT>::type >(Loc)); } // to_upper -----------------------------------------------// //! Convert to upper case /! Each element of the input sequence is converted to upper case. The result is a copy of the input converted to upper case. It is returned as a sequence or copied to the output iterator \param Output An output iterator to which the result will be copied \param Input An input range \param Loc A locale used for conversion \return An output iterator pointing just after the last inserted character or a copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template<typename OutputIteratorT, typename RangeT> inline OutputIteratorT to_upper_copy( OutputIteratorT Output, const RangeT& Input, const std::locale& Loc=std::locale()) { return ::boost::algorithm::detail::transform_range_copy( Output, ::boost::as_literal(Input), ::boost::algorithm::detail::to_upperF< typename range_value<RangeT>::type >(Loc)); } //! Convert to upper case /! \overload / template<typename SequenceT> inline SequenceT to_upper_copy( const SequenceT& Input, const std::locale& Loc=std::locale()) { return ::boost::algorithm::detail::transform_range_copy<SequenceT>( Input, ::boost::algorithm::detail::to_upperF< typename range_value<SequenceT>::type >(Loc)); } //! Convert to upper case /! Each element of the input sequence is converted to upper case. The input sequence is modified in-place. \param Input An input range \param Loc a locale used for conversion / template<typename WritableRangeT> inline void to_upper( WritableRangeT& Input, const std::locale& Loc=std::locale()) { ::boost::algorithm::detail::transform_range( ::boost::as_literal(Input), ::boost::algorithm::detail::to_upperF< typename range_value<WritableRangeT>::type >(Loc)); } } // namespace algorithm // pull names to the boost namespace using algorithm::to_lower; using algorithm::to_lower_copy; using algorithm::to_upper; using algorithm::to_upper_copy; } // namespace boost #endif // BOOST_STRING_CASE_CONV_HPP PK��M�[ G3��3��string/find.hppnu��[��// Boost string_algo library find.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_FIND_HPP #define BOOST_STRING_FIND_HPP #include <boost/algorithm/string/config.hpp> #include <boost/range/iterator_range_core.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/iterator.hpp> #include <boost/range/as_literal.hpp> #include <boost/algorithm/string/finder.hpp> #include <boost/algorithm/string/compare.hpp> #include <boost/algorithm/string/constants.hpp> /! \file Defines a set of find algorithms. The algorithms are searching for a substring of the input. The result is given as an \c iterator_range delimiting the substring. / namespace boost { namespace algorithm { // Generic find -----------------------------------------------// //! Generic find algorithm /! Search the input using the given finder. \param Input A string which will be searched. \param Finder Finder object used for searching. \return An \c iterator_range delimiting the match. Returned iterator is either \c RangeT::iterator or \c RangeT::const_iterator, depending on the constness of the input parameter. / template<typename RangeT, typename FinderT> inline iterator_range< BOOST_STRING_TYPENAME range_iterator<RangeT>::type> find( RangeT& Input, const FinderT& Finder) { iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input)); return Finder(::boost::begin(lit_input),::boost::end(lit_input)); } // find_first -----------------------------------------------// //! Find first algorithm /! Search for the first occurrence of the substring in the input. \param Input A string which will be searched. \param Search A substring to be searched for. \return An \c iterator_range delimiting the match. Returned iterator is either \c RangeT::iterator or \c RangeT::const_iterator, depending on the constness of the input parameter. \note This function provides the strong exception-safety guarantee / template<typename Range1T, typename Range2T> inline iterator_range< BOOST_STRING_TYPENAME range_iterator<Range1T>::type> find_first( Range1T& Input, const Range2T& Search) { return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search)); } //! Find first algorithm ( case insensitive ) /! Search for the first occurrence of the substring in the input. Searching is case insensitive. \param Input A string which will be searched. \param Search A substring to be searched for. \param Loc A locale used for case insensitive comparison \return An \c iterator_range delimiting the match. Returned iterator is either \c Range1T::iterator or \c Range1T::const_iterator, depending on the constness of the input parameter. \note This function provides the strong exception-safety guarantee / template<typename Range1T, typename Range2T> inline iterator_range< BOOST_STRING_TYPENAME range_iterator<Range1T>::type> ifind_first( Range1T& Input, const Range2T& Search, const std::locale& Loc=std::locale()) { return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search,is_iequal(Loc))); } // find_last -----------------------------------------------// //! Find last algorithm /! Search for the last occurrence of the substring in the input. \param Input A string which will be searched. \param Search A substring to be searched for. \return An \c iterator_range delimiting the match. Returned iterator is either \c Range1T::iterator or \c Range1T::const_iterator, depending on the constness of the input parameter. \note This function provides the strong exception-safety guarantee / template<typename Range1T, typename Range2T> inline iterator_range< BOOST_STRING_TYPENAME range_iterator<Range1T>::type> find_last( Range1T& Input, const Range2T& Search) { return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search)); } //! Find last algorithm ( case insensitive ) /! Search for the last match a string in the input. Searching is case insensitive. \param Input A string which will be searched. \param Search A substring to be searched for. \param Loc A locale used for case insensitive comparison \return An \c iterator_range delimiting the match. Returned iterator is either \c Range1T::iterator or \c Range1T::const_iterator, depending on the constness of the input parameter. \note This function provides the strong exception-safety guarantee / template<typename Range1T, typename Range2T> inline iterator_range< BOOST_STRING_TYPENAME range_iterator<Range1T>::type> ifind_last( Range1T& Input, const Range2T& Search, const std::locale& Loc=std::locale()) { return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search, is_iequal(Loc))); } // find_nth ----------------------------------------------------------------------// //! Find n-th algorithm /! Search for the n-th (zero-indexed) occurrence of the substring in the input. \param Input A string which will be searched. \param Search A substring to be searched for. \param Nth An index (zero-indexed) of the match to be found. For negative N, the matches are counted from the end of string. \return An \c iterator_range delimiting the match. Returned iterator is either \c Range1T::iterator or \c Range1T::const_iterator, depending on the constness of the input parameter. / template<typename Range1T, typename Range2T> inline iterator_range< BOOST_STRING_TYPENAME range_iterator<Range1T>::type> find_nth( Range1T& Input, const Range2T& Search, int Nth) { return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth)); } //! Find n-th algorithm ( case insensitive ). /! Search for the n-th (zero-indexed) occurrence of the substring in the input. Searching is case insensitive. \param Input A string which will be searched. \param Search A substring to be searched for. \param Nth An index (zero-indexed) of the match to be found. For negative N, the matches are counted from the end of string. \param Loc A locale used for case insensitive comparison \return An \c iterator_range delimiting the match. Returned iterator is either \c Range1T::iterator or \c Range1T::const_iterator, depending on the constness of the input parameter. \note This function provides the strong exception-safety guarantee / template<typename Range1T, typename Range2T> inline iterator_range< BOOST_STRING_TYPENAME range_iterator<Range1T>::type> ifind_nth( Range1T& Input, const Range2T& Search, int Nth, const std::locale& Loc=std::locale()) { return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth,is_iequal(Loc))); } // find_head ----------------------------------------------------------------------// //! 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 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, at most size(Input)-\|N\| characters are extracted. \return An \c iterator_range delimiting the match. Returned iterator is either \c Range1T::iterator or \c Range1T::const_iterator, depending on the constness of the input parameter. \note This function provides the strong exception-safety guarantee / template<typename RangeT> inline iterator_range< BOOST_STRING_TYPENAME range_iterator<RangeT>::type> find_head( RangeT& Input, int N) { return ::boost::algorithm::find(Input, ::boost::algorithm::head_finder(N)); } // find_tail ----------------------------------------------------------------------// //! 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 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, at most size(Input)-\|N\| characters are extracted. \return An \c iterator_range delimiting the match. Returned iterator is either \c RangeT::iterator or \c RangeT::const_iterator, depending on the constness of the input parameter. \note This function provides the strong exception-safety guarantee / template<typename RangeT> inline iterator_range< BOOST_STRING_TYPENAME range_iterator<RangeT>::type> find_tail( RangeT& Input, int N) { return ::boost::algorithm::find(Input, ::boost::algorithm::tail_finder(N)); } // find_token --------------------------------------------------------------------// //! Find token algorithm /! Look for a given token in the string. Token is a character that matches the given predicate. If the "token compress mode" is enabled, adjacent tokens are considered to be one match. \param Input A input string. \param Pred A unary predicate to identify a token \param eCompress Enable/Disable compressing of adjacent tokens \return An \c iterator_range delimiting the match. Returned iterator is either \c RangeT::iterator or \c RangeT::const_iterator, depending on the constness of the input parameter. \note This function provides the strong exception-safety guarantee / template<typename RangeT, typename PredicateT> inline iterator_range< BOOST_STRING_TYPENAME range_iterator<RangeT>::type> find_token( RangeT& Input, PredicateT Pred, token_compress_mode_type eCompress=token_compress_off) { return ::boost::algorithm::find(Input, ::boost::algorithm::token_finder(Pred, eCompress)); } } // namespace algorithm // pull names to the boost namespace using algorithm::find; using algorithm::find_first; using algorithm::ifind_first; using algorithm::find_last; using algorithm::ifind_last; using algorithm::find_nth; using algorithm::ifind_nth; using algorithm::find_head; using algorithm::find_tail; using algorithm::find_token; } // namespace boost #endif // BOOST_STRING_FIND_HPP PK��M�[Ҭ�m7��m7��string/trim.hppnu��[��// Boost string_algo library trim.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_TRIM_HPP #define BOOST_STRING_TRIM_HPP #include <boost/algorithm/string/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/const_iterator.hpp> #include <boost/range/as_literal.hpp> #include <boost/range/iterator_range_core.hpp> #include <boost/algorithm/string/detail/trim.hpp> #include <boost/algorithm/string/classification.hpp> #include <locale> /! \file Defines trim algorithms. Trim algorithms are used to remove trailing and leading spaces from a sequence (string). Space is recognized using given locales. Parametric (\c _if) variants use a predicate (functor) to select which characters are to be trimmed.. Functions take a selection predicate as a parameter, which is used to determine whether a character is a space. Common predicates are provided in classification.hpp header. / namespace boost { namespace algorithm { // left trim -----------------------------------------------// //! Left trim - parametric /! Remove all leading spaces from the input. The supplied predicate is used to determine which characters are considered spaces. The result is a trimmed copy of the input. It is returned as a sequence or copied to the output iterator \param Output An output iterator to which the result will be copied \param Input An input range \param IsSpace A unary predicate identifying spaces \return An output iterator pointing just after the last inserted character or a copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template<typename OutputIteratorT, typename RangeT, typename PredicateT> inline OutputIteratorT trim_left_copy_if( OutputIteratorT Output, const RangeT& Input, PredicateT IsSpace) { iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input)); std::copy( ::boost::algorithm::detail::trim_begin( ::boost::begin(lit_range), ::boost::end(lit_range), IsSpace ), ::boost::end(lit_range), Output); return Output; } //! Left trim - parametric /! \overload / template<typename SequenceT, typename PredicateT> inline SequenceT trim_left_copy_if(const SequenceT& Input, PredicateT IsSpace) { return SequenceT( ::boost::algorithm::detail::trim_begin( ::boost::begin(Input), ::boost::end(Input), IsSpace ), ::boost::end(Input)); } //! Left trim - parametric /! Remove all leading spaces from the input. The result is a trimmed copy of the input. \param Input An input sequence \param Loc a locale used for 'space' classification \return A trimmed copy of the input \note This function provides the strong exception-safety guarantee / template<typename SequenceT> inline SequenceT trim_left_copy(const SequenceT& Input, const std::locale& Loc=std::locale()) { return ::boost::algorithm::trim_left_copy_if( Input, is_space(Loc)); } //! Left trim /! Remove all leading spaces from the input. The supplied predicate is used to determine which characters are considered spaces. The input sequence is modified in-place. \param Input An input sequence \param IsSpace A unary predicate identifying spaces / template<typename SequenceT, typename PredicateT> inline void trim_left_if(SequenceT& Input, PredicateT IsSpace) { Input.erase( ::boost::begin(Input), ::boost::algorithm::detail::trim_begin( ::boost::begin(Input), ::boost::end(Input), IsSpace)); } //! Left trim /! Remove all leading spaces from the input. The Input sequence is modified in-place. \param Input An input sequence \param Loc A locale used for 'space' classification / template<typename SequenceT> inline void trim_left(SequenceT& Input, const std::locale& Loc=std::locale()) { ::boost::algorithm::trim_left_if( Input, is_space(Loc)); } // right trim -----------------------------------------------// //! Right trim - parametric /! Remove all trailing spaces from the input. The supplied predicate is used to determine which characters are considered spaces. The result is a trimmed copy of the input. It is returned as a sequence or copied to the output iterator \param Output An output iterator to which the result will be copied \param Input An input range \param IsSpace A unary predicate identifying spaces \return An output iterator pointing just after the last inserted character or a copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template<typename OutputIteratorT, typename RangeT, typename PredicateT> inline OutputIteratorT trim_right_copy_if( OutputIteratorT Output, const RangeT& Input, PredicateT IsSpace ) { iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input)); std::copy( ::boost::begin(lit_range), ::boost::algorithm::detail::trim_end( ::boost::begin(lit_range), ::boost::end(lit_range), IsSpace ), Output ); return Output; } //! Right trim - parametric /! \overload / template<typename SequenceT, typename PredicateT> inline SequenceT trim_right_copy_if(const SequenceT& Input, PredicateT IsSpace) { return SequenceT( ::boost::begin(Input), ::boost::algorithm::detail::trim_end( ::boost::begin(Input), ::boost::end(Input), IsSpace) ); } //! Right trim /! Remove all trailing spaces from the input. The result is a trimmed copy of the input \param Input An input sequence \param Loc A locale used for 'space' classification \return A trimmed copy of the input \note This function provides the strong exception-safety guarantee / template<typename SequenceT> inline SequenceT trim_right_copy(const SequenceT& Input, const std::locale& Loc=std::locale()) { return ::boost::algorithm::trim_right_copy_if( Input, is_space(Loc)); } //! Right trim - parametric /! Remove all trailing spaces from the input. The supplied predicate is used to determine which characters are considered spaces. The input sequence is modified in-place. \param Input An input sequence \param IsSpace A unary predicate identifying spaces / template<typename SequenceT, typename PredicateT> inline void trim_right_if(SequenceT& Input, PredicateT IsSpace) { Input.erase( ::boost::algorithm::detail::trim_end( ::boost::begin(Input), ::boost::end(Input), IsSpace ), ::boost::end(Input) ); } //! Right trim /! Remove all trailing spaces from the input. The input sequence is modified in-place. \param Input An input sequence \param Loc A locale used for 'space' classification / template<typename SequenceT> inline void trim_right(SequenceT& Input, const std::locale& Loc=std::locale()) { ::boost::algorithm::trim_right_if( Input, is_space(Loc) ); } // both side trim -----------------------------------------------// //! Trim - parametric /! Remove all trailing and leading spaces from the input. The supplied predicate is used to determine which characters are considered spaces. The result is a trimmed copy of the input. It is returned as a sequence or copied to the output iterator \param Output An output iterator to which the result will be copied \param Input An input range \param IsSpace A unary predicate identifying spaces \return An output iterator pointing just after the last inserted character or a copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template<typename OutputIteratorT, typename RangeT, typename PredicateT> inline OutputIteratorT trim_copy_if( OutputIteratorT Output, const RangeT& Input, PredicateT IsSpace) { iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input)); BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type TrimEnd= ::boost::algorithm::detail::trim_end( ::boost::begin(lit_range), ::boost::end(lit_range), IsSpace); std::copy( detail::trim_begin( ::boost::begin(lit_range), TrimEnd, IsSpace), TrimEnd, Output ); return Output; } //! Trim - parametric /! \overload / template<typename SequenceT, typename PredicateT> inline SequenceT trim_copy_if(const SequenceT& Input, PredicateT IsSpace) { BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type TrimEnd= ::boost::algorithm::detail::trim_end( ::boost::begin(Input), ::boost::end(Input), IsSpace); return SequenceT( detail::trim_begin( ::boost::begin(Input), TrimEnd, IsSpace), TrimEnd ); } //! Trim /! Remove all leading and trailing spaces from the input. The result is a trimmed copy of the input \param Input An input sequence \param Loc A locale used for 'space' classification \return A trimmed copy of the input \note This function provides the strong exception-safety guarantee / template<typename SequenceT> inline SequenceT trim_copy( const SequenceT& Input, const std::locale& Loc=std::locale() ) { return ::boost::algorithm::trim_copy_if( Input, is_space(Loc) ); } //! Trim /! Remove all leading and trailing spaces from the input. The supplied predicate is used to determine which characters are considered spaces. The input sequence is modified in-place. \param Input An input sequence \param IsSpace A unary predicate identifying spaces / template<typename SequenceT, typename PredicateT> inline void trim_if(SequenceT& Input, PredicateT IsSpace) { ::boost::algorithm::trim_right_if( Input, IsSpace ); ::boost::algorithm::trim_left_if( Input, IsSpace ); } //! Trim /! Remove all leading and trailing spaces from the input. The input sequence is modified in-place. \param Input An input sequence \param Loc A locale used for 'space' classification / template<typename SequenceT> inline void trim(SequenceT& Input, const std::locale& Loc=std::locale()) { ::boost::algorithm::trim_if( Input, is_space( Loc ) ); } } // namespace algorithm // pull names to the boost namespace using algorithm::trim_left; using algorithm::trim_left_if; using algorithm::trim_left_copy; using algorithm::trim_left_copy_if; using algorithm::trim_right; using algorithm::trim_right_if; using algorithm::trim_right_copy; using algorithm::trim_right_copy_if; using algorithm::trim; using algorithm::trim_if; using algorithm::trim_copy; using algorithm::trim_copy_if; } // namespace boost #endif // BOOST_STRING_TRIM_HPP PK��M�[��^����string/predicate_facade.hppnu��[��// Boost string_algo library predicate_facade.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_PREDICATE_FACADE_HPP #define BOOST_STRING_PREDICATE_FACADE_HPP #include <boost/algorithm/string/config.hpp> / \file boost/algorith/string/predicate_facade.hpp This file contains predicate_facade definition. This template class is used to identify classification predicates, so they can be combined using composition operators. / namespace boost { namespace algorithm { // predicate facade ------------------------------------------------------// //! Predicate facade /! This class allows to recognize classification predicates, so that they can be combined using composition operators. Every classification predicate must be derived from this class. / template<typename Derived> struct predicate_facade {}; } // namespace algorithm } // namespace boost #endif // BOOST_STRING_CLASSIFICATION_DETAIL_HPP PK��M�[��Fk��k��string/replace.hppnu��[��// Boost string_algo library replace.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2006. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_REPLACE_HPP #define BOOST_STRING_REPLACE_HPP #include <boost/algorithm/string/config.hpp> #include <boost/range/iterator_range_core.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/iterator.hpp> #include <boost/range/const_iterator.hpp> #include <boost/algorithm/string/find_format.hpp> #include <boost/algorithm/string/finder.hpp> #include <boost/algorithm/string/formatter.hpp> #include <boost/algorithm/string/compare.hpp> /! \file Defines various replace algorithms. Each algorithm replaces part(s) of the input according to set of searching and replace criteria. / namespace boost { namespace algorithm { // replace_range --------------------------------------------------------------------// //! Replace range algorithm /! Replace the given range in the input string. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. \param Output An output iterator to which the result will be copied \param Input An input string \param SearchRange A range in the input to be substituted \param Format A substitute string \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename Range1T, typename Range2T> inline OutputIteratorT replace_range_copy( OutputIteratorT Output, const Range1T& Input, const iterator_range< BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type>& SearchRange, const Range2T& Format) { return ::boost::algorithm::find_format_copy( Output, Input, ::boost::algorithm::range_finder(SearchRange), ::boost::algorithm::const_formatter(Format)); } //! Replace range algorithm /! \overload / template<typename SequenceT, typename RangeT> inline SequenceT replace_range_copy( const SequenceT& Input, const iterator_range< BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>& SearchRange, const RangeT& Format) { return ::boost::algorithm::find_format_copy( Input, ::boost::algorithm::range_finder(SearchRange), ::boost::algorithm::const_formatter(Format)); } //! Replace range algorithm /! Replace the given range in the input string. The input sequence is modified in-place. \param Input An input string \param SearchRange A range in the input to be substituted \param Format A substitute string / template<typename SequenceT, typename RangeT> inline void replace_range( SequenceT& Input, const iterator_range< BOOST_STRING_TYPENAME range_iterator<SequenceT>::type>& SearchRange, const RangeT& Format) { ::boost::algorithm::find_format( Input, ::boost::algorithm::range_finder(SearchRange), ::boost::algorithm::const_formatter(Format)); } // replace_first --------------------------------------------------------------------// //! Replace first algorithm /! Replace the first match of the search substring in the input with the format string. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. \param Output An output iterator to which the result will be copied \param Input An input string \param Search A substring to be searched for \param Format A substitute string \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename Range1T, typename Range2T, typename Range3T> inline OutputIteratorT replace_first_copy( OutputIteratorT Output, const Range1T& Input, const Range2T& Search, const Range3T& Format) { return ::boost::algorithm::find_format_copy( Output, Input, ::boost::algorithm::first_finder(Search), ::boost::algorithm::const_formatter(Format) ); } //! Replace first algorithm /! \overload / template<typename SequenceT, typename Range1T, typename Range2T> inline SequenceT replace_first_copy( const SequenceT& Input, const Range1T& Search, const Range2T& Format ) { return ::boost::algorithm::find_format_copy( Input, ::boost::algorithm::first_finder(Search), ::boost::algorithm::const_formatter(Format) ); } //! Replace first algorithm /! replace the first match of the search substring in the input with the format string. The input sequence is modified in-place. \param Input An input string \param Search A substring to be searched for \param Format A substitute string / template<typename SequenceT, typename Range1T, typename Range2T> inline void replace_first( SequenceT& Input, const Range1T& Search, const Range2T& Format ) { ::boost::algorithm::find_format( Input, ::boost::algorithm::first_finder(Search), ::boost::algorithm::const_formatter(Format) ); } // replace_first ( case insensitive ) ---------------------------------------------// //! Replace first algorithm ( case insensitive ) /! Replace the first match of the search substring in the input with the format string. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. Searching is case insensitive. \param Output An output iterator to which the result will be copied \param Input An input string \param Search A substring to be searched for \param Format A substitute string \param Loc A locale used for case insensitive comparison \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename Range1T, typename Range2T, typename Range3T> inline OutputIteratorT ireplace_first_copy( OutputIteratorT Output, const Range1T& Input, const Range2T& Search, const Range3T& Format, const std::locale& Loc=std::locale() ) { return ::boost::algorithm::find_format_copy( Output, Input, ::boost::algorithm::first_finder(Search, is_iequal(Loc)), ::boost::algorithm::const_formatter(Format) ); } //! Replace first algorithm ( case insensitive ) /! \overload / template<typename SequenceT, typename Range2T, typename Range1T> inline SequenceT ireplace_first_copy( const SequenceT& Input, const Range2T& Search, const Range1T& Format, const std::locale& Loc=std::locale() ) { return ::boost::algorithm::find_format_copy( Input, ::boost::algorithm::first_finder(Search, is_iequal(Loc)), ::boost::algorithm::const_formatter(Format) ); } //! Replace first algorithm ( case insensitive ) /! Replace the first match of the search substring in the input with the format string. Input sequence is modified in-place. Searching is case insensitive. \param Input An input string \param Search A substring to be searched for \param Format A substitute string \param Loc A locale used for case insensitive comparison / template<typename SequenceT, typename Range1T, typename Range2T> inline void ireplace_first( SequenceT& Input, const Range1T& Search, const Range2T& Format, const std::locale& Loc=std::locale() ) { ::boost::algorithm::find_format( Input, ::boost::algorithm::first_finder(Search, is_iequal(Loc)), ::boost::algorithm::const_formatter(Format) ); } // replace_last --------------------------------------------------------------------// //! Replace last algorithm /! Replace the last match of the search string in the input with the format string. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. \param Output An output iterator to which the result will be copied \param Input An input string \param Search A substring to be searched for \param Format A substitute string \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename Range1T, typename Range2T, typename Range3T> inline OutputIteratorT replace_last_copy( OutputIteratorT Output, const Range1T& Input, const Range2T& Search, const Range3T& Format ) { return ::boost::algorithm::find_format_copy( Output, Input, ::boost::algorithm::last_finder(Search), ::boost::algorithm::const_formatter(Format) ); } //! Replace last algorithm /! \overload / template<typename SequenceT, typename Range1T, typename Range2T> inline SequenceT replace_last_copy( const SequenceT& Input, const Range1T& Search, const Range2T& Format ) { return ::boost::algorithm::find_format_copy( Input, ::boost::algorithm::last_finder(Search), ::boost::algorithm::const_formatter(Format) ); } //! Replace last algorithm /! Replace the last match of the search string in the input with the format string. Input sequence is modified in-place. \param Input An input string \param Search A substring to be searched for \param Format A substitute string / template<typename SequenceT, typename Range1T, typename Range2T> inline void replace_last( SequenceT& Input, const Range1T& Search, const Range2T& Format ) { ::boost::algorithm::find_format( Input, ::boost::algorithm::last_finder(Search), ::boost::algorithm::const_formatter(Format) ); } // replace_last ( case insensitive ) -----------------------------------------------// //! Replace last algorithm ( case insensitive ) /! Replace the last match of the search string in the input with the format string. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. Searching is case insensitive. \param Output An output iterator to which the result will be copied \param Input An input string \param Search A substring to be searched for \param Format A substitute string \param Loc A locale used for case insensitive comparison \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename Range1T, typename Range2T, typename Range3T> inline OutputIteratorT ireplace_last_copy( OutputIteratorT Output, const Range1T& Input, const Range2T& Search, const Range3T& Format, const std::locale& Loc=std::locale() ) { return ::boost::algorithm::find_format_copy( Output, Input, ::boost::algorithm::last_finder(Search, is_iequal(Loc)), ::boost::algorithm::const_formatter(Format) ); } //! Replace last algorithm ( case insensitive ) /! \overload / template<typename SequenceT, typename Range1T, typename Range2T> inline SequenceT ireplace_last_copy( const SequenceT& Input, const Range1T& Search, const Range2T& Format, const std::locale& Loc=std::locale() ) { return ::boost::algorithm::find_format_copy( Input, ::boost::algorithm::last_finder(Search, is_iequal(Loc)), ::boost::algorithm::const_formatter(Format) ); } //! Replace last algorithm ( case insensitive ) /! Replace the last match of the search string in the input with the format string.The input sequence is modified in-place. Searching is case insensitive. \param Input An input string \param Search A substring to be searched for \param Format A substitute string \param Loc A locale used for case insensitive comparison / template<typename SequenceT, typename Range1T, typename Range2T> inline void ireplace_last( SequenceT& Input, const Range1T& Search, const Range2T& Format, const std::locale& Loc=std::locale() ) { ::boost::algorithm::find_format( Input, ::boost::algorithm::last_finder(Search, is_iequal(Loc)), ::boost::algorithm::const_formatter(Format) ); } // replace_nth --------------------------------------------------------------------// //! Replace nth algorithm /! Replace an Nth (zero-indexed) match of the search string in the input with the format string. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. \param Output An output iterator to which the result will be copied \param Input An input string \param Search A substring to be searched for \param Nth An index of the match to be replaced. The index is 0-based. For negative N, matches are counted from the end of string. \param Format A substitute string \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename Range1T, typename Range2T, typename Range3T> inline OutputIteratorT replace_nth_copy( OutputIteratorT Output, const Range1T& Input, const Range2T& Search, int Nth, const Range3T& Format ) { return ::boost::algorithm::find_format_copy( Output, Input, ::boost::algorithm::nth_finder(Search, Nth), ::boost::algorithm::const_formatter(Format) ); } //! Replace nth algorithm /! \overload / template<typename SequenceT, typename Range1T, typename Range2T> inline SequenceT replace_nth_copy( const SequenceT& Input, const Range1T& Search, int Nth, const Range2T& Format ) { return ::boost::algorithm::find_format_copy( Input, ::boost::algorithm::nth_finder(Search, Nth), ::boost::algorithm::const_formatter(Format) ); } //! Replace nth algorithm /! Replace an Nth (zero-indexed) match of the search string in the input with the format string. Input sequence is modified in-place. \param Input An input string \param Search A substring to be searched for \param Nth An index of the match to be replaced. The index is 0-based. For negative N, matches are counted from the end of string. \param Format A substitute string / template<typename SequenceT, typename Range1T, typename Range2T> inline void replace_nth( SequenceT& Input, const Range1T& Search, int Nth, const Range2T& Format ) { ::boost::algorithm::find_format( Input, ::boost::algorithm::nth_finder(Search, Nth), ::boost::algorithm::const_formatter(Format) ); } // replace_nth ( case insensitive ) -----------------------------------------------// //! Replace nth algorithm ( case insensitive ) /! Replace an Nth (zero-indexed) match of the search string in the input with the format string. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. Searching is case insensitive. \param Output An output iterator to which the result will be copied \param Input An input string \param Search A substring to be searched for \param Nth An index of the match to be replaced. The index is 0-based. For negative N, matches are counted from the end of string. \param Format A substitute string \param Loc A locale used for case insensitive comparison \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename Range1T, typename Range2T, typename Range3T> inline OutputIteratorT ireplace_nth_copy( OutputIteratorT Output, const Range1T& Input, const Range2T& Search, int Nth, const Range3T& Format, const std::locale& Loc=std::locale() ) { return ::boost::algorithm::find_format_copy( Output, Input, ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc) ), ::boost::algorithm::const_formatter(Format) ); } //! Replace nth algorithm ( case insensitive ) /! \overload / template<typename SequenceT, typename Range1T, typename Range2T> inline SequenceT ireplace_nth_copy( const SequenceT& Input, const Range1T& Search, int Nth, const Range2T& Format, const std::locale& Loc=std::locale() ) { return ::boost::algorithm::find_format_copy( Input, ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)), ::boost::algorithm::const_formatter(Format) ); } //! Replace nth algorithm ( case insensitive ) /! Replace an Nth (zero-indexed) match of the search string in the input with the format string. Input sequence is modified in-place. Searching is case insensitive. \param Input An input string \param Search A substring to be searched for \param Nth An index of the match to be replaced. The index is 0-based. For negative N, matches are counted from the end of string. \param Format A substitute string \param Loc A locale used for case insensitive comparison / template<typename SequenceT, typename Range1T, typename Range2T> inline void ireplace_nth( SequenceT& Input, const Range1T& Search, int Nth, const Range2T& Format, const std::locale& Loc=std::locale() ) { ::boost::algorithm::find_format( Input, ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)), ::boost::algorithm::const_formatter(Format) ); } // replace_all --------------------------------------------------------------------// //! Replace all algorithm /! Replace all occurrences of the search string in the input with the format string. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. \param Output An output iterator to which the result will be copied \param Input An input string \param Search A substring to be searched for \param Format A substitute string \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename Range1T, typename Range2T, typename Range3T> inline OutputIteratorT replace_all_copy( OutputIteratorT Output, const Range1T& Input, const Range2T& Search, const Range3T& Format ) { return ::boost::algorithm::find_format_all_copy( Output, Input, ::boost::algorithm::first_finder(Search), ::boost::algorithm::const_formatter(Format) ); } //! Replace all algorithm /! \overload / template<typename SequenceT, typename Range1T, typename Range2T> inline SequenceT replace_all_copy( const SequenceT& Input, const Range1T& Search, const Range2T& Format ) { return ::boost::algorithm::find_format_all_copy( Input, ::boost::algorithm::first_finder(Search), ::boost::algorithm::const_formatter(Format) ); } //! Replace all algorithm /! Replace all occurrences of the search string in the input with the format string. The input sequence is modified in-place. \param Input An input string \param Search A substring to be searched for \param Format A substitute string / template<typename SequenceT, typename Range1T, typename Range2T> inline void replace_all( SequenceT& Input, const Range1T& Search, const Range2T& Format ) { ::boost::algorithm::find_format_all( Input, ::boost::algorithm::first_finder(Search), ::boost::algorithm::const_formatter(Format) ); } // replace_all ( case insensitive ) -----------------------------------------------// //! Replace all algorithm ( case insensitive ) /! Replace all occurrences of the search string in the input with the format string. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. Searching is case insensitive. \param Output An output iterator to which the result will be copied \param Input An input string \param Search A substring to be searched for \param Format A substitute string \param Loc A locale used for case insensitive comparison \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename Range1T, typename Range2T, typename Range3T> inline OutputIteratorT ireplace_all_copy( OutputIteratorT Output, const Range1T& Input, const Range2T& Search, const Range3T& Format, const std::locale& Loc=std::locale() ) { return ::boost::algorithm::find_format_all_copy( Output, Input, ::boost::algorithm::first_finder(Search, is_iequal(Loc)), ::boost::algorithm::const_formatter(Format) ); } //! Replace all algorithm ( case insensitive ) /! \overload / template<typename SequenceT, typename Range1T, typename Range2T> inline SequenceT ireplace_all_copy( const SequenceT& Input, const Range1T& Search, const Range2T& Format, const std::locale& Loc=std::locale() ) { return ::boost::algorithm::find_format_all_copy( Input, ::boost::algorithm::first_finder(Search, is_iequal(Loc)), ::boost::algorithm::const_formatter(Format) ); } //! Replace all algorithm ( case insensitive ) /! Replace all occurrences of the search string in the input with the format string.The input sequence is modified in-place. Searching is case insensitive. \param Input An input string \param Search A substring to be searched for \param Format A substitute string \param Loc A locale used for case insensitive comparison / template<typename SequenceT, typename Range1T, typename Range2T> inline void ireplace_all( SequenceT& Input, const Range1T& Search, const Range2T& Format, const std::locale& Loc=std::locale() ) { ::boost::algorithm::find_format_all( Input, ::boost::algorithm::first_finder(Search, is_iequal(Loc)), ::boost::algorithm::const_formatter(Format) ); } // replace_head --------------------------------------------------------------------// //! Replace head algorithm /! Replace the head of the input with the given format string. The head is a prefix of a string of given size. If the sequence is shorter then required, whole string if considered to be the head. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. \param Output An output iterator to which the result will be copied \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. \param Format A substitute string \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename Range1T, typename Range2T> inline OutputIteratorT replace_head_copy( OutputIteratorT Output, const Range1T& Input, int N, const Range2T& Format ) { return ::boost::algorithm::find_format_copy( Output, Input, ::boost::algorithm::head_finder(N), ::boost::algorithm::const_formatter(Format) ); } //! Replace head algorithm /! \overload / template<typename SequenceT, typename RangeT> inline SequenceT replace_head_copy( const SequenceT& Input, int N, const RangeT& Format ) { return ::boost::algorithm::find_format_copy( Input, ::boost::algorithm::head_finder(N), ::boost::algorithm::const_formatter(Format) ); } //! Replace head algorithm /! Replace the head of the input with the given format string. The head is a prefix of a string of given size. If the sequence is shorter then required, the whole string is considered to be the head. The input sequence is modified in-place. \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. \param Format A substitute string / template<typename SequenceT, typename RangeT> inline void replace_head( SequenceT& Input, int N, const RangeT& Format ) { ::boost::algorithm::find_format( Input, ::boost::algorithm::head_finder(N), ::boost::algorithm::const_formatter(Format) ); } // replace_tail --------------------------------------------------------------------// //! Replace tail algorithm /! Replace the tail of the input with the given format string. The tail is a suffix of a string of given size. If the sequence is shorter then required, whole string is considered to be the tail. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. \param Output An output iterator to which the result will be copied \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. \param Format A substitute string \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename Range1T, typename Range2T> inline OutputIteratorT replace_tail_copy( OutputIteratorT Output, const Range1T& Input, int N, const Range2T& Format ) { return ::boost::algorithm::find_format_copy( Output, Input, ::boost::algorithm::tail_finder(N), ::boost::algorithm::const_formatter(Format) ); } //! Replace tail algorithm /! \overload / template<typename SequenceT, typename RangeT> inline SequenceT replace_tail_copy( const SequenceT& Input, int N, const RangeT& Format ) { return ::boost::algorithm::find_format_copy( Input, ::boost::algorithm::tail_finder(N), ::boost::algorithm::const_formatter(Format) ); } //! Replace tail algorithm /! Replace the tail of the input with the given format sequence. The tail is a suffix of a string of given size. If the sequence is shorter then required, the whole string is considered to be the tail. The input sequence is modified in-place. \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. \param Format A substitute string / template<typename SequenceT, typename RangeT> inline void replace_tail( SequenceT& Input, int N, const RangeT& Format ) { ::boost::algorithm::find_format( Input, ::boost::algorithm::tail_finder(N), ::boost::algorithm::const_formatter(Format) ); } } // namespace algorithm // pull names to the boost namespace using algorithm::replace_range_copy; using algorithm::replace_range; using algorithm::replace_first_copy; using algorithm::replace_first; using algorithm::ireplace_first_copy; using algorithm::ireplace_first; using algorithm::replace_last_copy; using algorithm::replace_last; using algorithm::ireplace_last_copy; using algorithm::ireplace_last; using algorithm::replace_nth_copy; using algorithm::replace_nth; using algorithm::ireplace_nth_copy; using algorithm::ireplace_nth; using algorithm::replace_all_copy; using algorithm::replace_all; using algorithm::ireplace_all_copy; using algorithm::ireplace_all; using algorithm::replace_head_copy; using algorithm::replace_head; using algorithm::replace_tail_copy; using algorithm::replace_tail; } // namespace boost #endif // BOOST_REPLACE_HPP PK��M�[6=�-�a��a��string/regex.hppnu��[��// Boost string_algo library regex.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_REGEX_HPP #define BOOST_STRING_REGEX_HPP #include <boost/algorithm/string/config.hpp> #include <boost/regex.hpp> #include <boost/range/iterator_range_core.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/iterator.hpp> #include <boost/range/as_literal.hpp> #include <boost/algorithm/string/find_format.hpp> #include <boost/algorithm/string/regex_find_format.hpp> #include <boost/algorithm/string/formatter.hpp> #include <boost/algorithm/string/iter_find.hpp> /! \file Defines regex variants of the algorithms. / namespace boost { namespace algorithm { // find_regex -----------------------------------------------// //! Find regex algorithm /! Search for a substring matching the given regex in the input. \param Input A container which will be searched. \param Rx A regular expression \param Flags Regex options \return An \c iterator_range delimiting the match. Returned iterator is either \c RangeT::iterator or \c RangeT::const_iterator, depending on the constness of the input parameter. \note This function provides the strong exception-safety guarantee / template< typename RangeT, typename CharT, typename RegexTraitsT> inline iterator_range< BOOST_STRING_TYPENAME range_iterator<RangeT>::type > find_regex( RangeT& Input, const basic_regex<CharT, RegexTraitsT>& Rx, match_flag_type Flags=match_default ) { iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input)); return ::boost::algorithm::regex_finder(Rx,Flags)( ::boost::begin(lit_input), ::boost::end(lit_input) ); } // replace_regex --------------------------------------------------------------------// //! Replace regex algorithm /! Search for a substring matching given regex and format it with the specified format. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. \param Output An output iterator to which the result will be copied \param Input An input string \param Rx A regular expression \param Format Regex format definition \param Flags Regex options \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename RangeT, typename CharT, typename RegexTraitsT, typename FormatStringTraitsT, typename FormatStringAllocatorT > inline OutputIteratorT replace_regex_copy( OutputIteratorT Output, const RangeT& Input, const basic_regex<CharT, RegexTraitsT>& Rx, const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format, match_flag_type Flags=match_default \| format_default ) { return ::boost::algorithm::find_format_copy( Output, Input, ::boost::algorithm::regex_finder( Rx, Flags ), ::boost::algorithm::regex_formatter( Format, Flags ) ); } //! Replace regex algorithm /! \overload / template< typename SequenceT, typename CharT, typename RegexTraitsT, typename FormatStringTraitsT, typename FormatStringAllocatorT > inline SequenceT replace_regex_copy( const SequenceT& Input, const basic_regex<CharT, RegexTraitsT>& Rx, const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format, match_flag_type Flags=match_default \| format_default ) { return ::boost::algorithm::find_format_copy( Input, ::boost::algorithm::regex_finder( Rx, Flags ), ::boost::algorithm::regex_formatter( Format, Flags ) ); } //! Replace regex algorithm /! Search for a substring matching given regex and format it with the specified format. The input string is modified in-place. \param Input An input string \param Rx A regular expression \param Format Regex format definition \param Flags Regex options / template< typename SequenceT, typename CharT, typename RegexTraitsT, typename FormatStringTraitsT, typename FormatStringAllocatorT > inline void replace_regex( SequenceT& Input, const basic_regex<CharT, RegexTraitsT>& Rx, const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format, match_flag_type Flags=match_default \| format_default ) { ::boost::algorithm::find_format( Input, ::boost::algorithm::regex_finder( Rx, Flags ), ::boost::algorithm::regex_formatter( Format, Flags ) ); } // replace_all_regex --------------------------------------------------------------------// //! Replace all regex algorithm /! Format all substrings, matching given regex, with the specified format. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. \param Output An output iterator to which the result will be copied \param Input An input string \param Rx A regular expression \param Format Regex format definition \param Flags Regex options \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename RangeT, typename CharT, typename RegexTraitsT, typename FormatStringTraitsT, typename FormatStringAllocatorT > inline OutputIteratorT replace_all_regex_copy( OutputIteratorT Output, const RangeT& Input, const basic_regex<CharT, RegexTraitsT>& Rx, const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format, match_flag_type Flags=match_default \| format_default ) { return ::boost::algorithm::find_format_all_copy( Output, Input, ::boost::algorithm::regex_finder( Rx, Flags ), ::boost::algorithm::regex_formatter( Format, Flags ) ); } //! Replace all regex algorithm /! \overload / template< typename SequenceT, typename CharT, typename RegexTraitsT, typename FormatStringTraitsT, typename FormatStringAllocatorT > inline SequenceT replace_all_regex_copy( const SequenceT& Input, const basic_regex<CharT, RegexTraitsT>& Rx, const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format, match_flag_type Flags=match_default \| format_default ) { return ::boost::algorithm::find_format_all_copy( Input, ::boost::algorithm::regex_finder( Rx, Flags ), ::boost::algorithm::regex_formatter( Format, Flags ) ); } //! Replace all regex algorithm /! Format all substrings, matching given regex, with the specified format. The input string is modified in-place. \param Input An input string \param Rx A regular expression \param Format Regex format definition \param Flags Regex options / template< typename SequenceT, typename CharT, typename RegexTraitsT, typename FormatStringTraitsT, typename FormatStringAllocatorT > inline void replace_all_regex( SequenceT& Input, const basic_regex<CharT, RegexTraitsT>& Rx, const std::basic_string<CharT, FormatStringTraitsT, FormatStringAllocatorT>& Format, match_flag_type Flags=match_default \| format_default ) { ::boost::algorithm::find_format_all( Input, ::boost::algorithm::regex_finder( Rx, Flags ), ::boost::algorithm::regex_formatter( Format, Flags ) ); } // erase_regex --------------------------------------------------------------------// //! Erase regex algorithm /! Remove a substring matching given regex from the input. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. \param Output An output iterator to which the result will be copied \param Input An input string \param Rx A regular expression \param Flags Regex options \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename RangeT, typename CharT, typename RegexTraitsT > inline OutputIteratorT erase_regex_copy( OutputIteratorT Output, const RangeT& Input, const basic_regex<CharT, RegexTraitsT>& Rx, match_flag_type Flags=match_default ) { return ::boost::algorithm::find_format_copy( Output, Input, ::boost::algorithm::regex_finder( Rx, Flags ), ::boost::algorithm::empty_formatter( Input ) ); } //! Erase regex algorithm /! \overload / template< typename SequenceT, typename CharT, typename RegexTraitsT > inline SequenceT erase_regex_copy( const SequenceT& Input, const basic_regex<CharT, RegexTraitsT>& Rx, match_flag_type Flags=match_default ) { return ::boost::algorithm::find_format_copy( Input, ::boost::algorithm::regex_finder( Rx, Flags ), ::boost::algorithm::empty_formatter( Input ) ); } //! Erase regex algorithm /! Remove a substring matching given regex from the input. The input string is modified in-place. \param Input An input string \param Rx A regular expression \param Flags Regex options / template< typename SequenceT, typename CharT, typename RegexTraitsT > inline void erase_regex( SequenceT& Input, const basic_regex<CharT, RegexTraitsT>& Rx, match_flag_type Flags=match_default ) { ::boost::algorithm::find_format( Input, ::boost::algorithm::regex_finder( Rx, Flags ), ::boost::algorithm::empty_formatter( Input ) ); } // erase_all_regex --------------------------------------------------------------------// //! Erase all regex algorithm /! Erase all substrings, matching given regex, from the input. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. \param Output An output iterator to which the result will be copied \param Input An input string \param Rx A regular expression \param Flags Regex options \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename RangeT, typename CharT, typename RegexTraitsT > inline OutputIteratorT erase_all_regex_copy( OutputIteratorT Output, const RangeT& Input, const basic_regex<CharT, RegexTraitsT>& Rx, match_flag_type Flags=match_default ) { return ::boost::algorithm::find_format_all_copy( Output, Input, ::boost::algorithm::regex_finder( Rx, Flags ), ::boost::algorithm::empty_formatter( Input ) ); } //! Erase all regex algorithm /! \overload / template< typename SequenceT, typename CharT, typename RegexTraitsT > inline SequenceT erase_all_regex_copy( const SequenceT& Input, const basic_regex<CharT, RegexTraitsT>& Rx, match_flag_type Flags=match_default ) { return ::boost::algorithm::find_format_all_copy( Input, ::boost::algorithm::regex_finder( Rx, Flags ), ::boost::algorithm::empty_formatter( Input ) ); } //! Erase all regex algorithm /! Erase all substrings, matching given regex, from the input. The input string is modified in-place. \param Input An input string \param Rx A regular expression \param Flags Regex options / template< typename SequenceT, typename CharT, typename RegexTraitsT> inline void erase_all_regex( SequenceT& Input, const basic_regex<CharT, RegexTraitsT>& Rx, match_flag_type Flags=match_default ) { ::boost::algorithm::find_format_all( Input, ::boost::algorithm::regex_finder( Rx, Flags ), ::boost::algorithm::empty_formatter( Input ) ); } // find_all_regex ------------------------------------------------------------------// //! Find all regex algorithm /! This algorithm finds all substrings matching the give regex in the input. Each part is copied and added as a new element to the output container. Thus the result container must be able to hold copies of the matches (in a compatible structure like std::string) or a reference to it (e.g. using the iterator range class). Examples of such a container are \c std::vector<std::string> or \c std::list<boost::iterator_range<std::string::iterator>> \param Result A container that can hold copies of references to the substrings. \param Input A container which will be searched. \param Rx A regular expression \param Flags Regex options \return A reference to the result \note Prior content of the result will be overwritten. \note This function provides the strong exception-safety guarantee / template< typename SequenceSequenceT, typename RangeT, typename CharT, typename RegexTraitsT > inline SequenceSequenceT& find_all_regex( SequenceSequenceT& Result, const RangeT& Input, const basic_regex<CharT, RegexTraitsT>& Rx, match_flag_type Flags=match_default ) { return ::boost::algorithm::iter_find( Result, Input, ::boost::algorithm::regex_finder(Rx,Flags) ); } // split_regex ------------------------------------------------------------------// //! Split regex algorithm /! Tokenize expression. This function is equivalent to C strtok. Input sequence is split into tokens, separated by separators. Separator is an every match of the given regex. Each part is copied and added as a new element to the output container. Thus the result container must be able to hold copies of the matches (in a compatible structure like std::string) or a reference to it (e.g. using the iterator range class). Examples of such a container are \c std::vector<std::string> or \c std::list<boost::iterator_range<std::string::iterator>> \param Result A container that can hold copies of references to the substrings. \param Input A container which will be searched. \param Rx A regular expression \param Flags Regex options \return A reference to the result \note Prior content of the result will be overwritten. \note This function provides the strong exception-safety guarantee / template< typename SequenceSequenceT, typename RangeT, typename CharT, typename RegexTraitsT > inline SequenceSequenceT& split_regex( SequenceSequenceT& Result, const RangeT& Input, const basic_regex<CharT, RegexTraitsT>& Rx, match_flag_type Flags=match_default ) { return ::boost::algorithm::iter_split( Result, Input, ::boost::algorithm::regex_finder(Rx,Flags) ); } // join_if ------------------------------------------------------------------// #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING //! Conditional join algorithm /! This algorithm joins all strings in a 'list' into one long string. Segments are concatenated by given separator. Only segments that match the given regular expression will be added to the result This is a specialization of join_if algorithm. \param Input A container that holds the input strings. It must be a container-of-containers. \param Separator A string that will separate the joined segments. \param Rx A regular expression \param Flags Regex options \return Concatenated string. \note This function provides the strong exception-safety guarantee / template< typename SequenceSequenceT, typename Range1T, typename CharT, typename RegexTraitsT > inline typename range_value<SequenceSequenceT>::type join_if( const SequenceSequenceT& Input, const Range1T& Separator, const basic_regex<CharT, RegexTraitsT>& Rx, match_flag_type Flags=match_default ) { // Define working types typedef typename range_value<SequenceSequenceT>::type ResultT; typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT; // Parse input InputIteratorT itBegin=::boost::begin(Input); InputIteratorT itEnd=::boost::end(Input); // Construct container to hold the result ResultT Result; // Roll to the first element that will be added while( itBegin!=itEnd && !::boost::regex_match(::boost::begin(itBegin), ::boost::end(itBegin), Rx, Flags)) ++itBegin; // Add this element if(itBegin!=itEnd) { detail::insert(Result, ::boost::end(Result), itBegin); ++itBegin; } for(;itBegin!=itEnd; ++itBegin) { if(::boost::regex_match(::boost::begin(itBegin), ::boost::end(itBegin), Rx, Flags)) { // Add separator detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator)); // Add element detail::insert(Result, ::boost::end(Result), itBegin); } } return Result; } #else // BOOST_NO_FUNCTION_TEMPLATE_ORDERING //! Conditional join algorithm /! This algorithm joins all strings in a 'list' into one long string. Segments are concatenated by given separator. Only segments that match the given regular expression will be added to the result This is a specialization of join_if algorithm. \param Input A container that holds the input strings. It must be a container-of-containers. \param Separator A string that will separate the joined segments. \param Rx A regular expression \param Flags Regex options \return Concatenated string. \note This function provides the strong exception-safety guarantee / template< typename SequenceSequenceT, typename Range1T, typename CharT, typename RegexTraitsT > inline typename range_value<SequenceSequenceT>::type join_if_regex( const SequenceSequenceT& Input, const Range1T& Separator, const basic_regex<CharT, RegexTraitsT>& Rx, match_flag_type Flags=match_default ) { // Define working types typedef typename range_value<SequenceSequenceT>::type ResultT; typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT; // Parse input InputIteratorT itBegin=::boost::begin(Input); InputIteratorT itEnd=::boost::end(Input); // Construct container to hold the result ResultT Result; // Roll to the first element that will be added while( itBegin!=itEnd && !::boost::regex_match(::boost::begin(itBegin), ::boost::end(itBegin), Rx, Flags)) ++itBegin; // Add this element if(itBegin!=itEnd) { detail::insert(Result, ::boost::end(Result), itBegin); ++itBegin; } for(;itBegin!=itEnd; ++itBegin) { if(::boost::regex_match(::boost::begin(itBegin), ::boost::end(itBegin), Rx, Flags)) { // Add separator detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator)); // Add element detail::insert(Result, ::boost::end(Result), itBegin); } } return Result; } #endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING } // namespace algorithm // pull names into the boost namespace using algorithm::find_regex; using algorithm::replace_regex; using algorithm::replace_regex_copy; using algorithm::replace_all_regex; using algorithm::replace_all_regex_copy; using algorithm::erase_regex; using algorithm::erase_regex_copy; using algorithm::erase_all_regex; using algorithm::erase_all_regex_copy; using algorithm::find_all_regex; using algorithm::split_regex; #ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING using algorithm::join_if; #else // BOOST_NO_FUNCTION_TEMPLATE_ORDERING using algorithm::join_if_regex; #endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING } // namespace boost #endif // BOOST_STRING_REGEX_HPP PK��M�[a�ZFY��Y��string/iter_find.hppnu��[��// Boost string_algo library iter_find.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_ITER_FIND_HPP #define BOOST_STRING_ITER_FIND_HPP #include <boost/algorithm/string/config.hpp> #include <algorithm> #include <iterator> #include <boost/iterator/transform_iterator.hpp> #include <boost/range/iterator_range_core.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/iterator.hpp> #include <boost/range/value_type.hpp> #include <boost/range/as_literal.hpp> #include <boost/algorithm/string/concept.hpp> #include <boost/algorithm/string/find_iterator.hpp> #include <boost/algorithm/string/detail/util.hpp> /! \file Defines generic split algorithms. Split algorithms can be used to divide a sequence into several part according to a given criteria. Result is given as a 'container of containers' where elements are copies or references to extracted parts. There are two algorithms provided. One iterates over matching substrings, the other one over the gaps between these matches. / namespace boost { namespace algorithm { // iterate find ---------------------------------------------------// //! Iter find algorithm /! This algorithm executes a given finder in iteration on the input, until the end of input is reached, or no match is found. Iteration is done using built-in find_iterator, so the real searching is performed only when needed. In each iteration new match is found and added to the result. \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 \c std::vector<boost::iterator_range<iterator>> (each element of such a vector will container a range delimiting a match). \param Input A container which will be searched. \param Finder A Finder object used for searching \return A reference to the result \note Prior content of the result will be overwritten. / template< typename SequenceSequenceT, typename RangeT, typename FinderT > inline SequenceSequenceT& iter_find( SequenceSequenceT& Result, #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) RangeT&& Input, #else RangeT& Input, #endif FinderT Finder ) { BOOST_CONCEPT_ASSERT(( FinderConcept< FinderT, BOOST_STRING_TYPENAME range_iterator<RangeT>::type> )); iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input)); typedef BOOST_STRING_TYPENAME range_iterator<RangeT>::type input_iterator_type; typedef find_iterator<input_iterator_type> find_iterator_type; typedef detail::copy_iterator_rangeF< BOOST_STRING_TYPENAME range_value<SequenceSequenceT>::type, input_iterator_type> copy_range_type; input_iterator_type InputEnd=::boost::end(lit_input); typedef transform_iterator<copy_range_type, find_iterator_type> transform_iter_type; transform_iter_type itBegin= ::boost::make_transform_iterator( find_iterator_type( ::boost::begin(lit_input), InputEnd, Finder ), copy_range_type()); transform_iter_type itEnd= ::boost::make_transform_iterator( find_iterator_type(), copy_range_type()); SequenceSequenceT Tmp(itBegin, itEnd); Result.swap(Tmp); return Result; } // iterate split ---------------------------------------------------// //! Split find algorithm /! This algorithm executes a given finder in iteration on the input, until the end of input is reached, or no match is found. Iteration is done using built-in find_iterator, so the real searching is performed only when needed. Each match is used as a separator of segments. These segments are then returned in the result. \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 \c std::vector<boost::iterator_range<iterator>> (each element of such a vector will container a range delimiting a match). \param Input A container which will be searched. \param Finder A finder object used for searching \return A reference to the result \note Prior content of the result will be overwritten. / template< typename SequenceSequenceT, typename RangeT, typename FinderT > inline SequenceSequenceT& iter_split( SequenceSequenceT& Result, #if !defined(BOOST_NO_CXX11_RVALUE_REFERENCES) RangeT&& Input, #else RangeT& Input, #endif FinderT Finder ) { BOOST_CONCEPT_ASSERT(( FinderConcept<FinderT, BOOST_STRING_TYPENAME range_iterator<RangeT>::type> )); iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input)); typedef BOOST_STRING_TYPENAME range_iterator<RangeT>::type input_iterator_type; typedef split_iterator<input_iterator_type> find_iterator_type; typedef detail::copy_iterator_rangeF< BOOST_STRING_TYPENAME range_value<SequenceSequenceT>::type, input_iterator_type> copy_range_type; input_iterator_type InputEnd=::boost::end(lit_input); typedef transform_iterator<copy_range_type, find_iterator_type> transform_iter_type; transform_iter_type itBegin= ::boost::make_transform_iterator( find_iterator_type( ::boost::begin(lit_input), InputEnd, Finder ), copy_range_type() ); transform_iter_type itEnd= ::boost::make_transform_iterator( find_iterator_type(), copy_range_type() ); SequenceSequenceT Tmp(itBegin, itEnd); Result.swap(Tmp); return Result; } } // namespace algorithm // pull names to the boost namespace using algorithm::iter_find; using algorithm::iter_split; } // namespace boost #endif // BOOST_STRING_ITER_FIND_HPP PK��M�[y��S�$��$��string/finder.hppnu��[��// Boost string_algo library finder.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2006. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_FINDER_HPP #define BOOST_STRING_FINDER_HPP #include <boost/algorithm/string/config.hpp> #include <boost/range/iterator_range_core.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/iterator.hpp> #include <boost/range/const_iterator.hpp> #include <boost/algorithm/string/constants.hpp> #include <boost/algorithm/string/detail/finder.hpp> #include <boost/algorithm/string/compare.hpp> /! \file Defines Finder generators. Finder object is a functor which is able to find a substring matching a specific criteria in the input. Finders are used as a pluggable components for replace, find and split facilities. This header contains generator functions for finders provided in this library. / namespace boost { namespace algorithm { // Finder generators ------------------------------------------// //! "First" finder /! Construct the \c first_finder. The finder searches for the first occurrence of the string in a given input. The result is given as an \c iterator_range delimiting the match. \param Search A substring to be searched for. \return An instance of the \c first_finder object / template<typename RangeT> inline detail::first_finderF< BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type, is_equal> first_finder( const RangeT& Search ) { return detail::first_finderF< BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type, is_equal>( ::boost::as_literal(Search), is_equal() ) ; } //! "First" finder /! \overload / template<typename RangeT,typename PredicateT> inline detail::first_finderF< BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type, PredicateT> first_finder( const RangeT& Search, PredicateT Comp ) { return detail::first_finderF< BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type, PredicateT>( ::boost::as_literal(Search), Comp ); } //! "Last" finder /! Construct the \c last_finder. The finder searches for the last occurrence of the string in a given input. The result is given as an \c iterator_range delimiting the match. \param Search A substring to be searched for. \return An instance of the \c last_finder object / template<typename RangeT> inline detail::last_finderF< BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type, is_equal> last_finder( const RangeT& Search ) { return detail::last_finderF< BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type, is_equal>( ::boost::as_literal(Search), is_equal() ); } //! "Last" finder /! \overload / template<typename RangeT, typename PredicateT> inline detail::last_finderF< BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type, PredicateT> last_finder( const RangeT& Search, PredicateT Comp ) { return detail::last_finderF< BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type, PredicateT>( ::boost::as_literal(Search), Comp ) ; } //! "Nth" finder /! Construct the \c nth_finder. The finder searches for the n-th (zero-indexed) occurrence of the string in a given input. The result is given as an \c iterator_range delimiting the match. \param Search A substring to be searched for. \param Nth An index of the match to be find \return An instance of the \c nth_finder object / template<typename RangeT> inline detail::nth_finderF< BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type, is_equal> nth_finder( const RangeT& Search, int Nth) { return detail::nth_finderF< BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type, is_equal>( ::boost::as_literal(Search), Nth, is_equal() ) ; } //! "Nth" finder /! \overload / template<typename RangeT, typename PredicateT> inline detail::nth_finderF< BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type, PredicateT> nth_finder( const RangeT& Search, int Nth, PredicateT Comp ) { return detail::nth_finderF< BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type, PredicateT>( ::boost::as_literal(Search), Nth, Comp ); } //! "Head" finder /! Construct the \c head_finder. The finder returns a head of a given input. The head is a prefix of a string up to n elements in size. If an input has less then n elements, whole input is considered a head. The result is given as an \c iterator_range delimiting the match. \param N The size of the head \return An instance of the \c head_finder object / inline detail::head_finderF head_finder( int N ) { return detail::head_finderF(N); } //! "Tail" finder /! Construct the \c tail_finder. The finder returns a tail of a given input. The tail is a suffix of a string up to n elements in size. If an input has less then n elements, whole input is considered a head. The result is given as an \c iterator_range delimiting the match. \param N The size of the head \return An instance of the \c tail_finder object / inline detail::tail_finderF tail_finder( int N ) { return detail::tail_finderF(N); } //! "Token" finder /! Construct the \c token_finder. The finder searches for a token specified by a predicate. It is similar to std::find_if algorithm, with an exception that it return a range of instead of a single iterator. If "compress token mode" is enabled, adjacent matching tokens are concatenated into one match. Thus the finder can be used to search for continuous segments of characters satisfying the given predicate. The result is given as an \c iterator_range delimiting the match. \param Pred An element selection predicate \param eCompress Compress flag \return An instance of the \c token_finder object / template< typename PredicateT > inline detail::token_finderF<PredicateT> token_finder( PredicateT Pred, token_compress_mode_type eCompress=token_compress_off ) { return detail::token_finderF<PredicateT>( Pred, eCompress ); } //! "Range" finder /! Construct the \c range_finder. The finder does not perform any operation. It simply returns the given range for any input. \param Begin Beginning of the range \param End End of the range \return An instance of the \c range_finger object / template< typename ForwardIteratorT > inline detail::range_finderF<ForwardIteratorT> range_finder( ForwardIteratorT Begin, ForwardIteratorT End ) { return detail::range_finderF<ForwardIteratorT>( Begin, End ); } //! "Range" finder /! \overload / template< typename ForwardIteratorT > inline detail::range_finderF<ForwardIteratorT> range_finder( iterator_range<ForwardIteratorT> Range ) { return detail::range_finderF<ForwardIteratorT>( Range ); } } // namespace algorithm // pull the names to the boost namespace using algorithm::first_finder; using algorithm::last_finder; using algorithm::nth_finder; using algorithm::head_finder; using algorithm::tail_finder; using algorithm::token_finder; using algorithm::range_finder; } // namespace boost #endif // BOOST_STRING_FINDER_HPP PK��M�[�V��(��(��string/find_format.hppnu��[��// Boost string_algo library find_format.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_FIND_FORMAT_HPP #define BOOST_STRING_FIND_FORMAT_HPP #include <deque> #include <boost/range/iterator_range_core.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/const_iterator.hpp> #include <boost/range/as_literal.hpp> #include <boost/algorithm/string/concept.hpp> #include <boost/algorithm/string/detail/find_format.hpp> #include <boost/algorithm/string/detail/find_format_all.hpp> /! \file Defines generic replace algorithms. Each algorithm replaces part(s) of the input. The part to be replaced is looked up using a Finder object. Result of finding is then used by a Formatter object to generate the replacement. / namespace boost { namespace algorithm { // generic replace -----------------------------------------------------------------// //! Generic replace algorithm /! Use the Finder to search for a substring. Use the Formatter to format this substring and replace it in the input. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. \param Output An output iterator to which the result will be copied \param Input An input sequence \param Finder A Finder object used to search for a match to be replaced \param Formatter A Formatter object used to format a match \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename RangeT, typename FinderT, typename FormatterT> inline OutputIteratorT find_format_copy( OutputIteratorT Output, const RangeT& Input, FinderT Finder, FormatterT Formatter ) { // Concept check BOOST_CONCEPT_ASSERT(( FinderConcept< FinderT, BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> )); BOOST_CONCEPT_ASSERT(( FormatterConcept< FormatterT, FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> )); iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input)); return detail::find_format_copy_impl( Output, lit_input, Formatter, Finder( ::boost::begin(lit_input), ::boost::end(lit_input) ) ); } //! Generic replace algorithm /! \overload / template< typename SequenceT, typename FinderT, typename FormatterT> inline SequenceT find_format_copy( const SequenceT& Input, FinderT Finder, FormatterT Formatter ) { // Concept check BOOST_CONCEPT_ASSERT(( FinderConcept< FinderT, BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> )); BOOST_CONCEPT_ASSERT(( FormatterConcept< FormatterT, FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> )); return detail::find_format_copy_impl( Input, Formatter, Finder(::boost::begin(Input), ::boost::end(Input))); } //! Generic replace algorithm /! Use the Finder to search for a substring. Use the Formatter to format this substring and replace it in the input. The input is modified in-place. \param Input An input sequence \param Finder A Finder object used to search for a match to be replaced \param Formatter A Formatter object used to format a match / template< typename SequenceT, typename FinderT, typename FormatterT> inline void find_format( SequenceT& Input, FinderT Finder, FormatterT Formatter) { // Concept check BOOST_CONCEPT_ASSERT(( FinderConcept< FinderT, BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> )); BOOST_CONCEPT_ASSERT(( FormatterConcept< FormatterT, FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> )); detail::find_format_impl( Input, Formatter, Finder(::boost::begin(Input), ::boost::end(Input))); } // find_format_all generic ----------------------------------------------------------------// //! Generic replace all algorithm /! Use the Finder to search for a substring. Use the Formatter to format this substring and replace it in the input. Repeat this for all matching substrings. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. \param Output An output iterator to which the result will be copied \param Input An input sequence \param Finder A Finder object used to search for a match to be replaced \param Formatter A Formatter object used to format a match \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename RangeT, typename FinderT, typename FormatterT> inline OutputIteratorT find_format_all_copy( OutputIteratorT Output, const RangeT& Input, FinderT Finder, FormatterT Formatter) { // Concept check BOOST_CONCEPT_ASSERT(( FinderConcept< FinderT, BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> )); BOOST_CONCEPT_ASSERT(( FormatterConcept< FormatterT, FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> )); iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input)); return detail::find_format_all_copy_impl( Output, lit_input, Finder, Formatter, Finder(::boost::begin(lit_input), ::boost::end(lit_input))); } //! Generic replace all algorithm /! \overload / template< typename SequenceT, typename FinderT, typename FormatterT > inline SequenceT find_format_all_copy( const SequenceT& Input, FinderT Finder, FormatterT Formatter ) { // Concept check BOOST_CONCEPT_ASSERT(( FinderConcept< FinderT, BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> )); BOOST_CONCEPT_ASSERT(( FormatterConcept< FormatterT, FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> )); return detail::find_format_all_copy_impl( Input, Finder, Formatter, Finder( ::boost::begin(Input), ::boost::end(Input) ) ); } //! Generic replace all algorithm /! Use the Finder to search for a substring. Use the Formatter to format this substring and replace it in the input. Repeat this for all matching substrings.The input is modified in-place. \param Input An input sequence \param Finder A Finder object used to search for a match to be replaced \param Formatter A Formatter object used to format a match / template< typename SequenceT, typename FinderT, typename FormatterT > inline void find_format_all( SequenceT& Input, FinderT Finder, FormatterT Formatter ) { // Concept check BOOST_CONCEPT_ASSERT(( FinderConcept< FinderT, BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> )); BOOST_CONCEPT_ASSERT(( FormatterConcept< FormatterT, FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> )); detail::find_format_all_impl( Input, Finder, Formatter, Finder(::boost::begin(Input), ::boost::end(Input))); } } // namespace algorithm // pull the names to the boost namespace using algorithm::find_format_copy; using algorithm::find_format; using algorithm::find_format_all_copy; using algorithm::find_format_all; } // namespace boost #endif // BOOST_STRING_FIND_FORMAT_HPP PK��M�[��F�� string/std/rope_traits.hppnu��[��// Boost string_algo library string_traits.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_STD_ROPE_TRAITS_HPP #define BOOST_STRING_STD_ROPE_TRAITS_HPP #include <boost/algorithm/string/yes_no_type.hpp> #include <rope> #include <boost/algorithm/string/sequence_traits.hpp> namespace boost { namespace algorithm { // SGI's std::rope<> traits -----------------------------------------------// // native replace trait template<typename T, typename TraitsT, typename AllocT> class has_native_replace< std::rope<T,TraitsT,AllocT> > { public: #if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) enum { value = true }; #else BOOST_STATIC_CONSTANT(bool, value=true); #endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) typedef mpl::bool_<value> type; }; // stable iterators trait template<typename T, typename TraitsT, typename AllocT> class has_stable_iterators< std::rope<T,TraitsT,AllocT> > { public: #if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) enum { value = true }; #else BOOST_STATIC_CONSTANT(bool, value=true); #endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) typedef mpl::bool_<value> type; }; // const time insert trait template<typename T, typename TraitsT, typename AllocT> class has_const_time_insert< std::rope<T,TraitsT,AllocT> > { public: #if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) enum { value = true }; #else BOOST_STATIC_CONSTANT(bool, value=true); #endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) typedef mpl::bool_<value> type; }; // const time erase trait template<typename T, typename TraitsT, typename AllocT> class has_const_time_erase< std::rope<T,TraitsT,AllocT> > { public: #if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) enum { value = true }; #else BOOST_STATIC_CONSTANT(bool, value=true); #endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) typedef mpl::bool_<value> type; }; } // namespace algorithm } // namespace boost #endif // BOOST_STRING_ROPE_TRAITS_HPP PK��M�[�6��string/std/string_traits.hppnu��[��// Boost string_algo library string_traits.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_STD_STRING_TRAITS_HPP #define BOOST_STRING_STD_STRING_TRAITS_HPP #include <boost/algorithm/string/yes_no_type.hpp> #include <string> #include <boost/algorithm/string/sequence_traits.hpp> namespace boost { namespace algorithm { // std::basic_string<> traits -----------------------------------------------// // native replace trait template<typename T, typename TraitsT, typename AllocT> class has_native_replace< std::basic_string<T, TraitsT, AllocT> > { public: #if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) enum { value = true } ; #else BOOST_STATIC_CONSTANT(bool, value=true); #endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) typedef mpl::bool_<has_native_replace<T>::value> type; }; } // namespace algorithm } // namespace boost #endif // BOOST_STRING_LIST_TRAITS_HPP PK��M�[� C8��8��string/std/list_traits.hppnu��[��// Boost string_algo library list_traits.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_STD_LIST_TRAITS_HPP #define BOOST_STRING_STD_LIST_TRAITS_HPP #include <boost/algorithm/string/yes_no_type.hpp> #include <list> #include <boost/algorithm/string/sequence_traits.hpp> namespace boost { namespace algorithm { // std::list<> traits -----------------------------------------------// // stable iterators trait template<typename T, typename AllocT> class has_stable_iterators< ::std::list<T,AllocT> > { public: #if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) enum { value = true }; #else BOOST_STATIC_CONSTANT(bool, value=true); #endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) typedef mpl::bool_<has_stable_iterators<T>::value> type; }; // const time insert trait template<typename T, typename AllocT> class has_const_time_insert< ::std::list<T,AllocT> > { public: #if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) enum { value = true }; #else BOOST_STATIC_CONSTANT(bool, value=true); #endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) typedef mpl::bool_<has_const_time_insert<T>::value> type; }; // const time erase trait template<typename T, typename AllocT> class has_const_time_erase< ::std::list<T,AllocT> > { public: #if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) enum { value = true }; #else BOOST_STATIC_CONSTANT(bool, value=true); #endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) typedef mpl::bool_<has_const_time_erase<T>::value> type; }; } // namespace algorithm } // namespace boost #endif // BOOST_STRING_STD_LIST_TRAITS_HPP PK��M�[�14��string/std/slist_traits.hppnu��[��// Boost string_algo library slist_traits.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_STD_SLIST_TRAITS_HPP #define BOOST_STRING_STD_SLIST_TRAITS_HPP #include <boost/algorithm/string/config.hpp> #include <boost/algorithm/string/yes_no_type.hpp> #include BOOST_SLIST_HEADER #include <boost/algorithm/string/sequence_traits.hpp> namespace boost { namespace algorithm { // SGI's std::slist<> traits -----------------------------------------------// // stable iterators trait template<typename T, typename AllocT> class has_stable_iterators< BOOST_STD_EXTENSION_NAMESPACE::slist<T,AllocT> > { public: #if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) enum { value = true }; #else BOOST_STATIC_CONSTANT(bool, value=true); #endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) typedef mpl::bool_<has_stable_iterators<T>::value> type; }; // const time insert trait template<typename T, typename AllocT> class has_const_time_insert< BOOST_STD_EXTENSION_NAMESPACE::slist<T,AllocT> > { public: #if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) enum { value = true }; #else BOOST_STATIC_CONSTANT(bool, value=true); #endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) typedef mpl::bool_<has_const_time_insert<T>::value> type; }; // const time erase trait template<typename T, typename AllocT> class has_const_time_erase< BOOST_STD_EXTENSION_NAMESPACE::slist<T,AllocT> > { public: #if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) enum { value = true }; #else BOOST_STATIC_CONSTANT(bool, value=true); #endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) typedef mpl::bool_<has_const_time_erase<T>::value> type; }; } // namespace algorithm } // namespace boost #endif // BOOST_STRING_STD_LIST_TRAITS_HPP PK��M�[��i��string/regex_find_format.hppnu��[��// Boost string_algo library regex_find_format.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_REGEX_FIND_FORMAT_HPP #define BOOST_STRING_REGEX_FIND_FORMAT_HPP #include <boost/algorithm/string/config.hpp> #include <boost/regex.hpp> #include <boost/algorithm/string/detail/finder_regex.hpp> #include <boost/algorithm/string/detail/formatter_regex.hpp> /! \file Defines the \c regex_finder and \c regex_formatter generators. These two functors are designed to work together. \c regex_formatter uses additional information about a match contained in the regex_finder search result. / namespace boost { namespace algorithm { // regex_finder -----------------------------------------------// //! "Regex" finder /! Construct the \c regex_finder. Finder uses the regex engine to search for a match. Result is given in \c regex_search_result. This is an extension of the iterator_range. In addition it contains match results from the \c regex_search algorithm. \param Rx A regular expression \param MatchFlags Regex search options \return An instance of the \c regex_finder object / template< typename CharT, typename RegexTraitsT> inline detail::find_regexF< basic_regex<CharT, RegexTraitsT> > regex_finder( const basic_regex<CharT, RegexTraitsT>& Rx, match_flag_type MatchFlags=match_default ) { return detail:: find_regexF< basic_regex<CharT, RegexTraitsT> >( Rx, MatchFlags ); } // regex_formater ---------------------------------------------// //! Regex formatter /! Construct the \c regex_formatter. Regex formatter uses the regex engine to format a match found by the \c regex_finder. This formatted it designed to closely cooperate with \c regex_finder. \param Format Regex format definition \param Flags Format flags \return An instance of the \c regex_formatter functor / template< typename CharT, typename TraitsT, typename AllocT > inline detail::regex_formatF< std::basic_string< CharT, TraitsT, AllocT > > regex_formatter( const std::basic_string<CharT, TraitsT, AllocT>& Format, match_flag_type Flags=format_default ) { return detail::regex_formatF< std::basic_string<CharT, TraitsT, AllocT> >( Format, Flags ); } } // namespace algorithm // pull the names to the boost namespace using algorithm::regex_finder; using algorithm::regex_formatter; } // namespace boost #endif // BOOST_STRING_REGEX_FIND_FORMAT_HPP PK��M�[��wE\|��E\|��string/erase.hppnu��[��// Boost string_algo library erase.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2006. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_ERASE_HPP #define BOOST_STRING_ERASE_HPP #include <boost/algorithm/string/config.hpp> #include <boost/range/iterator_range_core.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/iterator.hpp> #include <boost/range/const_iterator.hpp> #include <boost/algorithm/string/find_format.hpp> #include <boost/algorithm/string/finder.hpp> #include <boost/algorithm/string/formatter.hpp> /! \file Defines various erase algorithms. Each algorithm removes part(s) of the input according to a searching criteria. / namespace boost { namespace algorithm { // erase_range -------------------------------------------------------// //! Erase range algorithm /! Remove the given range from the input. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. \param Output An output iterator to which the result will be copied \param Input An input sequence \param SearchRange A range in the input to be removed \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template<typename OutputIteratorT, typename RangeT> inline OutputIteratorT erase_range_copy( OutputIteratorT Output, const RangeT& Input, const iterator_range< BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>& SearchRange ) { return ::boost::algorithm::find_format_copy( Output, Input, ::boost::algorithm::range_finder(SearchRange), ::boost::algorithm::empty_formatter(Input) ); } //! Erase range algorithm /! \overload / template<typename SequenceT> inline SequenceT erase_range_copy( const SequenceT& Input, const iterator_range< BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>& SearchRange ) { return ::boost::algorithm::find_format_copy( Input, ::boost::algorithm::range_finder(SearchRange), ::boost::algorithm::empty_formatter(Input) ); } //! Erase range algorithm /! Remove the given range from the input. The input sequence is modified in-place. \param Input An input sequence \param SearchRange A range in the input to be removed / template<typename SequenceT> inline void erase_range( SequenceT& Input, const iterator_range< BOOST_STRING_TYPENAME range_iterator<SequenceT>::type>& SearchRange ) { ::boost::algorithm::find_format( Input, ::boost::algorithm::range_finder(SearchRange), ::boost::algorithm::empty_formatter(Input) ); } // erase_first --------------------------------------------------------// //! Erase first algorithm /! Remove the first occurrence of the substring from the input. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. \param Output An output iterator to which the result will be copied \param Input An input string \param Search A substring to be searched for \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename Range1T, typename Range2T> inline OutputIteratorT erase_first_copy( OutputIteratorT Output, const Range1T& Input, const Range2T& Search ) { return ::boost::algorithm::find_format_copy( Output, Input, ::boost::algorithm::first_finder(Search), ::boost::algorithm::empty_formatter(Input) ); } //! Erase first algorithm /! \overload / template<typename SequenceT, typename RangeT> inline SequenceT erase_first_copy( const SequenceT& Input, const RangeT& Search ) { return ::boost::algorithm::find_format_copy( Input, ::boost::algorithm::first_finder(Search), ::boost::algorithm::empty_formatter(Input) ); } //! Erase first algorithm /! Remove the first occurrence of the substring from the input. The input sequence is modified in-place. \param Input An input string \param Search A substring to be searched for. / template<typename SequenceT, typename RangeT> inline void erase_first( SequenceT& Input, const RangeT& Search ) { ::boost::algorithm::find_format( Input, ::boost::algorithm::first_finder(Search), ::boost::algorithm::empty_formatter(Input) ); } // erase_first ( case insensitive ) ------------------------------------// //! Erase first algorithm ( case insensitive ) /! Remove the first occurrence of the substring from the input. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. Searching is case insensitive. \param Output An output iterator to which the result will be copied \param Input An input string \param Search A substring to be searched for \param Loc A locale used for case insensitive comparison \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename Range1T, typename Range2T> inline OutputIteratorT ierase_first_copy( OutputIteratorT Output, const Range1T& Input, const Range2T& Search, const std::locale& Loc=std::locale() ) { return ::boost::algorithm::find_format_copy( Output, Input, ::boost::algorithm::first_finder(Search, is_iequal(Loc)), ::boost::algorithm::empty_formatter(Input) ); } //! Erase first algorithm ( case insensitive ) /! \overload / template<typename SequenceT, typename RangeT> inline SequenceT ierase_first_copy( const SequenceT& Input, const RangeT& Search, const std::locale& Loc=std::locale() ) { return ::boost::algorithm::find_format_copy( Input, ::boost::algorithm::first_finder(Search, is_iequal(Loc)), ::boost::algorithm::empty_formatter(Input) ); } //! Erase first algorithm ( case insensitive ) /! Remove the first occurrence of the substring from the input. The input sequence is modified in-place. Searching is case insensitive. \param Input An input string \param Search A substring to be searched for \param Loc A locale used for case insensitive comparison / template<typename SequenceT, typename RangeT> inline void ierase_first( SequenceT& Input, const RangeT& Search, const std::locale& Loc=std::locale() ) { ::boost::algorithm::find_format( Input, ::boost::algorithm::first_finder(Search, is_iequal(Loc)), ::boost::algorithm::empty_formatter(Input) ); } // erase_last --------------------------------------------------------// //! Erase last algorithm /! Remove the last occurrence of the substring from the input. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. \param Output An output iterator to which the result will be copied \param Input An input string \param Search A substring to be searched for. \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename Range1T, typename Range2T> inline OutputIteratorT erase_last_copy( OutputIteratorT Output, const Range1T& Input, const Range2T& Search ) { return ::boost::algorithm::find_format_copy( Output, Input, ::boost::algorithm::last_finder(Search), ::boost::algorithm::empty_formatter(Input) ); } //! Erase last algorithm /! \overload / template<typename SequenceT, typename RangeT> inline SequenceT erase_last_copy( const SequenceT& Input, const RangeT& Search ) { return ::boost::algorithm::find_format_copy( Input, ::boost::algorithm::last_finder(Search), ::boost::algorithm::empty_formatter(Input) ); } //! Erase last algorithm /! Remove the last occurrence of the substring from the input. The input sequence is modified in-place. \param Input An input string \param Search A substring to be searched for / template<typename SequenceT, typename RangeT> inline void erase_last( SequenceT& Input, const RangeT& Search ) { ::boost::algorithm::find_format( Input, ::boost::algorithm::last_finder(Search), ::boost::algorithm::empty_formatter(Input) ); } // erase_last ( case insensitive ) ------------------------------------// //! Erase last algorithm ( case insensitive ) /! Remove the last occurrence of the substring from the input. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. Searching is case insensitive. \param Output An output iterator to which the result will be copied \param Input An input string \param Search A substring to be searched for \param Loc A locale used for case insensitive comparison \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename Range1T, typename Range2T> inline OutputIteratorT ierase_last_copy( OutputIteratorT Output, const Range1T& Input, const Range2T& Search, const std::locale& Loc=std::locale() ) { return ::boost::algorithm::find_format_copy( Output, Input, ::boost::algorithm::last_finder(Search, is_iequal(Loc)), ::boost::algorithm::empty_formatter(Input) ); } //! Erase last algorithm ( case insensitive ) /! \overload / template<typename SequenceT, typename RangeT> inline SequenceT ierase_last_copy( const SequenceT& Input, const RangeT& Search, const std::locale& Loc=std::locale() ) { return ::boost::algorithm::find_format_copy( Input, ::boost::algorithm::last_finder(Search, is_iequal(Loc)), ::boost::algorithm::empty_formatter(Input) ); } //! Erase last algorithm ( case insensitive ) /! Remove the last occurrence of the substring from the input. The input sequence is modified in-place. Searching is case insensitive. \param Input An input string \param Search A substring to be searched for \param Loc A locale used for case insensitive comparison / template<typename SequenceT, typename RangeT> inline void ierase_last( SequenceT& Input, const RangeT& Search, const std::locale& Loc=std::locale() ) { ::boost::algorithm::find_format( Input, ::boost::algorithm::last_finder(Search, is_iequal(Loc)), ::boost::algorithm::empty_formatter(Input) ); } // erase_nth --------------------------------------------------------------------// //! Erase nth algorithm /! Remove the Nth occurrence of the substring in the input. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. \param Output An output iterator to which the result will be copied \param Input An input string \param Search A substring to be searched for \param Nth An index of the match to be replaced. The index is 0-based. For negative N, matches are counted from the end of string. \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename Range1T, typename Range2T> inline OutputIteratorT erase_nth_copy( OutputIteratorT Output, const Range1T& Input, const Range2T& Search, int Nth ) { return ::boost::algorithm::find_format_copy( Output, Input, ::boost::algorithm::nth_finder(Search, Nth), ::boost::algorithm::empty_formatter(Input) ); } //! Erase nth algorithm /! \overload / template<typename SequenceT, typename RangeT> inline SequenceT erase_nth_copy( const SequenceT& Input, const RangeT& Search, int Nth ) { return ::boost::algorithm::find_format_copy( Input, ::boost::algorithm::nth_finder(Search, Nth), ::boost::algorithm::empty_formatter(Input) ); } //! Erase nth algorithm /! Remove the Nth occurrence of the substring in the input. The input sequence is modified in-place. \param Input An input string \param Search A substring to be searched for. \param Nth An index of the match to be replaced. The index is 0-based. For negative N, matches are counted from the end of string. / template<typename SequenceT, typename RangeT> inline void erase_nth( SequenceT& Input, const RangeT& Search, int Nth ) { ::boost::algorithm::find_format( Input, ::boost::algorithm::nth_finder(Search, Nth), ::boost::algorithm::empty_formatter(Input) ); } // erase_nth ( case insensitive ) ---------------------------------------------// //! Erase nth algorithm ( case insensitive ) /! Remove the Nth occurrence of the substring in the input. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. Searching is case insensitive. \param Output An output iterator to which the result will be copied \param Input An input string \param Search A substring to be searched for. \param Nth An index of the match to be replaced. The index is 0-based. For negative N, matches are counted from the end of string. \param Loc A locale used for case insensitive comparison \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename Range1T, typename Range2T> inline OutputIteratorT ierase_nth_copy( OutputIteratorT Output, const Range1T& Input, const Range2T& Search, int Nth, const std::locale& Loc=std::locale() ) { return ::boost::algorithm::find_format_copy( Output, Input, ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)), ::boost::algorithm::empty_formatter(Input) ); } //! Erase nth algorithm /! \overload / template<typename SequenceT, typename RangeT> inline SequenceT ierase_nth_copy( const SequenceT& Input, const RangeT& Search, int Nth, const std::locale& Loc=std::locale() ) { return ::boost::algorithm::find_format_copy( Input, ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)), empty_formatter(Input) ); } //! Erase nth algorithm /! Remove the Nth occurrence of the substring in the input. The input sequence is modified in-place. Searching is case insensitive. \param Input An input string \param Search A substring to be searched for. \param Nth An index of the match to be replaced. The index is 0-based. For negative N, matches are counted from the end of string. \param Loc A locale used for case insensitive comparison / template<typename SequenceT, typename RangeT> inline void ierase_nth( SequenceT& Input, const RangeT& Search, int Nth, const std::locale& Loc=std::locale() ) { ::boost::algorithm::find_format( Input, ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)), ::boost::algorithm::empty_formatter(Input) ); } // erase_all --------------------------------------------------------// //! Erase all algorithm /! Remove all the occurrences of the string from the input. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. \param Output An output iterator to which the result will be copied \param Input An input sequence \param Search A substring to be searched for. \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename Range1T, typename Range2T> inline OutputIteratorT erase_all_copy( OutputIteratorT Output, const Range1T& Input, const Range2T& Search ) { return ::boost::algorithm::find_format_all_copy( Output, Input, ::boost::algorithm::first_finder(Search), ::boost::algorithm::empty_formatter(Input) ); } //! Erase all algorithm /! \overload / template<typename SequenceT, typename RangeT> inline SequenceT erase_all_copy( const SequenceT& Input, const RangeT& Search ) { return ::boost::algorithm::find_format_all_copy( Input, ::boost::algorithm::first_finder(Search), ::boost::algorithm::empty_formatter(Input) ); } //! Erase all algorithm /! Remove all the occurrences of the string from the input. The input sequence is modified in-place. \param Input An input string \param Search A substring to be searched for. / template<typename SequenceT, typename RangeT> inline void erase_all( SequenceT& Input, const RangeT& Search ) { ::boost::algorithm::find_format_all( Input, ::boost::algorithm::first_finder(Search), ::boost::algorithm::empty_formatter(Input) ); } // erase_all ( case insensitive ) ------------------------------------// //! Erase all algorithm ( case insensitive ) /! Remove all the occurrences of the string from the input. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. Searching is case insensitive. \param Output An output iterator to which the result will be copied \param Input An input string \param Search A substring to be searched for \param Loc A locale used for case insensitive comparison \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename Range1T, typename Range2T> inline OutputIteratorT ierase_all_copy( OutputIteratorT Output, const Range1T& Input, const Range2T& Search, const std::locale& Loc=std::locale() ) { return ::boost::algorithm::find_format_all_copy( Output, Input, ::boost::algorithm::first_finder(Search, is_iequal(Loc)), ::boost::algorithm::empty_formatter(Input) ); } //! Erase all algorithm ( case insensitive ) /! \overload / template<typename SequenceT, typename RangeT> inline SequenceT ierase_all_copy( const SequenceT& Input, const RangeT& Search, const std::locale& Loc=std::locale() ) { return ::boost::algorithm::find_format_all_copy( Input, ::boost::algorithm::first_finder(Search, is_iequal(Loc)), ::boost::algorithm::empty_formatter(Input) ); } //! Erase all algorithm ( case insensitive ) /! Remove all the occurrences of the string from the input. The input sequence is modified in-place. Searching is case insensitive. \param Input An input string \param Search A substring to be searched for. \param Loc A locale used for case insensitive comparison / template<typename SequenceT, typename RangeT> inline void ierase_all( SequenceT& Input, const RangeT& Search, const std::locale& Loc=std::locale() ) { ::boost::algorithm::find_format_all( Input, ::boost::algorithm::first_finder(Search, is_iequal(Loc)), ::boost::algorithm::empty_formatter(Input) ); } // erase_head --------------------------------------------------------------------// //! Erase head algorithm /! Remove the head from the input. The head is a prefix of a sequence of given size. If the sequence is shorter then required, the whole string is considered to be the head. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. \param Output An output iterator to which the result will be copied \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. \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename RangeT> inline OutputIteratorT erase_head_copy( OutputIteratorT Output, const RangeT& Input, int N ) { return ::boost::algorithm::find_format_copy( Output, Input, ::boost::algorithm::head_finder(N), ::boost::algorithm::empty_formatter( Input ) ); } //! Erase head algorithm /! \overload / template<typename SequenceT> inline SequenceT erase_head_copy( const SequenceT& Input, int N ) { return ::boost::algorithm::find_format_copy( Input, ::boost::algorithm::head_finder(N), ::boost::algorithm::empty_formatter( Input ) ); } //! Erase head algorithm /! Remove the head from the input. The head is a prefix of a sequence of given size. If the sequence is shorter then required, the whole string is considered to be the head. The input sequence is modified in-place. \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. / template<typename SequenceT> inline void erase_head( SequenceT& Input, int N ) { ::boost::algorithm::find_format( Input, ::boost::algorithm::head_finder(N), ::boost::algorithm::empty_formatter( Input ) ); } // erase_tail --------------------------------------------------------------------// //! Erase tail algorithm /! Remove the tail from the input. The tail is a suffix of a sequence of given size. If the sequence is shorter then required, the whole string is considered to be the tail. The result is a modified copy of the input. It is returned as a sequence or copied to the output iterator. \param Output An output iterator to which the result will be copied \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. \return An output iterator pointing just after the last inserted character or a modified copy of the input \note The second variant of this function provides the strong exception-safety guarantee / template< typename OutputIteratorT, typename RangeT> inline OutputIteratorT erase_tail_copy( OutputIteratorT Output, const RangeT& Input, int N ) { return ::boost::algorithm::find_format_copy( Output, Input, ::boost::algorithm::tail_finder(N), ::boost::algorithm::empty_formatter( Input ) ); } //! Erase tail algorithm /! \overload / template<typename SequenceT> inline SequenceT erase_tail_copy( const SequenceT& Input, int N ) { return ::boost::algorithm::find_format_copy( Input, ::boost::algorithm::tail_finder(N), ::boost::algorithm::empty_formatter( Input ) ); } //! Erase tail algorithm /! Remove the tail from the input. The tail is a suffix of a sequence of given size. If the sequence is shorter then required, the whole string is considered to be the tail. The input sequence is modified in-place. \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. / template<typename SequenceT> inline void erase_tail( SequenceT& Input, int N ) { ::boost::algorithm::find_format( Input, ::boost::algorithm::tail_finder(N), ::boost::algorithm::empty_formatter( Input ) ); } } // namespace algorithm // pull names into the boost namespace using algorithm::erase_range_copy; using algorithm::erase_range; using algorithm::erase_first_copy; using algorithm::erase_first; using algorithm::ierase_first_copy; using algorithm::ierase_first; using algorithm::erase_last_copy; using algorithm::erase_last; using algorithm::ierase_last_copy; using algorithm::ierase_last; using algorithm::erase_nth_copy; using algorithm::erase_nth; using algorithm::ierase_nth_copy; using algorithm::ierase_nth; using algorithm::erase_all_copy; using algorithm::erase_all; using algorithm::ierase_all_copy; using algorithm::ierase_all; using algorithm::erase_head_copy; using algorithm::erase_head; using algorithm::erase_tail_copy; using algorithm::erase_tail; } // namespace boost #endif // BOOST_ERASE_HPP PK��M�[�(��string/detail/formatter.hppnu��[��// Boost string_algo library formatter.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org for updates, documentation, and revision history. #ifndef BOOST_STRING_FORMATTER_DETAIL_HPP #define BOOST_STRING_FORMATTER_DETAIL_HPP #include <boost/range/iterator_range_core.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/const_iterator.hpp> #include <boost/algorithm/string/detail/util.hpp> // generic replace functors -----------------------------------------------// namespace boost { namespace algorithm { namespace detail { // const format functor ----------------------------------------------------// // constant format functor template<typename RangeT> struct const_formatF { private: typedef BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type format_iterator; typedef iterator_range<format_iterator> result_type; public: // Construction const_formatF(const RangeT& Format) : m_Format(::boost::begin(Format), ::boost::end(Format)) {} // Operation #if BOOST_WORKAROUND(BOOST_BORLANDC, BOOST_TESTED_AT(0x564)) template<typename Range2T> result_type& operator()(const Range2T&) { return m_Format; } #endif template<typename Range2T> const result_type& operator()(const Range2T&) const { return m_Format; } private: result_type m_Format; }; // identity format functor ----------------------------------------------------// // identity format functor template<typename RangeT> struct identity_formatF { // Operation template< typename Range2T > const RangeT& operator()(const Range2T& Replace) const { return RangeT(::boost::begin(Replace), ::boost::end(Replace)); } }; // empty format functor ( used by erase ) ------------------------------------// // empty format functor template< typename CharT > struct empty_formatF { template< typename ReplaceT > empty_container<CharT> operator()(const ReplaceT&) const { return empty_container<CharT>(); } }; // dissect format functor ----------------------------------------------------// // dissect format functor template<typename FinderT> struct dissect_formatF { public: // Construction dissect_formatF(FinderT Finder) : m_Finder(Finder) {} // Operation template<typename RangeT> inline iterator_range< BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> operator()(const RangeT& Replace) const { return m_Finder(::boost::begin(Replace), ::boost::end(Replace)); } private: FinderT m_Finder; }; } // namespace detail } // namespace algorithm } // namespace boost #endif // BOOST_STRING_FORMATTER_DETAIL_HPP PK��M�[��V��V��#��string/detail/find_format_store.hppnu��[��// Boost string_algo library find_format_store.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_FIND_FORMAT_STORE_DETAIL_HPP #define BOOST_STRING_FIND_FORMAT_STORE_DETAIL_HPP #include <boost/algorithm/string/config.hpp> #include <boost/range/iterator_range_core.hpp> namespace boost { namespace algorithm { namespace detail { // temporary format and find result storage --------------------------------// #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif template< typename ForwardIteratorT, typename FormatterT, typename FormatResultT > class find_format_store : public iterator_range<ForwardIteratorT> { public: // typedefs typedef iterator_range<ForwardIteratorT> base_type; typedef FormatterT formatter_type; typedef FormatResultT format_result_type; public: // Construction find_format_store( const base_type& FindResult, const format_result_type& FormatResult, const formatter_type& Formatter ) : base_type(FindResult), m_FormatResult(FormatResult), m_Formatter(Formatter) {} // Assignment template< typename FindResultT > find_format_store& operator=( FindResultT FindResult ) { iterator_range<ForwardIteratorT>::operator=(FindResult); if( !this->empty() ) { m_FormatResult=m_Formatter(FindResult); } return this; } // Retrieve format result const format_result_type& format_result() { return m_FormatResult; } private: format_result_type m_FormatResult; const formatter_type& m_Formatter; }; template<typename InputT, typename FindResultT> bool check_find_result(InputT&, FindResultT& FindResult) { typedef BOOST_STRING_TYPENAME range_const_iterator<InputT>::type input_iterator_type; iterator_range<input_iterator_type> ResultRange(FindResult); return !ResultRange.empty(); } #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif } // namespace detail } // namespace algorithm } // namespace boost #endif // BOOST_STRING_FIND_FORMAT_STORE_DETAIL_HPP PK��M�[锏��string/detail/case_conv.hppnu��[��// Boost string_algo library string_funct.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_CASE_CONV_DETAIL_HPP #define BOOST_STRING_CASE_CONV_DETAIL_HPP #include <boost/algorithm/string/config.hpp> #include <locale> #include <functional> #include <boost/iterator/transform_iterator.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/type_traits/make_unsigned.hpp> namespace boost { namespace algorithm { namespace detail { // case conversion functors -----------------------------------------------// #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(push) #pragma warning(disable:4512) //assignment operator could not be generated #endif // a tolower functor template<typename CharT> struct to_lowerF { typedef CharT argument_type; typedef CharT result_type; // Constructor to_lowerF( const std::locale& Loc ) : m_Loc( &Loc ) {} // Operation CharT operator ()( CharT Ch ) const { #if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL) return std::tolower( static_cast<typename boost::make_unsigned <CharT>::type> ( Ch )); #else return std::tolower<CharT>( Ch, m_Loc ); #endif } private: const std::locale m_Loc; }; // a toupper functor template<typename CharT> struct to_upperF { typedef CharT argument_type; typedef CharT result_type; // Constructor to_upperF( const std::locale& Loc ) : m_Loc( &Loc ) {} // Operation CharT operator ()( CharT Ch ) const { #if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL) return std::toupper( static_cast<typename boost::make_unsigned <CharT>::type> ( Ch )); #else return std::toupper<CharT>( Ch, m_Loc ); #endif } private: const std::locale m_Loc; }; #if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) #pragma warning(pop) #endif // algorithm implementation ------------------------------------------------------------------------- // Transform a range template<typename OutputIteratorT, typename RangeT, typename FunctorT> OutputIteratorT transform_range_copy( OutputIteratorT Output, const RangeT& Input, FunctorT Functor) { return std::transform( ::boost::begin(Input), ::boost::end(Input), Output, Functor); } // Transform a range (in-place) template<typename RangeT, typename FunctorT> void transform_range( const RangeT& Input, FunctorT Functor) { std::transform( ::boost::begin(Input), ::boost::end(Input), ::boost::begin(Input), Functor); } template<typename SequenceT, typename RangeT, typename FunctorT> inline SequenceT transform_range_copy( const RangeT& Input, FunctorT Functor) { return SequenceT( ::boost::make_transform_iterator( ::boost::begin(Input), Functor), ::boost::make_transform_iterator( ::boost::end(Input), Functor)); } } // namespace detail } // namespace algorithm } // namespace boost #endif // BOOST_STRING_CASE_CONV_DETAIL_HPP PK��M�[�@�]��]��string/detail/trim.hppnu��[��// Boost string_algo library trim.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_TRIM_DETAIL_HPP #define BOOST_STRING_TRIM_DETAIL_HPP #include <boost/algorithm/string/config.hpp> #include <iterator> namespace boost { namespace algorithm { namespace detail { // trim iterator helper -----------------------------------------------// template< typename ForwardIteratorT, typename PredicateT > inline ForwardIteratorT trim_end_iter_select( ForwardIteratorT InBegin, ForwardIteratorT InEnd, PredicateT IsSpace, std::forward_iterator_tag ) { ForwardIteratorT TrimIt=InBegin; for( ForwardIteratorT It=InBegin; It!=InEnd; ++It ) { if ( !IsSpace(It) ) { TrimIt=It; ++TrimIt; } } return TrimIt; } template< typename ForwardIteratorT, typename PredicateT > inline ForwardIteratorT trim_end_iter_select( ForwardIteratorT InBegin, ForwardIteratorT InEnd, PredicateT IsSpace, std::bidirectional_iterator_tag ) { for( ForwardIteratorT It=InEnd; It!=InBegin; ) { if ( !IsSpace((--It)) ) return ++It; } return InBegin; } // Search for first non matching character from the beginning of the sequence template< typename ForwardIteratorT, typename PredicateT > inline ForwardIteratorT trim_begin( ForwardIteratorT InBegin, ForwardIteratorT InEnd, PredicateT IsSpace ) { ForwardIteratorT It=InBegin; for(; It!=InEnd; ++It ) { if (!IsSpace(It)) return It; } return It; } // Search for first non matching character from the end of the sequence template< typename ForwardIteratorT, typename PredicateT > inline ForwardIteratorT trim_end( ForwardIteratorT InBegin, ForwardIteratorT InEnd, PredicateT IsSpace ) { typedef BOOST_STRING_TYPENAME std::iterator_traits<ForwardIteratorT>::iterator_category category; return ::boost::algorithm::detail::trim_end_iter_select( InBegin, InEnd, IsSpace, category() ); } } // namespace detail } // namespace algorithm } // namespace boost #endif // BOOST_STRING_TRIM_DETAIL_HPP PK��M�[�n�8��8��!��string/detail/replace_storage.hppnu��[��// Boost string_algo library replace_storage.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_REPLACE_STORAGE_DETAIL_HPP #define BOOST_STRING_REPLACE_STORAGE_DETAIL_HPP #include <boost/algorithm/string/config.hpp> #include <algorithm> #include <boost/mpl/bool.hpp> #include <boost/algorithm/string/sequence_traits.hpp> #include <boost/algorithm/string/detail/sequence.hpp> namespace boost { namespace algorithm { namespace detail { // storage handling routines -----------------------------------------------// template< typename StorageT, typename OutputIteratorT > inline OutputIteratorT move_from_storage( StorageT& Storage, OutputIteratorT DestBegin, OutputIteratorT DestEnd ) { OutputIteratorT OutputIt=DestBegin; while( !Storage.empty() && OutputIt!=DestEnd ) { OutputIt=Storage.front(); Storage.pop_front(); ++OutputIt; } return OutputIt; } template< typename StorageT, typename WhatT > inline void copy_to_storage( StorageT& Storage, const WhatT& What ) { Storage.insert( Storage.end(), ::boost::begin(What), ::boost::end(What) ); } // process segment routine -----------------------------------------------// template< bool HasStableIterators > struct process_segment_helper { // Optimized version of process_segment for generic sequence template< typename StorageT, typename InputT, typename ForwardIteratorT > ForwardIteratorT operator()( StorageT& Storage, InputT& /Input/, ForwardIteratorT InsertIt, ForwardIteratorT SegmentBegin, ForwardIteratorT SegmentEnd ) { // Copy data from the storage until the beginning of the segment ForwardIteratorT It=::boost::algorithm::detail::move_from_storage( Storage, InsertIt, SegmentBegin ); // 3 cases are possible : // a) Storage is empty, It==SegmentBegin // b) Storage is empty, It!=SegmentBegin // c) Storage is not empty if( Storage.empty() ) { if( It==SegmentBegin ) { // Case a) everything is grand, just return end of segment return SegmentEnd; } else { // Case b) move the segment backwards return std::copy( SegmentBegin, SegmentEnd, It ); } } else { // Case c) -> shift the segment to the left and keep the overlap in the storage while( It!=SegmentEnd ) { // Store value into storage Storage.push_back( It ); // Get the top from the storage and put it here It=Storage.front(); Storage.pop_front(); // Advance ++It; } return It; } } }; template<> struct process_segment_helper< true > { // Optimized version of process_segment for list-like sequence template< typename StorageT, typename InputT, typename ForwardIteratorT > ForwardIteratorT operator()( StorageT& Storage, InputT& Input, ForwardIteratorT InsertIt, ForwardIteratorT SegmentBegin, ForwardIteratorT SegmentEnd ) { // Call replace to do the job ::boost::algorithm::detail::replace( Input, InsertIt, SegmentBegin, Storage ); // Empty the storage Storage.clear(); // Iterators were not changed, simply return the end of segment return SegmentEnd; } }; // Process one segment in the replace_all algorithm template< typename StorageT, typename InputT, typename ForwardIteratorT > inline ForwardIteratorT process_segment( StorageT& Storage, InputT& Input, ForwardIteratorT InsertIt, ForwardIteratorT SegmentBegin, ForwardIteratorT SegmentEnd ) { return process_segment_helper< has_stable_iterators<InputT>::value>()( Storage, Input, InsertIt, SegmentBegin, SegmentEnd ); } } // namespace detail } // namespace algorithm } // namespace boost #endif // BOOST_STRING_REPLACE_STORAGE_DETAIL_HPP PK��M�[ 濙�Y��Y��string/detail/finder.hppnu��[��// Boost string_algo library finder.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2006. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_FINDER_DETAIL_HPP #define BOOST_STRING_FINDER_DETAIL_HPP #include <boost/algorithm/string/config.hpp> #include <boost/algorithm/string/constants.hpp> #include <iterator> #include <boost/range/iterator_range_core.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/empty.hpp> #include <boost/range/as_literal.hpp> namespace boost { namespace algorithm { namespace detail { // find first functor -----------------------------------------------// // find a subsequence in the sequence ( functor ) /* Returns a pair <begin,end> marking the subsequence in the sequence. If the find fails, functor returns <End,End> / template<typename SearchIteratorT,typename PredicateT> struct first_finderF { typedef SearchIteratorT search_iterator_type; // Construction template< typename SearchT > first_finderF( const SearchT& Search, PredicateT Comp ) : m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {} first_finderF( search_iterator_type SearchBegin, search_iterator_type SearchEnd, PredicateT Comp ) : m_Search(SearchBegin, SearchEnd), m_Comp(Comp) {} // Operation template< typename ForwardIteratorT > iterator_range<ForwardIteratorT> operator()( ForwardIteratorT Begin, ForwardIteratorT End ) const { typedef iterator_range<ForwardIteratorT> result_type; typedef ForwardIteratorT input_iterator_type; // Outer loop for(input_iterator_type OuterIt=Begin; OuterIt!=End; ++OuterIt) { // Sanity check if( boost::empty(m_Search) ) return result_type( End, End ); input_iterator_type InnerIt=OuterIt; search_iterator_type SubstrIt=m_Search.begin(); for(; InnerIt!=End && SubstrIt!=m_Search.end(); ++InnerIt,++SubstrIt) { if( !( m_Comp(InnerIt,SubstrIt) ) ) break; } // Substring matching succeeded if ( SubstrIt==m_Search.end() ) return result_type( OuterIt, InnerIt ); } return result_type( End, End ); } private: iterator_range<search_iterator_type> m_Search; PredicateT m_Comp; }; // find last functor -----------------------------------------------// // find the last match a subsequence in the sequence ( functor ) / Returns a pair <begin,end> marking the subsequence in the sequence. If the find fails, returns <End,End> / template<typename SearchIteratorT, typename PredicateT> struct last_finderF { typedef SearchIteratorT search_iterator_type; typedef first_finderF< search_iterator_type, PredicateT> first_finder_type; // Construction template< typename SearchT > last_finderF( const SearchT& Search, PredicateT Comp ) : m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {} last_finderF( search_iterator_type SearchBegin, search_iterator_type SearchEnd, PredicateT Comp ) : m_Search(SearchBegin, SearchEnd), m_Comp(Comp) {} // Operation template< typename ForwardIteratorT > iterator_range<ForwardIteratorT> operator()( ForwardIteratorT Begin, ForwardIteratorT End ) const { typedef iterator_range<ForwardIteratorT> result_type; if( boost::empty(m_Search) ) return result_type( End, End ); typedef BOOST_STRING_TYPENAME std::iterator_traits<ForwardIteratorT>::iterator_category category; return findit( Begin, End, category() ); } private: // forward iterator template< typename ForwardIteratorT > iterator_range<ForwardIteratorT> findit( ForwardIteratorT Begin, ForwardIteratorT End, std::forward_iterator_tag ) const { typedef iterator_range<ForwardIteratorT> result_type; first_finder_type first_finder( m_Search.begin(), m_Search.end(), m_Comp ); result_type M=first_finder( Begin, End ); result_type Last=M; while( M ) { Last=M; M=first_finder( ::boost::end(M), End ); } return Last; } // bidirectional iterator template< typename ForwardIteratorT > iterator_range<ForwardIteratorT> findit( ForwardIteratorT Begin, ForwardIteratorT End, std::bidirectional_iterator_tag ) const { typedef iterator_range<ForwardIteratorT> result_type; typedef ForwardIteratorT input_iterator_type; // Outer loop for(input_iterator_type OuterIt=End; OuterIt!=Begin; ) { input_iterator_type OuterIt2=--OuterIt; input_iterator_type InnerIt=OuterIt2; search_iterator_type SubstrIt=m_Search.begin(); for(; InnerIt!=End && SubstrIt!=m_Search.end(); ++InnerIt,++SubstrIt) { if( !( m_Comp(InnerIt,SubstrIt) ) ) break; } // Substring matching succeeded if( SubstrIt==m_Search.end() ) return result_type( OuterIt2, InnerIt ); } return result_type( End, End ); } private: iterator_range<search_iterator_type> m_Search; PredicateT m_Comp; }; // find n-th functor -----------------------------------------------// // find the n-th match of a subsequence in the sequence ( functor ) / Returns a pair <begin,end> marking the subsequence in the sequence. If the find fails, returns <End,End> / template<typename SearchIteratorT, typename PredicateT> struct nth_finderF { typedef SearchIteratorT search_iterator_type; typedef first_finderF< search_iterator_type, PredicateT> first_finder_type; typedef last_finderF< search_iterator_type, PredicateT> last_finder_type; // Construction template< typename SearchT > nth_finderF( const SearchT& Search, int Nth, PredicateT Comp) : m_Search(::boost::begin(Search), ::boost::end(Search)), m_Nth(Nth), m_Comp(Comp) {} nth_finderF( search_iterator_type SearchBegin, search_iterator_type SearchEnd, int Nth, PredicateT Comp) : m_Search(SearchBegin, SearchEnd), m_Nth(Nth), m_Comp(Comp) {} // Operation template< typename ForwardIteratorT > iterator_range<ForwardIteratorT> operator()( ForwardIteratorT Begin, ForwardIteratorT End ) const { if(m_Nth>=0) { return find_forward(Begin, End, m_Nth); } else { return find_backward(Begin, End, -m_Nth); } } private: // Implementation helpers template< typename ForwardIteratorT > iterator_range<ForwardIteratorT> find_forward( ForwardIteratorT Begin, ForwardIteratorT End, unsigned int N) const { typedef iterator_range<ForwardIteratorT> result_type; // Sanity check if( boost::empty(m_Search) ) return result_type( End, End ); // Instantiate find functor first_finder_type first_finder( m_Search.begin(), m_Search.end(), m_Comp ); result_type M( Begin, Begin ); for( unsigned int n=0; n<=N; ++n ) { // find next match M=first_finder( ::boost::end(M), End ); if ( !M ) { // Subsequence not found, return return M; } } return M; } template< typename ForwardIteratorT > iterator_range<ForwardIteratorT> find_backward( ForwardIteratorT Begin, ForwardIteratorT End, unsigned int N) const { typedef iterator_range<ForwardIteratorT> result_type; // Sanity check if( boost::empty(m_Search) ) return result_type( End, End ); // Instantiate find functor last_finder_type last_finder( m_Search.begin(), m_Search.end(), m_Comp ); result_type M( End, End ); for( unsigned int n=1; n<=N; ++n ) { // find next match M=last_finder( Begin, ::boost::begin(M) ); if ( !M ) { // Subsequence not found, return return M; } } return M; } private: iterator_range<search_iterator_type> m_Search; int m_Nth; PredicateT m_Comp; }; // find head/tail implementation helpers ---------------------------// template<typename ForwardIteratorT> iterator_range<ForwardIteratorT> find_head_impl( ForwardIteratorT Begin, ForwardIteratorT End, unsigned int N, std::forward_iterator_tag ) { typedef ForwardIteratorT input_iterator_type; typedef iterator_range<ForwardIteratorT> result_type; input_iterator_type It=Begin; for( unsigned int Index=0; Index<N && It!=End; ++Index,++It ) ; return result_type( Begin, It ); } template< typename ForwardIteratorT > iterator_range<ForwardIteratorT> find_head_impl( ForwardIteratorT Begin, ForwardIteratorT End, unsigned int N, std::random_access_iterator_tag ) { typedef iterator_range<ForwardIteratorT> result_type; if ( (End<=Begin) \|\| ( static_cast<unsigned int>(End-Begin) < N ) ) return result_type( Begin, End ); return result_type(Begin,Begin+N); } // Find head implementation template<typename ForwardIteratorT> iterator_range<ForwardIteratorT> find_head_impl( ForwardIteratorT Begin, ForwardIteratorT End, unsigned int N ) { typedef BOOST_STRING_TYPENAME std::iterator_traits<ForwardIteratorT>::iterator_category category; return ::boost::algorithm::detail::find_head_impl( Begin, End, N, category() ); } template< typename ForwardIteratorT > iterator_range<ForwardIteratorT> find_tail_impl( ForwardIteratorT Begin, ForwardIteratorT End, unsigned int N, std::forward_iterator_tag ) { typedef ForwardIteratorT input_iterator_type; typedef iterator_range<ForwardIteratorT> result_type; unsigned int Index=0; input_iterator_type It=Begin; input_iterator_type It2=Begin; // Advance It2 by N increments for( Index=0; Index<N && It2!=End; ++Index,++It2 ) ; // Advance It, It2 to the end for(; It2!=End; ++It,++It2 ) ; return result_type( It, It2 ); } template< typename ForwardIteratorT > iterator_range<ForwardIteratorT> find_tail_impl( ForwardIteratorT Begin, ForwardIteratorT End, unsigned int N, std::bidirectional_iterator_tag ) { typedef ForwardIteratorT input_iterator_type; typedef iterator_range<ForwardIteratorT> result_type; input_iterator_type It=End; for( unsigned int Index=0; Index<N && It!=Begin; ++Index,--It ) ; return result_type( It, End ); } template< typename ForwardIteratorT > iterator_range<ForwardIteratorT> find_tail_impl( ForwardIteratorT Begin, ForwardIteratorT End, unsigned int N, std::random_access_iterator_tag ) { typedef iterator_range<ForwardIteratorT> result_type; if ( (End<=Begin) \|\| ( static_cast<unsigned int>(End-Begin) < N ) ) return result_type( Begin, End ); return result_type( End-N, End ); } // Operation template< typename ForwardIteratorT > iterator_range<ForwardIteratorT> find_tail_impl( ForwardIteratorT Begin, ForwardIteratorT End, unsigned int N ) { typedef BOOST_STRING_TYPENAME std::iterator_traits<ForwardIteratorT>::iterator_category category; return ::boost::algorithm::detail::find_tail_impl( Begin, End, N, category() ); } // find head functor -----------------------------------------------// // find a head in the sequence ( functor ) / This functor find a head of the specified range. For a specified N, the head is a subsequence of N starting elements of the range. / struct head_finderF { // Construction head_finderF( int N ) : m_N(N) {} // Operation template< typename ForwardIteratorT > iterator_range<ForwardIteratorT> operator()( ForwardIteratorT Begin, ForwardIteratorT End ) const { if(m_N>=0) { return ::boost::algorithm::detail::find_head_impl( Begin, End, m_N ); } else { iterator_range<ForwardIteratorT> Res= ::boost::algorithm::detail::find_tail_impl( Begin, End, -m_N ); return ::boost::make_iterator_range(Begin, Res.begin()); } } private: int m_N; }; // find tail functor -----------------------------------------------// // find a tail in the sequence ( functor ) / This functor find a tail of the specified range. For a specified N, the head is a subsequence of N starting elements of the range. / struct tail_finderF { // Construction tail_finderF( int N ) : m_N(N) {} // Operation template< typename ForwardIteratorT > iterator_range<ForwardIteratorT> operator()( ForwardIteratorT Begin, ForwardIteratorT End ) const { if(m_N>=0) { return ::boost::algorithm::detail::find_tail_impl( Begin, End, m_N ); } else { iterator_range<ForwardIteratorT> Res= ::boost::algorithm::detail::find_head_impl( Begin, End, -m_N ); return ::boost::make_iterator_range(Res.end(), End); } } private: int m_N; }; // find token functor -----------------------------------------------// // find a token in a sequence ( functor ) / This find functor finds a token specified be a predicate in a sequence. It is equivalent of std::find algorithm, with an exception that it return range instead of a single iterator. If bCompress is set to true, adjacent matching tokens are concatenated into one match. / template< typename PredicateT > struct token_finderF { // Construction token_finderF( PredicateT Pred, token_compress_mode_type eCompress=token_compress_off ) : m_Pred(Pred), m_eCompress(eCompress) {} // Operation template< typename ForwardIteratorT > iterator_range<ForwardIteratorT> operator()( ForwardIteratorT Begin, ForwardIteratorT End ) const { typedef iterator_range<ForwardIteratorT> result_type; ForwardIteratorT It=std::find_if( Begin, End, m_Pred ); if( It==End ) { return result_type( End, End ); } else { ForwardIteratorT It2=It; if( m_eCompress==token_compress_on ) { // Find first non-matching character while( It2!=End && m_Pred(It2) ) ++It2; } else { // Advance by one position ++It2; } return result_type( It, It2 ); } } private: PredicateT m_Pred; token_compress_mode_type m_eCompress; }; // find range functor -----------------------------------------------// // find a range in the sequence ( functor ) /* This functor actually does not perform any find operation. It always returns given iterator range as a result. / template<typename ForwardIterator1T> struct range_finderF { typedef ForwardIterator1T input_iterator_type; typedef iterator_range<input_iterator_type> result_type; // Construction range_finderF( input_iterator_type Begin, input_iterator_type End ) : m_Range(Begin, End) {} range_finderF(const iterator_range<input_iterator_type>& Range) : m_Range(Range) {} // Operation template< typename ForwardIterator2T > iterator_range<ForwardIterator2T> operator()( ForwardIterator2T, ForwardIterator2T ) const { #if BOOST_WORKAROUND( __MWERKS__, <= 0x3003 ) return iterator_range<const ForwardIterator2T>(this->m_Range); #else return m_Range; #endif } private: iterator_range<input_iterator_type> m_Range; }; } // namespace detail } // namespace algorithm } // namespace boost #endif // BOOST_STRING_FINDER_DETAIL_HPP PK��M�[;C�Wi��i��string/detail/sequence.hppnu��[��// Boost string_algo library sequence.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_DETAIL_SEQUENCE_HPP #define BOOST_STRING_DETAIL_SEQUENCE_HPP #include <boost/algorithm/string/config.hpp> #include <boost/mpl/bool.hpp> #include <boost/mpl/logical.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/algorithm/string/sequence_traits.hpp> namespace boost { namespace algorithm { namespace detail { // insert helpers -------------------------------------------------// template< typename InputT, typename ForwardIteratorT > inline void insert( InputT& Input, BOOST_STRING_TYPENAME InputT::iterator At, ForwardIteratorT Begin, ForwardIteratorT End ) { Input.insert( At, Begin, End ); } template< typename InputT, typename InsertT > inline void insert( InputT& Input, BOOST_STRING_TYPENAME InputT::iterator At, const InsertT& Insert ) { ::boost::algorithm::detail::insert( Input, At, ::boost::begin(Insert), ::boost::end(Insert) ); } // erase helper ---------------------------------------------------// // Erase a range in the sequence / Returns the iterator pointing just after the erase subrange / template< typename InputT > inline typename InputT::iterator erase( InputT& Input, BOOST_STRING_TYPENAME InputT::iterator From, BOOST_STRING_TYPENAME InputT::iterator To ) { return Input.erase( From, To ); } // replace helper implementation ----------------------------------// // Optimized version of replace for generic sequence containers // Assumption: insert and erase are expensive template< bool HasConstTimeOperations > struct replace_const_time_helper { template< typename InputT, typename ForwardIteratorT > void operator()( InputT& Input, BOOST_STRING_TYPENAME InputT::iterator From, BOOST_STRING_TYPENAME InputT::iterator To, ForwardIteratorT Begin, ForwardIteratorT End ) { // Copy data to the container ( as much as possible ) ForwardIteratorT InsertIt=Begin; BOOST_STRING_TYPENAME InputT::iterator InputIt=From; for(; InsertIt!=End && InputIt!=To; InsertIt++, InputIt++ ) { InputIt=InsertIt; } if ( InsertIt!=End ) { // Replace sequence is longer, insert it Input.insert( InputIt, InsertIt, End ); } else { if ( InputIt!=To ) { // Replace sequence is shorter, erase the rest Input.erase( InputIt, To ); } } } }; template<> struct replace_const_time_helper< true > { // Const-time erase and insert methods -> use them template< typename InputT, typename ForwardIteratorT > void operator()( InputT& Input, BOOST_STRING_TYPENAME InputT::iterator From, BOOST_STRING_TYPENAME InputT::iterator To, ForwardIteratorT Begin, ForwardIteratorT End ) { BOOST_STRING_TYPENAME InputT::iterator At=Input.erase( From, To ); if ( Begin!=End ) { if(!Input.empty()) { Input.insert( At, Begin, End ); } else { Input.insert( Input.begin(), Begin, End ); } } } }; // No native replace method template< bool HasNative > struct replace_native_helper { template< typename InputT, typename ForwardIteratorT > void operator()( InputT& Input, BOOST_STRING_TYPENAME InputT::iterator From, BOOST_STRING_TYPENAME InputT::iterator To, ForwardIteratorT Begin, ForwardIteratorT End ) { replace_const_time_helper< boost::mpl::and_< has_const_time_insert<InputT>, has_const_time_erase<InputT> >::value >()( Input, From, To, Begin, End ); } }; // Container has native replace method template<> struct replace_native_helper< true > { template< typename InputT, typename ForwardIteratorT > void operator()( InputT& Input, BOOST_STRING_TYPENAME InputT::iterator From, BOOST_STRING_TYPENAME InputT::iterator To, ForwardIteratorT Begin, ForwardIteratorT End ) { Input.replace( From, To, Begin, End ); } }; // replace helper -------------------------------------------------// template< typename InputT, typename ForwardIteratorT > inline void replace( InputT& Input, BOOST_STRING_TYPENAME InputT::iterator From, BOOST_STRING_TYPENAME InputT::iterator To, ForwardIteratorT Begin, ForwardIteratorT End ) { replace_native_helper< has_native_replace<InputT>::value >()( Input, From, To, Begin, End ); } template< typename InputT, typename InsertT > inline void replace( InputT& Input, BOOST_STRING_TYPENAME InputT::iterator From, BOOST_STRING_TYPENAME InputT::iterator To, const InsertT& Insert ) { if(From!=To) { ::boost::algorithm::detail::replace( Input, From, To, ::boost::begin(Insert), ::boost::end(Insert) ); } else { ::boost::algorithm::detail::insert( Input, From, ::boost::begin(Insert), ::boost::end(Insert) ); } } } // namespace detail } // namespace algorithm } // namespace boost #endif // BOOST_STRING_DETAIL_SEQUENCE_HPP PK��M�[u��string/detail/find_format.hppnu��[��// Boost string_algo library find_format.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_FIND_FORMAT_DETAIL_HPP #define BOOST_STRING_FIND_FORMAT_DETAIL_HPP #include <boost/algorithm/string/config.hpp> #include <boost/range/iterator_range_core.hpp> #include <boost/range/const_iterator.hpp> #include <boost/range/iterator.hpp> #include <boost/algorithm/string/detail/find_format_store.hpp> #include <boost/algorithm/string/detail/replace_storage.hpp> namespace boost { namespace algorithm { namespace detail { // find_format_copy (iterator variant) implementation -------------------------------// template< typename OutputIteratorT, typename InputT, typename FormatterT, typename FindResultT, typename FormatResultT > inline OutputIteratorT find_format_copy_impl2( OutputIteratorT Output, const InputT& Input, FormatterT Formatter, const FindResultT& FindResult, const FormatResultT& FormatResult ) { typedef find_format_store< BOOST_STRING_TYPENAME range_const_iterator<InputT>::type, FormatterT, FormatResultT > store_type; // Create store for the find result store_type M( FindResult, FormatResult, Formatter ); if ( !M ) { // Match not found - return original sequence Output = std::copy( ::boost::begin(Input), ::boost::end(Input), Output ); return Output; } // Copy the beginning of the sequence Output = std::copy( ::boost::begin(Input), ::boost::begin(M), Output ); // Format find result // Copy formatted result Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output ); // Copy the rest of the sequence Output = std::copy( M.end(), ::boost::end(Input), Output ); return Output; } template< typename OutputIteratorT, typename InputT, typename FormatterT, typename FindResultT > inline OutputIteratorT find_format_copy_impl( OutputIteratorT Output, const InputT& Input, FormatterT Formatter, const FindResultT& FindResult ) { if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) { return ::boost::algorithm::detail::find_format_copy_impl2( Output, Input, Formatter, FindResult, Formatter(FindResult) ); } else { return std::copy( ::boost::begin(Input), ::boost::end(Input), Output ); } } // find_format_copy implementation --------------------------------------------------// template< typename InputT, typename FormatterT, typename FindResultT, typename FormatResultT > inline InputT find_format_copy_impl2( const InputT& Input, FormatterT Formatter, const FindResultT& FindResult, const FormatResultT& FormatResult) { typedef find_format_store< BOOST_STRING_TYPENAME range_const_iterator<InputT>::type, FormatterT, FormatResultT > store_type; // Create store for the find result store_type M( FindResult, FormatResult, Formatter ); if ( !M ) { // Match not found - return original sequence return InputT( Input ); } InputT Output; // Copy the beginning of the sequence boost::algorithm::detail::insert( Output, ::boost::end(Output), ::boost::begin(Input), M.begin() ); // Copy formatted result boost::algorithm::detail::insert( Output, ::boost::end(Output), M.format_result() ); // Copy the rest of the sequence boost::algorithm::detail::insert( Output, ::boost::end(Output), M.end(), ::boost::end(Input) ); return Output; } template< typename InputT, typename FormatterT, typename FindResultT > inline InputT find_format_copy_impl( const InputT& Input, FormatterT Formatter, const FindResultT& FindResult) { if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) { return ::boost::algorithm::detail::find_format_copy_impl2( Input, Formatter, FindResult, Formatter(FindResult) ); } else { return Input; } } // replace implementation ----------------------------------------------------// template< typename InputT, typename FormatterT, typename FindResultT, typename FormatResultT > inline void find_format_impl2( InputT& Input, FormatterT Formatter, const FindResultT& FindResult, const FormatResultT& FormatResult) { typedef find_format_store< BOOST_STRING_TYPENAME range_iterator<InputT>::type, FormatterT, FormatResultT > store_type; // Create store for the find result store_type M( FindResult, FormatResult, Formatter ); if ( !M ) { // Search not found - return original sequence return; } // Replace match ::boost::algorithm::detail::replace( Input, M.begin(), M.end(), M.format_result() ); } template< typename InputT, typename FormatterT, typename FindResultT > inline void find_format_impl( InputT& Input, FormatterT Formatter, const FindResultT& FindResult) { if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) { ::boost::algorithm::detail::find_format_impl2( Input, Formatter, FindResult, Formatter(FindResult) ); } } } // namespace detail } // namespace algorithm } // namespace boost #endif // BOOST_STRING_FIND_FORMAT_DETAIL_HPP PK��M�[T��4� �� string/detail/predicate.hppnu��[��// Boost string_algo library predicate.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_PREDICATE_DETAIL_HPP #define BOOST_STRING_PREDICATE_DETAIL_HPP #include <iterator> #include <boost/algorithm/string/find.hpp> namespace boost { namespace algorithm { namespace detail { // ends_with predicate implementation ----------------------------------// template< typename ForwardIterator1T, typename ForwardIterator2T, typename PredicateT> inline bool ends_with_iter_select( ForwardIterator1T Begin, ForwardIterator1T End, ForwardIterator2T SubBegin, ForwardIterator2T SubEnd, PredicateT Comp, std::bidirectional_iterator_tag) { ForwardIterator1T it=End; ForwardIterator2T pit=SubEnd; for(;it!=Begin && pit!=SubBegin;) { if( !(Comp((--it),(--pit))) ) return false; } return pit==SubBegin; } template< typename ForwardIterator1T, typename ForwardIterator2T, typename PredicateT> inline bool ends_with_iter_select( ForwardIterator1T Begin, ForwardIterator1T End, ForwardIterator2T SubBegin, ForwardIterator2T SubEnd, PredicateT Comp, std::forward_iterator_tag) { if ( SubBegin==SubEnd ) { // empty subsequence check return true; } iterator_range<ForwardIterator1T> Result =last_finder( ::boost::make_iterator_range(SubBegin, SubEnd), Comp)(Begin, End); return !Result.empty() && Result.end()==End; } } // namespace detail } // namespace algorithm } // namespace boost #endif // BOOST_STRING_PREDICATE_DETAIL_HPP PK��M�[ư�� string/detail/find_iterator.hppnu��[��// Boost string_algo library find_iterator.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_FIND_ITERATOR_DETAIL_HPP #define BOOST_STRING_FIND_ITERATOR_DETAIL_HPP #include <boost/algorithm/string/config.hpp> #include <boost/range/iterator_range_core.hpp> #include <boost/iterator/iterator_facade.hpp> #include <boost/iterator/iterator_categories.hpp> #include <boost/function.hpp> namespace boost { namespace algorithm { namespace detail { // find_iterator base -----------------------------------------------// // Find iterator base template<typename IteratorT> class find_iterator_base { protected: // typedefs typedef IteratorT input_iterator_type; typedef iterator_range<IteratorT> match_type; typedef function2< match_type, input_iterator_type, input_iterator_type> finder_type; protected: // Protected construction/destruction // Default constructor find_iterator_base() {} // Copy construction find_iterator_base( const find_iterator_base& Other ) : m_Finder(Other.m_Finder) {} // Constructor template<typename FinderT> find_iterator_base( FinderT Finder, int ) : m_Finder(Finder) {} // Destructor ~find_iterator_base() {} // Find operation match_type do_find( input_iterator_type Begin, input_iterator_type End ) const { if (!m_Finder.empty()) { return m_Finder(Begin,End); } else { return match_type(End,End); } } // Check bool is_null() const { return m_Finder.empty(); } private: // Finder finder_type m_Finder; }; } // namespace detail } // namespace algorithm } // namespace boost #endif // BOOST_STRING_FIND_ITERATOR_DETAIL_HPP PK��M�[1�i� �� string/detail/util.hppnu��[��// Boost string_algo library util.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_UTIL_DETAIL_HPP #define BOOST_STRING_UTIL_DETAIL_HPP #include <boost/algorithm/string/config.hpp> #include <functional> #include <boost/range/iterator_range_core.hpp> namespace boost { namespace algorithm { namespace detail { // empty container -----------------------------------------------// // empty_container / This class represents always empty container, containing elements of type CharT. It is supposed to be used in a const version only / template< typename CharT > struct empty_container { typedef empty_container<CharT> type; typedef CharT value_type; typedef std::size_t size_type; typedef std::ptrdiff_t difference_type; typedef const value_type& reference; typedef const value_type& const_reference; typedef const value_type iterator; typedef const value_type* const_iterator; // Operations const_iterator begin() const { return reinterpret_cast<const_iterator>(0); } const_iterator end() const { return reinterpret_cast<const_iterator>(0); } bool empty() const { return false; } size_type size() const { return 0; } }; // bounded copy algorithm -----------------------------------------------// // Bounded version of the std::copy algorithm template<typename InputIteratorT, typename OutputIteratorT> inline OutputIteratorT bounded_copy( InputIteratorT First, InputIteratorT Last, OutputIteratorT DestFirst, OutputIteratorT DestLast ) { InputIteratorT InputIt=First; OutputIteratorT OutputIt=DestFirst; for(; InputIt!=Last && OutputIt!=DestLast; InputIt++, OutputIt++ ) { OutputIt=InputIt; } return OutputIt; } // iterator range utilities -----------------------------------------// // copy range functor template< typename SeqT, typename IteratorT=BOOST_STRING_TYPENAME SeqT::const_iterator > struct copy_iterator_rangeF { typedef iterator_range<IteratorT> argument_type; typedef SeqT result_type; SeqT operator()( const iterator_range<IteratorT>& Range ) const { return copy_range<SeqT>(Range); } }; } // namespace detail } // namespace algorithm } // namespace boost #endif // BOOST_STRING_UTIL_DETAIL_HPP PK��M�[� �5��string/detail/finder_regex.hppnu��[��// Boost string_algo library find_regex.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_FINDER_REGEX_DETAIL_HPP #define BOOST_STRING_FINDER_REGEX_DETAIL_HPP #include <boost/algorithm/string/config.hpp> #include <boost/regex.hpp> #include <boost/range/iterator_range_core.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> namespace boost { namespace algorithm { namespace detail { // regex find functor -----------------------------------------------// // regex search result template<typename IteratorT> struct regex_search_result : public iterator_range<IteratorT> { typedef regex_search_result<IteratorT> type; typedef iterator_range<IteratorT> base_type; typedef BOOST_STRING_TYPENAME base_type::value_type value_type; typedef BOOST_STRING_TYPENAME base_type::difference_type difference_type; typedef BOOST_STRING_TYPENAME base_type::const_iterator const_iterator; typedef BOOST_STRING_TYPENAME base_type::iterator iterator; typedef boost::match_results<iterator> match_results_type; // Construction // Construction from the match result regex_search_result( const match_results_type& MatchResults ) : base_type( MatchResults[0].first, MatchResults[0].second ), m_MatchResults( MatchResults ) {} // Construction of empty match. End iterator has to be specified regex_search_result( IteratorT End ) : base_type( End, End ) {} regex_search_result( const regex_search_result& Other ) : base_type( Other.begin(), Other.end() ), m_MatchResults( Other.m_MatchResults ) {} // Assignment regex_search_result& operator=( const regex_search_result& Other ) { base_type::operator=( Other ); m_MatchResults=Other.m_MatchResults; return this; } // Match result retrieval const match_results_type& match_results() const { return m_MatchResults; } private: // Saved match result match_results_type m_MatchResults; }; // find_regex / Regex based search functor / template<typename RegExT> struct find_regexF { typedef RegExT regex_type; typedef const RegExT& regex_reference_type; // Construction find_regexF( regex_reference_type Rx, match_flag_type MatchFlags = match_default ) : m_Rx(Rx), m_MatchFlags(MatchFlags) {} // Operation template< typename ForwardIteratorT > regex_search_result<ForwardIteratorT> operator()( ForwardIteratorT Begin, ForwardIteratorT End ) const { typedef ForwardIteratorT input_iterator_type; typedef regex_search_result<ForwardIteratorT> result_type; // instantiate match result match_results<input_iterator_type> result; // search for a match if ( ::boost::regex_search( Begin, End, result, m_Rx, m_MatchFlags ) ) { // construct a result return result_type( result ); } else { // empty result return result_type( End ); } } private: regex_reference_type m_Rx; // Regexp match_flag_type m_MatchFlags; // match flags }; } // namespace detail } // namespace algorithm } // namespace boost #endif // BOOST_STRING_FIND_DETAIL_HPP PK��M�[z��t0��t0�� string/detail/classification.hppnu��[��// Boost string_algo library classification.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_CLASSIFICATION_DETAIL_HPP #define BOOST_STRING_CLASSIFICATION_DETAIL_HPP #include <boost/algorithm/string/config.hpp> #include <algorithm> #include <cstring> #include <functional> #include <locale> #include <boost/range/begin.hpp> #include <boost/range/distance.hpp> #include <boost/range/end.hpp> #include <boost/algorithm/string/predicate_facade.hpp> #include <boost/type_traits/remove_const.hpp> namespace boost { namespace algorithm { namespace detail { // classification functors -----------------------------------------------// // is_classified functor struct is_classifiedF : public predicate_facade<is_classifiedF> { // Boost.ResultOf support typedef bool result_type; // Constructor from a locale is_classifiedF(std::ctype_base::mask Type, std::locale const & Loc = std::locale()) : m_Type(Type), m_Locale(Loc) {} // Operation template<typename CharT> bool operator()( CharT Ch ) const { return std::use_facet< std::ctype<CharT> >(m_Locale).is( m_Type, Ch ); } #if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x582) && !defined(_USE_OLD_RW_STL) template<> bool operator()( char const Ch ) const { return std::use_facet< std::ctype<char> >(m_Locale).is( m_Type, Ch ); } #endif private: std::ctype_base::mask m_Type; std::locale m_Locale; }; // is_any_of functor / returns true if the value is from the specified set / template<typename CharT> struct is_any_ofF : public predicate_facade<is_any_ofF<CharT> > { private: // set cannot operate on const value-type typedef typename ::boost::remove_const<CharT>::type set_value_type; public: // Boost.ResultOf support typedef bool result_type; // Constructor template<typename RangeT> is_any_ofF( const RangeT& Range ) : m_Size(0) { // Prepare storage m_Storage.m_dynSet=0; std::size_t Size=::boost::distance(Range); m_Size=Size; set_value_type Storage=0; if(use_fixed_storage(m_Size)) { // Use fixed storage Storage=&m_Storage.m_fixSet[0]; } else { // Use dynamic storage m_Storage.m_dynSet=new set_value_type[m_Size]; Storage=m_Storage.m_dynSet; } // Use fixed storage ::std::copy(::boost::begin(Range), ::boost::end(Range), Storage); ::std::sort(Storage, Storage+m_Size); } // Copy constructor is_any_ofF(const is_any_ofF& Other) : m_Size(Other.m_Size) { // Prepare storage m_Storage.m_dynSet=0; const set_value_type* SrcStorage=0; set_value_type* DestStorage=0; if(use_fixed_storage(m_Size)) { // Use fixed storage DestStorage=&m_Storage.m_fixSet[0]; SrcStorage=&Other.m_Storage.m_fixSet[0]; } else { // Use dynamic storage m_Storage.m_dynSet=new set_value_type[m_Size]; DestStorage=m_Storage.m_dynSet; SrcStorage=Other.m_Storage.m_dynSet; } // Use fixed storage ::std::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)m_Size); } // Destructor ~is_any_ofF() { if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0) { delete [] m_Storage.m_dynSet; } } // Assignment is_any_ofF& operator=(const is_any_ofF& Other) { // Handle self assignment if(this==&Other) return this; // Prepare storage const set_value_type* SrcStorage; set_value_type* DestStorage; if(use_fixed_storage(Other.m_Size)) { // Use fixed storage DestStorage=&m_Storage.m_fixSet[0]; SrcStorage=&Other.m_Storage.m_fixSet[0]; // Delete old storage if was present if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0) { delete [] m_Storage.m_dynSet; } // Set new size m_Size=Other.m_Size; } else { // Other uses dynamic storage SrcStorage=Other.m_Storage.m_dynSet; // Check what kind of storage are we using right now if(use_fixed_storage(m_Size)) { // Using fixed storage, allocate new set_value_type* pTemp=new set_value_type[Other.m_Size]; DestStorage=pTemp; m_Storage.m_dynSet=pTemp; m_Size=Other.m_Size; } else { // Using dynamic storage, check if can reuse if(m_Storage.m_dynSet!=0 && m_Size>=Other.m_Size && m_Size<Other.m_Size2) { // Reuse the current storage DestStorage=m_Storage.m_dynSet; m_Size=Other.m_Size; } else { // Allocate the new one set_value_type pTemp=new set_value_type[Other.m_Size]; DestStorage=pTemp; // Delete old storage if necessary if(m_Storage.m_dynSet!=0) { delete [] m_Storage.m_dynSet; } // Store the new storage m_Storage.m_dynSet=pTemp; // Set new size m_Size=Other.m_Size; } } } // Copy the data ::std::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)m_Size); return this; } // Operation template<typename Char2T> bool operator()( Char2T Ch ) const { const set_value_type* Storage= (use_fixed_storage(m_Size)) ? &m_Storage.m_fixSet[0] : m_Storage.m_dynSet; return ::std::binary_search(Storage, Storage+m_Size, Ch); } private: // check if the size is eligible for fixed storage static bool use_fixed_storage(std::size_t size) { return size<=sizeof(set_value_type)2; } private: // storage // The actual used storage is selected on the type union { set_value_type* m_dynSet; set_value_type m_fixSet[sizeof(set_value_type)2]; } m_Storage; // storage size ::std::size_t m_Size; }; // is_from_range functor /* returns true if the value is from the specified range. (i.e. x>=From && x>=To) / template<typename CharT> struct is_from_rangeF : public predicate_facade< is_from_rangeF<CharT> > { // Boost.ResultOf support typedef bool result_type; // Constructor is_from_rangeF( CharT From, CharT To ) : m_From(From), m_To(To) {} // Operation template<typename Char2T> bool operator()( Char2T Ch ) const { return ( m_From <= Ch ) && ( Ch <= m_To ); } private: CharT m_From; CharT m_To; }; // class_and composition predicate template<typename Pred1T, typename Pred2T> struct pred_andF : public predicate_facade< pred_andF<Pred1T,Pred2T> > { public: // Boost.ResultOf support typedef bool result_type; // Constructor pred_andF( Pred1T Pred1, Pred2T Pred2 ) : m_Pred1(Pred1), m_Pred2(Pred2) {} // Operation template<typename CharT> bool operator()( CharT Ch ) const { return m_Pred1(Ch) && m_Pred2(Ch); } private: Pred1T m_Pred1; Pred2T m_Pred2; }; // class_or composition predicate template<typename Pred1T, typename Pred2T> struct pred_orF : public predicate_facade< pred_orF<Pred1T,Pred2T> > { public: // Boost.ResultOf support typedef bool result_type; // Constructor pred_orF( Pred1T Pred1, Pred2T Pred2 ) : m_Pred1(Pred1), m_Pred2(Pred2) {} // Operation template<typename CharT> bool operator()( CharT Ch ) const { return m_Pred1(Ch) \|\| m_Pred2(Ch); } private: Pred1T m_Pred1; Pred2T m_Pred2; }; // class_not composition predicate template< typename PredT > struct pred_notF : public predicate_facade< pred_notF<PredT> > { public: // Boost.ResultOf support typedef bool result_type; // Constructor pred_notF( PredT Pred ) : m_Pred(Pred) {} // Operation template<typename CharT> bool operator()( CharT Ch ) const { return !m_Pred(Ch); } private: PredT m_Pred; }; } // namespace detail } // namespace algorithm } // namespace boost #endif // BOOST_STRING_CLASSIFICATION_DETAIL_HPP PK��M�[}4\|��!��string/detail/formatter_regex.hppnu��[��// Boost string_algo library formatter_regex.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_FORMATTER_REGEX_DETAIL_HPP #define BOOST_STRING_FORMATTER_REGEX_DETAIL_HPP #include <boost/algorithm/string/config.hpp> #include <string> #include <boost/regex.hpp> #include <boost/algorithm/string/detail/finder_regex.hpp> namespace boost { namespace algorithm { namespace detail { // regex format functor -----------------------------------------// // regex format functor template<typename StringT> struct regex_formatF { private: typedef StringT result_type; typedef BOOST_STRING_TYPENAME StringT::value_type char_type; public: // Construction regex_formatF( const StringT& Fmt, match_flag_type Flags=format_default ) : m_Fmt(Fmt), m_Flags( Flags ) {} template<typename InputIteratorT> result_type operator()( const regex_search_result<InputIteratorT>& Replace ) const { if ( Replace.empty() ) { return result_type(); } else { return Replace.match_results().format( m_Fmt, m_Flags ); } } private: const StringT& m_Fmt; match_flag_type m_Flags; }; } // namespace detail } // namespace algorithm } // namespace boost #endif // BOOST_STRING_FORMATTER_DETAIL_HPP PK��M�[:,��.(��.(��!��string/detail/find_format_all.hppnu��[��// Boost string_algo library find_format_all.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_FIND_FORMAT_ALL_DETAIL_HPP #define BOOST_STRING_FIND_FORMAT_ALL_DETAIL_HPP #include <boost/algorithm/string/config.hpp> #include <boost/range/iterator_range_core.hpp> #include <boost/range/const_iterator.hpp> #include <boost/range/value_type.hpp> #include <boost/algorithm/string/detail/find_format_store.hpp> #include <boost/algorithm/string/detail/replace_storage.hpp> #include <deque> namespace boost { namespace algorithm { namespace detail { // find_format_all_copy (iterator variant) implementation ---------------------------// template< typename OutputIteratorT, typename InputT, typename FinderT, typename FormatterT, typename FindResultT, typename FormatResultT > inline OutputIteratorT find_format_all_copy_impl2( OutputIteratorT Output, const InputT& Input, FinderT Finder, FormatterT Formatter, const FindResultT& FindResult, const FormatResultT& FormatResult ) { typedef BOOST_STRING_TYPENAME range_const_iterator<InputT>::type input_iterator_type; typedef find_format_store< input_iterator_type, FormatterT, FormatResultT > store_type; // Create store for the find result store_type M( FindResult, FormatResult, Formatter ); // Initialize last match input_iterator_type LastMatch=::boost::begin(Input); // Iterate through all matches while( M ) { // Copy the beginning of the sequence Output = std::copy( LastMatch, M.begin(), Output ); // Copy formatted result Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output ); // Proceed to the next match LastMatch=M.end(); M=Finder( LastMatch, ::boost::end(Input) ); } // Copy the rest of the sequence Output = std::copy( LastMatch, ::boost::end(Input), Output ); return Output; } template< typename OutputIteratorT, typename InputT, typename FinderT, typename FormatterT, typename FindResultT > inline OutputIteratorT find_format_all_copy_impl( OutputIteratorT Output, const InputT& Input, FinderT Finder, FormatterT Formatter, const FindResultT& FindResult ) { if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) { return ::boost::algorithm::detail::find_format_all_copy_impl2( Output, Input, Finder, Formatter, FindResult, Formatter(FindResult) ); } else { return std::copy( ::boost::begin(Input), ::boost::end(Input), Output ); } } // find_format_all_copy implementation ----------------------------------------------// template< typename InputT, typename FinderT, typename FormatterT, typename FindResultT, typename FormatResultT > inline InputT find_format_all_copy_impl2( const InputT& Input, FinderT Finder, FormatterT Formatter, const FindResultT& FindResult, const FormatResultT& FormatResult) { typedef BOOST_STRING_TYPENAME range_const_iterator<InputT>::type input_iterator_type; typedef find_format_store< input_iterator_type, FormatterT, FormatResultT > store_type; // Create store for the find result store_type M( FindResult, FormatResult, Formatter ); // Initialize last match input_iterator_type LastMatch=::boost::begin(Input); // Output temporary InputT Output; // Iterate through all matches while( M ) { // Copy the beginning of the sequence boost::algorithm::detail::insert( Output, ::boost::end(Output), LastMatch, M.begin() ); // Copy formatted result boost::algorithm::detail::insert( Output, ::boost::end(Output), M.format_result() ); // Proceed to the next match LastMatch=M.end(); M=Finder( LastMatch, ::boost::end(Input) ); } // Copy the rest of the sequence ::boost::algorithm::detail::insert( Output, ::boost::end(Output), LastMatch, ::boost::end(Input) ); return Output; } template< typename InputT, typename FinderT, typename FormatterT, typename FindResultT > inline InputT find_format_all_copy_impl( const InputT& Input, FinderT Finder, FormatterT Formatter, const FindResultT& FindResult) { if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) { return ::boost::algorithm::detail::find_format_all_copy_impl2( Input, Finder, Formatter, FindResult, Formatter(FindResult) ); } else { return Input; } } // find_format_all implementation ------------------------------------------------// template< typename InputT, typename FinderT, typename FormatterT, typename FindResultT, typename FormatResultT > inline void find_format_all_impl2( InputT& Input, FinderT Finder, FormatterT Formatter, FindResultT FindResult, FormatResultT FormatResult) { typedef BOOST_STRING_TYPENAME range_iterator<InputT>::type input_iterator_type; typedef find_format_store< input_iterator_type, FormatterT, FormatResultT > store_type; // Create store for the find result store_type M( FindResult, FormatResult, Formatter ); // Instantiate replacement storage std::deque< BOOST_STRING_TYPENAME range_value<InputT>::type> Storage; // Initialize replacement iterators input_iterator_type InsertIt=::boost::begin(Input); input_iterator_type SearchIt=::boost::begin(Input); while( M ) { // process the segment InsertIt=process_segment( Storage, Input, InsertIt, SearchIt, M.begin() ); // Adjust search iterator SearchIt=M.end(); // Copy formatted replace to the storage ::boost::algorithm::detail::copy_to_storage( Storage, M.format_result() ); // Find range for a next match M=Finder( SearchIt, ::boost::end(Input) ); } // process the last segment InsertIt=::boost::algorithm::detail::process_segment( Storage, Input, InsertIt, SearchIt, ::boost::end(Input) ); if ( Storage.empty() ) { // Truncate input ::boost::algorithm::detail::erase( Input, InsertIt, ::boost::end(Input) ); } else { // Copy remaining data to the end of input ::boost::algorithm::detail::insert( Input, ::boost::end(Input), Storage.begin(), Storage.end() ); } } template< typename InputT, typename FinderT, typename FormatterT, typename FindResultT > inline void find_format_all_impl( InputT& Input, FinderT Finder, FormatterT Formatter, FindResultT FindResult) { if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) { ::boost::algorithm::detail::find_format_all_impl2( Input, Finder, Formatter, FindResult, Formatter(FindResult) ); } } } // namespace detail } // namespace algorithm } // namespace boost #endif // BOOST_STRING_FIND_FORMAT_ALL_DETAIL_HPP PK��M�[��;��C��C��string/predicate.hppnu��[��// Boost string_algo library predicate.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_PREDICATE_HPP #define BOOST_STRING_PREDICATE_HPP #include <iterator> #include <boost/algorithm/string/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/iterator.hpp> #include <boost/range/const_iterator.hpp> #include <boost/range/as_literal.hpp> #include <boost/range/iterator_range_core.hpp> #include <boost/algorithm/string/compare.hpp> #include <boost/algorithm/string/find.hpp> #include <boost/algorithm/string/detail/predicate.hpp> /! \file boost/algorithm/string/predicate.hpp Defines string-related predicates. The predicates determine whether a substring is contained in the input string under various conditions: a string starts with the substring, ends with the substring, simply contains the substring or if both strings are equal. Additionaly the algorithm \c all() checks all elements of a container to satisfy a condition. All predicates provide the strong exception guarantee. / namespace boost { namespace algorithm { // starts_with predicate -----------------------------------------------// //! 'Starts with' predicate /! This predicate holds when the test string is a prefix of the Input. In other words, if the input starts with the test. When the optional predicate is specified, it is used for character-wise comparison. \param Input An input sequence \param Test A test sequence \param Comp An element comparison predicate \return The result of the test \note This function provides the strong exception-safety guarantee / template<typename Range1T, typename Range2T, typename PredicateT> inline bool starts_with( const Range1T& Input, const Range2T& Test, PredicateT Comp) { iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input)); iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test)); typedef BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type Iterator1T; typedef BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type Iterator2T; Iterator1T InputEnd=::boost::end(lit_input); Iterator2T TestEnd=::boost::end(lit_test); Iterator1T it=::boost::begin(lit_input); Iterator2T pit=::boost::begin(lit_test); for(; it!=InputEnd && pit!=TestEnd; ++it,++pit) { if( !(Comp(it,pit)) ) return false; } return pit==TestEnd; } //! 'Starts with' predicate /! \overload / template<typename Range1T, typename Range2T> inline bool starts_with( const Range1T& Input, const Range2T& Test) { return ::boost::algorithm::starts_with(Input, Test, is_equal()); } //! 'Starts with' predicate ( case insensitive ) /! This predicate holds when the test string is a prefix of the Input. In other words, if the input starts with the test. Elements are compared case insensitively. \param Input An input sequence \param Test A test sequence \param Loc A locale used for case insensitive comparison \return The result of the test \note This function provides the strong exception-safety guarantee / template<typename Range1T, typename Range2T> inline bool istarts_with( const Range1T& Input, const Range2T& Test, const std::locale& Loc=std::locale()) { return ::boost::algorithm::starts_with(Input, Test, is_iequal(Loc)); } // ends_with predicate -----------------------------------------------// //! 'Ends with' predicate /! This predicate holds when the test string is a suffix of the Input. In other words, if the input ends with the test. When the optional predicate is specified, it is used for character-wise comparison. \param Input An input sequence \param Test A test sequence \param Comp An element comparison predicate \return The result of the test \note This function provides the strong exception-safety guarantee / template<typename Range1T, typename Range2T, typename PredicateT> inline bool ends_with( const Range1T& Input, const Range2T& Test, PredicateT Comp) { iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input)); iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test)); typedef BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type Iterator1T; typedef BOOST_STRING_TYPENAME std::iterator_traits<Iterator1T>::iterator_category category; return detail:: ends_with_iter_select( ::boost::begin(lit_input), ::boost::end(lit_input), ::boost::begin(lit_test), ::boost::end(lit_test), Comp, category()); } //! 'Ends with' predicate /! \overload / template<typename Range1T, typename Range2T> inline bool ends_with( const Range1T& Input, const Range2T& Test) { return ::boost::algorithm::ends_with(Input, Test, is_equal()); } //! 'Ends with' predicate ( case insensitive ) /! This predicate holds when the test container is a suffix of the Input. In other words, if the input ends with the test. Elements are compared case insensitively. \param Input An input sequence \param Test A test sequence \param Loc A locale used for case insensitive comparison \return The result of the test \note This function provides the strong exception-safety guarantee / template<typename Range1T, typename Range2T> inline bool iends_with( const Range1T& Input, const Range2T& Test, const std::locale& Loc=std::locale()) { return ::boost::algorithm::ends_with(Input, Test, is_iequal(Loc)); } // contains predicate -----------------------------------------------// //! 'Contains' predicate /! This predicate holds when the test container is contained in the Input. When the optional predicate is specified, it is used for character-wise comparison. \param Input An input sequence \param Test A test sequence \param Comp An element comparison predicate \return The result of the test \note This function provides the strong exception-safety guarantee / template<typename Range1T, typename Range2T, typename PredicateT> inline bool contains( const Range1T& Input, const Range2T& Test, PredicateT Comp) { iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input)); iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test)); if (::boost::empty(lit_test)) { // Empty range is contained always return true; } // Use the temporary variable to make VACPP happy bool bResult=(::boost::algorithm::first_finder(lit_test,Comp)(::boost::begin(lit_input), ::boost::end(lit_input))); return bResult; } //! 'Contains' predicate /! \overload / template<typename Range1T, typename Range2T> inline bool contains( const Range1T& Input, const Range2T& Test) { return ::boost::algorithm::contains(Input, Test, is_equal()); } //! 'Contains' predicate ( case insensitive ) /! This predicate holds when the test container is contained in the Input. Elements are compared case insensitively. \param Input An input sequence \param Test A test sequence \param Loc A locale used for case insensitive comparison \return The result of the test \note This function provides the strong exception-safety guarantee / template<typename Range1T, typename Range2T> inline bool icontains( const Range1T& Input, const Range2T& Test, const std::locale& Loc=std::locale()) { return ::boost::algorithm::contains(Input, Test, is_iequal(Loc)); } // equals predicate -----------------------------------------------// //! 'Equals' predicate /! This predicate holds when the test container is equal to the input container i.e. all elements in both containers are same. When the optional predicate is specified, it is used for character-wise comparison. \param Input An input sequence \param Test A test sequence \param Comp An element comparison predicate \return The result of the test \note This is a two-way version of \c std::equal algorithm \note This function provides the strong exception-safety guarantee / template<typename Range1T, typename Range2T, typename PredicateT> inline bool equals( const Range1T& Input, const Range2T& Test, PredicateT Comp) { iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input)); iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test)); typedef BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type Iterator1T; typedef BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type Iterator2T; Iterator1T InputEnd=::boost::end(lit_input); Iterator2T TestEnd=::boost::end(lit_test); Iterator1T it=::boost::begin(lit_input); Iterator2T pit=::boost::begin(lit_test); for(; it!=InputEnd && pit!=TestEnd; ++it,++pit) { if( !(Comp(it,pit)) ) return false; } return (pit==TestEnd) && (it==InputEnd); } //! 'Equals' predicate /! \overload / template<typename Range1T, typename Range2T> inline bool equals( const Range1T& Input, const Range2T& Test) { return ::boost::algorithm::equals(Input, Test, is_equal()); } //! 'Equals' predicate ( case insensitive ) /! This predicate holds when the test container is equal to the input container i.e. all elements in both containers are same. Elements are compared case insensitively. \param Input An input sequence \param Test A test sequence \param Loc A locale used for case insensitive comparison \return The result of the test \note This is a two-way version of \c std::equal algorithm \note This function provides the strong exception-safety guarantee / template<typename Range1T, typename Range2T> inline bool iequals( const Range1T& Input, const Range2T& Test, const std::locale& Loc=std::locale()) { return ::boost::algorithm::equals(Input, Test, is_iequal(Loc)); } // lexicographical_compare predicate -----------------------------// //! Lexicographical compare predicate /! This predicate is an overload of std::lexicographical_compare for range arguments It check whether the first argument is lexicographically less then the second one. If the optional predicate is specified, it is used for character-wise comparison \param Arg1 First argument \param Arg2 Second argument \param Pred Comparison predicate \return The result of the test \note This function provides the strong exception-safety guarantee / template<typename Range1T, typename Range2T, typename PredicateT> inline bool lexicographical_compare( const Range1T& Arg1, const Range2T& Arg2, PredicateT Pred) { iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_arg1(::boost::as_literal(Arg1)); iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_arg2(::boost::as_literal(Arg2)); return std::lexicographical_compare( ::boost::begin(lit_arg1), ::boost::end(lit_arg1), ::boost::begin(lit_arg2), ::boost::end(lit_arg2), Pred); } //! Lexicographical compare predicate /! \overload / template<typename Range1T, typename Range2T> inline bool lexicographical_compare( const Range1T& Arg1, const Range2T& Arg2) { return ::boost::algorithm::lexicographical_compare(Arg1, Arg2, is_less()); } //! Lexicographical compare predicate (case-insensitive) /! This predicate is an overload of std::lexicographical_compare for range arguments. It check whether the first argument is lexicographically less then the second one. Elements are compared case insensitively \param Arg1 First argument \param Arg2 Second argument \param Loc A locale used for case insensitive comparison \return The result of the test \note This function provides the strong exception-safety guarantee / template<typename Range1T, typename Range2T> inline bool ilexicographical_compare( const Range1T& Arg1, const Range2T& Arg2, const std::locale& Loc=std::locale()) { return ::boost::algorithm::lexicographical_compare(Arg1, Arg2, is_iless(Loc)); } // all predicate -----------------------------------------------// //! 'All' predicate /! This predicate holds it all its elements satisfy a given condition, represented by the predicate. \param Input An input sequence \param Pred A predicate \return The result of the test \note This function provides the strong exception-safety guarantee / template<typename RangeT, typename PredicateT> inline bool all( const RangeT& Input, PredicateT Pred) { iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input)); typedef BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type Iterator1T; Iterator1T InputEnd=::boost::end(lit_input); for( Iterator1T It=::boost::begin(lit_input); It!=InputEnd; ++It) { if (!Pred(It)) return false; } return true; } } // namespace algorithm // pull names to the boost namespace using algorithm::starts_with; using algorithm::istarts_with; using algorithm::ends_with; using algorithm::iends_with; using algorithm::contains; using algorithm::icontains; using algorithm::equals; using algorithm::iequals; using algorithm::all; using algorithm::lexicographical_compare; using algorithm::ilexicographical_compare; } // namespace boost #endif // BOOST_STRING_PREDICATE_HPP PK��M�[z��G�/��/��string/find_iterator.hppnu��[��// Boost string_algo library find_iterator.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2004. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_FIND_ITERATOR_HPP #define BOOST_STRING_FIND_ITERATOR_HPP #include <boost/algorithm/string/config.hpp> #include <boost/iterator/iterator_facade.hpp> #include <boost/iterator/iterator_categories.hpp> #include <boost/range/iterator_range_core.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/iterator.hpp> #include <boost/range/as_literal.hpp> #include <boost/algorithm/string/detail/find_iterator.hpp> /! \file Defines find iterator classes. Find iterator repeatedly applies a Finder to the specified input string to search for matches. Dereferencing the iterator yields the current match or a range between the last and the current match depending on the iterator used. / namespace boost { namespace algorithm { // find_iterator -----------------------------------------------// //! find_iterator /! Find iterator encapsulates a Finder and allows for incremental searching in a string. Each increment moves the iterator to the next match. Find iterator is a readable forward traversal iterator. Dereferencing the iterator yields an iterator_range delimiting the current match. / template<typename IteratorT> class find_iterator : public iterator_facade< find_iterator<IteratorT>, const iterator_range<IteratorT>, forward_traversal_tag >, private detail::find_iterator_base<IteratorT> { private: // facade support friend class ::boost::iterator_core_access; private: // typedefs typedef detail::find_iterator_base<IteratorT> base_type; typedef BOOST_STRING_TYPENAME base_type::input_iterator_type input_iterator_type; typedef BOOST_STRING_TYPENAME base_type::match_type match_type; public: //! Default constructor /! Construct null iterator. All null iterators are equal. \post eof()==true / find_iterator() {} //! Copy constructor /! Construct a copy of the find_iterator / find_iterator( const find_iterator& Other ) : base_type(Other), m_Match(Other.m_Match), m_End(Other.m_End) {} //! Constructor /! Construct new find_iterator for a given finder and a range. / template<typename FinderT> find_iterator( IteratorT Begin, IteratorT End, FinderT Finder ) : detail::find_iterator_base<IteratorT>(Finder,0), m_Match(Begin,Begin), m_End(End) { increment(); } //! Constructor /! Construct new find_iterator for a given finder and a range. / template<typename FinderT, typename RangeT> find_iterator( RangeT& Col, FinderT Finder ) : detail::find_iterator_base<IteratorT>(Finder,0) { iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_col(::boost::as_literal(Col)); m_Match=::boost::make_iterator_range(::boost::begin(lit_col), ::boost::begin(lit_col)); m_End=::boost::end(lit_col); increment(); } private: // iterator operations // dereference const match_type& dereference() const { return m_Match; } // increment void increment() { m_Match=this->do_find(m_Match.end(),m_End); } // comparison bool equal( const find_iterator& Other ) const { bool bEof=eof(); bool bOtherEof=Other.eof(); return bEof \|\| bOtherEof ? bEof==bOtherEof : ( m_Match==Other.m_Match && m_End==Other.m_End ); } public: // operations //! Eof check /! Check the eof condition. Eof condition means that there is nothing more to be searched i.e. find_iterator is after the last match. / bool eof() const { return this->is_null() \|\| ( m_Match.begin() == m_End && m_Match.end() == m_End ); } private: // Attributes match_type m_Match; input_iterator_type m_End; }; //! find iterator construction helper /! Construct a find iterator to iterate through the specified string / template<typename RangeT, typename FinderT> inline find_iterator< BOOST_STRING_TYPENAME range_iterator<RangeT>::type> make_find_iterator( RangeT& Collection, FinderT Finder) { return find_iterator<BOOST_STRING_TYPENAME range_iterator<RangeT>::type>( Collection, Finder); } // split iterator -----------------------------------------------// //! split_iterator /! Split iterator encapsulates a Finder and allows for incremental searching in a string. Unlike the find iterator, split iterator iterates through gaps between matches. Find iterator is a readable forward traversal iterator. Dereferencing the iterator yields an iterator_range delimiting the current match. / template<typename IteratorT> class split_iterator : public iterator_facade< split_iterator<IteratorT>, const iterator_range<IteratorT>, forward_traversal_tag >, private detail::find_iterator_base<IteratorT> { private: // facade support friend class ::boost::iterator_core_access; private: // typedefs typedef detail::find_iterator_base<IteratorT> base_type; typedef BOOST_STRING_TYPENAME base_type::input_iterator_type input_iterator_type; typedef BOOST_STRING_TYPENAME base_type::match_type match_type; public: //! Default constructor /! Construct null iterator. All null iterators are equal. \post eof()==true / split_iterator() : m_Next(), m_End(), m_bEof(true) {} //! Copy constructor /! Construct a copy of the split_iterator / split_iterator( const split_iterator& Other ) : base_type(Other), m_Match(Other.m_Match), m_Next(Other.m_Next), m_End(Other.m_End), m_bEof(Other.m_bEof) {} //! Constructor /! Construct new split_iterator for a given finder and a range. / template<typename FinderT> split_iterator( IteratorT Begin, IteratorT End, FinderT Finder ) : detail::find_iterator_base<IteratorT>(Finder,0), m_Match(Begin,Begin), m_Next(Begin), m_End(End), m_bEof(false) { // force the correct behavior for empty sequences and yield at least one token if(Begin!=End) { increment(); } } //! Constructor /! Construct new split_iterator for a given finder and a collection. / template<typename FinderT, typename RangeT> split_iterator( RangeT& Col, FinderT Finder ) : detail::find_iterator_base<IteratorT>(Finder,0), m_bEof(false) { iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_col(::boost::as_literal(Col)); m_Match=make_iterator_range(::boost::begin(lit_col), ::boost::begin(lit_col)); m_Next=::boost::begin(lit_col); m_End=::boost::end(lit_col); // force the correct behavior for empty sequences and yield at least one token if(m_Next!=m_End) { increment(); } } private: // iterator operations // dereference const match_type& dereference() const { return m_Match; } // increment void increment() { match_type FindMatch=this->do_find( m_Next, m_End ); if(FindMatch.begin()==m_End && FindMatch.end()==m_End) { if(m_Match.end()==m_End) { // Mark iterator as eof m_bEof=true; } } m_Match=match_type( m_Next, FindMatch.begin() ); m_Next=FindMatch.end(); } // comparison bool equal( const split_iterator& Other ) const { bool bEof=eof(); bool bOtherEof=Other.eof(); return bEof \|\| bOtherEof ? bEof==bOtherEof : ( m_Match==Other.m_Match && m_Next==Other.m_Next && m_End==Other.m_End ); } public: // operations //! Eof check /! Check the eof condition. Eof condition means that there is nothing more to be searched i.e. find_iterator is after the last match. / bool eof() const { return this->is_null() \|\| m_bEof; } private: // Attributes match_type m_Match; input_iterator_type m_Next; input_iterator_type m_End; bool m_bEof; }; //! split iterator construction helper /! * Construct a split iterator to iterate through the specified collection / template<typename RangeT, typename FinderT> inline split_iterator< BOOST_STRING_TYPENAME range_iterator<RangeT>::type> make_split_iterator( RangeT& Collection, FinderT Finder) { return split_iterator<BOOST_STRING_TYPENAME range_iterator<RangeT>::type>( Collection, Finder); } } // namespace algorithm // pull names to the boost namespace using algorithm::find_iterator; using algorithm::make_find_iterator; using algorithm::split_iterator; using algorithm::make_split_iterator; } // namespace boost #endif // BOOST_STRING_FIND_ITERATOR_HPP PK��M�[e �I��string/join.hppnu��[��// Boost string_algo library join.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2006. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_JOIN_HPP #define BOOST_STRING_JOIN_HPP #include <boost/algorithm/string/config.hpp> #include <boost/algorithm/string/detail/sequence.hpp> #include <boost/range/value_type.hpp> #include <boost/range/as_literal.hpp> /! \file Defines join algorithm. Join algorithm is a counterpart to split algorithms. It joins strings from a 'list' by adding user defined separator. Additionally there is a version that allows simple filtering by providing a predicate. / namespace boost { namespace algorithm { // join --------------------------------------------------------------// //! Join algorithm /! This algorithm joins all strings in a 'list' into one long string. Segments are concatenated by given separator. \param Input A container that holds the input strings. It must be a container-of-containers. \param Separator A string that will separate the joined segments. \return Concatenated string. \note This function provides the strong exception-safety guarantee / template< typename SequenceSequenceT, typename Range1T> inline typename range_value<SequenceSequenceT>::type join( const SequenceSequenceT& Input, const Range1T& Separator) { // Define working types typedef typename range_value<SequenceSequenceT>::type ResultT; typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT; // Parse input InputIteratorT itBegin=::boost::begin(Input); InputIteratorT itEnd=::boost::end(Input); // Construct container to hold the result ResultT Result; // Append first element if(itBegin!=itEnd) { detail::insert(Result, ::boost::end(Result), itBegin); ++itBegin; } for(;itBegin!=itEnd; ++itBegin) { // Add separator detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator)); // Add element detail::insert(Result, ::boost::end(Result), itBegin); } return Result; } // join_if ----------------------------------------------------------// //! Conditional join algorithm /! This algorithm joins all strings in a 'list' into one long string. Segments are concatenated by given separator. Only segments that satisfy the predicate will be added to the result. \param Input A container that holds the input strings. It must be a container-of-containers. \param Separator A string that will separate the joined segments. \param Pred A segment selection predicate \return Concatenated string. \note This function provides the strong exception-safety guarantee / template< typename SequenceSequenceT, typename Range1T, typename PredicateT> inline typename range_value<SequenceSequenceT>::type join_if( const SequenceSequenceT& Input, const Range1T& Separator, PredicateT Pred) { // Define working types typedef typename range_value<SequenceSequenceT>::type ResultT; typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT; // Parse input InputIteratorT itBegin=::boost::begin(Input); InputIteratorT itEnd=::boost::end(Input); // Construct container to hold the result ResultT Result; // Roll to the first element that will be added while(itBegin!=itEnd && !Pred(itBegin)) ++itBegin; // Add this element if(itBegin!=itEnd) { detail::insert(Result, ::boost::end(Result), itBegin); ++itBegin; } for(;itBegin!=itEnd; ++itBegin) { if(Pred(itBegin)) { // Add separator detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator)); // Add element detail::insert(Result, ::boost::end(Result), itBegin); } } return Result; } } // namespace algorithm // pull names to the boost namespace using algorithm::join; using algorithm::join_if; } // namespace boost #endif // BOOST_STRING_JOIN_HPP PK��M�[�6�z-��z-��string/classification.hppnu��[��// Boost string_algo library classification.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_CLASSIFICATION_HPP #define BOOST_STRING_CLASSIFICATION_HPP #include <algorithm> #include <locale> #include <boost/range/value_type.hpp> #include <boost/range/as_literal.hpp> #include <boost/algorithm/string/detail/classification.hpp> #include <boost/algorithm/string/predicate_facade.hpp> /! \file Classification predicates are included in the library to give some more convenience when using algorithms like \c trim() and \c all(). They wrap functionality of STL classification functions ( e.g. \c std::isspace() ) into generic functors. / namespace boost { namespace algorithm { // classification functor generator -------------------------------------// //! is_classified predicate /! Construct the \c is_classified predicate. This predicate holds if the input is of specified \c std::ctype category. \param Type A \c std::ctype category \param Loc A locale used for classification \return An instance of the \c is_classified predicate / inline detail::is_classifiedF is_classified(std::ctype_base::mask Type, const std::locale& Loc=std::locale()) { return detail::is_classifiedF(Type, Loc); } //! is_space predicate /! Construct the \c is_classified predicate for the \c ctype_base::space category. \param Loc A locale used for classification \return An instance of the \c is_classified predicate / inline detail::is_classifiedF is_space(const std::locale& Loc=std::locale()) { return detail::is_classifiedF(std::ctype_base::space, Loc); } //! is_alnum predicate /! Construct the \c is_classified predicate for the \c ctype_base::alnum category. \param Loc A locale used for classification \return An instance of the \c is_classified predicate / inline detail::is_classifiedF is_alnum(const std::locale& Loc=std::locale()) { return detail::is_classifiedF(std::ctype_base::alnum, Loc); } //! is_alpha predicate /! Construct the \c is_classified predicate for the \c ctype_base::alpha category. \param Loc A locale used for classification \return An instance of the \c is_classified predicate / inline detail::is_classifiedF is_alpha(const std::locale& Loc=std::locale()) { return detail::is_classifiedF(std::ctype_base::alpha, Loc); } //! is_cntrl predicate /! Construct the \c is_classified predicate for the \c ctype_base::cntrl category. \param Loc A locale used for classification \return An instance of the \c is_classified predicate / inline detail::is_classifiedF is_cntrl(const std::locale& Loc=std::locale()) { return detail::is_classifiedF(std::ctype_base::cntrl, Loc); } //! is_digit predicate /! Construct the \c is_classified predicate for the \c ctype_base::digit category. \param Loc A locale used for classification \return An instance of the \c is_classified predicate / inline detail::is_classifiedF is_digit(const std::locale& Loc=std::locale()) { return detail::is_classifiedF(std::ctype_base::digit, Loc); } //! is_graph predicate /! Construct the \c is_classified predicate for the \c ctype_base::graph category. \param Loc A locale used for classification \return An instance of the \c is_classified predicate / inline detail::is_classifiedF is_graph(const std::locale& Loc=std::locale()) { return detail::is_classifiedF(std::ctype_base::graph, Loc); } //! is_lower predicate /! Construct the \c is_classified predicate for the \c ctype_base::lower category. \param Loc A locale used for classification \return An instance of \c is_classified predicate / inline detail::is_classifiedF is_lower(const std::locale& Loc=std::locale()) { return detail::is_classifiedF(std::ctype_base::lower, Loc); } //! is_print predicate /! Construct the \c is_classified predicate for the \c ctype_base::print category. \param Loc A locale used for classification \return An instance of the \c is_classified predicate / inline detail::is_classifiedF is_print(const std::locale& Loc=std::locale()) { return detail::is_classifiedF(std::ctype_base::print, Loc); } //! is_punct predicate /! Construct the \c is_classified predicate for the \c ctype_base::punct category. \param Loc A locale used for classification \return An instance of the \c is_classified predicate / inline detail::is_classifiedF is_punct(const std::locale& Loc=std::locale()) { return detail::is_classifiedF(std::ctype_base::punct, Loc); } //! is_upper predicate /! Construct the \c is_classified predicate for the \c ctype_base::upper category. \param Loc A locale used for classification \return An instance of the \c is_classified predicate / inline detail::is_classifiedF is_upper(const std::locale& Loc=std::locale()) { return detail::is_classifiedF(std::ctype_base::upper, Loc); } //! is_xdigit predicate /! Construct the \c is_classified predicate for the \c ctype_base::xdigit category. \param Loc A locale used for classification \return An instance of the \c is_classified predicate / inline detail::is_classifiedF is_xdigit(const std::locale& Loc=std::locale()) { return detail::is_classifiedF(std::ctype_base::xdigit, Loc); } //! is_any_of predicate /! Construct the \c is_any_of predicate. The predicate holds if the input is included in the specified set of characters. \param Set A set of characters to be recognized \return An instance of the \c is_any_of predicate / template<typename RangeT> inline detail::is_any_ofF< BOOST_STRING_TYPENAME range_value<RangeT>::type> is_any_of( const RangeT& Set ) { iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_set(boost::as_literal(Set)); return detail::is_any_ofF<BOOST_STRING_TYPENAME range_value<RangeT>::type>(lit_set); } //! is_from_range predicate /! Construct the \c is_from_range predicate. The predicate holds if the input is included in the specified range. (i.e. From <= Ch <= To ) \param From The start of the range \param To The end of the range \return An instance of the \c is_from_range predicate / template<typename CharT> inline detail::is_from_rangeF<CharT> is_from_range(CharT From, CharT To) { return detail::is_from_rangeF<CharT>(From,To); } // predicate combinators ---------------------------------------------------// //! predicate 'and' composition predicate /! Construct the \c class_and predicate. This predicate can be used to logically combine two classification predicates. \c class_and holds, if both predicates return true. \param Pred1 The first predicate \param Pred2 The second predicate \return An instance of the \c class_and predicate / template<typename Pred1T, typename Pred2T> inline detail::pred_andF<Pred1T, Pred2T> operator&&( const predicate_facade<Pred1T>& Pred1, const predicate_facade<Pred2T>& Pred2 ) { // Doing the static_cast with the pointer instead of the reference // is a workaround for some compilers which have problems with // static_cast's of template references, i.e. CW8. /grafik/ return detail::pred_andF<Pred1T,Pred2T>( static_cast<const Pred1T>(&Pred1), static_cast<const Pred2T>(&Pred2) ); } //! predicate 'or' composition predicate /! Construct the \c class_or predicate. This predicate can be used to logically combine two classification predicates. \c class_or holds, if one of the predicates return true. \param Pred1 The first predicate \param Pred2 The second predicate \return An instance of the \c class_or predicate / template<typename Pred1T, typename Pred2T> inline detail::pred_orF<Pred1T, Pred2T> operator\|\|( const predicate_facade<Pred1T>& Pred1, const predicate_facade<Pred2T>& Pred2 ) { // Doing the static_cast with the pointer instead of the reference // is a workaround for some compilers which have problems with // static_cast's of template references, i.e. CW8. /grafik/ return detail::pred_orF<Pred1T,Pred2T>( static_cast<const Pred1T>(&Pred1), static_cast<const Pred2T>(&Pred2)); } //! predicate negation operator /! Construct the \c class_not predicate. This predicate represents a negation. \c class_or holds if of the predicates return false. \param Pred The predicate to be negated \return An instance of the \c class_not predicate / template<typename PredT> inline detail::pred_notF<PredT> operator!( const predicate_facade<PredT>& Pred ) { // Doing the static_cast with the pointer instead of the reference // is a workaround for some compilers which have problems with // static_cast's of template references, i.e. CW8. /grafik/ return detail::pred_notF<PredT>(static_cast<const PredT>(&Pred)); } } // namespace algorithm // pull names to the boost namespace using algorithm::is_classified; using algorithm::is_space; using algorithm::is_alnum; using algorithm::is_alpha; using algorithm::is_cntrl; using algorithm::is_digit; using algorithm::is_graph; using algorithm::is_lower; using algorithm::is_upper; using algorithm::is_print; using algorithm::is_punct; using algorithm::is_xdigit; using algorithm::is_any_of; using algorithm::is_from_range; } // namespace boost #endif // BOOST_STRING_PREDICATE_HPP PK��M�[[\Y>��string/constants.hppnu��[��// Boost string_algo library constants.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2003. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_CONSTANTS_HPP #define BOOST_STRING_CONSTANTS_HPP namespace boost { namespace algorithm { //! Token compression mode /! Specifies token compression mode for the token_finder. / enum token_compress_mode_type { token_compress_on, //!< Compress adjacent tokens token_compress_off //!< Do not compress adjacent tokens }; } // namespace algorithm // pull the names to the boost namespace using algorithm::token_compress_on; using algorithm::token_compress_off; } // namespace boost #endif // BOOST_STRING_CONSTANTS_HPP PK��M�[��string/compare.hppnu��[��// Boost string_algo library compare.hpp header file -------------------------// // Copyright Pavol Droba 2002-2006. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_COMPARE_HPP #define BOOST_STRING_COMPARE_HPP #include <boost/algorithm/string/config.hpp> #include <locale> /! \file Defines element comparison predicates. Many algorithms in this library can take an additional argument with a predicate used to compare elements. This makes it possible, for instance, to have case insensitive versions of the algorithms. / namespace boost { namespace algorithm { // is_equal functor -----------------------------------------------// //! is_equal functor /! Standard STL equal_to only handle comparison between arguments of the same type. This is a less restrictive version which wraps operator ==. / struct is_equal { //! Function operator /! Compare two operands for equality / template< typename T1, typename T2 > bool operator()( const T1& Arg1, const T2& Arg2 ) const { return Arg1==Arg2; } }; //! case insensitive version of is_equal /! Case insensitive comparison predicate. Comparison is done using specified locales. / struct is_iequal { //! Constructor /! \param Loc locales used for comparison / is_iequal( const std::locale& Loc=std::locale() ) : m_Loc( Loc ) {} //! Function operator /! Compare two operands. Case is ignored. / template< typename T1, typename T2 > bool operator()( const T1& Arg1, const T2& Arg2 ) const { #if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL) return std::toupper(Arg1)==std::toupper(Arg2); #else return std::toupper<T1>(Arg1,m_Loc)==std::toupper<T2>(Arg2,m_Loc); #endif } private: std::locale m_Loc; }; // is_less functor -----------------------------------------------// //! is_less functor /! Convenient version of standard std::less. Operation is templated, therefore it is not required to specify the exact types upon the construction / struct is_less { //! Functor operation /! Compare two operands using > operator / template< typename T1, typename T2 > bool operator()( const T1& Arg1, const T2& Arg2 ) const { return Arg1<Arg2; } }; //! case insensitive version of is_less /! Case insensitive comparison predicate. Comparison is done using specified locales. / struct is_iless { //! Constructor /! \param Loc locales used for comparison / is_iless( const std::locale& Loc=std::locale() ) : m_Loc( Loc ) {} //! Function operator /! Compare two operands. Case is ignored. / template< typename T1, typename T2 > bool operator()( const T1& Arg1, const T2& Arg2 ) const { #if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL) return std::toupper(Arg1)<std::toupper(Arg2); #else return std::toupper<T1>(Arg1,m_Loc)<std::toupper<T2>(Arg2,m_Loc); #endif } private: std::locale m_Loc; }; // is_not_greater functor -----------------------------------------------// //! is_not_greater functor /! Convenient version of standard std::not_greater_to. Operation is templated, therefore it is not required to specify the exact types upon the construction / struct is_not_greater { //! Functor operation /! Compare two operands using > operator / template< typename T1, typename T2 > bool operator()( const T1& Arg1, const T2& Arg2 ) const { return Arg1<=Arg2; } }; //! case insensitive version of is_not_greater /! Case insensitive comparison predicate. Comparison is done using specified locales. / struct is_not_igreater { //! Constructor /! \param Loc locales used for comparison / is_not_igreater( const std::locale& Loc=std::locale() ) : m_Loc( Loc ) {} //! Function operator /! Compare two operands. Case is ignored. / template< typename T1, typename T2 > bool operator()( const T1& Arg1, const T2& Arg2 ) const { #if defined(BOOST_BORLANDC) && (BOOST_BORLANDC >= 0x560) && (BOOST_BORLANDC <= 0x564) && !defined(_USE_OLD_RW_STL) return std::toupper(Arg1)<=std::toupper(Arg2); #else return std::toupper<T1>(Arg1,m_Loc)<=std::toupper<T2>(Arg2,m_Loc); #endif } private: std::locale m_Loc; }; } // namespace algorithm // pull names to the boost namespace using algorithm::is_equal; using algorithm::is_iequal; using algorithm::is_less; using algorithm::is_iless; using algorithm::is_not_greater; using algorithm::is_not_igreater; } // namespace boost #endif // BOOST_STRING_COMPARE_HPP PK��M�[ұ�@��@��cxx17/transform_reduce.hppnu��[��/ Copyright (c) Marshall Clow 2017. 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) / /// \file transform_reduce.hpp /// \brief Combine the (transformed) elements of a sequence (or two) into a single value. /// \author Marshall Clow #ifndef BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP #define BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP #include <functional> // for std::plus #include <iterator> // for std::iterator_traits #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/value_type.hpp> namespace boost { namespace algorithm { template<class InputIterator1, class InputIterator2, class T, class BinaryOperation1, class BinaryOperation2> T transform_reduce(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, T init, BinaryOperation1 bOp1, BinaryOperation2 bOp2) { for (; first1 != last1; ++first1, (void) ++first2) init = bOp1(init, bOp2(first1, first2)); return init; } template<class InputIterator, class T, class BinaryOperation, class UnaryOperation> T transform_reduce(InputIterator first, InputIterator last, T init, BinaryOperation bOp, UnaryOperation uOp) { for (; first != last; ++first) init = bOp(init, uOp(first)); return init; } template<class InputIterator1, class InputIterator2, class T> T transform_reduce(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, T init) { return boost::algorithm::transform_reduce(first1, last1, first2, init, std::plus<T>(), std::multiplies<T>()); } }} // namespace boost and algorithm #endif // BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP PK��M�[��cxx17/inclusive_scan.hppnu��[��/* Copyright (c) Marshall Clow 2017. 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) / /// \file transform_reduce.hpp /// \brief Combine the (transformed) elements of a sequence (or two) into a single value. /// \author Marshall Clow #ifndef BOOST_ALGORITHM_INCLUSIVE_SCAN_HPP #define BOOST_ALGORITHM_INCLUSIVE_SCAN_HPP #include <functional> // for std::plus #include <iterator> // for std::iterator_traits #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/value_type.hpp> namespace boost { namespace algorithm { template<class InputIterator, class OutputIterator, class T, class BinaryOperation> OutputIterator inclusive_scan(InputIterator first, InputIterator last, OutputIterator result, BinaryOperation bOp, T init) { for (; first != last; ++first, (void) ++result) { init = bOp(init, first); result = init; } return result; } template<class InputIterator, class OutputIterator, class BinaryOperation> OutputIterator inclusive_scan(InputIterator first, InputIterator last, OutputIterator result, BinaryOperation bOp) { if (first != last) { typename std::iterator_traits<InputIterator>::value_type init = first; result++ = init; if (++first != last) return boost::algorithm::inclusive_scan(first, last, result, bOp, init); } return result; } template<class InputIterator, class OutputIterator> OutputIterator inclusive_scan(InputIterator first, InputIterator last, OutputIterator result) { typedef typename std::iterator_traits<InputIterator>::value_type VT; return boost::algorithm::inclusive_scan(first, last, result, std::plus<VT>()); } }} // namespace boost and algorithm #endif // BOOST_ALGORITHM_INCLUSIVE_SCAN_HPP PK��M�['1� ��cxx17/exclusive_scan.hppnu��[��/ Copyright (c) Marshall Clow 2017. 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) / /// \file exclusive_scan.hpp /// \brief ??? /// \author Marshall Clow #ifndef BOOST_ALGORITHM_EXCLUSIVE_SCAN_HPP #define BOOST_ALGORITHM_EXCLUSIVE_SCAN_HPP #include <functional> // for std::plus #include <iterator> // for std::iterator_traits #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/value_type.hpp> namespace boost { namespace algorithm { template<class InputIterator, class OutputIterator, class T, class BinaryOperation> OutputIterator exclusive_scan(InputIterator first, InputIterator last, OutputIterator result, T init, BinaryOperation bOp) { if (first != last) { T saved = init; do { init = bOp(init, first); result = saved; saved = init; ++result; } while (++first != last); } return result; } template<class InputIterator, class OutputIterator, class T> OutputIterator exclusive_scan(InputIterator first, InputIterator last, OutputIterator result, T init) { typedef typename std::iterator_traits<InputIterator>::value_type VT; return boost::algorithm::exclusive_scan(first, last, result, init, std::plus<VT>()); } }} // namespace boost and algorithm #endif // BOOST_ALGORITHM_EXCLUSIVE_SCAN_HPP PK��M�[�#s�U��U��cxx17/for_each_n.hppnu��[��/ Copyright (c) Marshall Clow 2017. 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) / /// \file for_each_n.hpp /// \brief Apply a functor to the elements of a sequence /// \author Marshall Clow #ifndef BOOST_ALGORITHM_FOR_EACH_N_HPP #define BOOST_ALGORITHM_FOR_EACH_N_HPP #include <utility> // for std::pair #include <boost/config.hpp> namespace boost { namespace algorithm { /// \fn for_each_n(InputIterator first, Size n, Function f); /// \return first + n /// /// \param first The start of the first range. /// \param n One past the end of the first range. /// \param f A functor to apply to the elements of the sequence /// \note If f returns a result, the result is ignored. template<class InputIterator, class Size, class Function> InputIterator for_each_n(InputIterator first, Size n, Function f) { for ( ; n > 0; --n, ++first ) f(first); return first; } }} // namespace boost and algorithm #endif // BOOST_ALGORITHM_FOR_EACH_N_HPP PK��M�[.� <��"��cxx17/transform_inclusive_scan.hppnu��[��/* Copyright (c) Marshall Clow 2017. 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) / /// \file transform_reduce.hpp /// \brief Combine the (transformed) elements of a sequence (or two) into a single value. /// \author Marshall Clow #ifndef BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP #define BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP #include <functional> // for std::plus #include <iterator> // for std::iterator_traits #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/value_type.hpp> namespace boost { namespace algorithm { template<class InputIterator, class OutputIterator, class BinaryOperation, class UnaryOperation, class T> OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last, OutputIterator result, BinaryOperation bOp, UnaryOperation uOp, T init) { for (; first != last; ++first, (void) ++result) { init = bOp(init, uOp(first)); result = init; } return result; } template<class InputIterator, class OutputIterator, class BinaryOperation, class UnaryOperation> OutputIterator transform_inclusive_scan(InputIterator first, InputIterator last, OutputIterator result, BinaryOperation bOp, UnaryOperation uOp) { if (first != last) { typename std::iterator_traits<InputIterator>::value_type init = uOp(first); result++ = init; if (++first != last) return boost::algorithm::transform_inclusive_scan (first, last, result, bOp, uOp, init); } return result; } }} // namespace boost and algorithm #endif // BOOST_ALGORITHM_TRANSFORM_REDUCE_HPP PK��M�[��fN �� cxx17/reduce.hppnu��[��/ Copyright (c) Marshall Clow 2017. 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) / /// \file reduce.hpp /// \brief Combine the elements of a sequence into a single value /// \author Marshall Clow #ifndef BOOST_ALGORITHM_REDUCE_HPP #define BOOST_ALGORITHM_REDUCE_HPP #include <functional> // for std::plus #include <iterator> // for std::iterator_traits #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/value_type.hpp> namespace boost { namespace algorithm { template<class InputIterator, class T, class BinaryOperation> T reduce(InputIterator first, InputIterator last, T init, BinaryOperation bOp) { ; for (; first != last; ++first) init = bOp(init, first); return init; } template<class InputIterator, class T> T reduce(InputIterator first, InputIterator last, T init) { typedef typename std::iterator_traits<InputIterator>::value_type VT; return boost::algorithm::reduce(first, last, init, std::plus<VT>()); } template<class InputIterator> typename std::iterator_traits<InputIterator>::value_type reduce(InputIterator first, InputIterator last) { return boost::algorithm::reduce(first, last, typename std::iterator_traits<InputIterator>::value_type()); } template<class Range> typename boost::range_value<Range>::type reduce(const Range &r) { return boost::algorithm::reduce(boost::begin(r), boost::end(r)); } // Not sure that this won't be ambiguous (1) template<class Range, class T> T reduce(const Range &r, T init) { return boost::algorithm::reduce(boost::begin (r), boost::end (r), init); } // Not sure that this won't be ambiguous (2) template<class Range, class T, class BinaryOperation> T reduce(const Range &r, T init, BinaryOperation bOp) { return boost::algorithm::reduce(boost::begin(r), boost::end(r), init, bOp); } }} // namespace boost and algorithm #endif // BOOST_ALGORITHM_REDUCE_HPP PK��M�[H�-"M��M��"��cxx17/transform_exclusive_scan.hppnu��[��/* Copyright (c) Marshall Clow 2017. 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) / /// \file transform_exclusive_scan.hpp /// \brief ???? /// \author Marshall Clow #ifndef BOOST_ALGORITHM_TRANSFORM_EXCLUSIVE_SCAN_HPP #define BOOST_ALGORITHM_TRANSFORM_EXCLUSIVE_SCAN_HPP #include <functional> // for std::plus #include <iterator> // for std::iterator_traits #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/value_type.hpp> namespace boost { namespace algorithm { template<class InputIterator, class OutputIterator, class T, class BinaryOperation, class UnaryOperation> OutputIterator transform_exclusive_scan(InputIterator first, InputIterator last, OutputIterator result, T init, BinaryOperation bOp, UnaryOperation uOp) { if (first != last) { T saved = init; do { init = bOp(init, uOp(first)); result = saved; saved = init; ++result; } while (++first != last); } return result; } }} // namespace boost and algorithm #endif // BOOST_ALGORITHM_TRANSFORM_EXCLUSIVE_SCAN_HPP PK��M�[<�C�B3��B3��hex.hppnu��[��/ 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. / /// \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/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/exception/exception.hpp> #include <boost/exception/info.hpp> #include <boost/throw_exception.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 char hexDigits ) { 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 = hexDigits [ val & 0x0F ]; return std::copy ( res, res + num_hex_digits, out ); } template <typename T> unsigned char hex_char_to_int ( T val ) { char c = static_cast<char> ( val ); unsigned retval = 0; if ( c >= '0' && c <= '9' ) retval = c - '0'; else if ( c >= 'A' && c <= 'F' ) retval = c - 'A' + 10; else if ( c >= 'a' && c <= 'f' ) retval = c - 'a' + 10; else BOOST_THROW_EXCEPTION (non_hex_input() << bad_char (c)); return static_cast<char>(retval); } // 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 (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, "0123456789ABCDEF" ); return out; } /// \fn hex_lower ( InputIterator first, InputIterator last, OutputIterator out ) /// \brief Converts a sequence of integral types into a lower case 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_lower ( InputIterator first, InputIterator last, OutputIterator out ) { for ( ; first != last; ++first ) out = detail::encode_one ( first, out, "0123456789abcdef" ); 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, "0123456789ABCDEF" ); return out; } /// \fn hex_lower ( const T ptr, OutputIterator out ) /// \brief Converts a sequence of integral types into a lower case 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_lower ( const T ptr, OutputIterator out ) { while ( ptr ) out = detail::encode_one ( ptr++, out, "0123456789abcdef" ); 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 hex_lower ( const Range &r, OutputIterator out ) /// \brief Converts a sequence of integral types into a lower case 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_lower ( const Range &r, OutputIterator out ) { return hex_lower (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 ) { // 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 hex_lower ( const String &input ) /// \brief Converts a sequence of integral types into a lower case hexadecimal sequence of characters. /// /// \param input A container to be converted /// \return A container with the encoded text template<typename String> String hex_lower ( const String &input ) { String output; output.reserve (input.size () * (2 * sizeof (typename String::value_type))); (void) hex_lower (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 PK��M�[�Ƹ%��%�� string.hppnu��[��// Boost string_algo library string_algo.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2004. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_ALGO_HPP #define BOOST_STRING_ALGO_HPP /! \file Cumulative include for string_algo library / #include <boost/algorithm/string/std_containers_traits.hpp> #include <boost/algorithm/string/trim.hpp> #include <boost/algorithm/string/case_conv.hpp> #include <boost/algorithm/string/predicate.hpp> #include <boost/algorithm/string/find.hpp> #include <boost/algorithm/string/split.hpp> #include <boost/algorithm/string/join.hpp> #include <boost/algorithm/string/replace.hpp> #include <boost/algorithm/string/erase.hpp> #include <boost/algorithm/string/classification.hpp> #include <boost/algorithm/string/find_iterator.hpp> #endif // BOOST_STRING_ALGO_HPP PK��M�[zv��sort_subrange.hppnu��[��/* Copyright (c) Marshall Clow 2008-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) Revision history: 28 Sep 2015 mtc First version / /// \file sort_subrange.hpp /// \brief Sort a subrange /// \author Marshall Clow /// /// Suggested by Sean Parent in his CppCon 2015 keynote #ifndef BOOST_ALGORITHM_SORT_SUBRANGE_HPP #define BOOST_ALGORITHM_SORT_SUBRANGE_HPP #include <functional> // For std::less #include <iterator> // For std::iterator_traits #include <algorithm> // For nth_element and partial_sort #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> namespace boost { namespace algorithm { /// \fn sort_subrange ( T const& val, /// Iterator first, Iterator last, /// Iterator sub_first, Iterator sub_last, /// Pred p ) /// \brief Sort the subrange [sub_first, sub_last) that is inside /// the range [first, last) as if you had sorted the entire range. /// /// \param first The start of the larger range /// \param last The end of the larger range /// \param sub_first The start of the sub range /// \param sub_last The end of the sub range /// \param p A predicate to use to compare the values. /// p ( a, b ) returns a boolean. /// template<typename Iterator, typename Pred> void sort_subrange ( Iterator first, Iterator last, Iterator sub_first, Iterator sub_last, Pred p) { if (sub_first == sub_last) return; // the empty sub-range is already sorted. if (sub_first != first) { // sub-range is at the start, don't need to partition (void) std::nth_element(first, sub_first, last, p); ++sub_first; } std::partial_sort(sub_first, sub_last, last, p); } template<typename Iterator> void sort_subrange (Iterator first, Iterator last, Iterator sub_first, Iterator sub_last) { typedef typename std::iterator_traits<Iterator>::value_type value_type; return sort_subrange(first, last, sub_first, sub_last, std::less<value_type>()); } /// range versions? /// \fn partition_subrange ( T const& val, /// Iterator first, Iterator last, /// Iterator sub_first, Iterator sub_last, /// Pred p ) /// \brief Gather the elements of the subrange [sub_first, sub_last) that is /// inside the range [first, last) as if you had sorted the entire range. /// /// \param first The start of the larger range /// \param last The end of the larger range /// \param sub_first The start of the sub range /// \param sub_last The end of the sub range /// \param p A predicate to use to compare the values. /// p ( a, b ) returns a boolean. /// template<typename Iterator, typename Pred> void partition_subrange ( Iterator first, Iterator last, Iterator sub_first, Iterator sub_last, Pred p) { if (sub_first != first) { (void) std::nth_element(first, sub_first, last, p); ++sub_first; } if (sub_last != last) (void) std::nth_element(sub_first, sub_last, last, p); } template<typename Iterator> void partition_subrange (Iterator first, Iterator last, Iterator sub_first, Iterator sub_last) { typedef typename std::iterator_traits<Iterator>::value_type value_type; return partition_subrange(first, last, sub_first, sub_last, std::less<value_type>()); } }} #endif // BOOST_ALGORITHM_SORT_SUBRANGE_HPP PK��M�[�S`SH ��H ��cxx14/mismatch.hppnu��[��/ Copyright (c) Marshall Clow 2008-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) / /// \file mismatch.hpp /// \brief Find the first mismatched element in a sequence /// \author Marshall Clow #ifndef BOOST_ALGORITHM_MISMATCH_HPP #define BOOST_ALGORITHM_MISMATCH_HPP #include <utility> // for std::pair #include <boost/config.hpp> namespace boost { namespace algorithm { /// \fn mismatch ( InputIterator1 first1, InputIterator1 last1, /// InputIterator2 first2, InputIterator2 last2, /// BinaryPredicate pred ) /// \return a pair of iterators pointing to the first elements in the sequence that do not match /// /// \param first1 The start of the first range. /// \param last1 One past the end of the first range. /// \param first2 The start of the second range. /// \param last2 One past the end of the second range. /// \param pred A predicate for comparing the elements of the ranges template <class InputIterator1, class InputIterator2, class BinaryPredicate> BOOST_CXX14_CONSTEXPR std::pair<InputIterator1, InputIterator2> mismatch ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, BinaryPredicate pred ) { for (; first1 != last1 && first2 != last2; ++first1, ++first2) if ( !pred ( first1, first2 )) break; return std::pair<InputIterator1, InputIterator2>(first1, first2); } /// \fn mismatch ( InputIterator1 first1, InputIterator1 last1, /// InputIterator2 first2, InputIterator2 last2 ) /// \return a pair of iterators pointing to the first elements in the sequence that do not match /// /// \param first1 The start of the first range. /// \param last1 One past the end of the first range. /// \param first2 The start of the second range. /// \param last2 One past the end of the second range. template <class InputIterator1, class InputIterator2> BOOST_CXX14_CONSTEXPR std::pair<InputIterator1, InputIterator2> mismatch ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2 ) { for (; first1 != last1 && first2 != last2; ++first1, ++first2) if ( first1 != first2 ) break; return std::pair<InputIterator1, InputIterator2>(first1, first2); } // There are already range-based versions of these. }} // namespace boost and algorithm #endif // BOOST_ALGORITHM_MISMATCH_HPP PK��M�[��`-��-��cxx14/is_permutation.hppnu��[��/ Copyright (c) Marshall Clow 2014. 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) / /// \file is_permutation.hpp /// \brief Is a sequence a permutation of another sequence (four iterator versions) /// \author Marshall Clow #ifndef BOOST_ALGORITHM_IS_PERMUTATION14_HPP #define BOOST_ALGORITHM_IS_PERMUTATION14_HPP #include <utility> // for std::pair #include <functional> // for std::equal_to #include <iterator> #include <boost/config.hpp> #include <boost/algorithm/cxx11/is_permutation.hpp> #include <boost/algorithm/cxx14/mismatch.hpp> namespace boost { namespace algorithm { /// \fn is_permutation ( ForwardIterator1 first, ForwardIterator1 last, /// ForwardIterator2 first2, ForwardIterator2 last2 ) /// \brief Tests to see if the sequence [first,last) is a permutation of the sequence starting at first2 /// /// \param first1 The start of the input sequence /// \param last2 One past the end of the input sequence /// \param first2 The start of the second sequence /// \param last1 One past the end of the second sequence /// \note This function is part of the C++2014 standard library. template< class ForwardIterator1, class ForwardIterator2 > bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2 ) { // How should I deal with the idea that ForwardIterator1::value_type // and ForwardIterator2::value_type could be different? Define my own comparison predicate? std::pair<ForwardIterator1, ForwardIterator2> eq = boost::algorithm::mismatch ( first1, last1, first2, last2 ); if ( eq.first == last1 && eq.second == last2) return true; return boost::algorithm::detail::is_permutation_tag ( eq.first, last1, eq.second, last2, std::equal_to<typename std::iterator_traits<ForwardIterator1>::value_type> (), typename std::iterator_traits<ForwardIterator1>::iterator_category (), typename std::iterator_traits<ForwardIterator2>::iterator_category ()); } /// \fn is_permutation ( ForwardIterator1 first, ForwardIterator1 last, /// ForwardIterator2 first2, ForwardIterator2 last2, /// BinaryPredicate p ) /// \brief Tests to see if the sequence [first,last) is a permutation of the sequence starting at first2 /// /// \param first1 The start of the input sequence /// \param last1 One past the end of the input sequence /// \param first2 The start of the second sequence /// \param last2 One past the end of the second sequence /// \param pred The predicate to compare elements with /// /// \note This function is part of the C++2014 standard library. template< class ForwardIterator1, class ForwardIterator2, class BinaryPredicate > bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate pred ) { std::pair<ForwardIterator1, ForwardIterator2> eq = boost::algorithm::mismatch ( first1, last1, first2, last2, pred ); if ( eq.first == last1 && eq.second == last2) return true; return boost::algorithm::detail::is_permutation_tag ( first1, last1, first2, last2, pred, typename std::iterator_traits<ForwardIterator1>::iterator_category (), typename std::iterator_traits<ForwardIterator2>::iterator_category ()); } }} #endif // BOOST_ALGORITHM_IS_PERMUTATION14_HPP PK��M�[��cxx14/equal.hppnu��[��/ Copyright (c) Marshall Clow 2008-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) / /// \file equal.hpp /// \brief Test ranges to if they are equal /// \author Marshall Clow #ifndef BOOST_ALGORITHM_EQUAL_HPP #define BOOST_ALGORITHM_EQUAL_HPP #include <iterator> #include <boost/config.hpp> namespace boost { namespace algorithm { namespace detail { template <class T1, class T2> struct eq { BOOST_CONSTEXPR bool operator () ( const T1& v1, const T2& v2 ) const { return v1 == v2 ;} }; template <class RandomAccessIterator1, class RandomAccessIterator2, class BinaryPredicate> BOOST_CXX14_CONSTEXPR bool equal ( RandomAccessIterator1 first1, RandomAccessIterator1 last1, RandomAccessIterator2 first2, RandomAccessIterator2 last2, BinaryPredicate pred, std::random_access_iterator_tag, std::random_access_iterator_tag ) { // Random-access iterators let is check the sizes in constant time if ( std::distance ( first1, last1 ) != std::distance ( first2, last2 )) return false; // std::equal for (; first1 != last1; ++first1, ++first2) if (!pred(first1, first2)) return false; return true; } template <class InputIterator1, class InputIterator2, class BinaryPredicate> BOOST_CXX14_CONSTEXPR bool equal ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, BinaryPredicate pred, std::input_iterator_tag, std::input_iterator_tag ) { for (; first1 != last1 && first2 != last2; ++first1, ++first2 ) if ( !pred(first1, first2 )) return false; return first1 == last1 && first2 == last2; } } /// \fn equal ( InputIterator1 first1, InputIterator1 last1, /// InputIterator2 first2, InputIterator2 last2, /// BinaryPredicate pred ) /// \return true if all elements in the two ranges are equal /// /// \param first1 The start of the first range. /// \param last1 One past the end of the first range. /// \param first2 The start of the second range. /// \param last2 One past the end of the second range. /// \param pred A predicate for comparing the elements of the ranges template <class InputIterator1, class InputIterator2, class BinaryPredicate> BOOST_CXX14_CONSTEXPR bool equal ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2, BinaryPredicate pred ) { return boost::algorithm::detail::equal ( first1, last1, first2, last2, pred, typename std::iterator_traits<InputIterator1>::iterator_category (), typename std::iterator_traits<InputIterator2>::iterator_category ()); } /// \fn equal ( InputIterator1 first1, InputIterator1 last1, /// InputIterator2 first2, InputIterator2 last2 ) /// \return true if all elements in the two ranges are equal /// /// \param first1 The start of the first range. /// \param last1 One past the end of the first range. /// \param first2 The start of the second range. /// \param last2 One past the end of the second range. template <class InputIterator1, class InputIterator2> BOOST_CXX14_CONSTEXPR bool equal ( InputIterator1 first1, InputIterator1 last1, InputIterator2 first2, InputIterator2 last2 ) { return boost::algorithm::detail::equal ( first1, last1, first2, last2, boost::algorithm::detail::eq< typename std::iterator_traits<InputIterator1>::value_type, typename std::iterator_traits<InputIterator2>::value_type> (), typename std::iterator_traits<InputIterator1>::iterator_category (), typename std::iterator_traits<InputIterator2>::iterator_category ()); } // There are already range-based versions of these. }} // namespace boost and algorithm #endif // BOOST_ALGORITHM_EQUAL_HPP PK��M�[3��k�� clamp.hppnu��[��/ Copyright (c) Marshall Clow 2008-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) Revision history: 27 June 2009 mtc First version 23 Oct 2010 mtc Added predicate version / /// \file clamp.hpp /// \brief Clamp algorithm /// \author Marshall Clow /// /// Suggested by olafvdspek in https://svn.boost.org/trac/boost/ticket/3215 #ifndef BOOST_ALGORITHM_CLAMP_HPP #define BOOST_ALGORITHM_CLAMP_HPP #include <functional> // For std::less #include <iterator> // For std::iterator_traits #include <cassert> #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/mpl/identity.hpp> // for identity #include <boost/utility/enable_if.hpp> // for boost::disable_if namespace boost { namespace algorithm { /// \fn clamp ( T const& val, /// typename boost::mpl::identity<T>::type const & lo, /// typename boost::mpl::identity<T>::type const & hi, Pred p ) /// \return the value "val" brought into the range [ lo, hi ] /// using the comparison predicate p. /// If p ( val, lo ) return lo. /// If p ( hi, val ) return hi. /// Otherwise, return the original value. /// /// \param val The value to be clamped /// \param lo The lower bound of the range to be clamped to /// \param hi The upper bound of the range to be clamped to /// \param p A predicate to use to compare the values. /// p ( a, b ) returns a boolean. /// template<typename T, typename Pred> BOOST_CXX14_CONSTEXPR T const & clamp ( T const& val, typename boost::mpl::identity<T>::type const & lo, typename boost::mpl::identity<T>::type const & hi, Pred p ) { // assert ( !p ( hi, lo )); // Can't assert p ( lo, hi ) b/c they might be equal return p ( val, lo ) ? lo : p ( hi, val ) ? hi : val; } /// \fn clamp ( T const& val, /// typename boost::mpl::identity<T>::type const & lo, /// typename boost::mpl::identity<T>::type const & hi ) /// \return the value "val" brought into the range [ lo, hi ]. /// If the value is less than lo, return lo. /// If the value is greater than "hi", return hi. /// Otherwise, return the original value. /// /// \param val The value to be clamped /// \param lo The lower bound of the range to be clamped to /// \param hi The upper bound of the range to be clamped to /// template<typename T> BOOST_CXX14_CONSTEXPR T const& clamp ( const T& val, typename boost::mpl::identity<T>::type const & lo, typename boost::mpl::identity<T>::type const & hi ) { return boost::algorithm::clamp ( val, lo, hi, std::less<T>()); } /// \fn clamp_range ( InputIterator first, InputIterator last, OutputIterator out, /// std::iterator_traits<InputIterator>::value_type const & lo, /// std::iterator_traits<InputIterator>::value_type const & hi ) /// \return clamp the sequence of values [first, last) into [ lo, hi ] /// /// \param first The start of the range of values /// \param last One past the end of the range of input values /// \param out An output iterator to write the clamped values into /// \param lo The lower bound of the range to be clamped to /// \param hi The upper bound of the range to be clamped to /// template<typename InputIterator, typename OutputIterator> BOOST_CXX14_CONSTEXPR 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 ) { // this could also be written with bind and std::transform while ( first != last ) out++ = boost::algorithm::clamp ( first++, lo, hi ); return out; } /// \fn clamp_range ( const Range &r, OutputIterator out, /// typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type const & lo, /// typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type const & hi ) /// \return clamp the sequence of values [first, last) into [ lo, hi ] /// /// \param r The range of values to be clamped /// \param out An output iterator to write the clamped values into /// \param lo The lower bound of the range to be clamped to /// \param hi The upper bound of the range to be clamped to /// template<typename Range, typename OutputIterator> BOOST_CXX14_CONSTEXPR typename boost::disable_if_c<boost::is_same<Range, OutputIterator>::value, OutputIterator>::type clamp_range ( const Range &r, OutputIterator out, typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type const & lo, typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type const & hi ) { return boost::algorithm::clamp_range ( boost::begin ( r ), boost::end ( r ), out, lo, hi ); } /// \fn clamp_range ( InputIterator first, InputIterator last, OutputIterator out, /// std::iterator_traits<InputIterator>::value_type const & lo, /// std::iterator_traits<InputIterator>::value_type const & hi, Pred p ) /// \return clamp the sequence of values [first, last) into [ lo, hi ] /// using the comparison predicate p. /// /// \param first The start of the range of values /// \param last One past the end of the range of input values /// \param out An output iterator to write the clamped values into /// \param lo The lower bound of the range to be clamped to /// \param hi The upper bound of the range to be clamped to /// \param p A predicate to use to compare the values. /// p ( a, b ) returns a boolean. /// template<typename InputIterator, typename OutputIterator, typename Pred> BOOST_CXX14_CONSTEXPR 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 ) { // this could also be written with bind and std::transform while ( first != last ) out++ = boost::algorithm::clamp ( first++, lo, hi, p ); return out; } /// \fn clamp_range ( const Range &r, OutputIterator out, /// typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type const & lo, /// typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type const & hi, /// Pred p ) /// \return clamp the sequence of values [first, last) into [ lo, hi ] /// using the comparison predicate p. /// /// \param r The range of values to be clamped /// \param out An output iterator to write the clamped values into /// \param lo The lower bound of the range to be clamped to /// \param hi The upper bound of the range to be clamped to /// \param p A predicate to use to compare the values. /// p ( a, b ) returns a boolean. // // Disable this template if the first two parameters are the same type; // In that case, the user will get the two iterator version. template<typename Range, typename OutputIterator, typename Pred> BOOST_CXX14_CONSTEXPR typename boost::disable_if_c<boost::is_same<Range, OutputIterator>::value, OutputIterator>::type clamp_range ( const Range &r, OutputIterator out, typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type const & lo, typename std::iterator_traits<typename boost::range_iterator<const Range>::type>::value_type const & hi, Pred p ) { return boost::algorithm::clamp_range ( boost::begin ( r ), boost::end ( r ), out, lo, hi, p ); } }} #endif // BOOST_ALGORITHM_CLAMP_HPP PK��M�[g�� minmax.hppnu��[��// (C) Copyright Herve Bronnimann 2004. // // 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) / Revision history: 1 July 2004 Split the code into two headers to lessen dependence on Boost.tuple. (Herve) 26 June 2004 Added the code for the boost minmax library. (Herve) / #ifndef BOOST_ALGORITHM_MINMAX_HPP #define BOOST_ALGORITHM_MINMAX_HPP / PROPOSED STANDARD EXTENSIONS: * * minmax(a, b) * Effect: (b<a) ? std::make_pair(b,a) : std::make_pair(a,b); * * minmax(a, b, comp) * Effect: comp(b,a) ? std::make_pair(b,a) : std::make_pair(a,b); * / #include <boost/config.hpp> #include <boost/tuple/tuple.hpp> // for using pairs with boost::cref #include <boost/ref.hpp> namespace boost { template <typename T> tuple< T const&, T const& > minmax(T const& a, T const& b) { return (b<a) ? make_tuple(cref(b),cref(a)) : make_tuple(cref(a),cref(b)); } template <typename T, class BinaryPredicate> tuple< T const&, T const& > minmax(T const& a, T const& b, BinaryPredicate comp) { return comp(b,a) ? make_tuple(cref(b),cref(a)) : make_tuple(cref(a),cref(b)); } } // namespace boost #endif // BOOST_ALGORITHM_MINMAX_HPP PK��M�[A�I�u ��u �� algorithm.hppnu��[��/ Copyright (c) Marshall Clow 2014. 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) Revision history: 2 Dec 2014 mtc First version; power / /// \file algorithm.hpp /// \brief Misc Algorithms /// \author Marshall Clow /// #ifndef BOOST_ALGORITHM_HPP #define BOOST_ALGORITHM_HPP #include <functional> // for plus and multiplies #include <boost/config.hpp> #include <boost/utility/enable_if.hpp> // for boost::disable_if #include <boost/type_traits/is_integral.hpp> namespace boost { namespace algorithm { template <typename T> BOOST_CXX14_CONSTEXPR T identity_operation ( std::multiplies<T> ) { return T(1); } template <typename T> BOOST_CXX14_CONSTEXPR T identity_operation ( std::plus<T> ) { return T(0); } /// \fn power ( T x, Integer n ) /// \return the value "x" raised to the power "n" /// /// \param x The value to be exponentiated /// \param n The exponent (must be >= 0) /// // \remark Taken from Knuth, The Art of Computer Programming, Volume 2: // Seminumerical Algorithms, Section 4.6.3 template <typename T, typename Integer> BOOST_CXX14_CONSTEXPR typename boost::enable_if<boost::is_integral<Integer>, T>::type power (T x, Integer n) { T y = 1; // Should be "T y{1};" if (n == 0) return y; while (true) { if (n % 2 == 1) { y = x y; if (n == 1) return y; } n = n / 2; x = x * x; } return y; } /// \fn power ( T x, Integer n, Operation op ) /// \return the value "x" raised to the power "n" /// using the operation "op". /// /// \param x The value to be exponentiated /// \param n The exponent (must be >= 0) /// \param op The operation used /// // \remark Taken from Knuth, The Art of Computer Programming, Volume 2: // Seminumerical Algorithms, Section 4.6.3 template <typename T, typename Integer, typename Operation> BOOST_CXX14_CONSTEXPR typename boost::enable_if<boost::is_integral<Integer>, T>::type power (T x, Integer n, Operation op) { T y = identity_operation(op); if (n == 0) return y; while (true) { if (n % 2 == 1) { y = op(x, y); if (n == 1) return y; } n = n / 2; x = op(x, x); } return y; } }} #endif // BOOST_ALGORITHM_HPP PK��M�[�� find_backward.hppnu��[��/* Copyright (c) T. Zachary Laine 2018. 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) / #ifndef BOOST_ALGORITHM_FIND_BACKWARD_HPP #define BOOST_ALGORITHM_FIND_BACKWARD_HPP #include <utility> #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> namespace boost { namespace algorithm { template<typename BidiIter, typename T> BOOST_CXX14_CONSTEXPR BidiIter find_backward(BidiIter first, BidiIter last, const T & x) { BidiIter it = last; while (it != first) { if (--it == x) return it; } return last; } template<typename Range, typename T> BOOST_CXX14_CONSTEXPR typename boost::range_iterator<Range>::type find_backward(Range & range, const T & x) { return ::boost::algorithm::find_backward(boost::begin(range), boost::end(range), x); } template<typename BidiIter, typename T> BOOST_CXX14_CONSTEXPR BidiIter find_not_backward(BidiIter first, BidiIter last, const T & x) { BidiIter it = last; while (it != first) { if (--it != x) return it; } return last; } template<typename Range, typename T> BOOST_CXX14_CONSTEXPR typename boost::range_iterator<Range>::type find_not_backward(Range & range, const T & x) { return ::boost::algorithm::find_not_backward(boost::begin(range), boost::end(range), x); } template<typename BidiIter, typename Pred> BOOST_CXX14_CONSTEXPR BidiIter find_if_backward(BidiIter first, BidiIter last, Pred p) { BidiIter it = last; while (it != first) { if (p(--it)) return it; } return last; } template<typename Range, typename Pred> BOOST_CXX14_CONSTEXPR typename boost::range_iterator<Range>::type find_if_backward(Range & range, Pred p) { return ::boost::algorithm::find_if_backward(boost::begin(range), boost::end(range), p); } template<typename BidiIter, typename Pred> BOOST_CXX14_CONSTEXPR BidiIter find_if_not_backward(BidiIter first, BidiIter last, Pred p) { BidiIter it = last; while (it != first) { if (!p(--it)) return it; } return last; } template<typename Range, typename Pred> BOOST_CXX14_CONSTEXPR typename boost::range_iterator<Range>::type find_if_not_backward(Range & range, Pred p) { return ::boost::algorithm::find_if_not_backward(boost::begin(range), boost::end(range), p); } }} // namespace boost and algorithm #endif // BOOST_ALGORITHM_FIND_BACKWARD_HPP PK��M�[%��D��D�� gather.hppnu��[��/ Copyright 2008 Adobe Systems Incorporated 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) Revision history: January 2008 mtc Version for Adobe Source Library January 2013 mtc Version for Boost.Algorithm / /************************************************************************************************/ /! \author Marshall Clow \date January 2008 / #ifndef BOOST_ALGORITHM_GATHER_HPP #define BOOST_ALGORITHM_GATHER_HPP #include <algorithm> // for std::stable_partition #include <functional> #include <utility> // for std::make_pair #include <boost/config.hpp> #include <boost/bind/bind.hpp> // for boost::bind #include <boost/range/begin.hpp> // for boost::begin(range) #include <boost/range/end.hpp> // for boost::end(range) /************************************************************************************************/ /! \defgroup gather gather \ingroup mutating_algorithm \c gather() takes a collection of elements defined by a pair of iterators and moves the ones satisfying a predicate to them to a position (called the pivot) within the sequence. The algorithm is stable. The result is a pair of iterators that contains the items that satisfy the predicate. Given an sequence containing: <pre> 0 1 2 3 4 5 6 7 8 9 </pre> a call to gather ( arr, arr + 10, arr + 4, IsEven ()) will result in: <pre> 1 3 0 2 4 6 8 5 7 9 \|---\|-----\| first \| second pivot </pre> The problem is broken down into two basic steps, namely, moving the items before the pivot and then moving the items from the pivot to the end. These "moves" are done with calls to stable_partition. \par Storage Requirements: The algorithm uses stable_partition, which will attempt to allocate temporary memory, but will work in-situ if there is none available. \par Time Complexity: If there is sufficient memory available, the run time is linear in <code>N</code>. If there is not any memory available, then the run time is <code>O(N log N)</code>. / /***********************************************************************************************/ namespace boost { namespace algorithm { /***********************************************************************************************/ /! \ingroup gather \brief iterator-based gather implementation / template < typename BidirectionalIterator, // models BidirectionalIterator typename Pred> // models UnaryPredicate std::pair<BidirectionalIterator, BidirectionalIterator> gather ( BidirectionalIterator first, BidirectionalIterator last, BidirectionalIterator pivot, Pred pred ) { // The first call partitions everything up to (but not including) the pivot element, // while the second call partitions the rest of the sequence. using namespace boost::placeholders; return std::make_pair ( std::stable_partition ( first, pivot, !boost::bind<bool> ( pred, _1 )), std::stable_partition ( pivot, last, boost::bind<bool> ( pred, _1 ))); } /************************************************************************************************/ /! \ingroup gather \brief range-based gather implementation / template < typename BidirectionalRange, // typename Pred> // Pred models UnaryPredicate 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 ) { return boost::algorithm::gather ( boost::begin ( range ), boost::end ( range ), pivot, pred ); } /***********************************************************************************************/ }} // namespace /***********************************************************************************************/ #endif PK��M�[_m�٠��apply_permutation.hppnu��[��/ Copyright (c) Alexander Zaitsev <zamazan4ik@gmail.com>, 2017 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) See http://www.boost.org/ for latest version. Based on https://blogs.msdn.microsoft.com/oldnewthing/20170104-00/?p=95115 / /// \file apply_permutation.hpp /// \brief Apply permutation to a sequence. /// \author Alexander Zaitsev #ifndef BOOST_ALGORITHM_APPLY_PERMUTATION_HPP #define BOOST_ALGORITHM_APPLY_PERMUTATION_HPP #include <algorithm> #include <type_traits> #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> namespace boost { namespace algorithm { /// \fn apply_permutation ( RandomAccessIterator1 item_begin, RandomAccessIterator1 item_end, RandomAccessIterator2 ind_begin ) /// \brief Reorder item sequence with index sequence order /// /// \param item_begin The start of the item sequence /// \param item_end One past the end of the item sequence /// \param ind_begin The start of the index sequence. /// /// \note Item sequence size should be equal to index size. Otherwise behavior is undefined. /// Complexity: O(N). template<typename RandomAccessIterator1, typename RandomAccessIterator2> void apply_permutation(RandomAccessIterator1 item_begin, RandomAccessIterator1 item_end, RandomAccessIterator2 ind_begin, RandomAccessIterator2 ind_end) { typedef typename std::iterator_traits<RandomAccessIterator1>::difference_type Diff; typedef typename std::iterator_traits<RandomAccessIterator2>::difference_type Index; using std::swap; Diff size = std::distance(item_begin, item_end); for (Diff i = 0; i < size; i++) { Diff current = i; while (i != ind_begin[current]) { Index next = ind_begin[current]; swap(item_begin[current], item_begin[next]); ind_begin[current] = current; current = next; } ind_begin[current] = current; } } /// \fn apply_reverse_permutation ( RandomAccessIterator1 item_begin, RandomAccessIterator1 item_end, RandomAccessIterator2 ind_begin ) /// \brief Reorder item sequence with index sequence order /// /// \param item_begin The start of the item sequence /// \param item_end One past the end of the item sequence /// \param ind_begin The start of the index sequence. /// /// \note Item sequence size should be equal to index size. Otherwise behavior is undefined. /// Complexity: O(N). template<typename RandomAccessIterator1, typename RandomAccessIterator2> void apply_reverse_permutation( RandomAccessIterator1 item_begin, RandomAccessIterator1 item_end, RandomAccessIterator2 ind_begin, RandomAccessIterator2 ind_end) { typedef typename std::iterator_traits<RandomAccessIterator2>::difference_type Diff; using std::swap; Diff length = std::distance(item_begin, item_end); for (Diff i = 0; i < length; i++) { while (i != ind_begin[i]) { Diff next = ind_begin[i]; swap(item_begin[i], item_begin[next]); swap(ind_begin[i], ind_begin[next]); } } } /// \fn apply_permutation ( Range1 item_range, Range2 ind_range ) /// \brief Reorder item sequence with index sequence order /// /// \param item_range The item sequence /// \param ind_range The index sequence /// /// \note Item sequence size should be equal to index size. Otherwise behavior is undefined. /// Complexity: O(N). template<typename Range1, typename Range2> void apply_permutation(Range1& item_range, Range2& ind_range) { apply_permutation(boost::begin(item_range), boost::end(item_range), boost::begin(ind_range), boost::end(ind_range)); } /// \fn apply_reverse_permutation ( Range1 item_range, Range2 ind_range ) /// \brief Reorder item sequence with index sequence order /// /// \param item_range The item sequence /// \param ind_range The index sequence /// /// \note Item sequence size should be equal to index size. Otherwise behavior is undefined. /// Complexity: O(N). template<typename Range1, typename Range2> void apply_reverse_permutation(Range1& item_range, Range2& ind_range) { apply_reverse_permutation(boost::begin(item_range), boost::end(item_range), boost::begin(ind_range), boost::end(ind_range)); } }} #endif //BOOST_ALGORITHM_APPLY_PERMUTATION_HPP PK��M�[Hi��string_regex.hppnu��[��// Boost string_algo library string_regex.hpp header file ---------------------------// // Copyright Pavol Droba 2002-2004. // // 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) // See http://www.boost.org/ for updates, documentation, and revision history. #ifndef BOOST_STRING_ALGO_REGEX_HPP #define BOOST_STRING_ALGO_REGEX_HPP /! \file Cumulative include for string_algo library. In addition to string.hpp contains also regex-related stuff. / #include <boost/regex.hpp> #include <boost/algorithm/string.hpp> #include <boost/algorithm/string/regex.hpp> #endif // BOOST_STRING_ALGO_REGEX_HPP PK��M�[)��find_not.hppnu��[��/ Copyright (c) T. Zachary Laine 2018. 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) / #ifndef BOOST_ALGORITHM_FIND_NOT_HPP #define BOOST_ALGORITHM_FIND_NOT_HPP #include <utility> #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> namespace boost { namespace algorithm { template<typename InputIter, typename Sentinel, typename T> BOOST_CXX14_CONSTEXPR InputIter find_not(InputIter first, Sentinel last, const T & x) { for (; first != last; ++first) { if (first != x) break; } return first; } template<typename Range, typename T> BOOST_CXX14_CONSTEXPR typename boost::range_iterator<Range>::type find_not(Range & r, const T & x) { return ::boost::algorithm::find_not(boost::begin(r), boost::end(r), x); } }} // namespace boost and algorithm #endif // BOOST_ALGORITHM_FIND_NOT_HPP PK��M�[��+n� �� cxx11/any_of.hppnu��[��/* Copyright (c) Marshall Clow 2008-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 / /// \file /// \brief Test ranges to see if any elements match a value or predicate. /// \author Marshall Clow #ifndef BOOST_ALGORITHM_ANY_OF_HPP #define BOOST_ALGORITHM_ANY_OF_HPP #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> namespace boost { namespace algorithm { /// \fn any_of ( InputIterator first, InputIterator last, Predicate p ) /// \return true if any of the elements in [first, last) satisfy the predicate /// \note returns false on an empty range /// /// \param first The start of the input sequence /// \param last One past the end of the input sequence /// \param p A predicate for testing the elements of the sequence /// template<typename InputIterator, typename Predicate> BOOST_CXX14_CONSTEXPR bool any_of ( InputIterator first, InputIterator last, Predicate p ) { for ( ; first != last; ++first ) if ( p(first)) return true; return false; } /// \fn any_of ( const Range &r, Predicate p ) /// \return true if any elements in the range satisfy the predicate 'p' /// \note returns false on an empty range /// /// \param r The input range /// \param p A predicate for testing the elements of the range /// template<typename Range, typename Predicate> BOOST_CXX14_CONSTEXPR bool any_of ( const Range &r, Predicate p ) { return boost::algorithm::any_of (boost::begin (r), boost::end (r), p); } /// \fn any_of_equal ( InputIterator first, InputIterator last, const V &val ) /// \return true if any of the elements in [first, last) are equal to 'val' /// \note returns false on an empty range /// /// \param first The start of the input sequence /// \param last One past the end of the input sequence /// \param val A value to compare against /// template<typename InputIterator, typename V> BOOST_CXX14_CONSTEXPR bool any_of_equal ( InputIterator first, InputIterator last, const V &val ) { for ( ; first != last; ++first ) if ( val == first ) return true; return false; } /// \fn any_of_equal ( const Range &r, const V &val ) /// \return true if any of the elements in the range are equal to 'val' /// \note returns false on an empty range /// /// \param r The input range /// \param val A value to compare against /// template<typename Range, typename V> BOOST_CXX14_CONSTEXPR bool any_of_equal ( const Range &r, const V &val ) { return boost::algorithm::any_of_equal (boost::begin (r), boost::end (r), val); } }} // namespace boost and algorithm #endif // BOOST_ALGORITHM_ANY_OF_HPP PK��M�[t�DW��W��cxx11/iota.hppnu��[��/ Copyright (c) Marshall Clow 2008-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) / /// \file iota.hpp /// \brief Generate an increasing series /// \author Marshall Clow #ifndef BOOST_ALGORITHM_IOTA_HPP #define BOOST_ALGORITHM_IOTA_HPP #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> namespace boost { namespace algorithm { /// \fn iota ( ForwardIterator first, ForwardIterator last, T value ) /// \brief Generates an increasing sequence of values, and stores them in [first, last) /// /// \param first The start of the input sequence /// \param last One past the end of the input sequence /// \param value The initial value of the sequence to be generated /// \note This function is part of the C++2011 standard library. template <typename ForwardIterator, typename T> BOOST_CXX14_CONSTEXPR void iota ( ForwardIterator first, ForwardIterator last, T value ) { for ( ; first != last; ++first, ++value ) first = value; } /// \fn iota ( Range &r, T value ) /// \brief Generates an increasing sequence of values, and stores them in the input Range. /// /// \param r The input range /// \param value The initial value of the sequence to be generated /// template <typename Range, typename T> BOOST_CXX14_CONSTEXPR void iota ( Range &r, T value ) { boost::algorithm::iota (boost::begin(r), boost::end(r), value); } /// \fn iota_n ( OutputIterator out, T value, std::size_t n ) /// \brief Generates an increasing sequence of values, and stores them in the input Range. /// /// \param out An output iterator to write the results into /// \param value The initial value of the sequence to be generated /// \param n The number of items to write /// template <typename OutputIterator, typename T> BOOST_CXX14_CONSTEXPR OutputIterator iota_n ( OutputIterator out, T value, std::size_t n ) { for ( ; n > 0; --n, ++value ) out++ = value; return out; } }} #endif // BOOST_ALGORITHM_IOTA_HPP PK��M�[[�7/��/��cxx11/partition_point.hppnu��[��/ 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) / /// \file partition_point.hpp /// \brief Find the partition point in a sequence /// \author Marshall Clow #ifndef BOOST_ALGORITHM_PARTITION_POINT_HPP #define BOOST_ALGORITHM_PARTITION_POINT_HPP #include <iterator> // for std::distance, advance #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> namespace boost { namespace algorithm { /// \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 /// /// \param first The start of the input sequence /// \param last One past the end of the input sequence /// \param p The predicate to test the values with /// \note This function is part of the C++2011 standard library. template <typename ForwardIterator, typename Predicate> ForwardIterator partition_point ( ForwardIterator first, ForwardIterator last, Predicate p ) { std::size_t dist = std::distance ( first, last ); while ( first != last ) { std::size_t d2 = dist / 2; ForwardIterator ret_val = first; std::advance (ret_val, d2); if (p (ret_val)) { first = ++ret_val; dist -= d2 + 1; } else { last = ret_val; dist = d2; } } return first; } /// \fn partition_point ( Range &r, Predicate p ) /// \brief Given a partitioned range, returns the partition point /// /// \param r The input range /// \param p The predicate to test the values with /// template <typename Range, typename Predicate> typename boost::range_iterator<Range>::type partition_point ( Range &r, Predicate p ) { return boost::algorithm::partition_point (boost::begin(r), boost::end(r), p); } }} #endif // BOOST_ALGORITHM_PARTITION_POINT_HPP PK��M�[�=�V��cxx11/is_permutation.hppnu��[��/* 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) / /// \file is_permutation.hpp /// \brief Is a sequence a permutation of another sequence /// \author Marshall Clow #ifndef BOOST_ALGORITHM_IS_PERMUTATION11_HPP #define BOOST_ALGORITHM_IS_PERMUTATION11_HPP #include <algorithm> // for std::find_if, count_if, mismatch #include <utility> // for std::pair #include <functional> // for std::equal_to #include <iterator> #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/utility/enable_if.hpp> #include <boost/type_traits/is_same.hpp> namespace boost { namespace algorithm { /// \cond DOXYGEN_HIDE namespace detail { template <typename Predicate, typename Iterator> struct value_predicate { value_predicate ( Predicate p, Iterator it ) : p_ ( p ), it_ ( it ) {} template <typename T1> bool operator () ( const T1 &t1 ) const { return p_ ( it_, t1 ); } private: Predicate p_; Iterator it_; }; // Preconditions: // 1. The sequences are the same length // 2. Any common elements on the front have been removed (not necessary for correctness, just for performance) template< class ForwardIterator1, class ForwardIterator2, class BinaryPredicate > bool is_permutation_inner ( ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate p ) { // for each unique value in the sequence [first1,last1), count how many times // it occurs, and make sure it occurs the same number of times in [first2, last2) for ( ForwardIterator1 iter = first1; iter != last1; ++iter ) { value_predicate<BinaryPredicate, ForwardIterator1> pred ( p, iter ); /* For each value we haven't seen yet... / if ( std::find_if ( first1, iter, pred ) == iter ) { std::size_t dest_count = std::count_if ( first2, last2, pred ); if ( dest_count == 0 \|\| dest_count != (std::size_t) std::count_if ( iter, last1, pred )) return false; } } return true; } template< class ForwardIterator1, class ForwardIterator2, class BinaryPredicate> bool is_permutation_tag ( ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, ForwardIterator2 last2, BinaryPredicate p, std::forward_iterator_tag, std::forward_iterator_tag ) { // Skip the common prefix (if any) while ( first1 != last1 && first2 != last2 && p ( first1, first2 )) { ++first1; ++first2; } if ( first1 != last1 && first2 != last2 ) return boost::algorithm::detail::is_permutation_inner ( first1, last1, first2, last2, std::equal_to<typename std::iterator_traits<ForwardIterator1>::value_type> ()); return first1 == last1 && first2 == last2; } template <class RandomAccessIterator1, class RandomAccessIterator2, class BinaryPredicate> bool is_permutation_tag ( RandomAccessIterator1 first1, RandomAccessIterator1 last1, RandomAccessIterator2 first2, RandomAccessIterator2 last2, BinaryPredicate p, std::random_access_iterator_tag, std::random_access_iterator_tag ) { // Cheap check if ( std::distance ( first1, last1 ) != std::distance ( first2, last2 )) return false; // Skip the common prefix (if any) while ( first1 != last1 && first2 != last2 && p ( first1, first2 )) { ++first1; ++first2; } if ( first1 != last1 && first2 != last2 ) return is_permutation_inner (first1, last1, first2, last2, p); return first1 == last1 && first2 == last2; } } /// \endcond /// \fn is_permutation ( ForwardIterator1 first, ForwardIterator1 last, ForwardIterator2 first2, BinaryPredicate p ) /// \brief Tests to see if the sequence [first,last) is a permutation of the sequence starting at first2 /// /// \param first1 The start of the input sequence /// \param last1 One past the end of the input sequence /// \param first2 The start of the second sequence /// \param p The predicate to compare elements with /// /// \note This function is part of the C++2011 standard library. template< class ForwardIterator1, class ForwardIterator2, class BinaryPredicate > bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2, BinaryPredicate p ) { // Skip the common prefix (if any) std::pair<ForwardIterator1, ForwardIterator2> eq = std::mismatch (first1, last1, first2, p); first1 = eq.first; first2 = eq.second; if ( first1 != last1 ) { // Create last2 ForwardIterator2 last2 = first2; std::advance ( last2, std::distance (first1, last1)); return boost::algorithm::detail::is_permutation_inner ( first1, last1, first2, last2, p ); } return true; } /// \fn is_permutation ( ForwardIterator1 first, ForwardIterator1 last, ForwardIterator2 first2 ) /// \brief Tests to see if the sequence [first,last) is a permutation of the sequence starting at first2 /// /// \param first1 The start of the input sequence /// \param last2 One past the end of the input sequence /// \param first2 The start of the second sequence /// \note This function is part of the C++2011 standard library. template< class ForwardIterator1, class ForwardIterator2 > bool is_permutation ( ForwardIterator1 first1, ForwardIterator1 last1, ForwardIterator2 first2 ) { // How should I deal with the idea that ForwardIterator1::value_type // and ForwardIterator2::value_type could be different? Define my own comparison predicate? // Skip the common prefix (if any) std::pair<ForwardIterator1, ForwardIterator2> eq = std::mismatch (first1, last1, first2 ); first1 = eq.first; first2 = eq.second; if ( first1 != last1 ) { // Create last2 ForwardIterator2 last2 = first2; std::advance ( last2, std::distance (first1, last1)); return boost::algorithm::detail::is_permutation_inner ( first1, last1, first2, last2, std::equal_to<typename std::iterator_traits<ForwardIterator1>::value_type> ()); } return true; } /// \fn is_permutation ( const Range &r, ForwardIterator first2 ) /// \brief Tests to see if the sequence [first,last) is a permutation of the sequence starting at first2 /// /// \param r The input range /// \param first2 The start of the second sequence template <typename Range, typename ForwardIterator> bool is_permutation ( const Range &r, ForwardIterator first2 ) { return boost::algorithm::is_permutation (boost::begin (r), boost::end (r), first2 ); } /// \fn is_permutation ( const Range &r, ForwardIterator first2, BinaryPredicate pred ) /// \brief Tests to see if the sequence [first,last) is a permutation of the sequence starting at first2 /// /// \param r The input range /// \param first2 The start of the second sequence /// \param pred The predicate to compare elements with /// // Disable this template when the first two parameters are the same type // That way the non-range version will be chosen. template <typename Range, typename ForwardIterator, typename BinaryPredicate> typename boost::disable_if_c<boost::is_same<Range, ForwardIterator>::value, bool>::type is_permutation ( const Range &r, ForwardIterator first2, BinaryPredicate pred ) { return boost::algorithm::is_permutation (boost::begin (r), boost::end (r), first2, pred ); } }} #endif // BOOST_ALGORITHM_IS_PERMUTATION11_HPP PK��M�[��cxx11/partition_copy.hppnu��[��/ 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) / /// \file partition_copy.hpp /// \brief Copy a subset of a sequence to a new sequence /// \author Marshall Clow #ifndef BOOST_ALGORITHM_PARTITION_COPY_HPP #define BOOST_ALGORITHM_PARTITION_COPY_HPP #include <utility> // for std::pair #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> namespace boost { namespace algorithm { /// \fn partition_copy ( InputIterator first, InputIterator last, /// OutputIterator1 out_true, OutputIterator2 out_false, UnaryPredicate p ) /// \brief Copies the elements that satisfy the predicate p from the range [first, last) /// to the range beginning at d_first_true, and /// copies the elements that do not satisfy p to the range beginning at d_first_false. /// /// /// \param first The start of the input sequence /// \param last One past the end of the input sequence /// \param out_true An output iterator to write the elements that satisfy the predicate into /// \param out_false An output iterator to write the elements that do not satisfy the predicate into /// \param p A predicate for dividing the elements of the input sequence. /// /// \note This function is part of the C++2011 standard library. template <typename InputIterator, typename OutputIterator1, typename OutputIterator2, typename UnaryPredicate> BOOST_CXX14_CONSTEXPR std::pair<OutputIterator1, OutputIterator2> partition_copy ( InputIterator first, InputIterator last, OutputIterator1 out_true, OutputIterator2 out_false, UnaryPredicate p ) { for ( ; first != last; ++first ) if ( p (first)) out_true++ = first; else out_false++ = first; return std::pair<OutputIterator1, OutputIterator2> ( out_true, out_false ); } /// \fn partition_copy ( const Range &r, /// OutputIterator1 out_true, OutputIterator2 out_false, UnaryPredicate p ) /// /// \param r The input range /// \param out_true An output iterator to write the elements that satisfy the predicate into /// \param out_false An output iterator to write the elements that do not satisfy the predicate into /// \param p A predicate for dividing the elements of the input sequence. /// template <typename Range, typename OutputIterator1, typename OutputIterator2, typename UnaryPredicate> BOOST_CXX14_CONSTEXPR std::pair<OutputIterator1, OutputIterator2> partition_copy ( const Range &r, OutputIterator1 out_true, OutputIterator2 out_false, UnaryPredicate p ) { return boost::algorithm::partition_copy (boost::begin(r), boost::end(r), out_true, out_false, p ); } }} // namespace boost and algorithm #endif // BOOST_ALGORITHM_PARTITION_COPY_HPP PK��M�[ �mHb��b��cxx11/copy_if.hppnu��[��/* Copyright (c) Marshall Clow 2008-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) / /// \file copy_if.hpp /// \brief Copy a subset of a sequence to a new sequence /// \author Marshall Clow #ifndef BOOST_ALGORITHM_COPY_IF_HPP #define BOOST_ALGORITHM_COPY_IF_HPP #include <utility> // for std::pair, std::make_pair #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> namespace boost { namespace algorithm { /// \fn copy_if ( InputIterator first, InputIterator last, OutputIterator result, Predicate p ) /// \brief Copies all the elements from the input range that satisfy the /// predicate to the output range. /// \return The updated output iterator /// /// \param first The start of the input sequence /// \param last One past the end of the input sequence /// \param result An output iterator to write the results into /// \param p A predicate for testing the elements of the range /// \note This function is part of the C++2011 standard library. template<typename InputIterator, typename OutputIterator, typename Predicate> BOOST_CXX14_CONSTEXPR OutputIterator copy_if ( InputIterator first, InputIterator last, OutputIterator result, Predicate p ) { for ( ; first != last; ++first ) if (p(first)) result++ = first; return result; } /// \fn copy_if ( const Range &r, OutputIterator result, Predicate p ) /// \brief Copies all the elements from the input range that satisfy the /// predicate to the output range. /// \return The updated output iterator /// /// \param r The input range /// \param result An output iterator to write the results into /// \param p A predicate for testing the elements of the range /// template<typename Range, typename OutputIterator, typename Predicate> BOOST_CXX14_CONSTEXPR OutputIterator copy_if ( const Range &r, OutputIterator result, Predicate p ) { return boost::algorithm::copy_if (boost::begin (r), boost::end(r), result, p); } /// \fn copy_while ( InputIterator first, InputIterator last, OutputIterator result, Predicate p ) /// \brief Copies all the elements at the start of the input range that /// satisfy the predicate to the output range. /// \return The updated input and output iterators /// /// \param first The start of the input sequence /// \param last One past the end of the input sequence /// \param result An output iterator to write the results into /// \param p A predicate for testing the elements of the range /// template<typename InputIterator, typename OutputIterator, typename Predicate> BOOST_CXX14_CONSTEXPR std::pair<InputIterator, OutputIterator> copy_while ( InputIterator first, InputIterator last, OutputIterator result, Predicate p ) { for ( ; first != last && p(first); ++first ) result++ = first; return std::make_pair(first, result); } /// \fn copy_while ( const Range &r, OutputIterator result, Predicate p ) /// \brief Copies all the elements at the start of the input range that /// satisfy the predicate to the output range. /// \return The updated input and output iterators /// /// \param r The input range /// \param result An output iterator to write the results into /// \param p A predicate for testing the elements of the range /// template<typename Range, typename OutputIterator, typename Predicate> BOOST_CXX14_CONSTEXPR std::pair<typename boost::range_iterator<const Range>::type, OutputIterator> copy_while ( const Range &r, OutputIterator result, Predicate p ) { return boost::algorithm::copy_while (boost::begin (r), boost::end(r), result, p); } /// \fn copy_until ( InputIterator first, InputIterator last, OutputIterator result, Predicate p ) /// \brief Copies all the elements at the start of the input range that do not /// satisfy the predicate to the output range. /// \return The updated output iterator /// /// \param first The start of the input sequence /// \param last One past the end of the input sequence /// \param result An output iterator to write the results into /// \param p A predicate for testing the elements of the range /// template<typename InputIterator, typename OutputIterator, typename Predicate> BOOST_CXX14_CONSTEXPR std::pair<InputIterator, OutputIterator> copy_until ( InputIterator first, InputIterator last, OutputIterator result, Predicate p ) { for ( ; first != last && !p(first); ++first ) result++ = first; return std::make_pair(first, result); } /// \fn copy_until ( const Range &r, OutputIterator result, Predicate p ) /// \brief Copies all the elements at the start of the input range that do not /// satisfy the predicate to the output range. /// \return The updated output iterator /// /// \param r The input range /// \param result An output iterator to write the results into /// \param p A predicate for testing the elements of the range /// template<typename Range, typename OutputIterator, typename Predicate> BOOST_CXX14_CONSTEXPR std::pair<typename boost::range_iterator<const Range>::type, OutputIterator> copy_until ( const Range &r, OutputIterator result, Predicate p ) { return boost::algorithm::copy_until (boost::begin (r), boost::end(r), result, p); } }} // namespace boost and algorithm #endif // BOOST_ALGORITHM_COPY_IF_HPP PK��M�[�-��cxx11/all_of.hppnu��[��/* Copyright (c) Marshall Clow 2008-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) / /// \file all_of.hpp /// \brief Test ranges to see if all elements match a value or predicate. /// \author Marshall Clow #ifndef BOOST_ALGORITHM_ALL_OF_HPP #define BOOST_ALGORITHM_ALL_OF_HPP #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> namespace boost { namespace algorithm { /// \fn all_of ( InputIterator first, InputIterator last, Predicate p ) /// \return true if all elements in [first, last) satisfy the predicate 'p' /// \note returns true on an empty range /// /// \param first The start of the input sequence /// \param last One past the end of the input sequence /// \param p A predicate for testing the elements of the sequence /// /// \note This function is part of the C++2011 standard library. template<typename InputIterator, typename Predicate> BOOST_CXX14_CONSTEXPR bool all_of ( InputIterator first, InputIterator last, Predicate p ) { for ( ; first != last; ++first ) if ( !p(first)) return false; return true; } /// \fn all_of ( const Range &r, Predicate p ) /// \return true if all elements in the range satisfy the predicate 'p' /// \note returns true on an empty range /// /// \param r The input range /// \param p A predicate for testing the elements of the range /// template<typename Range, typename Predicate> BOOST_CXX14_CONSTEXPR bool all_of ( const Range &r, Predicate p ) { return boost::algorithm::all_of ( boost::begin (r), boost::end (r), p ); } /// \fn all_of_equal ( InputIterator first, InputIterator last, const T &val ) /// \return true if all elements in [first, last) are equal to 'val' /// \note returns true on an empty range /// /// \param first The start of the input sequence /// \param last One past the end of the input sequence /// \param val A value to compare against /// template<typename InputIterator, typename T> BOOST_CXX14_CONSTEXPR bool all_of_equal ( InputIterator first, InputIterator last, const T &val ) { for ( ; first != last; ++first ) if ( val != first ) return false; return true; } /// \fn all_of_equal ( const Range &r, const T &val ) /// \return true if all elements in the range are equal to 'val' /// \note returns true on an empty range /// /// \param r The input range /// \param val A value to compare against /// template<typename Range, typename T> BOOST_CXX14_CONSTEXPR bool all_of_equal ( const Range &r, const T &val ) { return boost::algorithm::all_of_equal ( boost::begin (r), boost::end (r), val ); } }} // namespace boost and algorithm #endif // BOOST_ALGORITHM_ALL_OF_HPP PK��M�['>�@+��@+��cxx11/is_sorted.hppnu��[��// Copyright (c) 2010 Nuovation System Designs, LLC // Grant Erickson <gerickson@nuovations.com> // // Reworked somewhat by Marshall Clow; August 2010 // // 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) // // See http://www.boost.org/ for latest version. // #ifndef BOOST_ALGORITHM_ORDERED_HPP #define BOOST_ALGORITHM_ORDERED_HPP #include <functional> #include <iterator> #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/utility/enable_if.hpp> #include <boost/type_traits/is_same.hpp> #include <boost/mpl/identity.hpp> namespace boost { namespace algorithm { /// \fn is_sorted_until ( ForwardIterator first, ForwardIterator last, Pred p ) /// \return the point in the sequence [first, last) where the elements are unordered /// (according to the comparison predicate 'p'). /// /// \param first The start of the sequence to be tested. /// \param last One past the end of the sequence /// \param p A binary predicate that returns true if two elements are ordered. /// template <typename ForwardIterator, typename Pred> BOOST_CXX14_CONSTEXPR ForwardIterator is_sorted_until ( ForwardIterator first, ForwardIterator last, Pred p ) { if ( first == last ) return last; // the empty sequence is ordered ForwardIterator next = first; while ( ++next != last ) { if ( p ( next, first )) return next; first = next; } return last; } /// \fn is_sorted_until ( ForwardIterator first, ForwardIterator last ) /// \return the point in the sequence [first, last) where the elements are unordered /// /// \param first The start of the sequence to be tested. /// \param last One past the end of the sequence /// template <typename ForwardIterator> BOOST_CXX14_CONSTEXPR 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<value_type>()); } /// \fn is_sorted ( ForwardIterator first, ForwardIterator last, Pred p ) /// \return whether or not the entire sequence is sorted /// /// \param first The start of the sequence to be tested. /// \param last One past the end of the sequence /// \param p A binary predicate that returns true if two elements are ordered. /// template <typename ForwardIterator, typename Pred> BOOST_CXX14_CONSTEXPR bool is_sorted ( ForwardIterator first, ForwardIterator last, Pred p ) { return boost::algorithm::is_sorted_until (first, last, p) == last; } /// \fn is_sorted ( ForwardIterator first, ForwardIterator last ) /// \return whether or not the entire sequence is sorted /// /// \param first The start of the sequence to be tested. /// \param last One past the end of the sequence /// template <typename ForwardIterator> BOOST_CXX14_CONSTEXPR bool is_sorted ( ForwardIterator first, ForwardIterator last ) { return boost::algorithm::is_sorted_until (first, last) == last; } /// /// -- Range based versions of the C++11 functions /// /// \fn is_sorted_until ( const R &range, Pred p ) /// \return the point in the range R where the elements are unordered /// (according to the comparison predicate 'p'). /// /// \param range The range to be tested. /// \param p A binary predicate that returns true if two elements are ordered. /// template <typename R, typename Pred> BOOST_CXX14_CONSTEXPR typename boost::lazy_disable_if_c< boost::is_same<R, Pred>::value, typename boost::range_iterator<const R> >::type is_sorted_until ( const R &range, Pred p ) { return boost::algorithm::is_sorted_until ( boost::begin ( range ), boost::end ( range ), p ); } /// \fn is_sorted_until ( const R &range ) /// \return the point in the range R where the elements are unordered /// /// \param range The range to be tested. /// template <typename R> BOOST_CXX14_CONSTEXPR typename boost::range_iterator<const R>::type is_sorted_until ( const R &range ) { 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'). /// /// \param range The range to be tested. /// \param p A binary predicate that returns true if two elements are ordered. /// template <typename R, typename Pred> BOOST_CXX14_CONSTEXPR 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 ); } /// \fn is_sorted ( const R &range ) /// \return whether or not the entire range R is sorted /// /// \param range The range to be tested. /// template <typename R> BOOST_CXX14_CONSTEXPR bool is_sorted ( const R &range ) { return boost::algorithm::is_sorted ( boost::begin ( range ), boost::end ( range )); } /// /// -- Range based versions of the C++11 functions /// /// \fn is_increasing ( ForwardIterator first, ForwardIterator last ) /// \return true if the entire sequence is increasing; i.e, each item is greater than or /// equal to the previous one. /// /// \param first The start of the sequence to be tested. /// \param last One past the end of the sequence /// /// \note This function will return true for sequences that contain items that compare /// equal. If that is not what you intended, you should use is_strictly_increasing instead. template <typename ForwardIterator> BOOST_CXX14_CONSTEXPR 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<value_type>()); } /// \fn is_increasing ( const R &range ) /// \return true if the entire sequence is increasing; i.e, each item is greater than or /// equal to the previous one. /// /// \param range The range to be tested. /// /// \note This function will return true for sequences that contain items that compare /// equal. If that is not what you intended, you should use is_strictly_increasing instead. template <typename R> BOOST_CXX14_CONSTEXPR bool is_increasing ( const R &range ) { return is_increasing ( boost::begin ( range ), boost::end ( range )); } /// \fn is_decreasing ( ForwardIterator first, ForwardIterator last ) /// \return true if the entire sequence is decreasing; i.e, each item is less than /// or equal to the previous one. /// /// \param first The start of the sequence to be tested. /// \param last One past the end of the sequence /// /// \note This function will return true for sequences that contain items that compare /// equal. If that is not what you intended, you should use is_strictly_decreasing instead. template <typename ForwardIterator> BOOST_CXX14_CONSTEXPR 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<value_type>()); } /// \fn is_decreasing ( const R &range ) /// \return true if the entire sequence is decreasing; i.e, each item is less than /// or equal to the previous one. /// /// \param range The range to be tested. /// /// \note This function will return true for sequences that contain items that compare /// equal. If that is not what you intended, you should use is_strictly_decreasing instead. template <typename R> BOOST_CXX14_CONSTEXPR bool is_decreasing ( const R &range ) { return is_decreasing ( boost::begin ( range ), boost::end ( range )); } /// \fn is_strictly_increasing ( ForwardIterator first, ForwardIterator last ) /// \return true if the entire sequence is strictly increasing; i.e, each item is greater /// than the previous one /// /// \param first The start of the sequence to be tested. /// \param last One past the end of the sequence /// /// \note This function will return false for sequences that contain items that compare /// equal. If that is not what you intended, you should use is_increasing instead. template <typename ForwardIterator> BOOST_CXX14_CONSTEXPR 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_equal<value_type>()); } /// \fn is_strictly_increasing ( const R &range ) /// \return true if the entire sequence is strictly increasing; i.e, each item is greater /// than the previous one /// /// \param range The range to be tested. /// /// \note This function will return false for sequences that contain items that compare /// equal. If that is not what you intended, you should use is_increasing instead. template <typename R> BOOST_CXX14_CONSTEXPR bool is_strictly_increasing ( const R &range ) { return is_strictly_increasing ( boost::begin ( range ), boost::end ( range )); } /// \fn is_strictly_decreasing ( ForwardIterator first, ForwardIterator last ) /// \return true if the entire sequence is strictly decreasing; i.e, each item is less than /// the previous one /// /// \param first The start of the sequence to be tested. /// \param last One past the end of the sequence /// /// \note This function will return false for sequences that contain items that compare /// equal. If that is not what you intended, you should use is_decreasing instead. template <typename ForwardIterator> BOOST_CXX14_CONSTEXPR 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_equal<value_type>()); } /// \fn is_strictly_decreasing ( const R &range ) /// \return true if the entire sequence is strictly decreasing; i.e, each item is less than /// the previous one /// /// \param range The range to be tested. /// /// \note This function will return false for sequences that contain items that compare /// equal. If that is not what you intended, you should use is_decreasing instead. template <typename R> BOOST_CXX14_CONSTEXPR bool is_strictly_decreasing ( const R &range ) { return is_strictly_decreasing ( boost::begin ( range ), boost::end ( range )); } }} // namespace boost #endif // BOOST_ALGORITHM_ORDERED_HPP PK��M�[u�΀��cxx11/find_if_not.hppnu��[��/ 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) / /// \file find_if_not.hpp /// \brief Find the first element in a sequence that does not satisfy a predicate. /// \author Marshall Clow #ifndef BOOST_ALGORITHM_FIND_IF_NOT_HPP #define BOOST_ALGORITHM_FIND_IF_NOT_HPP #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> namespace boost { namespace algorithm { /// \fn find_if_not(InputIterator first, InputIterator last, Predicate p) /// \brief Finds the first element in the sequence that does not satisfy the predicate. /// \return The iterator pointing to the desired element. /// /// \param first The start of the input sequence /// \param last One past the end of the input sequence /// \param p A predicate for testing the elements of the range /// \note This function is part of the C++2011 standard library. template<typename InputIterator, typename Predicate> BOOST_CXX14_CONSTEXPR InputIterator find_if_not ( InputIterator first, InputIterator last, Predicate p ) { for ( ; first != last; ++first ) if ( !p(first)) break; return first; } /// \fn find_if_not ( const Range &r, Predicate p ) /// \brief Finds the first element in the sequence that does not satisfy the predicate. /// \return The iterator pointing to the desired element. /// /// \param r The input range /// \param p A predicate for testing the elements of the range /// template<typename Range, typename Predicate> BOOST_CXX14_CONSTEXPR typename boost::range_iterator<const Range>::type find_if_not ( const Range &r, Predicate p ) { return boost::algorithm::find_if_not (boost::begin (r), boost::end(r), p); } }} #endif // BOOST_ALGORITHM_FIND_IF_NOT_HPP PK��M�[�U��cxx11/copy_n.hppnu��[��/* 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) / /// \file copy_n.hpp /// \brief Copy n items from one sequence to another /// \author Marshall Clow #ifndef BOOST_ALGORITHM_COPY_N_HPP #define BOOST_ALGORITHM_COPY_N_HPP #include <boost/config.hpp> namespace boost { namespace algorithm { /// \fn copy_n ( InputIterator first, Size n, OutputIterator result ) /// \brief Copies exactly n (n > 0) elements from the range starting at first to /// the range starting at result. /// \return The updated output iterator /// /// \param first The start of the input sequence /// \param n The number of elements to copy /// \param result An output iterator to write the results into /// \note This function is part of the C++2011 standard library. template <typename InputIterator, typename Size, typename OutputIterator> BOOST_CXX14_CONSTEXPR OutputIterator copy_n ( InputIterator first, Size n, OutputIterator result ) { for ( ; n > 0; --n, ++first, ++result ) result = first; return result; } }} // namespace boost and algorithm #endif // BOOST_ALGORITHM_COPY_IF_HPP PK��M�[��l)c��c��cxx11/is_partitioned.hppnu��[��/ 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) / /// \file is_partitioned.hpp /// \brief Tell if a sequence is partitioned /// \author Marshall Clow #ifndef BOOST_ALGORITHM_IS_PARTITIONED_HPP #define BOOST_ALGORITHM_IS_PARTITIONED_HPP #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> namespace boost { namespace algorithm { /// \fn is_partitioned ( InputIterator first, InputIterator last, UnaryPredicate p ) /// \brief 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. /// /// \param first The start of the input sequence /// \param last One past the end of the input sequence /// \param p The predicate to test the values with /// \note This function is part of the C++2011 standard library. template <typename InputIterator, typename UnaryPredicate> BOOST_CXX14_CONSTEXPR bool is_partitioned ( InputIterator first, InputIterator last, UnaryPredicate p ) { // 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 for ( ; first != last; ++first ) if ( p (first)) return false; return true; } /// \fn is_partitioned ( const Range &r, UnaryPredicate p ) /// \brief 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. /// /// \param r The input range /// \param p The predicate to test the values with /// template <typename Range, typename UnaryPredicate> BOOST_CXX14_CONSTEXPR bool is_partitioned ( const Range &r, UnaryPredicate p ) { return boost::algorithm::is_partitioned (boost::begin(r), boost::end(r), p); } }} #endif // BOOST_ALGORITHM_IS_PARTITIONED_HPP PK��M�[9Pjt� �� cxx11/none_of.hppnu��[��/ Copyright (c) Marshall Clow 2008-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) / /// \file none_of.hpp /// \brief Test ranges to see if no elements match a value or predicate. /// \author Marshall Clow #ifndef BOOST_ALGORITHM_NONE_OF_HPP #define BOOST_ALGORITHM_NONE_OF_HPP #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> namespace boost { namespace algorithm { /// \fn none_of ( InputIterator first, InputIterator last, Predicate p ) /// \return true if none of the elements in [first, last) satisfy the predicate 'p' /// \note returns true on an empty range /// /// \param first The start of the input sequence /// \param last One past the end of the input sequence /// \param p A predicate for testing the elements of the sequence /// template<typename InputIterator, typename Predicate> BOOST_CXX14_CONSTEXPR bool none_of ( InputIterator first, InputIterator last, Predicate p ) { for ( ; first != last; ++first ) if ( p(first)) return false; return true; } /// \fn none_of ( const Range &r, Predicate p ) /// \return true if none of the elements in the range satisfy the predicate 'p' /// \note returns true on an empty range /// /// \param r The input range /// \param p A predicate for testing the elements of the range /// template<typename Range, typename Predicate> BOOST_CXX14_CONSTEXPR bool none_of ( const Range &r, Predicate p ) { return boost::algorithm::none_of (boost::begin (r), boost::end (r), p ); } /// \fn none_of_equal ( InputIterator first, InputIterator last, const V &val ) /// \return true if none of the elements in [first, last) are equal to 'val' /// \note returns true on an empty range /// /// \param first The start of the input sequence /// \param last One past the end of the input sequence /// \param val A value to compare against /// template<typename InputIterator, typename V> BOOST_CXX14_CONSTEXPR bool none_of_equal ( InputIterator first, InputIterator last, const V &val ) { for ( ; first != last; ++first ) if ( val == first ) return false; return true; } /// \fn none_of_equal ( const Range &r, const V &val ) /// \return true if none of the elements in the range are equal to 'val' /// \note returns true on an empty range /// /// \param r The input range /// \param val A value to compare against /// template<typename Range, typename V> BOOST_CXX14_CONSTEXPR bool none_of_equal ( const Range &r, const V & val ) { return boost::algorithm::none_of_equal (boost::begin (r), boost::end (r), val); } }} // namespace boost and algorithm #endif // BOOST_ALGORITHM_NONE_OF_HPP PK��M�[a!�^��^��cxx11/one_of.hppnu��[��/ Copyright (c) Marshall Clow 2008-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) / /// \file one_of.hpp /// \brief Test ranges to see if only one element matches a value or predicate. /// \author Marshall Clow #ifndef BOOST_ALGORITHM_ONE_OF_HPP #define BOOST_ALGORITHM_ONE_OF_HPP #include <boost/config.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/algorithm/cxx11/none_of.hpp> namespace boost { namespace algorithm { /// \fn one_of ( InputIterator first, InputIterator last, Predicate p ) /// \return true if the predicate 'p' is true for exactly one item in [first, last). /// /// \param first The start of the input sequence /// \param last One past the end of the input sequence /// \param p A predicate for testing the elements of the sequence /// template<typename InputIterator, typename Predicate> BOOST_CXX14_CONSTEXPR bool one_of ( InputIterator first, InputIterator last, Predicate p ) { // find_if for (; first != last; ++first) if (p(first)) break; if (first == last) return false; // Didn't occur at all return boost::algorithm::none_of (++first, last, p); } /// \fn one_of ( const Range &r, Predicate p ) /// \return true if the predicate 'p' is true for exactly one item in the range. /// /// \param r The input range /// \param p A predicate for testing the elements of the range /// template<typename Range, typename Predicate> BOOST_CXX14_CONSTEXPR bool one_of ( const Range &r, Predicate p ) { return boost::algorithm::one_of ( boost::begin (r), boost::end (r), p ); } /// \fn one_of_equal ( InputIterator first, InputIterator last, const V &val ) /// \return true if the value 'val' exists only once in [first, last). /// /// \param first The start of the input sequence /// \param last One past the end of the input sequence /// \param val A value to compare against /// template<typename InputIterator, typename V> BOOST_CXX14_CONSTEXPR bool one_of_equal ( InputIterator first, InputIterator last, const V &val ) { // find for (; first != last; ++first) if (first == val) break; if (first == last) return false; // Didn't occur at all return boost::algorithm::none_of_equal (++first, last, val); } /// \fn one_of_equal ( const Range &r, const V &val ) /// \return true if the value 'val' exists only once in the range. /// /// \param r The input range /// \param val A value to compare against /// template<typename Range, typename V> BOOST_CXX14_CONSTEXPR bool one_of_equal ( const Range &r, const V &val ) { return boost::algorithm::one_of_equal ( boost::begin (r), boost::end (r), val ); } }} // namespace boost and algorithm #endif // BOOST_ALGORITHM_ALL_HPP PK��M�[������ searching/knuth_morris_pratt.hppnu��[��/ 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 / #ifndef BOOST_ALGORITHM_KNUTH_MORRIS_PRATT_SEARCH_HPP #define BOOST_ALGORITHM_KNUTH_MORRIS_PRATT_SEARCH_HPP #include <vector> #include <iterator> // for std::iterator_traits #include <boost/config.hpp> #include <boost/assert.hpp> #include <boost/static_assert.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/utility/enable_if.hpp> #include <boost/type_traits/is_same.hpp> #include <boost/algorithm/searching/detail/debugging.hpp> // #define BOOST_ALGORITHM_KNUTH_MORRIS_PRATT_DEBUG namespace boost { namespace algorithm { // #define NEW_KMP / A templated version of the Knuth-Morris-Pratt searching algorithm. Requirements: * 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://www.inf.fh-flensburg.de/lang/algorithmen/pattern/kmpen.htm / template <typename patIter> class knuth_morris_pratt { typedef typename std::iterator_traits<patIter>::difference_type difference_type; public: knuth_morris_pratt ( patIter first, patIter last ) : pat_first ( first ), pat_last ( last ), k_pattern_length ( std::distance ( pat_first, pat_last )), skip_ ( k_pattern_length + 1 ) { #ifdef NEW_KMP preKmp ( pat_first, pat_last ); #else init_skip_table ( pat_first, pat_last ); #endif #ifdef BOOST_ALGORITHM_KNUTH_MORRIS_PRATT_DEBUG detail::PrintTable ( skip_.begin (), skip_.end ()); #endif } ~knuth_morris_pratt () {} /// \fn operator ( corpusIter corpus_first, corpusIter corpus_last, Pred p ) /// \brief Searches the corpus for the pattern that was passed into the constructor /// /// \param corpus_first The start of the data to search (Random Access Iterator) /// \param corpus_last One past the end of the data to search /// \param p A predicate used for the search comparisons. /// template <typename corpusIter> std::pair<corpusIter, corpusIter> operator () ( corpusIter corpus_first, corpusIter corpus_last ) const { BOOST_STATIC_ASSERT (( boost::is_same< typename std::iterator_traits<patIter>::value_type, typename std::iterator_traits<corpusIter>::value_type>::value )); if ( corpus_first == corpus_last ) return std::make_pair(corpus_last, corpus_last); // if nothing to search, we didn't find it! if ( pat_first == pat_last ) return std::make_pair(corpus_first, corpus_first); // empty pattern matches at start const difference_type k_corpus_length = std::distance ( corpus_first, corpus_last ); // If the pattern is larger than the corpus, we can't find it! if ( k_corpus_length < k_pattern_length ) return std::make_pair(corpus_last, corpus_last); return do_search ( corpus_first, corpus_last, k_corpus_length ); } template <typename Range> std::pair<typename boost::range_iterator<Range>::type, 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; const difference_type k_pattern_length; std::vector <difference_type> skip_; /// \fn operator ( corpusIter corpus_first, corpusIter corpus_last, Pred p ) /// \brief Searches the corpus for the pattern that was passed into the constructor /// /// \param corpus_first The start of the data to search (Random Access Iterator) /// \param corpus_last One past the end of the data to search /// \param p A predicate used for the search comparisons. /// template <typename corpusIter> std::pair<corpusIter, corpusIter> do_search ( corpusIter corpus_first, corpusIter corpus_last, difference_type k_corpus_length ) const { difference_type match_start = 0; // position in the corpus that we're matching #ifdef NEW_KMP int patternIdx = 0; while ( match_start < k_corpus_length ) { while ( patternIdx > -1 && pat_first[patternIdx] != corpus_first [match_start] ) patternIdx = skip_ [patternIdx]; //<--- Shifting the pattern on mismatch patternIdx++; match_start++; //<--- corpus is always increased by 1 if ( patternIdx >= (int) k_pattern_length ) return corpus_first + match_start - patternIdx; } #else // At this point, we know: // k_pattern_length <= k_corpus_length // for all elements of skip, it holds -1 .. k_pattern_length // // In the loop, we have the following invariants // idx is in the range 0 .. k_pattern_length // match_start is in the range 0 .. k_corpus_length - k_pattern_length + 1 const difference_type last_match = k_corpus_length - k_pattern_length; difference_type idx = 0; // position in the pattern we're comparing while ( match_start <= last_match ) { while ( pat_first [ idx ] == corpus_first [ match_start + idx ] ) { if ( ++idx == k_pattern_length ) return std::make_pair(corpus_first + match_start, corpus_first + match_start + k_pattern_length); } // Figure out where to start searching again // assert ( idx - skip_ [ idx ] > 0 ); // we're always moving forward match_start += idx - skip_ [ idx ]; idx = skip_ [ idx ] >= 0 ? skip_ [ idx ] : 0; // assert ( idx >= 0 && idx < k_pattern_length ); } #endif // We didn't find anything return std::make_pair(corpus_last, corpus_last); } void preKmp ( patIter first, patIter last ) { const difference_type count = std::distance ( first, last ); difference_type i, j; i = 0; j = skip_[0] = -1; while (i < count) { while (j > -1 && first[i] != first[j]) j = skip_[j]; i++; j++; if (first[i] == first[j]) skip_[i] = skip_[j]; else skip_[i] = j; } } void init_skip_table ( patIter first, patIter last ) { const difference_type count = std::distance ( first, last ); difference_type j; skip_ [ 0 ] = -1; for ( int i = 1; i <= count; ++i ) { j = skip_ [ i - 1 ]; while ( j >= 0 ) { if ( first [ j ] == first [ i - 1 ] ) break; j = skip_ [ j ]; } skip_ [ i ] = j + 1; } } // \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 knuth_morris_pratt_search ( corpusIter corpus_first, corpusIter corpus_last, /// patIter pat_first, patIter pat_last ) /// \brief Searches the corpus for the pattern. /// /// \param corpus_first The start of the data to search (Random Access Iterator) /// \param corpus_last One past the end of the data to search /// \param pat_first The start of the pattern to search for (Random Access Iterator) /// \param pat_last One past the end of the data to search for /// template <typename patIter, typename corpusIter> std::pair<corpusIter, corpusIter> knuth_morris_pratt_search ( 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> std::pair<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::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 ) { knuth_morris_pratt<patIter> kmp ( pat_first, pat_last ); return kmp (boost::begin (corpus), boost::end (corpus)); } 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 ) { 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)); } }} #endif // BOOST_ALGORITHM_KNUTH_MORRIS_PRATT_SEARCH_HPP PK��M�[z�bE��E��searching/detail/debugging.hppnu��[��/ 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 / #ifndef BOOST_ALGORITHM_SEARCH_DETAIL_DEBUG_HPP #define BOOST_ALGORITHM_SEARCH_DETAIL_DEBUG_HPP #include <iostream> /// \cond DOXYGEN_HIDE namespace boost { namespace algorithm { namespace detail { // Debugging support template <typename Iter> void PrintTable ( Iter first, Iter last ) { std::cout << std::distance ( first, last ) << ": { "; for ( Iter iter = first; iter != last; ++iter ) std::cout << iter << " "; std::cout << "}" << std::endl; } }}} /// \endcond #endif // BOOST_ALGORITHM_SEARCH_DETAIL_DEBUG_HPP PK��M�[L`��searching/detail/bm_traits.hppnu��[��/* 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 / #ifndef BOOST_ALGORITHM_SEARCH_DETAIL_BM_TRAITS_HPP #define BOOST_ALGORITHM_SEARCH_DETAIL_BM_TRAITS_HPP #include <climits> // for CHAR_BIT #include <vector> #include <iterator> // for std::iterator_traits #include <boost/type_traits/make_unsigned.hpp> #include <boost/type_traits/is_integral.hpp> #include <boost/type_traits/remove_pointer.hpp> #include <boost/type_traits/remove_const.hpp> #include <boost/array.hpp> #ifdef BOOST_NO_CXX11_HDR_UNORDERED_MAP #include <boost/unordered_map.hpp> #else #include <unordered_map> #endif #include <boost/algorithm/searching/detail/debugging.hpp> namespace boost { namespace algorithm { namespace detail { // // Default implementations of the skip tables for B-M and B-M-H // template<typename key_type, typename value_type, bool /useArray/> class skip_table; // General case for data searching other than bytes; use a map template<typename key_type, typename value_type> class skip_table<key_type, value_type, false> { private: #ifdef BOOST_NO_CXX11_HDR_UNORDERED_MAP typedef boost::unordered_map<key_type, value_type> skip_map; #else typedef std::unordered_map<key_type, value_type> skip_map; #endif const value_type k_default_value; skip_map skip_; public: skip_table ( std::size_t patSize, value_type default_value ) : k_default_value ( default_value ), skip_ ( patSize ) {} void insert ( key_type key, value_type val ) { skip_ [ key ] = val; // Would skip_.insert (val) be better here? } value_type operator [] ( key_type key ) const { typename skip_map::const_iterator it = skip_.find ( key ); return it == skip_.end () ? k_default_value : it->second; } void PrintSkipTable () const { std::cout << "BM(H) Skip Table <unordered_map>:" << std::endl; for ( typename skip_map::const_iterator it = skip_.begin (); it != skip_.end (); ++it ) if ( it->second != k_default_value ) std::cout << " " << it->first << ": " << it->second << std::endl; std::cout << std::endl; } }; // Special case small numeric values; use an array template<typename key_type, typename value_type> class skip_table<key_type, value_type, true> { private: typedef typename boost::make_unsigned<key_type>::type unsigned_key_type; typedef boost::array<value_type, 1U << (CHAR_BIT sizeof(key_type))> skip_map; skip_map skip_; const value_type k_default_value; public: skip_table ( std::size_t /patSize/, value_type default_value ) : k_default_value ( default_value ) { std::fill_n ( skip_.begin(), skip_.size(), default_value ); } void insert ( key_type key, value_type val ) { skip_ [ static_cast<unsigned_key_type> ( key ) ] = val; } value_type operator [] ( key_type key ) const { return skip_ [ static_cast<unsigned_key_type> ( key ) ]; } void PrintSkipTable () const { std::cout << "BM(H) Skip Table <boost:array>:" << std::endl; for ( typename skip_map::const_iterator it = skip_.begin (); it != skip_.end (); ++it ) if ( it != k_default_value ) std::cout << " " << std::distance (skip_.begin (), it) << ": " << it << std::endl; std::cout << std::endl; } }; template<typename Iterator> struct BM_traits { typedef typename std::iterator_traits<Iterator>::difference_type value_type; typedef typename std::iterator_traits<Iterator>::value_type key_type; typedef boost::algorithm::detail::skip_table<key_type, value_type, boost::is_integral<key_type>::value && (sizeof(key_type)==1)> skip_table_t; }; }}} // namespaces #endif // BOOST_ALGORITHM_SEARCH_DETAIL_BM_TRAITS_HPP PK��M�[T)��8"��8"��"��searching/boyer_moore_horspool.hppnu��[��/* 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 / #ifndef BOOST_ALGORITHM_BOYER_MOORE_HORSPOOOL_SEARCH_HPP #define BOOST_ALGORITHM_BOYER_MOORE_HORSPOOOL_SEARCH_HPP #include <iterator> // for std::iterator_traits #include <boost/config.hpp> #include <boost/assert.hpp> #include <boost/static_assert.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/utility/enable_if.hpp> #include <boost/type_traits/is_same.hpp> #include <boost/algorithm/searching/detail/bm_traits.hpp> #include <boost/algorithm/searching/detail/debugging.hpp> // #define BOOST_ALGORITHM_BOYER_MOORE_HORSPOOL_DEBUG_HPP namespace boost { namespace algorithm { / A templated version of the boyer-moore-horspool searching algorithm. Requirements: * Random access iterators * The two iterator types (patIter and corpusIter) must "point to" the same underlying type. * Additional requirements may be imposed buy the skip table, such as: Numeric type (array-based skip table) Hashable type (map-based skip table) http://www-igm.univ-mlv.fr/%7Elecroq/string/node18.html / template <typename patIter, typename traits = detail::BM_traits<patIter> > class boyer_moore_horspool { typedef typename std::iterator_traits<patIter>::difference_type difference_type; public: boyer_moore_horspool ( patIter first, patIter last ) : pat_first ( first ), pat_last ( last ), k_pattern_length ( std::distance ( pat_first, pat_last )), skip_ ( k_pattern_length, k_pattern_length ) { // Build the skip table std::size_t i = 0; if ( first != last ) // empty pattern? for ( patIter iter = first; iter != last-1; ++iter, ++i ) skip_.insert ( iter, k_pattern_length - 1 - i ); #ifdef BOOST_ALGORITHM_BOYER_MOORE_HORSPOOL_DEBUG_HPP skip_.PrintSkipTable (); #endif } ~boyer_moore_horspool () {} /// \fn operator ( corpusIter corpus_first, corpusIter corpus_last) /// \brief Searches the corpus for the pattern that was passed into the constructor /// /// \param corpus_first The start of the data to search (Random Access Iterator) /// \param corpus_last One past the end of the data to search /// template <typename corpusIter> std::pair<corpusIter, corpusIter> operator () ( corpusIter corpus_first, corpusIter corpus_last ) const { BOOST_STATIC_ASSERT (( boost::is_same< typename std::iterator_traits<patIter>::value_type, typename std::iterator_traits<corpusIter>::value_type>::value )); if ( corpus_first == corpus_last ) return std::make_pair(corpus_last, corpus_last); // if nothing to search, we didn't find it! if ( pat_first == pat_last ) return std::make_pair(corpus_first, corpus_first); // empty pattern matches at start const difference_type k_corpus_length = std::distance ( corpus_first, corpus_last ); // If the pattern is larger than the corpus, we can't find it! if ( k_corpus_length < k_pattern_length ) return std::make_pair(corpus_last, corpus_last); // Do the search return this->do_search ( corpus_first, corpus_last ); } template <typename Range> std::pair<typename boost::range_iterator<Range>::type, 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; const difference_type k_pattern_length; typename traits::skip_table_t skip_; /// \fn do_search ( corpusIter corpus_first, corpusIter corpus_last ) /// \brief Searches the corpus for the pattern that was passed into the constructor /// /// \param corpus_first The start of the data to search (Random Access Iterator) /// \param corpus_last One past the end of the data to search /// \param k_corpus_length The length of the corpus to search /// template <typename corpusIter> std::pair<corpusIter, corpusIter> do_search ( corpusIter corpus_first, corpusIter corpus_last ) const { corpusIter curPos = corpus_first; const corpusIter lastPos = corpus_last - k_pattern_length; while ( curPos <= lastPos ) { // Do we match right where we are? std::size_t j = k_pattern_length - 1; while ( pat_first [j] == curPos [j] ) { // We matched - we're done! if ( j == 0 ) return std::make_pair(curPos, curPos + k_pattern_length); j--; } curPos += skip_ [ curPos [ k_pattern_length - 1 ]]; } return std::make_pair(corpus_last, corpus_last); } // \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. /// /// \param corpus_first The start of the data to search (Random Access Iterator) /// \param corpus_last One past the end of the data to search /// \param pat_first The start of the pattern to search for (Random Access Iterator) /// \param pat_last One past the end of the data to search for /// template <typename patIter, typename corpusIter> std::pair<corpusIter, corpusIter> boyer_moore_horspool_search ( 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> std::pair<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::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 ) { boyer_moore_horspool<patIter> bmh ( pat_first, pat_last ); return bm (boost::begin (corpus), boost::end (corpus)); } 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 ) { 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)); } }} #endif // BOOST_ALGORITHM_BOYER_MOORE_HORSPOOOL_SEARCH_HPP PK��M�[��ܮ--��--��searching/boyer_moore.hppnu��[��/ 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 / #ifndef BOOST_ALGORITHM_BOYER_MOORE_SEARCH_HPP #define BOOST_ALGORITHM_BOYER_MOORE_SEARCH_HPP #include <iterator> // for std::iterator_traits #include <boost/config.hpp> #include <boost/assert.hpp> #include <boost/static_assert.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/utility/enable_if.hpp> #include <boost/type_traits/is_same.hpp> #include <boost/algorithm/searching/detail/bm_traits.hpp> #include <boost/algorithm/searching/detail/debugging.hpp> namespace boost { namespace algorithm { / A templated version of the boyer-moore searching algorithm. References: http://www.cs.utexas.edu/users/moore/best-ideas/string-searching/ http://www.cs.utexas.edu/~moore/publications/fstrpos.pdf Explanations: http://en.wikipedia.org/wiki/Boyer%E2%80%93Moore_string_search_algorithm http://www.movsd.com/bm.htm http://www.cs.ucdavis.edu/~gusfield/cs224f09/bnotes.pdf The Boyer-Moore search algorithm uses two tables, a "bad character" table to tell how far to skip ahead when it hits a character that is not in the pattern, and a "good character" table to tell how far to skip ahead when it hits a mismatch on a character that _is_ in the pattern. Requirements: * Random access iterators * The two iterator types (patIter and corpusIter) must "point to" the same underlying type and be comparable. * Additional requirements may be imposed but the skip table, such as: Numeric type (array-based skip table) Hashable type (map-based skip table) / template <typename patIter, typename traits = detail::BM_traits<patIter> > class boyer_moore { typedef typename std::iterator_traits<patIter>::difference_type difference_type; public: boyer_moore ( patIter first, patIter last ) : pat_first ( first ), pat_last ( last ), k_pattern_length ( std::distance ( pat_first, pat_last )), skip_ ( k_pattern_length, -1 ), suffix_ ( k_pattern_length + 1 ) { this->build_skip_table ( first, last ); this->build_suffix_table ( first, last ); } ~boyer_moore () {} /// \fn operator ( corpusIter corpus_first, corpusIter corpus_last ) /// \brief Searches the corpus for the pattern that was passed into the constructor /// /// \param corpus_first The start of the data to search (Random Access Iterator) /// \param corpus_last One past the end of the data to search /// template <typename corpusIter> std::pair<corpusIter, corpusIter> operator () ( corpusIter corpus_first, corpusIter corpus_last ) const { BOOST_STATIC_ASSERT (( boost::is_same< typename std::iterator_traits<patIter>::value_type, typename std::iterator_traits<corpusIter>::value_type>::value )); if ( corpus_first == corpus_last ) return std::make_pair(corpus_last, corpus_last); // if nothing to search, we didn't find it! if ( pat_first == pat_last ) return std::make_pair(corpus_first, corpus_first); // empty pattern matches at start const difference_type k_corpus_length = std::distance ( corpus_first, corpus_last ); // If the pattern is larger than the corpus, we can't find it! if ( k_corpus_length < k_pattern_length ) return std::make_pair(corpus_last, corpus_last); // Do the search return this->do_search ( corpus_first, corpus_last ); } template <typename Range> std::pair<typename boost::range_iterator<Range>::type, 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; const difference_type k_pattern_length; typename traits::skip_table_t skip_; std::vector <difference_type> suffix_; /// \fn operator ( corpusIter corpus_first, corpusIter corpus_last, Pred p ) /// \brief Searches the corpus for the pattern that was passed into the constructor /// /// \param corpus_first The start of the data to search (Random Access Iterator) /// \param corpus_last One past the end of the data to search /// \param p A predicate used for the search comparisons. /// template <typename corpusIter> std::pair<corpusIter, corpusIter> do_search ( corpusIter corpus_first, corpusIter corpus_last ) const { /* ---- Do the matching ---- / corpusIter curPos = corpus_first; const corpusIter lastPos = corpus_last - k_pattern_length; difference_type j, k, m; while ( curPos <= lastPos ) { / while ( std::distance ( curPos, corpus_last ) >= k_pattern_length ) { / // Do we match right where we are? j = k_pattern_length; while ( pat_first [j-1] == curPos [j-1] ) { j--; // We matched - we're done! if ( j == 0 ) return std::make_pair(curPos, curPos + k_pattern_length); } // Since we didn't match, figure out how far to skip forward k = skip_ [ curPos [ j - 1 ]]; m = j - k - 1; if ( k < j && m > suffix_ [ j ] ) curPos += m; else curPos += suffix_ [ j ]; } return std::make_pair(corpus_last, corpus_last); // We didn't find anything } void build_skip_table ( patIter first, patIter last ) { for ( std::size_t i = 0; first != last; ++first, ++i ) skip_.insert ( first, i ); } template<typename Iter, typename Container> void compute_bm_prefix ( Iter first, Iter last, Container &prefix ) { const std::size_t count = std::distance ( first, last ); BOOST_ASSERT ( count > 0 ); BOOST_ASSERT ( prefix.size () == count ); prefix[0] = 0; std::size_t k = 0; for ( std::size_t i = 1; i < count; ++i ) { BOOST_ASSERT ( k < count ); while ( k > 0 && ( first[k] != first[i] )) { BOOST_ASSERT ( k < count ); k = prefix [ k - 1 ]; } if ( first[k] == first[i] ) k++; prefix [ i ] = k; } } void build_suffix_table ( patIter first, patIter last ) { const std::size_t count = (std::size_t) std::distance ( first, last ); if ( count > 0 ) { // empty pattern std::vector<typename std::iterator_traits<patIter>::value_type> reversed(count); (void) std::reverse_copy ( first, last, reversed.begin ()); std::vector<difference_type> prefix (count); compute_bm_prefix ( first, last, prefix ); std::vector<difference_type> prefix_reversed (count); compute_bm_prefix ( reversed.begin (), reversed.end (), prefix_reversed ); for ( std::size_t i = 0; i <= count; i++ ) suffix_[i] = count - prefix [count-1]; for ( std::size_t i = 0; i < count; i++ ) { const std::size_t j = count - prefix_reversed[i]; const difference_type k = i - prefix_reversed[i] + 1; if (suffix_[j] > k) suffix_[j] = k; } } } /// \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_search ( corpusIter corpus_first, corpusIter corpus_last, /// patIter pat_first, patIter pat_last ) /// \brief Searches the corpus for the pattern. /// /// \param corpus_first The start of the data to search (Random Access Iterator) /// \param corpus_last One past the end of the data to search /// \param pat_first The start of the pattern to search for (Random Access Iterator) /// \param pat_last One past the end of the data to search for /// template <typename patIter, typename corpusIter> std::pair<corpusIter, corpusIter> boyer_moore_search ( corpusIter corpus_first, corpusIter corpus_last, patIter pat_first, patIter pat_last ) { boyer_moore<patIter> bm ( pat_first, pat_last ); return bm ( corpus_first, corpus_last ); } template <typename PatternRange, typename corpusIter> std::pair<corpusIter, corpusIter> boyer_moore_search ( corpusIter corpus_first, corpusIter corpus_last, const PatternRange &pattern ) { 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 ); } template <typename patIter, typename CorpusRange> typename 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 ) { boyer_moore<patIter> bm ( pat_first, pat_last ); return bm (boost::begin (corpus), boost::end (corpus)); } 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 ) { 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)); } // Creator functions -- take a pattern range, return an object template <typename Range> boost::algorithm::boyer_moore<typename boost::range_iterator<const Range>::type> make_boyer_moore ( const Range &r ) { return boost::algorithm::boyer_moore <typename boost::range_iterator<const Range>::type> (boost::begin(r), boost::end(r)); } template <typename Range> boost::algorithm::boyer_moore<typename boost::range_iterator<Range>::type> make_boyer_moore ( Range &r ) { return boost::algorithm::boyer_moore <typename boost::range_iterator<Range>::type> (boost::begin(r), boost::end(r)); } }} #endif // BOOST_ALGORITHM_BOYER_MOORE_SEARCH_HPP PK��!\��m��count_if.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_COUNT_IF_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_COUNT_IF_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/range/difference_type.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function count_if /// /// range-based version of the count_if std algorithm /// /// \pre SinglePassRange is a model of the SinglePassRangeConcept /// \pre UnaryPredicate is a model of the UnaryPredicateConcept template< class SinglePassRange, class UnaryPredicate > inline BOOST_DEDUCED_TYPENAME boost::range_difference<SinglePassRange>::type count_if(SinglePassRange& rng, UnaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> )); return std::count_if(boost::begin(rng), boost::end(rng), pred); } /// \overload template< class SinglePassRange, class UnaryPredicate > inline BOOST_DEDUCED_TYPENAME boost::range_difference<const SinglePassRange>::type count_if(const SinglePassRange& rng, UnaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> )); return std::count_if(boost::begin(rng), boost::end(rng), pred); } } // namespace range using range::count_if; } // namespace boost #endif // include guard PK��!\~�H� �� stable_partition.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_STABLE_PARTITION_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_STABLE_PARTITION_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/range/detail/range_return.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function stable_partition /// /// range-based version of the stable_partition std algorithm /// /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept /// \pre UnaryPredicate is a model of the UnaryPredicateConcept template<class BidirectionalRange, class UnaryPredicate> inline BOOST_DEDUCED_TYPENAME range_iterator<BidirectionalRange>::type stable_partition(BidirectionalRange& rng, UnaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> )); return std::stable_partition(boost::begin(rng), boost::end(rng), pred); } /// \overload template<class BidirectionalRange, class UnaryPredicate> inline BOOST_DEDUCED_TYPENAME range_iterator<const BidirectionalRange>::type stable_partition(const BidirectionalRange& rng, UnaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> )); return std::stable_partition(boost::begin(rng),boost::end(rng),pred); } // range_return overloads template<range_return_value re, class BidirectionalRange, class UnaryPredicate> inline BOOST_DEDUCED_TYPENAME range_return<BidirectionalRange,re>::type stable_partition(BidirectionalRange& rng, UnaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> )); return range_return<BidirectionalRange,re>::pack( std::stable_partition(boost::begin(rng), boost::end(rng), pred), rng); } /// \overload template<range_return_value re, class BidirectionalRange, class UnaryPredicate> inline BOOST_DEDUCED_TYPENAME range_return<const BidirectionalRange,re>::type stable_partition(const BidirectionalRange& rng, UnaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> )); return range_return<const BidirectionalRange,re>::pack( std::stable_partition(boost::begin(rng),boost::end(rng),pred), rng); } } // namespace range using range::stable_partition; } // namespace boost #endif // include guard PK��!\V�C�/��/��mismatch.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_MISMATCH_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_MISMATCH_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/range/difference_type.hpp> #include <algorithm> namespace boost { namespace range_detail { template< class SinglePassTraversalReadableIterator1, class SinglePassTraversalReadableIterator2 > inline std::pair<SinglePassTraversalReadableIterator1, SinglePassTraversalReadableIterator2> mismatch_impl(SinglePassTraversalReadableIterator1 first1, SinglePassTraversalReadableIterator1 last1, SinglePassTraversalReadableIterator2 first2, SinglePassTraversalReadableIterator2 last2) { while (first1 != last1 && first2 != last2 && first1 == first2) { ++first1; ++first2; } return std::pair<SinglePassTraversalReadableIterator1, SinglePassTraversalReadableIterator2>(first1, first2); } template< class SinglePassTraversalReadableIterator1, class SinglePassTraversalReadableIterator2, class BinaryPredicate > inline std::pair<SinglePassTraversalReadableIterator1, SinglePassTraversalReadableIterator2> mismatch_impl(SinglePassTraversalReadableIterator1 first1, SinglePassTraversalReadableIterator1 last1, SinglePassTraversalReadableIterator2 first2, SinglePassTraversalReadableIterator2 last2, BinaryPredicate pred) { while (first1 != last1 && first2 != last2 && pred(first1, first2)) { ++first1; ++first2; } return std::pair<SinglePassTraversalReadableIterator1, SinglePassTraversalReadableIterator2>(first1, first2); } } // namespace range_detail namespace range { /// \brief template function mismatch /// /// range-based version of the mismatch std algorithm /// /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept template< class SinglePassRange1, class SinglePassRange2 > inline std::pair< BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type, BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type > mismatch(SinglePassRange1& rng1, const SinglePassRange2 & rng2) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> )); return ::boost::range_detail::mismatch_impl( ::boost::begin(rng1), ::boost::end(rng1), ::boost::begin(rng2), ::boost::end(rng2)); } /// \overload template< class SinglePassRange1, class SinglePassRange2 > inline std::pair< BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type, BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type > mismatch(const SinglePassRange1& rng1, const SinglePassRange2& rng2) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> )); return ::boost::range_detail::mismatch_impl( ::boost::begin(rng1), ::boost::end(rng1), ::boost::begin(rng2), ::boost::end(rng2)); } /// \overload template< class SinglePassRange1, class SinglePassRange2 > inline std::pair< BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type, BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type > mismatch(SinglePassRange1& rng1, SinglePassRange2 & rng2) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> )); return ::boost::range_detail::mismatch_impl( ::boost::begin(rng1), ::boost::end(rng1), ::boost::begin(rng2), ::boost::end(rng2)); } /// \overload template< class SinglePassRange1, class SinglePassRange2 > inline std::pair< BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type, BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type > mismatch(const SinglePassRange1& rng1, SinglePassRange2& rng2) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> )); return ::boost::range_detail::mismatch_impl( ::boost::begin(rng1), ::boost::end(rng1), ::boost::begin(rng2), ::boost::end(rng2)); } /// \overload template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate > inline std::pair< BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type, BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type > mismatch(SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> )); return ::boost::range_detail::mismatch_impl( ::boost::begin(rng1), ::boost::end(rng1), ::boost::begin(rng2), ::boost::end(rng2), pred); } /// \overload template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate > inline std::pair< BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type, BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange2>::type > mismatch(const SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> )); return ::boost::range_detail::mismatch_impl( ::boost::begin(rng1), ::boost::end(rng1), ::boost::begin(rng2), ::boost::end(rng2), pred); } /// \overload template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate > inline std::pair< BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type, BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type > mismatch(SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> )); return ::boost::range_detail::mismatch_impl( ::boost::begin(rng1), ::boost::end(rng1), ::boost::begin(rng2), ::boost::end(rng2), pred); } /// \overload template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate > inline std::pair< BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type, BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange2>::type > mismatch(const SinglePassRange1& rng1, SinglePassRange2& rng2, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange2> )); return ::boost::range_detail::mismatch_impl( ::boost::begin(rng1), ::boost::end(rng1), ::boost::begin(rng2), ::boost::end(rng2), pred); } } // namespace range using range::mismatch; } // namespace boost #endif // include guard PK��!\�E�q��swap_ranges.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_SWAP_RANGES_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_SWAP_RANGES_HPP_INCLUDED #include <boost/assert.hpp> #include <boost/concept_check.hpp> #include <boost/iterator/iterator_categories.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/range/iterator.hpp> #include <algorithm> namespace boost { namespace range_detail { template<class Iterator1, class Iterator2> void swap_ranges_impl(Iterator1 it1, Iterator1 last1, Iterator2 it2, Iterator2 last2, single_pass_traversal_tag, single_pass_traversal_tag) { ignore_unused_variable_warning(last2); for (; it1 != last1; ++it1, ++it2) { BOOST_ASSERT( it2 != last2 ); std::iter_swap(it1, it2); } } template<class Iterator1, class Iterator2> void swap_ranges_impl(Iterator1 it1, Iterator1 last1, Iterator2 it2, Iterator2 last2, random_access_traversal_tag, random_access_traversal_tag) { ignore_unused_variable_warning(last2); BOOST_ASSERT( last2 - it2 >= last1 - it1 ); std::swap_ranges(it1, last1, it2); } template<class Iterator1, class Iterator2> void swap_ranges_impl(Iterator1 first1, Iterator1 last1, Iterator2 first2, Iterator2 last2) { swap_ranges_impl(first1, last1, first2, last2, BOOST_DEDUCED_TYPENAME iterator_traversal<Iterator1>::type(), BOOST_DEDUCED_TYPENAME iterator_traversal<Iterator2>::type()); } } // namespace range_detail namespace range { /// \brief template function swap_ranges /// /// range-based version of the swap_ranges std algorithm /// /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept template< class SinglePassRange1, class SinglePassRange2 > inline SinglePassRange2& swap_ranges(SinglePassRange1& range1, SinglePassRange2& range2) { BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange1>)); BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange2>)); boost::range_detail::swap_ranges_impl( boost::begin(range1), boost::end(range1), boost::begin(range2), boost::end(range2)); return range2; } /// \overload template< class SinglePassRange1, class SinglePassRange2 > inline SinglePassRange2& swap_ranges(const SinglePassRange1& range1, SinglePassRange2& range2) { BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<const SinglePassRange1>)); BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange2>)); boost::range_detail::swap_ranges_impl( boost::begin(range1), boost::end(range1), boost::begin(range2), boost::end(range2)); return range2; } /// \overload template< class SinglePassRange1, class SinglePassRange2 > inline const SinglePassRange2& swap_ranges(SinglePassRange1& range1, const SinglePassRange2& range2) { BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<SinglePassRange1>)); BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<const SinglePassRange2>)); boost::range_detail::swap_ranges_impl( boost::begin(range1), boost::end(range1), boost::begin(range2), boost::end(range2)); return range2; } /// \overload template< class SinglePassRange1, class SinglePassRange2 > inline const SinglePassRange2& swap_ranges(const SinglePassRange1& range1, const SinglePassRange2& range2) { BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<const SinglePassRange1>)); BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<const SinglePassRange2>)); boost::range_detail::swap_ranges_impl( boost::begin(range1), boost::end(range1), boost::begin(range2), boost::end(range2)); return range2; } } // namespace range using range::swap_ranges; } // namespace boost #endif // include guard PK��!\/�� fill_n.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_FILL_N_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_FILL_N_HPP_INCLUDED #include <boost/assert.hpp> #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function fill_n /// /// range-based version of the fill_n std algorithm /// /// \pre ForwardRange is a model of the ForwardRangeConcept /// \pre n <= std::distance(boost::begin(rng), boost::end(rng)) template< class ForwardRange, class Size, class Value > inline ForwardRange& fill_n(ForwardRange& rng, Size n, const Value& val) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); BOOST_ASSERT( static_cast<Size>(std::distance(boost::begin(rng), boost::end(rng))) >= n ); std::fill_n(boost::begin(rng), n, val); return rng; } /// \overload template< class ForwardRange, class Size, class Value > inline const ForwardRange& fill_n(const ForwardRange& rng, Size n, const Value& val) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); BOOST_ASSERT( static_cast<Size>(std::distance(boost::begin(rng), boost::end(rng))) >= n ); std::fill_n(boost::begin(rng), n, val); return rng; } } // namespace range using range::fill_n; } // namespace boost #endif // include guard PK��!\{��Q��Q��fill.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_FILL_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_FILL_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function fill /// /// range-based version of the fill std algorithm /// /// \pre ForwardRange is a model of the ForwardRangeConcept template< class ForwardRange, class Value > inline ForwardRange& fill(ForwardRange& rng, const Value& val) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); std::fill(boost::begin(rng), boost::end(rng), val); return rng; } /// \overload template< class ForwardRange, class Value > inline const ForwardRange& fill(const ForwardRange& rng, const Value& val) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); std::fill(boost::begin(rng), boost::end(rng), val); return rng; } } // namespace range using range::fill; } #endif // include guard PK��!\zy�3��3��upper_bound.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_UPPER_BOUND_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_UPPER_BOUND_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/range/detail/range_return.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function upper_bound /// /// range-based version of the upper_bound std algorithm /// /// \pre ForwardRange is a model of the ForwardRangeConcept template< class ForwardRange, class Value > inline BOOST_DEDUCED_TYPENAME disable_if< is_const<ForwardRange>, BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type >::type upper_bound( ForwardRange& rng, const Value& val ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return std::upper_bound(boost::begin(rng), boost::end(rng), val); } /// \overload template< class ForwardRange, class Value > BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type upper_bound( const ForwardRange& rng, const Value& val ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return std::upper_bound(boost::begin(rng), boost::end(rng), val); } /// \overload template< class ForwardRange, class Value, class SortPredicate > inline BOOST_DEDUCED_TYPENAME disable_if< is_const<ForwardRange>, BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type >::type upper_bound( ForwardRange& rng, const Value& val, SortPredicate pred ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred); } /// \overload template< class ForwardRange, class Value, class SortPredicate > inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type upper_bound( const ForwardRange& rng, const Value& val, SortPredicate pred ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return std::upper_bound(boost::begin(rng), boost::end(rng), val, pred); } /// \overload template< range_return_value re, class ForwardRange, class Value > inline BOOST_DEDUCED_TYPENAME disable_if< is_const<ForwardRange>, BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type >::type upper_bound( ForwardRange& rng, const Value& val ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return range_return<ForwardRange,re>:: pack(std::upper_bound(boost::begin(rng), boost::end(rng), val), rng); } /// \overload template< range_return_value re, class ForwardRange, class Value > inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type upper_bound( const ForwardRange& rng, const Value& val ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return range_return<const ForwardRange,re>:: pack(std::upper_bound(boost::begin(rng), boost::end(rng), val), rng); } /// \overload template< range_return_value re, class ForwardRange, class Value, class SortPredicate > inline BOOST_DEDUCED_TYPENAME disable_if< is_const<ForwardRange>, BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type >::type upper_bound( ForwardRange& rng, const Value& val, SortPredicate pred ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return range_return<ForwardRange,re>:: pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred), rng); } /// \overload template< range_return_value re, class ForwardRange, class Value, class SortPredicate > inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type upper_bound( const ForwardRange& rng, const Value& val, SortPredicate pred ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return range_return<const ForwardRange,re>:: pack(std::upper_bound(boost::begin(rng), boost::end(rng), val, pred), rng); } } // namespace range using range::upper_bound; } // namespace boost #endif // include guard PK��!\1#eB&��&��lower_bound.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_LOWER_BOUND_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_LOWER_BOUND_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/range/detail/range_return.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function lower_bound /// /// range-based version of the lower_bound std algorithm /// /// \pre ForwardRange is a model of the ForwardRangeConcept template< class ForwardRange, class Value > inline BOOST_DEDUCED_TYPENAME disable_if< is_const<ForwardRange>, BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type >::type lower_bound( ForwardRange& rng, const Value& val ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return std::lower_bound(boost::begin(rng), boost::end(rng), val); } /// \overload template< class ForwardRange, class Value > inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type lower_bound( const ForwardRange& rng, const Value& val ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return std::lower_bound(boost::begin(rng), boost::end(rng), val); } /// \overload template< class ForwardRange, class Value, class SortPredicate > inline BOOST_DEDUCED_TYPENAME disable_if< is_const<ForwardRange>, BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type >::type lower_bound( ForwardRange& rng, const Value& val, SortPredicate pred ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return std::lower_bound(boost::begin(rng), boost::end(rng), val, pred); } /// \overload template< class ForwardRange, class Value, class SortPredicate > inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type lower_bound( const ForwardRange& rng, const Value& val, SortPredicate pred ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return std::lower_bound(boost::begin(rng), boost::end(rng), val, pred); } /// \overload template< range_return_value re, class ForwardRange, class Value > inline BOOST_DEDUCED_TYPENAME disable_if< is_const<ForwardRange>, BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type >::type lower_bound( ForwardRange& rng, const Value& val ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return range_return<ForwardRange,re>:: pack(std::lower_bound(boost::begin(rng), boost::end(rng), val), rng); } /// \overload template< range_return_value re, class ForwardRange, class Value > inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type lower_bound( const ForwardRange& rng, const Value& val ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return range_return<const ForwardRange,re>:: pack(std::lower_bound(boost::begin(rng), boost::end(rng), val), rng); } /// \overload template< range_return_value re, class ForwardRange, class Value, class SortPredicate > inline BOOST_DEDUCED_TYPENAME disable_if< is_const<ForwardRange>, BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type >::type lower_bound( ForwardRange& rng, const Value& val, SortPredicate pred ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return range_return<ForwardRange,re>:: pack(std::lower_bound(boost::begin(rng), boost::end(rng), val, pred), rng); } /// \overload template< range_return_value re, class ForwardRange, class Value, class SortPredicate > inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type lower_bound( const ForwardRange& rng, const Value& val, SortPredicate pred ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return range_return<const ForwardRange,re>:: pack(std::lower_bound(boost::begin(rng), boost::end(rng), val, pred), rng); } } // namespace range using range::lower_bound; } // namespace boost #endif // include guard PK��!\;��"��"��binary_search.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_BINARY_SEARCH_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_BINARY_SEARCH_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function binary_search /// /// range-based version of the binary_search std algorithm /// /// \pre ForwardRange is a model of the ForwardRangeConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept template<class ForwardRange, class Value> inline bool binary_search(const ForwardRange& rng, const Value& val) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return std::binary_search(boost::begin(rng), boost::end(rng), val); } /// \overload template<class ForwardRange, class Value, class BinaryPredicate> inline bool binary_search(const ForwardRange& rng, const Value& val, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return std::binary_search(boost::begin(rng), boost::end(rng), val, pred); } } // namespace range using range::binary_search; } // namespace boost #endif // include guard PK��!\ �TƜ �� transform.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_TRANSFORM_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_TRANSFORM_HPP_INCLUDED #include <boost/assert.hpp> #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function transform /// /// range-based version of the transform std algorithm /// /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept /// \pre OutputIterator is a model of the OutputIteratorConcept /// \pre UnaryOperation is a model of the UnaryFunctionConcept /// \pre BinaryOperation is a model of the BinaryFunctionConcept template< class SinglePassRange1, class OutputIterator, class UnaryOperation > inline OutputIterator transform(const SinglePassRange1& rng, OutputIterator out, UnaryOperation fun) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); return std::transform(boost::begin(rng),boost::end(rng),out,fun); } } // namespace range namespace range_detail { template< class SinglePassTraversalReadableIterator1, class SinglePassTraversalReadableIterator2, class OutputIterator, class BinaryFunction > inline OutputIterator transform_impl(SinglePassTraversalReadableIterator1 first1, SinglePassTraversalReadableIterator1 last1, SinglePassTraversalReadableIterator2 first2, SinglePassTraversalReadableIterator2 last2, OutputIterator out, BinaryFunction fn) { for (; first1 != last1 && first2 != last2; ++first1, ++first2) { out = fn(first1, first2); ++out; } return out; } } namespace range { /// \overload template< class SinglePassRange1, class SinglePassRange2, class OutputIterator, class BinaryOperation > inline OutputIterator transform(const SinglePassRange1& rng1, const SinglePassRange2& rng2, OutputIterator out, BinaryOperation fun) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> )); return boost::range_detail::transform_impl( boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2), out, fun); } } // namespace range using range::transform; } // namespace boost #endif // include guard PK��!\A��T��generate.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_GENERATE_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_GENERATE_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function generate /// /// range-based version of the generate std algorithm /// /// \pre ForwardRange is a model of the ForwardRangeConcept /// \pre Generator is a model of the UnaryFunctionConcept template< class ForwardRange, class Generator > inline ForwardRange& generate( ForwardRange& rng, Generator gen ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); std::generate(boost::begin(rng), boost::end(rng), gen); return rng; } /// \overload template< class ForwardRange, class Generator > inline const ForwardRange& generate( const ForwardRange& rng, Generator gen ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); std::generate(boost::begin(rng), boost::end(rng), gen); return rng; } } // namespace range using range::generate; } // namespace boost #endif // include guard PK��!\~�4��reverse_copy.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_REVERSE_COPY_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_REVERSE_COPY_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/iterator/iterator_concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function reverse_copy /// /// range-based version of the reverse_copy std algorithm /// /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept template<class BidirectionalRange, class OutputIterator> inline OutputIterator reverse_copy(const BidirectionalRange& rng, OutputIterator out) { BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> )); return std::reverse_copy(boost::begin(rng), boost::end(rng), out); } } // namespace range using range::reverse_copy; } // namespace boost #endif // include guard PK��!\��replace_copy.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_REPLACE_COPY_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_REPLACE_COPY_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function replace_copy /// /// range-based version of the replace_copy std algorithm /// /// \pre ForwardRange is a model of the ForwardRangeConcept template< class ForwardRange, class OutputIterator, class Value > inline OutputIterator replace_copy(const ForwardRange& rng, OutputIterator out_it, const Value& what, const Value& with_what) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return std::replace_copy(boost::begin(rng), boost::end(rng), out_it, what, with_what); } } // namespace range using range::replace_copy; } // namespace boost #endif // include guard PK��!\�{>�� find_if.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_FIND_IF_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_FIND_IF_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/range/detail/range_return.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function find_if /// /// range-based version of the find_if std algorithm /// /// \pre SinglePassRange is a model of the SinglePassRangeConcept /// \pre UnaryPredicate is a model of the UnaryPredicateConcept template< class SinglePassRange, class UnaryPredicate > inline BOOST_DEDUCED_TYPENAME disable_if< is_const<SinglePassRange>, BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type >::type find_if( SinglePassRange& rng, UnaryPredicate pred ) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> )); return std::find_if(boost::begin(rng), boost::end(rng), pred); } /// \overload template< class SinglePassRange, class UnaryPredicate > inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type find_if( const SinglePassRange& rng, UnaryPredicate pred ) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> )); return std::find_if(boost::begin(rng), boost::end(rng), pred); } // range_return overloads /// \overload template< range_return_value re, class SinglePassRange, class UnaryPredicate > inline BOOST_DEDUCED_TYPENAME disable_if< is_const<SinglePassRange>, BOOST_DEDUCED_TYPENAME range_return<SinglePassRange,re>::type >::type find_if( SinglePassRange& rng, UnaryPredicate pred ) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> )); return range_return<SinglePassRange,re>:: pack(std::find_if(boost::begin(rng), boost::end(rng), pred), rng); } /// \overload template< range_return_value re, class SinglePassRange, class UnaryPredicate > inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange,re>::type find_if( const SinglePassRange& rng, UnaryPredicate pred ) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> )); return range_return<const SinglePassRange,re>:: pack(std::find_if(boost::begin(rng), boost::end(rng), pred), rng); } } // namespace range using range::find_if; } // namespace boost #endif // include guard PK��!\�3j��remove_copy_if.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_REMOVE_COPY_IF_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_REMOVE_COPY_IF_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { /// \brief template function remove_copy_if /// /// range-based version of the remove_copy_if std algorithm /// /// \pre SinglePassRange is a model of the SinglePassRangeConcept /// \pre OutputIterator is a model of the OutputIteratorConcept /// \pre Predicate is a model of the PredicateConcept /// \pre InputIterator's value type is convertible to Predicate's argument type /// \pre out_it is not an iterator in the range rng template< class SinglePassRange, class OutputIterator, class Predicate > inline OutputIterator remove_copy_if(const SinglePassRange& rng, OutputIterator out_it, Predicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> )); return std::remove_copy_if(boost::begin(rng), boost::end(rng), out_it, pred); } } #endif // include guard PK��!\�>��copy.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_COPY_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_COPY_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/range/iterator_range.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function copy /// /// range-based version of the copy std algorithm /// /// \pre SinglePassRange is a model of the SinglePassRangeConcept /// \pre OutputIterator is a model of the OutputIteratorConcept template< class SinglePassRange, class OutputIterator > inline OutputIterator copy(const SinglePassRange& rng, OutputIterator out) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> )); return std::copy(boost::begin(rng),boost::end(rng),out); } } // namespace range using range::copy; } // namespace boost #endif // include guard PK��!\j �n��rotate_copy.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_ROTATE_COPY_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_ROTATE_COPY_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/range/iterator.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function rotate /// /// range-based version of the rotate std algorithm /// /// \pre Rng meets the requirements for a Forward range template<typename ForwardRange, typename OutputIterator> inline OutputIterator rotate_copy( const ForwardRange& rng, BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type middle, OutputIterator target ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return std::rotate_copy(boost::begin(rng), middle, boost::end(rng), target); } } // namespace range using range::rotate_copy; } // namespace boost #endif // include guard PK��!\-9� �� inplace_merge.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_INPLACE_MERGE_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_INPLACE_MERGE_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function inplace_merge /// /// range-based version of the inplace_merge std algorithm /// /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept template<class BidirectionalRange> inline BidirectionalRange& inplace_merge(BidirectionalRange& rng, BOOST_DEDUCED_TYPENAME range_iterator<BidirectionalRange>::type middle) { BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> )); std::inplace_merge(boost::begin(rng), middle, boost::end(rng)); return rng; } /// \overload template<class BidirectionalRange> inline const BidirectionalRange& inplace_merge(const BidirectionalRange& rng, BOOST_DEDUCED_TYPENAME boost::range_iterator<const BidirectionalRange>::type middle) { BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> )); std::inplace_merge(boost::begin(rng), middle, boost::end(rng)); return rng; } /// \overload template<class BidirectionalRange, class BinaryPredicate> inline BidirectionalRange& inplace_merge(BidirectionalRange& rng, BOOST_DEDUCED_TYPENAME boost::range_iterator<BidirectionalRange>::type middle, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> )); std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred); return rng; } /// \overload template<class BidirectionalRange, class BinaryPredicate> inline const BidirectionalRange& inplace_merge(const BidirectionalRange& rng, BOOST_DEDUCED_TYPENAME boost::range_iterator<const BidirectionalRange>::type middle, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> )); std::inplace_merge(boost::begin(rng), middle, boost::end(rng), pred); return rng; } } // namespace range using range::inplace_merge; } // namespace boost #endif // include guard PK��!\3ɻ,1��1�� search.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_SEARCH_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_SEARCH_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/range/detail/range_return.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function search /// /// range-based version of the search std algorithm /// /// \pre ForwardRange1 is a model of the ForwardRangeConcept /// \pre ForwardRange2 is a model of the ForwardRangeConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept template< class ForwardRange1, class ForwardRange2 > inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type search(ForwardRange1& rng1, const ForwardRange2& rng2) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> )); return std::search(boost::begin(rng1),boost::end(rng1), boost::begin(rng2),boost::end(rng2)); } /// \overload template< class ForwardRange1, class ForwardRange2 > inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type search(const ForwardRange1& rng1, const ForwardRange2& rng2) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> )); return std::search(boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2)); } /// \overload template< class ForwardRange1, class ForwardRange2, class BinaryPredicate > inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> )); return std::search(boost::begin(rng1),boost::end(rng1), boost::begin(rng2),boost::end(rng2),pred); } /// \overload template< class ForwardRange1, class ForwardRange2, class BinaryPredicate > inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type search(const ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> )); return std::search(boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2), pred); } // range_return overloads /// \overload template< range_return_value re, class ForwardRange1, class ForwardRange2 > inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type search(ForwardRange1& rng1, const ForwardRange2& rng2) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> )); return range_return<ForwardRange1,re>:: pack(std::search(boost::begin(rng1),boost::end(rng1), boost::begin(rng2),boost::end(rng2)), rng1); } /// \overload template< range_return_value re, class ForwardRange1, class ForwardRange2 > inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type search(const ForwardRange1& rng1, const ForwardRange2& rng2) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> )); return range_return<const ForwardRange1,re>:: pack(std::search(boost::begin(rng1),boost::end(rng1), boost::begin(rng2),boost::end(rng2)), rng1); } /// \overload template< range_return_value re, class ForwardRange1, class ForwardRange2, class BinaryPredicate > inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type search(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> )); return range_return<ForwardRange1,re>:: pack(std::search(boost::begin(rng1),boost::end(rng1), boost::begin(rng2),boost::end(rng2),pred), rng1); } /// \overload template< range_return_value re, class ForwardRange1, class ForwardRange2, class BinaryPredicate > inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type search(const ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> )); return range_return<const ForwardRange1,re>:: pack(std::search(boost::begin(rng1),boost::end(rng1), boost::begin(rng2),boost::end(rng2),pred), rng1); } } // namespace range using range::search; } // namespace boost #endif // include guard PK��!\��( ��( �� remove.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_REMOVE_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_REMOVE_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/range/detail/range_return.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function remove /// /// range-based version of the remove std algorithm /// /// \pre ForwardRange is a model of the ForwardRangeConcept template< class ForwardRange, class Value > inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type remove(ForwardRange& rng, const Value& val) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return std::remove(boost::begin(rng),boost::end(rng),val); } /// \overload template< class ForwardRange, class Value > inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type remove(const ForwardRange& rng, const Value& val) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return std::remove(boost::begin(rng),boost::end(rng),val); } // range_return overloads /// \overload template< range_return_value re, class ForwardRange, class Value > inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type remove(ForwardRange& rng, const Value& val) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return range_return<ForwardRange,re>::pack( std::remove(boost::begin(rng), boost::end(rng), val), rng); } /// \overload template< range_return_value re, class ForwardRange, class Value > inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type remove(const ForwardRange& rng, const Value& val) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return range_return<const ForwardRange,re>::pack( std::remove(boost::begin(rng), boost::end(rng), val), rng); } } // namespace range using range::remove; } // namespace boost #endif // include guard PK��!\m0v� �� partition.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_PARTITION__HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_PARTITION__HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/range/detail/range_return.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function partition /// /// range-based version of the partition std algorithm /// /// \pre ForwardRange is a model of the ForwardRangeConcept template<class ForwardRange, class UnaryPredicate> inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type partition(ForwardRange& rng, UnaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return std::partition(boost::begin(rng),boost::end(rng),pred); } /// \overload template<class ForwardRange, class UnaryPredicate> inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type partition(const ForwardRange& rng, UnaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return std::partition(boost::begin(rng),boost::end(rng),pred); } // range_return overloads /// \overload template< range_return_value re, class ForwardRange, class UnaryPredicate > inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type partition(ForwardRange& rng, UnaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return boost::range_return<ForwardRange,re>:: pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng); } /// \overload template< range_return_value re, class ForwardRange, class UnaryPredicate > inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type partition(const ForwardRange& rng, UnaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return boost::range_return<const ForwardRange,re>:: pack(std::partition(boost::begin(rng), boost::end(rng), pred), rng); } } // namespace range using range::partition; } // namespace boost #endif // include guard PK��!\�֖�!��!��set_algorithm.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_SET_ALGORITHM_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_SET_ALGORITHM_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function includes /// /// range-based version of the includes std algorithm /// /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept template<class SinglePassRange1, class SinglePassRange2> inline bool includes(const SinglePassRange1& rng1, const SinglePassRange2& rng2) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> )); return std::includes(boost::begin(rng1),boost::end(rng1), boost::begin(rng2),boost::end(rng2)); } /// \overload template<class SinglePassRange1, class SinglePassRange2, class BinaryPredicate> inline bool includes(const SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> )); return std::includes(boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2), pred); } /// \brief template function set_union /// /// range-based version of the set_union std algorithm /// /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept template<class SinglePassRange1, class SinglePassRange2, class OutputIterator> inline OutputIterator set_union(const SinglePassRange1& rng1, const SinglePassRange2& rng2, OutputIterator out) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> )); return std::set_union(boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2), out); } /// \overload template<class SinglePassRange1, class SinglePassRange2, class OutputIterator, class BinaryPredicate> inline OutputIterator set_union(const SinglePassRange1& rng1, const SinglePassRange2& rng2, OutputIterator out, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> )); return std::set_union(boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2), out, pred); } /// \brief template function set_intersection /// /// range-based version of the set_intersection std algorithm /// /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept template<class SinglePassRange1, class SinglePassRange2, class OutputIterator> inline OutputIterator set_intersection(const SinglePassRange1& rng1, const SinglePassRange2& rng2, OutputIterator out) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> )); return std::set_intersection(boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2), out); } /// \overload template<class SinglePassRange1, class SinglePassRange2, class OutputIterator, class BinaryPredicate> inline OutputIterator set_intersection(const SinglePassRange1& rng1, const SinglePassRange2& rng2, OutputIterator out, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> )); return std::set_intersection(boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2), out, pred); } /// \brief template function set_difference /// /// range-based version of the set_difference std algorithm /// /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept template<class SinglePassRange1, class SinglePassRange2, class OutputIterator> inline OutputIterator set_difference(const SinglePassRange1& rng1, const SinglePassRange2& rng2, OutputIterator out) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> )); return std::set_difference(boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2), out); } /// \overload template<class SinglePassRange1, class SinglePassRange2, class OutputIterator, class BinaryPredicate> inline OutputIterator set_difference(const SinglePassRange1& rng1, const SinglePassRange2& rng2, OutputIterator out, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> )); return std::set_difference( boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2), out, pred); } /// \brief template function set_symmetric_difference /// /// range-based version of the set_symmetric_difference std algorithm /// /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept template<class SinglePassRange1, class SinglePassRange2, class OutputIterator> inline OutputIterator set_symmetric_difference(const SinglePassRange1& rng1, const SinglePassRange2& rng2, OutputIterator out) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> )); return std::set_symmetric_difference(boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2), out); } /// \overload template<class SinglePassRange1, class SinglePassRange2, class OutputIterator, class BinaryPredicate> inline OutputIterator set_symmetric_difference(const SinglePassRange1& rng1, const SinglePassRange2& rng2, OutputIterator out, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> )); return std::set_symmetric_difference( boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2), out, pred); } } // namespace range using range::includes; using range::set_union; using range::set_intersection; using range::set_difference; using range::set_symmetric_difference; } // namespace boost #endif // include guard PK��!\�N�� find.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_FIND_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_FIND_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/range/detail/range_return.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function find /// /// range-based version of the find std algorithm /// /// \pre SinglePassRange is a model of the SinglePassRangeConcept template< class SinglePassRange, class Value > inline BOOST_DEDUCED_TYPENAME disable_if< is_const<SinglePassRange>, BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type >::type find( SinglePassRange& rng, const Value& val ) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> )); return std::find(boost::begin(rng), boost::end(rng), val); } /// \overload template< class SinglePassRange, class Value > inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type find( const SinglePassRange& rng, const Value& val ) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> )); return std::find(boost::begin(rng), boost::end(rng), val); } // range_return overloads /// \overload template< range_return_value re, class SinglePassRange, class Value > inline BOOST_DEDUCED_TYPENAME disable_if< is_const<SinglePassRange>, BOOST_DEDUCED_TYPENAME range_return<SinglePassRange,re>::type >::type find( SinglePassRange& rng, const Value& val ) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> )); return range_return<SinglePassRange,re>:: pack(std::find(boost::begin(rng), boost::end(rng), val), rng); } /// \overload template< range_return_value re, class SinglePassRange, class Value > inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange,re>::type find( const SinglePassRange& rng, const Value& val ) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> )); return range_return<const SinglePassRange,re>:: pack(std::find(boost::begin(rng), boost::end(rng), val), rng); } } // namespace range using range::find; } #endif // include guard PK��!\ ��replace.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_REPLACE_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_REPLACE_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function replace /// /// range-based version of the replace std algorithm /// /// \pre ForwardRange is a model of the ForwardRangeConcept template< class ForwardRange, class Value > inline ForwardRange& replace(ForwardRange& rng, const Value& what, const Value& with_what) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); std::replace(boost::begin(rng), boost::end(rng), what, with_what); return rng; } /// \overload template< class ForwardRange, class Value > inline const ForwardRange& replace(const ForwardRange& rng, const Value& what, const Value& with_what) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); std::replace(boost::begin(rng), boost::end(rng), what, with_what); return rng; } } // namespace range using range::replace; } // namespace boost; #endif // include guard PK��!\�� equal_range.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_EQUAL_RANGE_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_EQUAL_RANGE_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function equal_range /// /// range-based version of the equal_range std algorithm /// /// \pre ForwardRange is a model of the ForwardRangeConcept /// \pre SortPredicate is a model of the BinaryPredicateConcept template<class ForwardRange, class Value> inline std::pair< BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type, BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type > equal_range(ForwardRange& rng, const Value& val) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return std::equal_range(boost::begin(rng), boost::end(rng), val); } /// \overload template<class ForwardRange, class Value> inline std::pair< BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type, BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type > equal_range(const ForwardRange& rng, const Value& val) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return std::equal_range(boost::begin(rng), boost::end(rng), val); } /// \overload template<class ForwardRange, class Value, class SortPredicate> inline std::pair< BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type, BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type > equal_range(ForwardRange& rng, const Value& val, SortPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return std::equal_range(boost::begin(rng), boost::end(rng), val, pred); } /// \overload template<class ForwardRange, class Value, class SortPredicate> inline std::pair< BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type, BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type > equal_range(const ForwardRange& rng, const Value& val, SortPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return std::equal_range(boost::begin(rng), boost::end(rng), val, pred); } } // namespace range using range::equal_range; } // namespace boost #endif // include guard PK��!\q��$��$��adjacent_find.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_ADJACENT_FIND_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_ADJACENT_FIND_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/range/value_type.hpp> #include <boost/range/detail/range_return.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function adjacent_find /// /// range-based version of the adjacent_find std algorithm /// /// \pre ForwardRange is a model of the ForwardRangeConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept template< typename ForwardRange > inline typename range_iterator<ForwardRange>::type adjacent_find(ForwardRange & rng) { BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>)); return std::adjacent_find(boost::begin(rng),boost::end(rng)); } /// \overload template< typename ForwardRange > inline typename range_iterator<const ForwardRange>::type adjacent_find(const ForwardRange& rng) { BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>)); return std::adjacent_find(boost::begin(rng),boost::end(rng)); } /// \overload template< typename ForwardRange, typename BinaryPredicate > inline typename range_iterator<ForwardRange>::type adjacent_find(ForwardRange & rng, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>)); BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, typename range_value<ForwardRange>::type, typename range_value<ForwardRange>::type>)); return std::adjacent_find(boost::begin(rng),boost::end(rng),pred); } /// \overload template< typename ForwardRange, typename BinaryPredicate > inline typename range_iterator<const ForwardRange>::type adjacent_find(const ForwardRange& rng, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>)); BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, typename range_value<const ForwardRange>::type, typename range_value<const ForwardRange>::type>)); return std::adjacent_find(boost::begin(rng),boost::end(rng),pred); } // range_return overloads /// \overload template< range_return_value re, typename ForwardRange > inline typename range_return<ForwardRange,re>::type adjacent_find(ForwardRange & rng) { BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>)); return range_return<ForwardRange,re>:: pack(std::adjacent_find(boost::begin(rng),boost::end(rng)), rng); } /// \overload template< range_return_value re, typename ForwardRange > inline typename range_return<const ForwardRange,re>::type adjacent_find(const ForwardRange& rng) { BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>)); return range_return<const ForwardRange,re>:: pack(std::adjacent_find(boost::begin(rng),boost::end(rng)), rng); } /// \overload template< range_return_value re, typename ForwardRange, typename BinaryPredicate > inline typename range_return<ForwardRange,re>::type adjacent_find(ForwardRange& rng, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>)); BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, typename range_value<ForwardRange>::type, typename range_value<ForwardRange>::type>)); return range_return<ForwardRange,re>:: pack(std::adjacent_find(boost::begin(rng),boost::end(rng),pred), rng); } /// \overload template< range_return_value re, typename ForwardRange, typename BinaryPredicate > inline typename range_return<const ForwardRange,re>::type adjacent_find(const ForwardRange& rng, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>)); return range_return<const ForwardRange,re>:: pack(std::adjacent_find(boost::begin(rng),boost::end(rng),pred), rng); } } // namespace range using range::adjacent_find; } // namespace boost #endif // include guard PK��!\Ӭ�3�4��4��search_n.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_SEARCH_N_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_SEARCH_N_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/range/detail/range_return.hpp> #include <boost/range/value_type.hpp> #include <iterator> #include <algorithm> namespace boost { namespace range_detail { // Rationale: search_n is implemented rather than delegate to // the standard library implementation because some standard // library implementations are broken eg. MSVC. // search_n forward iterator version template<typename ForwardIterator, typename Integer, typename Value> inline ForwardIterator search_n_impl(ForwardIterator first, ForwardIterator last, Integer count, const Value& value, std::forward_iterator_tag) { first = std::find(first, last, value); while (first != last) { typename std::iterator_traits<ForwardIterator>::difference_type n = count; ForwardIterator i = first; ++i; while (i != last && n != 1 && i==value) { ++i; --n; } if (n == 1) return first; if (i == last) return last; first = std::find(++i, last, value); } return last; } // search_n random-access iterator version template<typename RandomAccessIterator, typename Integer, typename Value> inline RandomAccessIterator search_n_impl(RandomAccessIterator first, RandomAccessIterator last, Integer count, const Value& value, std::random_access_iterator_tag) { typedef typename std::iterator_traits<RandomAccessIterator>::difference_type difference_t; difference_t tail_size = last - first; const difference_t pattern_size = count; if (tail_size < pattern_size) return last; const difference_t skip_offset = pattern_size - 1; RandomAccessIterator look_ahead = first + skip_offset; tail_size -= pattern_size; while (1) { // look_ahead here is pointing to the last element of the // next possible match while (!(look_ahead == value)) // skip loop... { if (tail_size < pattern_size) return last; // no match look_ahead += pattern_size; tail_size -= pattern_size; } difference_t remainder = skip_offset; for (RandomAccessIterator back_track = look_ahead - 1; back_track == value; --back_track) { if (--remainder == 0) { return look_ahead - skip_offset; // matched } } if (remainder > tail_size) return last; // no match look_ahead += remainder; tail_size -= remainder; } return last; } // search_n for forward iterators using a binary predicate // to determine a match template<typename ForwardIterator, typename Integer, typename Value, typename BinaryPredicate> inline ForwardIterator search_n_pred_impl(ForwardIterator first, ForwardIterator last, Integer count, const Value& value, BinaryPredicate pred, std::forward_iterator_tag) { typedef typename std::iterator_traits<ForwardIterator>::difference_type difference_t; while (first != last && !static_cast<bool>(pred(first, value))) ++first; while (first != last) { difference_t n = count; ForwardIterator i = first; ++i; while (i != last && n != 1 && static_cast<bool>(pred(i, value))) { ++i; --n; } if (n == 1) return first; if (i == last) return last; first = ++i; while (first != last && !static_cast<bool>(pred(first, value))) ++first; } return last; } // search_n for random-access iterators using a binary predicate // to determine a match template<typename RandomAccessIterator, typename Integer, typename Value, typename BinaryPredicate> inline RandomAccessIterator search_n_pred_impl(RandomAccessIterator first, RandomAccessIterator last, Integer count, const Value& value, BinaryPredicate pred, std::random_access_iterator_tag) { typedef typename std::iterator_traits<RandomAccessIterator>::difference_type difference_t; difference_t tail_size = last - first; const difference_t pattern_size = count; if (tail_size < pattern_size) return last; const difference_t skip_offset = pattern_size - 1; RandomAccessIterator look_ahead = first + skip_offset; tail_size -= pattern_size; while (1) { // look_ahead points to the last element of the next // possible match while (!static_cast<bool>(pred(look_ahead, value))) // skip loop { if (tail_size < pattern_size) return last; // no match look_ahead += pattern_size; tail_size -= pattern_size; } difference_t remainder = skip_offset; for (RandomAccessIterator back_track = look_ahead - 1; pred(back_track, value); --back_track) { if (--remainder == 0) return look_ahead -= skip_offset; // success } if (remainder > tail_size) { return last; // no match } look_ahead += remainder; tail_size -= remainder; } } template<typename ForwardIterator, typename Integer, typename Value> inline ForwardIterator search_n_impl(ForwardIterator first, ForwardIterator last, Integer count, const Value& value) { BOOST_RANGE_CONCEPT_ASSERT((ForwardIteratorConcept<ForwardIterator>)); BOOST_RANGE_CONCEPT_ASSERT((EqualityComparableConcept<Value>)); BOOST_RANGE_CONCEPT_ASSERT((EqualityComparableConcept<typename std::iterator_traits<ForwardIterator>::value_type>)); //BOOST_RANGE_CONCEPT_ASSERT((EqualityComparableConcept2<typename std::iterator_traits<ForwardIterator>::value_type, Value>)); typedef typename std::iterator_traits<ForwardIterator>::iterator_category cat_t; if (count <= 0) return first; if (count == 1) return std::find(first, last, value); return range_detail::search_n_impl(first, last, count, value, cat_t()); } template<typename ForwardIterator, typename Integer, typename Value, typename BinaryPredicate> inline ForwardIterator search_n_pred_impl(ForwardIterator first, ForwardIterator last, Integer count, const Value& value, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT((ForwardIteratorConcept<ForwardIterator>)); BOOST_RANGE_CONCEPT_ASSERT(( BinaryPredicateConcept< BinaryPredicate, typename std::iterator_traits<ForwardIterator>::value_type, Value> )); typedef typename std::iterator_traits<ForwardIterator>::iterator_category cat_t; if (count <= 0) return first; if (count == 1) { while (first != last && !static_cast<bool>(pred(first, value))) ++first; return first; } return range_detail::search_n_pred_impl(first, last, count, value, pred, cat_t()); } } // namespace range_detail namespace range { /// \brief template function search /// /// range-based version of the search std algorithm /// /// \pre ForwardRange is a model of the ForwardRangeConcept /// \pre Integer is an integral type /// \pre Value is a model of the EqualityComparableConcept /// \pre ForwardRange's value type is a model of the EqualityComparableConcept /// \pre Object's of ForwardRange's value type can be compared for equality with Objects of type Value template< class ForwardRange, class Integer, class Value > inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type search_n(ForwardRange& rng, Integer count, const Value& value) { BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>)); return range_detail::search_n_impl(boost::begin(rng),boost::end(rng), count, value); } /// \overload template< class ForwardRange, class Integer, class Value > inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type search_n(const ForwardRange& rng, Integer count, const Value& value) { BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<const ForwardRange>)); return range_detail::search_n_impl(boost::begin(rng), boost::end(rng), count, value); } /// \overload template< class ForwardRange, class Integer, class Value, class BinaryPredicate > inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type search_n(ForwardRange& rng, Integer count, const Value& value, BinaryPredicate binary_pred) { BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>)); BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, BOOST_DEDUCED_TYPENAME range_value<ForwardRange>::type, const Value&>)); return range_detail::search_n_pred_impl(boost::begin(rng), boost::end(rng), count, value, binary_pred); } /// \overload template< class ForwardRange, class Integer, class Value, class BinaryPredicate > inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type search_n(const ForwardRange& rng, Integer count, const Value& value, BinaryPredicate binary_pred) { BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<const ForwardRange>)); BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, BOOST_DEDUCED_TYPENAME range_value<const ForwardRange>::type, const Value&>)); return range_detail::search_n_pred_impl(boost::begin(rng), boost::end(rng), count, value, binary_pred); } // range_return overloads /// \overload template< range_return_value re, class ForwardRange, class Integer, class Value > inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type search_n(ForwardRange& rng, Integer count, const Value& value) { BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>)); return range_return<ForwardRange,re>:: pack(range_detail::search_n_impl(boost::begin(rng),boost::end(rng), count, value), rng); } /// \overload template< range_return_value re, class ForwardRange, class Integer, class Value > inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type search_n(const ForwardRange& rng, Integer count, const Value& value) { BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<const ForwardRange>)); return range_return<const ForwardRange,re>:: pack(range_detail::search_n_impl(boost::begin(rng), boost::end(rng), count, value), rng); } /// \overload template< range_return_value re, class ForwardRange, class Integer, class Value, class BinaryPredicate > inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type search_n(ForwardRange& rng, Integer count, const Value& value, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<ForwardRange>)); BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, BOOST_DEDUCED_TYPENAME range_value<ForwardRange>::type, const Value&>)); return range_return<ForwardRange,re>:: pack(range_detail::search_n_pred_impl(boost::begin(rng), boost::end(rng), count, value, pred), rng); } /// \overload template< range_return_value re, class ForwardRange, class Integer, class Value, class BinaryPredicate > inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type search_n(const ForwardRange& rng, Integer count, const Value& value, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT((ForwardRangeConcept<const ForwardRange>)); BOOST_RANGE_CONCEPT_ASSERT((BinaryPredicateConcept<BinaryPredicate, BOOST_DEDUCED_TYPENAME range_value<const ForwardRange>::type, const Value&>)); return range_return<const ForwardRange,re>:: pack(range_detail::search_n_pred_impl(boost::begin(rng), boost::end(rng), count, value, pred), rng); } } // namespace range using range::search_n; } // namespace boost #endif // include guard PK��!\�]�� rotate.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_ROTATE_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_ROTATE_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function rotate /// /// range-based version of the rotate std algorithm /// /// \pre Rng meets the requirements for a Forward range template<class ForwardRange> inline ForwardRange& rotate(ForwardRange& rng, BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type middle) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); std::rotate(boost::begin(rng), middle, boost::end(rng)); return rng; } /// \overload template<class ForwardRange> inline const ForwardRange& rotate(const ForwardRange& rng, BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type middle) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); std::rotate(boost::begin(rng), middle, boost::end(rng)); return rng; } } // namespace range using range::rotate; } // namespace boost #endif // include guard PK��!\h�� remove_if.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_REMOVE_IF_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_REMOVE_IF_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/range/detail/range_return.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function remove_if /// /// range-based version of the remove_if std algorithm /// /// \pre ForwardRange is a model of the ForwardRangeConcept /// \pre UnaryPredicate is a model of the UnaryPredicateConcept template< class ForwardRange, class UnaryPredicate > inline BOOST_DEDUCED_TYPENAME boost::range_iterator<ForwardRange>::type remove_if(ForwardRange& rng, UnaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return std::remove_if(boost::begin(rng), boost::end(rng), pred); } /// \overload template< class ForwardRange, class UnaryPredicate > inline BOOST_DEDUCED_TYPENAME boost::range_iterator<const ForwardRange>::type remove_if(const ForwardRange& rng, UnaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return std::remove_if(boost::begin(rng), boost::end(rng), pred); } // range_return overloads /// \overload template< range_return_value re, class ForwardRange, class UnaryPredicate > inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type remove_if(ForwardRange& rng, UnaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return range_return<ForwardRange,re>::pack( std::remove_if(boost::begin(rng), boost::end(rng), pred), rng); } /// \overload template< range_return_value re, class ForwardRange, class UnaryPredicate > inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type remove_if(const ForwardRange& rng, UnaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return range_return<const ForwardRange,re>::pack( std::remove_if(boost::begin(rng), boost::end(rng), pred), rng); } } // namespace range using range::remove_if; } // namespace boost #endif // include guard PK��!\!xG}��}��stable_sort.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_STABLE_SORT_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_STABLE_SORT_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function stable_sort /// /// range-based version of the stable_sort std algorithm /// /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept template<class RandomAccessRange> inline RandomAccessRange& stable_sort(RandomAccessRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> )); std::stable_sort(boost::begin(rng), boost::end(rng)); return rng; } /// \overload template<class RandomAccessRange> inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> )); std::stable_sort(boost::begin(rng), boost::end(rng)); return rng; } /// \overload template<class RandomAccessRange, class BinaryPredicate> inline RandomAccessRange& stable_sort(RandomAccessRange& rng, BinaryPredicate sort_pred) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> )); std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred); return rng; } /// \overload template<class RandomAccessRange, class BinaryPredicate> inline const RandomAccessRange& stable_sort(const RandomAccessRange& rng, BinaryPredicate sort_pred) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> )); std::stable_sort(boost::begin(rng), boost::end(rng), sort_pred); return rng; } } // namespace range using range::stable_sort; } // namespace boost #endif // include guard PK��!\��Ξ��unique_copy.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_UNIQUE_COPY_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_UNIQUE_COPY_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function unique_copy /// /// range-based version of the unique_copy std algorithm /// /// \pre SinglePassRange is a model of the SinglePassRangeConcept /// \pre OutputIterator is a model of the OutputIteratorConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept template< class SinglePassRange, class OutputIterator > inline OutputIterator unique_copy( const SinglePassRange& rng, OutputIterator out_it ) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> )); return std::unique_copy(boost::begin(rng), boost::end(rng), out_it); } /// \overload template< class SinglePassRange, class OutputIterator, class BinaryPredicate > inline OutputIterator unique_copy( const SinglePassRange& rng, OutputIterator out_it, BinaryPredicate pred ) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> )); return std::unique_copy(boost::begin(rng), boost::end(rng), out_it, pred); } } // namespace range using range::unique_copy; } // namespace boost #endif // include guard PK��!\�Q�@��replace_copy_if.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_REPLACE_COPY_IF_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_REPLACE_COPY_IF_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function replace_copy_if /// /// range-based version of the replace_copy_if std algorithm /// /// \pre ForwardRange is a model of the ForwardRangeConcept /// \pre Predicate is a model of the PredicateConcept /// \pre Value is convertible to Predicate's argument type /// \pre Value is Assignable /// \pre Value is convertible to a type in OutputIterator's set of value types. template< class ForwardRange, class OutputIterator, class Predicate, class Value > inline OutputIterator replace_copy_if(const ForwardRange& rng, OutputIterator out_it, Predicate pred, const Value& with_what) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return std::replace_copy_if(boost::begin(rng), boost::end(rng), out_it, pred, with_what); } } // namespace range using range::replace_copy_if; } // namespace boost #endif // include guard PK��!\#TƔ9��9��lexicographical_compare.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_LEXICOGRAPHICAL_COMPARE_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_LEXICOGRAPHICAL_COMPARE_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function lexicographic_compare /// /// range-based version of the lexicographic_compare std algorithm /// /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept template<class SinglePassRange1, class SinglePassRange2> inline bool lexicographical_compare(const SinglePassRange1& rng1, const SinglePassRange2& rng2) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> )); return std::lexicographical_compare( boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2)); } /// \overload template<class SinglePassRange1, class SinglePassRange2, class BinaryPredicate> inline bool lexicographical_compare(const SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> )); return std::lexicographical_compare( boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2), pred); } } // namespace range using range::lexicographical_compare; } // namespace boost #endif // include guard PK��!\��find_first_of.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_FIND_FIRST_OF_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_FIND_FIRST_OF_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/range/detail/range_return.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function find_first_of /// /// range-based version of the find_first_of std algorithm /// /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept /// \pre ForwardRange2 is a model of the ForwardRangeConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept template< class SinglePassRange1, class ForwardRange2 > inline BOOST_DEDUCED_TYPENAME disable_if< is_const<SinglePassRange1>, BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type >::type find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> )); return std::find_first_of(boost::begin(rng1),boost::end(rng1), boost::begin(rng2),boost::end(rng2)); } /// \overload template< class SinglePassRange1, class ForwardRange2 > inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> )); return std::find_first_of(boost::begin(rng1),boost::end(rng1), boost::begin(rng2),boost::end(rng2)); } /// \overload template< class SinglePassRange1, class ForwardRange2, class BinaryPredicate > inline BOOST_DEDUCED_TYPENAME disable_if< is_const<SinglePassRange1>, BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange1>::type >::type find_first_of(SinglePassRange1 & rng1, ForwardRange2 const & rng2, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> )); return std::find_first_of(boost::begin(rng1),boost::end(rng1), boost::begin(rng2),boost::end(rng2),pred); } /// \overload template< class SinglePassRange1, class ForwardRange2, class BinaryPredicate > inline BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange1>::type find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> )); return std::find_first_of(boost::begin(rng1),boost::end(rng1), boost::begin(rng2),boost::end(rng2),pred); } // range return overloads /// \overload template< range_return_value re, class SinglePassRange1, class ForwardRange2 > inline BOOST_DEDUCED_TYPENAME disable_if< is_const<SinglePassRange1>, BOOST_DEDUCED_TYPENAME range_return<SinglePassRange1,re>::type >::type find_first_of(SinglePassRange1& rng1, const ForwardRange2& rng2) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> )); return range_return<SinglePassRange1,re>:: pack(std::find_first_of(boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2)), rng1); } /// \overload template< range_return_value re, class SinglePassRange1, class ForwardRange2 > inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange1,re>::type find_first_of(const SinglePassRange1& rng1, const ForwardRange2& rng2) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> )); return range_return<const SinglePassRange1,re>:: pack(std::find_first_of(boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2)), rng1); } /// \overload template< range_return_value re, class SinglePassRange1, class ForwardRange2, class BinaryPredicate > inline BOOST_DEDUCED_TYPENAME disable_if< is_const<SinglePassRange1>, BOOST_DEDUCED_TYPENAME range_return<SinglePassRange1,re>::type >::type find_first_of(SinglePassRange1 & rng1, const ForwardRange2& rng2, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> )); return range_return<SinglePassRange1,re>:: pack(std::find_first_of(boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2), pred), rng1); } /// \overload template< range_return_value re, class SinglePassRange1, class ForwardRange2, class BinaryPredicate > inline BOOST_DEDUCED_TYPENAME range_return<const SinglePassRange1,re>::type find_first_of(const SinglePassRange1 & rng1, const ForwardRange2& rng2, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> )); return range_return<const SinglePassRange1,re>:: pack(std::find_first_of(boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2), pred), rng1); } } // namespace range using range::find_first_of; } // namespace boost #endif // include guard PK��!\汩��reverse.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_REVERSE_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_REVERSE_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/range/detail/range_return.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function reverse /// /// range-based version of the reverse std algorithm /// /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept template<class BidirectionalRange> inline BidirectionalRange& reverse(BidirectionalRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> )); std::reverse(boost::begin(rng), boost::end(rng)); return rng; } /// \overload template<class BidirectionalRange> inline const BidirectionalRange& reverse(const BidirectionalRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> )); std::reverse(boost::begin(rng), boost::end(rng)); return rng; } } // namespace range using range::reverse; } // namespace boost #endif // include guard PK��!\o�� random_shuffle.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_RANDOM_SHUFFLE_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_RANDOM_SHUFFLE_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> #ifdef BOOST_NO_CXX98_RANDOM_SHUFFLE #include <cstdlib> #endif namespace boost { namespace range { namespace detail { #ifdef BOOST_NO_CXX98_RANDOM_SHUFFLE // wrap std::rand as UniformRandomBitGenerator struct wrap_rand { typedef unsigned int result_type; static BOOST_CONSTEXPR result_type (min)() { return 0; } static BOOST_CONSTEXPR result_type (max)() { return RAND_MAX; } result_type operator()() { return std::rand(); } }; template< class RandomIt > inline void random_shuffle(RandomIt first, RandomIt last) { std::shuffle(first, last, wrap_rand()); } // wrap Generator as UniformRandomBitGenerator template< class Generator > struct wrap_generator { typedef unsigned int result_type; static const int max_arg = ((0u - 1u) >> 2) + 1; Generator& g; wrap_generator(Generator& gen) : g(gen) {} static BOOST_CONSTEXPR result_type (min)() { return 0; } static BOOST_CONSTEXPR result_type (max)() { return max_arg - 1; } result_type operator()() { return static_cast<result_type>(g(max_arg)); } }; template< class RandomIt, class Generator > inline void random_shuffle(RandomIt first, RandomIt last, Generator& gen) { std::shuffle(first, last, wrap_generator< Generator >(gen)); } #else using std::random_shuffle; #endif } // namespace detail /// \brief template function random_shuffle /// /// range-based version of the random_shuffle std algorithm /// /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept /// \pre Generator is a model of the UnaryFunctionConcept template<class RandomAccessRange> inline RandomAccessRange& random_shuffle(RandomAccessRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> )); detail::random_shuffle(boost::begin(rng), boost::end(rng)); return rng; } /// \overload template<class RandomAccessRange> inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> )); detail::random_shuffle(boost::begin(rng), boost::end(rng)); return rng; } /// \overload template<class RandomAccessRange, class Generator> inline RandomAccessRange& random_shuffle(RandomAccessRange& rng, Generator& gen) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> )); detail::random_shuffle(boost::begin(rng), boost::end(rng), gen); return rng; } /// \overload template<class RandomAccessRange, class Generator> inline const RandomAccessRange& random_shuffle(const RandomAccessRange& rng, Generator& gen) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> )); detail::random_shuffle(boost::begin(rng), boost::end(rng), gen); return rng; } } // namespace range using range::random_shuffle; } // namespace boost #endif // include guard PK��!\Ϡ<5��5��max_element.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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) // // Copyright 2019 Glen Joseph Fernandes (glenjofe@gmail.com) // // For more information, see http://www.boost.org/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_MAX_ELEMENT_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_MAX_ELEMENT_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/range/detail/less.hpp> #include <boost/range/detail/range_return.hpp> namespace boost { namespace range { namespace detail { template<typename Iterator, class Predicate> inline Iterator max_element(Iterator first, Iterator last, Predicate comp) { if (first == last) { return last; } Iterator result = first; while (++first != last) { if (comp(result, first)) { result = first; } } return result; } } // namespace detail /// \brief template function max_element /// /// range-based version of the max_element std algorithm /// /// \pre ForwardRange is a model of the ForwardRangeConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept template<class ForwardRange> inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type max_element(ForwardRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return detail::max_element(boost::begin(rng), boost::end(rng), detail::less()); } /// \overload template<class ForwardRange> inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type max_element(const ForwardRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return detail::max_element(boost::begin(rng), boost::end(rng), detail::less()); } /// \overload template<class ForwardRange, class BinaryPredicate> inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type max_element(ForwardRange& rng, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return detail::max_element(boost::begin(rng), boost::end(rng), pred); } /// \overload template<class ForwardRange, class BinaryPredicate> inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type max_element(const ForwardRange& rng, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return detail::max_element(boost::begin(rng), boost::end(rng), pred); } // range_return overloads /// \overload template<range_return_value re, class ForwardRange> inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type max_element(ForwardRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return range_return<ForwardRange,re>::pack( detail::max_element(boost::begin(rng), boost::end(rng), detail::less()), rng); } /// \overload template<range_return_value re, class ForwardRange> inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type max_element(const ForwardRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return range_return<const ForwardRange,re>::pack( detail::max_element(boost::begin(rng), boost::end(rng), detail::less()), rng); } /// \overload template<range_return_value re, class ForwardRange, class BinaryPredicate> inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type max_element(ForwardRange& rng, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return range_return<ForwardRange,re>::pack( detail::max_element(boost::begin(rng), boost::end(rng), pred), rng); } /// \overload template<range_return_value re, class ForwardRange, class BinaryPredicate> inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type max_element(const ForwardRange& rng, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return range_return<const ForwardRange,re>::pack( detail::max_element(boost::begin(rng), boost::end(rng), pred), rng); } } // namespace range using range::max_element; } // namespace boost #endif // include guard PK��!\��.��heap_algorithm.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_HEAP_ALGORITHM_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_HEAP_ALGORITHM_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function push_heap /// /// range-based version of the push_heap std algorithm /// /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept /// \pre Compare is a model of the BinaryPredicateConcept template<class RandomAccessRange> inline RandomAccessRange& push_heap(RandomAccessRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> )); std::push_heap(boost::begin(rng), boost::end(rng)); return rng; } /// \overload template<class RandomAccessRange> inline const RandomAccessRange& push_heap(const RandomAccessRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> )); std::push_heap(boost::begin(rng), boost::end(rng)); return rng; } /// \overload template<class RandomAccessRange, class Compare> inline RandomAccessRange& push_heap(RandomAccessRange& rng, Compare comp_pred) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> )); std::push_heap(boost::begin(rng), boost::end(rng), comp_pred); return rng; } /// \overload template<class RandomAccessRange, class Compare> inline const RandomAccessRange& push_heap(const RandomAccessRange& rng, Compare comp_pred) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> )); std::push_heap(boost::begin(rng), boost::end(rng), comp_pred); return rng; } /// \brief template function pop_heap /// /// range-based version of the pop_heap std algorithm /// /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept /// \pre Compare is a model of the BinaryPredicateConcept template<class RandomAccessRange> inline RandomAccessRange& pop_heap(RandomAccessRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> )); std::pop_heap(boost::begin(rng), boost::end(rng)); return rng; } /// \overload template<class RandomAccessRange> inline const RandomAccessRange& pop_heap(const RandomAccessRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> )); std::pop_heap(boost::begin(rng), boost::end(rng)); return rng; } /// \overload template<class RandomAccessRange, class Compare> inline RandomAccessRange& pop_heap(RandomAccessRange& rng, Compare comp_pred) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> )); std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred); return rng; } /// \overload template<class RandomAccessRange, class Compare> inline const RandomAccessRange& pop_heap(const RandomAccessRange& rng, Compare comp_pred) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> )); std::pop_heap(boost::begin(rng), boost::end(rng), comp_pred); return rng; } /// \brief template function make_heap /// /// range-based version of the make_heap std algorithm /// /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept /// \pre Compare is a model of the BinaryPredicateConcept template<class RandomAccessRange> inline RandomAccessRange& make_heap(RandomAccessRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> )); std::make_heap(boost::begin(rng), boost::end(rng)); return rng; } /// \overload template<class RandomAccessRange> inline const RandomAccessRange& make_heap(const RandomAccessRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> )); std::make_heap(boost::begin(rng), boost::end(rng)); return rng; } /// \overload template<class RandomAccessRange, class Compare> inline RandomAccessRange& make_heap(RandomAccessRange& rng, Compare comp_pred) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> )); std::make_heap(boost::begin(rng), boost::end(rng), comp_pred); return rng; } /// \overload template<class RandomAccessRange, class Compare> inline const RandomAccessRange& make_heap(const RandomAccessRange& rng, Compare comp_pred) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> )); std::make_heap(boost::begin(rng), boost::end(rng), comp_pred); return rng; } /// \brief template function sort_heap /// /// range-based version of the sort_heap std algorithm /// /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept /// \pre Compare is a model of the BinaryPredicateConcept template<class RandomAccessRange> inline RandomAccessRange& sort_heap(RandomAccessRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> )); std::sort_heap(boost::begin(rng), boost::end(rng)); return rng; } /// \overload template<class RandomAccessRange> inline const RandomAccessRange& sort_heap(const RandomAccessRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> )); std::sort_heap(boost::begin(rng), boost::end(rng)); return rng; } /// \overload template<class RandomAccessRange, class Compare> inline RandomAccessRange& sort_heap(RandomAccessRange& rng, Compare comp_pred) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> )); std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred); return rng; } /// \overload template<class RandomAccessRange, class Compare> inline const RandomAccessRange& sort_heap(const RandomAccessRange& rng, Compare comp_pred) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> )); std::sort_heap(boost::begin(rng), boost::end(rng), comp_pred); return rng; } } // namespace range using range::push_heap; using range::pop_heap; using range::make_heap; using range::sort_heap; } // namespace boost #endif // include guard PK��!\�\|5��5��min_element.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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) // // Copyright 2019 Glen Joseph Fernandes (glenjofe@gmail.com) // // For more information, see http://www.boost.org/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_MIN_ELEMENT_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_MIN_ELEMENT_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/range/detail/less.hpp> #include <boost/range/detail/range_return.hpp> namespace boost { namespace range { namespace detail { template<typename Iterator, class Predicate> inline Iterator min_element(Iterator first, Iterator last, Predicate comp) { if (first == last) { return last; } Iterator result = first; while (++first != last) { if (comp(first, result)) { result = first; } } return result; } } // namespace detail /// \brief template function min_element /// /// range-based version of the min_element std algorithm /// /// \pre ForwardRange is a model of the ForwardRangeConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept template<class ForwardRange> inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type min_element(ForwardRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return detail::min_element(boost::begin(rng), boost::end(rng), detail::less()); } /// \overload template<class ForwardRange> inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type min_element(const ForwardRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return detail::min_element(boost::begin(rng), boost::end(rng), detail::less()); } /// \overload template<class ForwardRange, class BinaryPredicate> inline BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange>::type min_element(ForwardRange& rng, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return detail::min_element(boost::begin(rng), boost::end(rng), pred); } /// \overload template<class ForwardRange, class BinaryPredicate> inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange>::type min_element(const ForwardRange& rng, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return detail::min_element(boost::begin(rng), boost::end(rng), pred); } // range_return overloads /// \overload template<range_return_value re, class ForwardRange> inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type min_element(ForwardRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return range_return<ForwardRange,re>::pack( detail::min_element(boost::begin(rng), boost::end(rng), detail::less()), rng); } /// \overload template<range_return_value re, class ForwardRange> inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type min_element(const ForwardRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return range_return<const ForwardRange,re>::pack( detail::min_element(boost::begin(rng), boost::end(rng), detail::less()), rng); } /// \overload template<range_return_value re, class ForwardRange, class BinaryPredicate> inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type min_element(ForwardRange& rng, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return range_return<ForwardRange,re>::pack( detail::min_element(boost::begin(rng), boost::end(rng), pred), rng); } /// \overload template<range_return_value re, class ForwardRange, class BinaryPredicate> inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type min_element(const ForwardRange& rng, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return range_return<const ForwardRange,re>::pack( detail::min_element(boost::begin(rng), boost::end(rng), pred), rng); } } // namespace range using range::min_element; } // namespace boost #endif // include guard PK��!\��. �� partial_sort.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_PARTIAL_SORT_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_PARTIAL_SORT_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function partial_sort /// /// range-based version of the partial_sort std algorithm /// /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept template<class RandomAccessRange> inline RandomAccessRange& partial_sort(RandomAccessRange& rng, BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type middle) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> )); std::partial_sort(boost::begin(rng), middle, boost::end(rng)); return rng; } /// \overload template<class RandomAccessRange> inline const RandomAccessRange& partial_sort(const RandomAccessRange& rng, BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type middle) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> )); std::partial_sort(boost::begin(rng), middle, boost::end(rng)); return rng; } /// \overload template<class RandomAccessRange, class BinaryPredicate> inline RandomAccessRange& partial_sort(RandomAccessRange& rng, BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type middle, BinaryPredicate sort_pred) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> )); std::partial_sort(boost::begin(rng), middle, boost::end(rng), sort_pred); return rng; } /// \overload template<class RandomAccessRange, class BinaryPredicate> inline const RandomAccessRange& partial_sort(const RandomAccessRange& rng, BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type middle, BinaryPredicate sort_pred) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> )); std::partial_sort(boost::begin(rng), middle, boost::end(rng), sort_pred); return rng; } } // namespace range using range::partial_sort; } // namespace boost #endif // include guard PK��!\�m� �� nth_element.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_NTH_ELEMENT_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_NTH_ELEMENT_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function nth_element /// /// range-based version of the nth_element std algorithm /// /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept template<class RandomAccessRange> inline RandomAccessRange& nth_element(RandomAccessRange& rng, BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type nth) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> )); std::nth_element(boost::begin(rng), nth, boost::end(rng)); return rng; } /// \overload template<class RandomAccessRange> inline const RandomAccessRange& nth_element(const RandomAccessRange& rng, BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type nth) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> )); std::nth_element(boost::begin(rng), nth, boost::end(rng)); return rng; } /// \overload template<class RandomAccessRange, class BinaryPredicate> inline RandomAccessRange& nth_element(RandomAccessRange& rng, BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type nth, BinaryPredicate sort_pred) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> )); std::nth_element(boost::begin(rng), nth, boost::end(rng), sort_pred); return rng; } /// \overload template<class RandomAccessRange, class BinaryPredicate> inline const RandomAccessRange& nth_element(const RandomAccessRange& rng, BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type nth, BinaryPredicate sort_pred) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> )); std::nth_element(boost::begin(rng), nth, boost::end(rng), sort_pred); return rng; } } // namespace range using range::nth_element; } // namespace boost #endif // include guard PK��!\�Ly��remove_copy.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_REMOVE_COPY_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_REMOVE_COPY_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function remove_copy /// /// range-based version of the remove_copy std algorithm /// /// \pre SinglePassRange is a model of the SinglePassRangeConcept /// \pre OutputIterator is a model of the OutputIteratorConcept /// \pre Value is a model of the EqualityComparableConcept /// \pre Objects of type Value can be compared for equality with objects of /// InputIterator's value type. template< class SinglePassRange, class OutputIterator, class Value > inline OutputIterator remove_copy(const SinglePassRange& rng, OutputIterator out_it, const Value& val) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> )); return std::remove_copy(boost::begin(rng), boost::end(rng), out_it, val); } } // namespace range using range::remove_copy; } // namespace boost #endif // include guard PK��!\m�ޙ��for_each.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_FOR_EACH_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_FOR_EACH_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/utility/enable_if.hpp> #include <boost/ref.hpp> #include <algorithm> #if BOOST_WORKAROUND(BOOST_MSVC, == 1600) #include <xutility> #endif namespace boost { namespace range { #if BOOST_WORKAROUND(BOOST_MSVC, == 1600) namespace for_each_detail { template<typename Iterator, typename UnaryFunction> inline UnaryFunction for_each_impl(Iterator first, Iterator last, UnaryFunction fun, typename ::boost::enable_if< is_reference_wrapper<UnaryFunction>, void >::type = 0) { typedef typename std::_Get_unchecked_type<Iterator>::type unchecked_iterator; unchecked_iterator unchecked_last = std::_Unchecked(last); for (unchecked_iterator unchecked_first = std::_Unchecked(first); first != last; ++first) fun.get()(unchecked_first); return fun; } template<typename Iterator, typename UnaryFunction> inline UnaryFunction for_each_impl(Iterator first, Iterator last, UnaryFunction fn, typename disable_if< is_reference_wrapper<UnaryFunction>, void >::type = 0) { return std::for_each<Iterator, UnaryFunction>(first, last, fn); } } #endif /// \brief template function for_each /// /// range-based version of the for_each std algorithm /// /// \pre SinglePassRange is a model of the SinglePassRangeConcept /// \pre UnaryFunction is a model of the UnaryFunctionConcept template< class SinglePassRange, class UnaryFunction > inline UnaryFunction for_each(SinglePassRange & rng, UnaryFunction fun) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> )); #if BOOST_WORKAROUND(BOOST_MSVC, == 1600) return for_each_detail::for_each_impl< typename range_iterator<SinglePassRange>::type, UnaryFunction >(boost::begin(rng), boost::end(rng), fun); #else return std::for_each< BOOST_DEDUCED_TYPENAME range_iterator<SinglePassRange>::type, UnaryFunction >(boost::begin(rng),boost::end(rng),fun); #endif } /// \overload template< class SinglePassRange, class UnaryFunction > inline UnaryFunction for_each(const SinglePassRange& rng, UnaryFunction fun) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> )); #if BOOST_WORKAROUND(BOOST_MSVC, == 1600) return for_each_detail::for_each_impl< typename range_iterator<const SinglePassRange>::type, UnaryFunction >(boost::begin(rng), boost::end(rng), fun); #else return std::for_each< BOOST_DEDUCED_TYPENAME range_iterator<const SinglePassRange>::type, UnaryFunction >(boost::begin(rng), boost::end(rng), fun); #endif } } // namespace range using range::for_each; } // namespace boost #endif // include guard PK��!\F�� count.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_COUNT_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_COUNT_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/range/difference_type.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function count /// /// range-based version of the count std algorithm /// /// \pre SinglePassRange is a model of the SinglePassRangeConcept template< class SinglePassRange, class Value > inline BOOST_DEDUCED_TYPENAME range_difference<SinglePassRange>::type count(SinglePassRange& rng, const Value& val) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<SinglePassRange> )); return std::count(boost::begin(rng), boost::end(rng), val); } /// \overload template< class SinglePassRange, class Value > inline BOOST_DEDUCED_TYPENAME range_difference<SinglePassRange const>::type count(const SinglePassRange& rng, const Value& val) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange> )); return std::count(boost::begin(rng), boost::end(rng), val); } } // namespace range using range::count; } // namespace boost #endif // include guard PK��!\ɲ�:#��:#�� equal.hppnu��[��// Boost.Range library // // Copyright Neil Groves 2009. // Use, modification and distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_EQUAL_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_EQUAL_HPP_INCLUDED #include <boost/config.hpp> #include <boost/range/concepts.hpp> #include <iterator> namespace boost { namespace range_detail { // An implementation of equality comparison that is optimized for iterator // traversal categories less than RandomAccessTraversal. template< class SinglePassTraversalReadableIterator1, class SinglePassTraversalReadableIterator2, class IteratorCategoryTag1, class IteratorCategoryTag2 > inline bool equal_impl( SinglePassTraversalReadableIterator1 first1, SinglePassTraversalReadableIterator1 last1, SinglePassTraversalReadableIterator2 first2, SinglePassTraversalReadableIterator2 last2, IteratorCategoryTag1, IteratorCategoryTag2 ) { for (;;) { // If we have reached the end of the left range then this is // the end of the loop. They are equal if and only if we have // simultaneously reached the end of the right range. if (first1 == last1) return first2 == last2; // If we have reached the end of the right range at this line // it indicates that the right range is shorter than the left // and hence the result is false. if (first2 == last2) return false; // continue looping if and only if the values are equal if (first1 != first2) break; ++first1; ++first2; } // Reaching this line in the algorithm indicates that a value // inequality has been detected. return false; } template< class SinglePassTraversalReadableIterator1, class SinglePassTraversalReadableIterator2, class IteratorCategoryTag1, class IteratorCategoryTag2, class BinaryPredicate > inline bool equal_impl( SinglePassTraversalReadableIterator1 first1, SinglePassTraversalReadableIterator1 last1, SinglePassTraversalReadableIterator2 first2, SinglePassTraversalReadableIterator2 last2, BinaryPredicate pred, IteratorCategoryTag1, IteratorCategoryTag2 ) { for (;;) { // If we have reached the end of the left range then this is // the end of the loop. They are equal if and only if we have // simultaneously reached the end of the right range. if (first1 == last1) return first2 == last2; // If we have reached the end of the right range at this line // it indicates that the right range is shorter than the left // and hence the result is false. if (first2 == last2) return false; // continue looping if and only if the values are equal if (!pred(first1, first2)) break; ++first1; ++first2; } // Reaching this line in the algorithm indicates that a value // inequality has been detected. return false; } // An implementation of equality comparison that is optimized for // random access iterators. template< class RandomAccessTraversalReadableIterator1, class RandomAccessTraversalReadableIterator2 > inline bool equal_impl( RandomAccessTraversalReadableIterator1 first1, RandomAccessTraversalReadableIterator1 last1, RandomAccessTraversalReadableIterator2 first2, RandomAccessTraversalReadableIterator2 last2, std::random_access_iterator_tag, std::random_access_iterator_tag ) { return ((last1 - first1) == (last2 - first2)) && std::equal(first1, last1, first2); } template< class RandomAccessTraversalReadableIterator1, class RandomAccessTraversalReadableIterator2, class BinaryPredicate > inline bool equal_impl( RandomAccessTraversalReadableIterator1 first1, RandomAccessTraversalReadableIterator1 last1, RandomAccessTraversalReadableIterator2 first2, RandomAccessTraversalReadableIterator2 last2, BinaryPredicate pred, std::random_access_iterator_tag, std::random_access_iterator_tag ) { return ((last1 - first1) == (last2 - first2)) && std::equal(first1, last1, first2, pred); } template< class SinglePassTraversalReadableIterator1, class SinglePassTraversalReadableIterator2 > inline bool equal( SinglePassTraversalReadableIterator1 first1, SinglePassTraversalReadableIterator1 last1, SinglePassTraversalReadableIterator2 first2, SinglePassTraversalReadableIterator2 last2 ) { BOOST_DEDUCED_TYPENAME std::iterator_traits< SinglePassTraversalReadableIterator1 >::iterator_category tag1; BOOST_DEDUCED_TYPENAME std::iterator_traits< SinglePassTraversalReadableIterator2 >::iterator_category tag2; return equal_impl(first1, last1, first2, last2, tag1, tag2); } template< class SinglePassTraversalReadableIterator1, class SinglePassTraversalReadableIterator2, class BinaryPredicate > inline bool equal( SinglePassTraversalReadableIterator1 first1, SinglePassTraversalReadableIterator1 last1, SinglePassTraversalReadableIterator2 first2, SinglePassTraversalReadableIterator2 last2, BinaryPredicate pred ) { BOOST_DEDUCED_TYPENAME std::iterator_traits< SinglePassTraversalReadableIterator1 >::iterator_category tag1; BOOST_DEDUCED_TYPENAME std::iterator_traits< SinglePassTraversalReadableIterator2 >::iterator_category tag2; return equal_impl(first1, last1, first2, last2, pred, tag1, tag2); } } // namespace range_detail namespace range { /// \brief template function equal /// /// range-based version of the equal std algorithm /// /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept template< class SinglePassRange1, class SinglePassRange2 > inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2 ) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> )); return ::boost::range_detail::equal( ::boost::begin(rng1), ::boost::end(rng1), ::boost::begin(rng2), ::boost::end(rng2) ); } /// \overload template< class SinglePassRange1, class SinglePassRange2, class BinaryPredicate > inline bool equal( const SinglePassRange1& rng1, const SinglePassRange2& rng2, BinaryPredicate pred ) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> )); return ::boost::range_detail::equal( ::boost::begin(rng1), ::boost::end(rng1), ::boost::begin(rng2), ::boost::end(rng2), pred); } } // namespace range using ::boost::range::equal; } // namespace boost #endif // include guard PK��!\�2�� unique.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_UNIQUE_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_UNIQUE_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/range/detail/range_return.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function unique /// /// range-based version of the unique std algorithm /// /// \pre Rng meets the requirements for a Forward range template< range_return_value re, class ForwardRange > inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type unique( ForwardRange& rng ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return range_return<ForwardRange,re>:: pack( std::unique( boost::begin(rng), boost::end(rng)), rng ); } /// \overload template< range_return_value re, class ForwardRange > inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type unique( const ForwardRange& rng ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return range_return<const ForwardRange,re>:: pack( std::unique( boost::begin(rng), boost::end(rng)), rng ); } /// \overload template< range_return_value re, class ForwardRange, class BinaryPredicate > inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange,re>::type unique( ForwardRange& rng, BinaryPredicate pred ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return range_return<ForwardRange,re>:: pack(std::unique(boost::begin(rng), boost::end(rng), pred), rng); } /// \overload template< range_return_value re, class ForwardRange, class BinaryPredicate > inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange,re>::type unique( const ForwardRange& rng, BinaryPredicate pred ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return range_return<const ForwardRange,re>:: pack(std::unique(boost::begin(rng), boost::end(rng), pred), rng); } /// \overload template< class ForwardRange > inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange, return_begin_found>::type unique( ForwardRange& rng ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return ::boost::range::unique<return_begin_found>(rng); } /// \overload template< class ForwardRange > inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange, return_begin_found>::type unique( const ForwardRange& rng ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return ::boost::range::unique<return_begin_found>(rng); } /// \overload template< class ForwardRange, class BinaryPredicate > inline BOOST_DEDUCED_TYPENAME range_return<ForwardRange, return_begin_found>::type unique( ForwardRange& rng, BinaryPredicate pred ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); return ::boost::range::unique<return_begin_found>(rng, pred); } /// \overload template< class ForwardRange, class BinaryPredicate > inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange, return_begin_found>::type unique( const ForwardRange& rng, BinaryPredicate pred ) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); return ::boost::range::unique<return_begin_found>(rng, pred); } } // namespace range using range::unique; } // namespace boost #endif // include guard PK��!\?T�� merge.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_MERGE_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_MERGE_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function merge /// /// range-based version of the merge std algorithm /// /// \pre SinglePassRange1 is a model of the SinglePassRangeConcept /// \pre SinglePassRange2 is a model of the SinglePassRangeConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept /// template<class SinglePassRange1, class SinglePassRange2, class OutputIterator> inline OutputIterator merge(const SinglePassRange1& rng1, const SinglePassRange2& rng2, OutputIterator out) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> )); return std::merge(boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2), out); } /// \overload template<class SinglePassRange1, class SinglePassRange2, class OutputIterator, class BinaryPredicate> inline OutputIterator merge(const SinglePassRange1& rng1, const SinglePassRange2& rng2, OutputIterator out, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( SinglePassRangeConcept<const SinglePassRange2> )); return std::merge(boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2), out, pred); } } // namespace range using range::merge; } // namespace boost #endif // include guard PK��!\��C��sort.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_SORT_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_SORT_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function sort /// /// range-based version of the sort std algorithm /// /// \pre RandomAccessRange is a model of the RandomAccessRangeConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept template<class RandomAccessRange> inline RandomAccessRange& sort(RandomAccessRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> )); std::sort(boost::begin(rng), boost::end(rng)); return rng; } /// \overload template<class RandomAccessRange> inline const RandomAccessRange& sort(const RandomAccessRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> )); std::sort(boost::begin(rng), boost::end(rng)); return rng; } /// \overload template<class RandomAccessRange, class BinaryPredicate> inline RandomAccessRange& sort(RandomAccessRange& rng, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<RandomAccessRange> )); std::sort(boost::begin(rng), boost::end(rng), pred); return rng; } /// \overload template<class RandomAccessRange, class BinaryPredicate> inline const RandomAccessRange& sort(const RandomAccessRange& rng, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( RandomAccessRangeConcept<const RandomAccessRange> )); std::sort(boost::begin(rng), boost::end(rng), pred); return rng; } } // namespace range using range::sort; } // namespace boost #endif // include guard PK��!\�,ҩ��permutation.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_PERMUTATION_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_PERMUTATION_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function next_permutation /// /// range-based version of the next_permutation std algorithm /// /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept /// \pre Compare is a model of the BinaryPredicateConcept template<class BidirectionalRange> inline bool next_permutation(BidirectionalRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> )); return std::next_permutation(boost::begin(rng), boost::end(rng)); } /// \overload template<class BidirectionalRange> inline bool next_permutation(const BidirectionalRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> )); return std::next_permutation(boost::begin(rng), boost::end(rng)); } /// \overload template<class BidirectionalRange, class Compare> inline bool next_permutation(BidirectionalRange& rng, Compare comp_pred) { BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> )); return std::next_permutation(boost::begin(rng), boost::end(rng), comp_pred); } /// \overload template<class BidirectionalRange, class Compare> inline bool next_permutation(const BidirectionalRange& rng, Compare comp_pred) { BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> )); return std::next_permutation(boost::begin(rng), boost::end(rng), comp_pred); } /// \brief template function prev_permutation /// /// range-based version of the prev_permutation std algorithm /// /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept /// \pre Compare is a model of the BinaryPredicateConcept template<class BidirectionalRange> inline bool prev_permutation(BidirectionalRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> )); return std::prev_permutation(boost::begin(rng), boost::end(rng)); } /// \overload template<class BidirectionalRange> inline bool prev_permutation(const BidirectionalRange& rng) { BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> )); return std::prev_permutation(boost::begin(rng), boost::end(rng)); } /// \overload template<class BidirectionalRange, class Compare> inline bool prev_permutation(BidirectionalRange& rng, Compare comp_pred) { BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<BidirectionalRange> )); return std::prev_permutation(boost::begin(rng), boost::end(rng), comp_pred); } /// \overload template<class BidirectionalRange, class Compare> inline bool prev_permutation(const BidirectionalRange& rng, Compare comp_pred) { BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> )); return std::prev_permutation(boost::begin(rng), boost::end(rng), comp_pred); } } // namespace range using range::next_permutation; using range::prev_permutation; } // namespace boost #endif // include guard PK��!\��S��S��partial_sort_copy.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_PARTIAL_SORT_COPY_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_PARTIAL_SORT_COPY_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/range/value_type.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function partial_sort_copy /// /// range-based version of the partial_sort_copy std algorithm /// /// \pre SinglePassRange is a model of the SinglePassRangeConcept /// \pre RandomAccessRange is a model of the Mutable_RandomAccessRangeConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept template<class SinglePassRange, class RandomAccessRange> inline BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2) { BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<const SinglePassRange>)); return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2)); } /// \overload template<class SinglePassRange, class RandomAccessRange> inline BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type partial_sort_copy(const SinglePassRange& rng1, const RandomAccessRange& rng2) { BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<const SinglePassRange>)); return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2)); } /// \overload template<class SinglePassRange, class RandomAccessRange, class BinaryPredicate> inline BOOST_DEDUCED_TYPENAME range_iterator<RandomAccessRange>::type partial_sort_copy(const SinglePassRange& rng1, RandomAccessRange& rng2, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<const SinglePassRange>)); return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2), pred); } /// \overload template<class SinglePassRange, class RandomAccessRange, class BinaryPredicate> inline BOOST_DEDUCED_TYPENAME range_iterator<const RandomAccessRange>::type partial_sort_copy(const SinglePassRange& rng1, const RandomAccessRange& rng2, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT((SinglePassRangeConcept<const SinglePassRange>)); return std::partial_sort_copy(boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2), pred); } } // namespace range using range::partial_sort_copy; } // namespace boost #endif // include guard PK��!\�-�b��b��replace_if.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_REPLACE_IF_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_REPLACE_IF_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function replace_if /// /// range-based version of the replace_if std algorithm /// /// \pre ForwardRange is a model of the ForwardRangeConcept /// \pre UnaryPredicate is a model of the UnaryPredicateConcept template< class ForwardRange, class UnaryPredicate, class Value > inline ForwardRange& replace_if(ForwardRange& rng, UnaryPredicate pred, const Value& val) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange> )); std::replace_if(boost::begin(rng), boost::end(rng), pred, val); return rng; } /// \overload template< class ForwardRange, class UnaryPredicate, class Value > inline const ForwardRange& replace_if(const ForwardRange& rng, UnaryPredicate pred, const Value& val) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange> )); std::replace_if(boost::begin(rng), boost::end(rng), pred, val); return rng; } } // namespace range using range::replace_if; } // namespace boost #endif // include guard PK��!\n��copy_backward.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_COPY_BACKWARD_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_COPY_BACKWARD_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function copy_backward /// /// range-based version of the copy_backwards std algorithm /// /// \pre BidirectionalRange is a model of the BidirectionalRangeConcept /// \pre BidirectionalTraversalWriteableIterator is a model of the BidirectionalIteratorConcept /// \pre BidirectionalTraversalWriteableIterator is a model of the WriteableIteratorConcept template< class BidirectionalRange, class BidirectionalTraversalWriteableIterator > inline BidirectionalTraversalWriteableIterator copy_backward(const BidirectionalRange& rng, BidirectionalTraversalWriteableIterator out) { BOOST_RANGE_CONCEPT_ASSERT(( BidirectionalRangeConcept<const BidirectionalRange> )); return std::copy_backward(boost::begin(rng), boost::end(rng), out); } } // namespace range using range::copy_backward; } // namespace boost #endif // include guard PK��!\�Wܔ��find_end.hppnu��[��// Copyright Neil Groves 2009. Use, modification and // distribution is subject to 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/libs/range/ // #ifndef BOOST_RANGE_ALGORITHM_FIND_END_HPP_INCLUDED #define BOOST_RANGE_ALGORITHM_FIND_END_HPP_INCLUDED #include <boost/concept_check.hpp> #include <boost/range/begin.hpp> #include <boost/range/end.hpp> #include <boost/range/concepts.hpp> #include <boost/range/detail/range_return.hpp> #include <algorithm> namespace boost { namespace range { /// \brief template function find_end /// /// range-based version of the find_end std algorithm /// /// \pre ForwardRange1 is a model of the ForwardRangeConcept /// \pre ForwardRange2 is a model of the ForwardRangeConcept /// \pre BinaryPredicate is a model of the BinaryPredicateConcept template< class ForwardRange1, class ForwardRange2 > inline BOOST_DEDUCED_TYPENAME disable_if< is_const<ForwardRange1>, BOOST_DEDUCED_TYPENAME range_iterator< ForwardRange1 >::type >::type find_end(ForwardRange1 & rng1, const ForwardRange2& rng2) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> )); return std::find_end(boost::begin(rng1),boost::end(rng1), boost::begin(rng2),boost::end(rng2)); } /// \overload template< class ForwardRange1, class ForwardRange2 > inline BOOST_DEDUCED_TYPENAME range_iterator< const ForwardRange1 >::type find_end(const ForwardRange1 & rng1, const ForwardRange2& rng2) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> )); return std::find_end(boost::begin(rng1),boost::end(rng1), boost::begin(rng2),boost::end(rng2)); } /// \overload template< class ForwardRange1, class ForwardRange2, class BinaryPredicate > inline BOOST_DEDUCED_TYPENAME disable_if< is_const<ForwardRange1>, BOOST_DEDUCED_TYPENAME range_iterator<ForwardRange1>::type >::type find_end(ForwardRange1 & rng1, const ForwardRange2& rng2, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> )); return std::find_end(boost::begin(rng1),boost::end(rng1), boost::begin(rng2),boost::end(rng2),pred); } /// \overload template< class ForwardRange1, class ForwardRange2, class BinaryPredicate > inline BOOST_DEDUCED_TYPENAME range_iterator<const ForwardRange1>::type find_end(const ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> )); return std::find_end(boost::begin(rng1),boost::end(rng1), boost::begin(rng2),boost::end(rng2),pred); } /// \overload template< range_return_value re, class ForwardRange1, class ForwardRange2 > inline BOOST_DEDUCED_TYPENAME disable_if< is_const<ForwardRange1>, BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type >::type find_end(ForwardRange1& rng1, const ForwardRange2& rng2) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> )); return range_return<ForwardRange1,re>:: pack(std::find_end(boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2)), rng1); } /// \overload template< range_return_value re, class ForwardRange1, class ForwardRange2 > inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type find_end(const ForwardRange1& rng1, const ForwardRange2& rng2) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> )); return range_return<const ForwardRange1,re>:: pack(std::find_end(boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2)), rng1); } /// \overload template< range_return_value re, class ForwardRange1, class ForwardRange2, class BinaryPredicate > inline BOOST_DEDUCED_TYPENAME disable_if< is_const<ForwardRange1>, BOOST_DEDUCED_TYPENAME range_return<ForwardRange1,re>::type >::type find_end(ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<ForwardRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> )); return range_return<ForwardRange1,re>:: pack(std::find_end(boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2), pred), rng1); } /// \overload template< range_return_value re, class ForwardRange1, class ForwardRange2, class BinaryPredicate > inline BOOST_DEDUCED_TYPENAME range_return<const ForwardRange1,re>::type find_end(const ForwardRange1& rng1, const ForwardRange2& rng2, BinaryPredicate pred) { BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange1> )); BOOST_RANGE_CONCEPT_ASSERT(( ForwardRangeConcept<const ForwardRange2> )); return range_return<const ForwardRange1,re>:: pack(std::find_end(boost::begin(rng1), boost::end(rng1), boost::begin(rng2), boost::end(rng2), pred), rng1); } } // namespace range using range::find_end; } // namespace boost #endif // include guard PK��M�[e?��is_palindrome.hppnu��[��PK��M�[�3� �� is_partitioned_until.hppnu��[��PK��M�[%�R�PD��PD��P��minmax_element.hppnu��[��PK��M�[�#AZ �� _��string/trim_all.hppnu��[��PK��M�[HX1϶��:��string/split.hppnu��[��PK��M�[�Rγ4��4��0��string/sequence_traits.hppnu��[��PK��M�[��string/yes_no_type.hppnu��[��PK��M�[�C�D��D�� ۮ��string/std_containers_traits.hppnu��[��PK��M�[ި��o��string/formatter.hppnu��[��PK��M�[� ��2��string/config.hppnu��[��PK��M�[�]�( ��( ��string/concept.hppnu��[��PK��M�[%ޯ��string/case_conv.hppnu��[��PK��M�[ G3��3��P��string/find.hppnu��[��PK��M�[Ҭ�m7��m7��string/trim.hppnu��[��PK��M�[��^����JS�string/predicate_facade.hppnu��[��PK��M�[��Fk��k��X�string/replace.hppnu��[��PK��M�[6=�-�a��a��l��string/regex.hppnu��[��PK��M�[a�ZFY��Y��2G�string/iter_find.hppnu��[��PK��M�[y��S�$��$��d�string/finder.hppnu��[��PK��M�[�V��(��(��string/find_format.hppnu��[��PK��M�[��F�� string/std/rope_traits.hppnu��[��PK��M�[�6��9��string/std/string_traits.hppnu��[��PK��M�[� C8��8��{��string/std/list_traits.hppnu��[��PK��M�[�14��string/std/slist_traits.hppnu��[��PK��M�[��i��string/regex_find_format.hppnu��[��PK��M�[��wE\|��E\|��string/erase.hppnu��[��PK��M�[�(��Y\�string/detail/formatter.hppnu��[��PK��M�[��V��V��#��k�string/detail/find_format_store.hppnu��[��PK��M�[锏��9x�string/detail/case_conv.hppnu��[��PK��M�[�@�]��]��string/detail/trim.hppnu��[��PK��M�[�n�8��8��!��string/detail/replace_storage.hppnu��[��PK��M�[ 濙�Y��Y��>��string/detail/finder.hppnu��[��PK��M�[;C�Wi��i��string/detail/sequence.hppnu��[��PK��M�[u��%�string/detail/find_format.hppnu��[��PK��M�[T��4� �� D�string/detail/predicate.hppnu��[��PK��M�[ư�� N�string/detail/find_iterator.hppnu��[��PK��M�[1�i� �� Y�string/detail/util.hppnu��[��PK��M�[� �5��f�string/detail/finder_regex.hppnu��[��PK��M�[z��t0��t0�� .y�string/detail/classification.hppnu��[��PK��M�[}4\|��!��string/detail/formatter_regex.hppnu��[��PK��M�[:,��.(��.(��!��string/detail/find_format_all.hppnu��[��PK��M�[��;��C��C��string/predicate.hppnu��[��PK��M�[z��G�/��/��string/find_iterator.hppnu��[��PK��M�[e �I��N�string/join.hppnu��[��PK��M�[�6�z-��z-��b�string/classification.hppnu��[��PK��M�[[\Y>��S��string/constants.hppnu��[��PK��M�[��~��string/compare.hppnu��[��PK��M�[ұ�@��@��cxx17/transform_reduce.hppnu��[��PK��M�[��A��cxx17/inclusive_scan.hppnu��[��PK��M�['1� ��U��cxx17/exclusive_scan.hppnu��[��PK��M�[�#s�U��U��cxx17/for_each_n.hppnu��[��PK��M�[.� <��"��K��cxx17/transform_inclusive_scan.hppnu��[��PK��M�[��fN �� x��cxx17/reduce.hppnu��[��PK��M�[H�-"M��M��"��cxx17/transform_exclusive_scan.hppnu��[��PK��M�[<�C�B3��B3��a��hex.hppnu��[��PK��M�[�Ƹ%��%�� string.hppnu��[��PK��M�[zv��9�sort_subrange.hppnu��[��PK��M�[�S`SH ��H ��$�cxx14/mismatch.hppnu��[��PK��M�[��`-��-��/�cxx14/is_permutation.hppnu��[��PK��M�[��=�cxx14/equal.hppnu��[��PK��M�[3��k�� M�clamp.hppnu��[��PK��M�[g�� l�minmax.hppnu��[��PK��M�[A�I�u ��u �� r�algorithm.hppnu��[��PK��M�[�� {�find_backward.hppnu��[��PK��M�[%��D��D�� gather.hppnu��[��PK��M�[_m�٠��`��apply_permutation.hppnu��[��PK��M�[Hi��E��string_regex.hppnu��[��PK��M�[)��_��find_not.hppnu��[��PK��M�[��+n� �� u��cxx11/any_of.hppnu��[��PK��M�[t�DW��W��cxx11/iota.hppnu��[��PK��M�[[�7/��/��F��cxx11/partition_point.hppnu��[��PK��M�[�=�V��cxx11/is_permutation.hppnu��[��PK��M�[��cxx11/partition_copy.hppnu��[��PK��M�[ �mHb��b��cxx11/copy_if.hppnu��[��PK��M�[�-��( �cxx11/all_of.hppnu��[��PK��M�['>�@+��@+��m�cxx11/is_sorted.hppnu��[��PK��M�[u�΀��C�cxx11/find_if_not.hppnu��[��PK��M�[�U��K�cxx11/copy_n.hppnu��[��PK��M�[��l)c��c��P�cxx11/is_partitioned.hppnu��[��PK��M�[9Pjt� �� Y�cxx11/none_of.hppnu��[��PK��M�[a!�^��^��d�cxx11/one_of.hppnu��[��PK��M�[������ hp�searching/knuth_morris_pratt.hppnu��[��PK��M�[z�bE��E��@��searching/detail/debugging.hppnu��[��PK��M�[L`��Ӟ�searching/detail/bm_traits.hppnu��[��PK��M�[T)��8"��8"��"��searching/boyer_moore_horspool.hppnu��[��PK��M�[��ܮ--��--��l��searching/boyer_moore.hppnu��[��PK��!\��m��count_if.hppnu��[��PK��!\~�H� �� stable_partition.hppnu��[��PK��!\V�C�/��/��mismatch.hppnu��[��PK��!\�E�q��0�swap_ranges.hppnu��[��PK��!\/�� B�fill_n.hppnu��[��PK��!\{��Q��Q��I�fill.hppnu��[��PK��!\zy�3��3��1O�upper_bound.hppnu��[��PK��!\1#eB&��&��`�lower_bound.hppnu��[��PK��!\;��"��"��r�binary_search.hppnu��[��PK��!\ �TƜ �� kx�transform.hppnu��[��PK��!\A��T��D��generate.hppnu��[��PK��!\~�4��G��reverse_copy.hppnu��[��PK��!\��e��replace_copy.hppnu��[��PK��!\�{>�� find_if.hppnu��[��PK��!\�3j��n��remove_copy_if.hppnu��[��PK��!\�>��Z��copy.hppnu��[��PK��!\j �n��`��rotate_copy.hppnu��[��PK��!\-9� �� ?��inplace_merge.hppnu��[��PK��!\3ɻ,1��1�� search.hppnu��[��PK��!\��( ��( �� remove.hppnu��[��PK��!\m0v� �� _��partition.hppnu��[��PK��!\�֖�!��!��)��set_algorithm.hppnu��[��PK��!\�N�� ? �find.hppnu��[��PK��!\ ��l �replace.hppnu��[��PK��!\�� equal_range.hppnu��[��PK��!\q��$��$��" �adjacent_find.hppnu��[��PK��!\Ӭ�3�4��4��3 �search_n.hppnu��[��PK��!\�]�� i �rotate.hppnu��[��PK��!\h�� "o �remove_if.hppnu��[��PK��!\!xG}��}��4y �stable_sort.hppnu��[��PK��!\��Ξ�� unique_copy.hppnu��[��PK��!\�Q�@��͈ �replace_copy_if.hppnu��[��PK��!\#TƔ9��9�� lexicographical_compare.hppnu��[��PK��!\�� find_first_of.hppnu��[��PK��!\汩�� reverse.hppnu��[��PK��!\o�� random_shuffle.hppnu��[��PK��!\Ϡ<5��5�� max_element.hppnu��[��PK��!\��.��=� �heap_algorithm.hppnu��[��PK��!\�\|5��5�� min_element.hppnu��[��PK��!\��. �� partial_sort.hppnu��[��PK��!\�m� �� U �nth_element.hppnu��[��PK��!\�Ly��Y �remove_copy.hppnu��[��PK��!\m�ޙ��@ �for_each.hppnu��[��PK��!\F�� ) �count.hppnu��[��PK��!\ɲ�:#��:#�� T/ �equal.hppnu��[��PK��!\�2�� R �unique.hppnu��[��PK��!\?T�� a �merge.hppnu��[��PK��!\��C��j �sort.hppnu��[��PK��!\�,ҩ��s �permutation.hppnu��[��PK��!\��S��S�� partial_sort_copy.hppnu��[��PK��!\�-�b��b�� replace_if.hppnu��[��PK��!\n��"� �copy_backward.hppnu��[��PK��!\�Wܔ��0� �find_end.hppnu��[��PK��,��

| ver. 1.6 | Github | . | PHP 8.2.30 | ??????????? ?????????: 0.01 | proxy | phpinfo | ???????????