diff --git a/include/boost/algorithm/minmax.hpp b/include/boost/algorithm/minmax.hpp deleted file mode 100644 index 2b5101a..0000000 --- a/include/boost/algorithm/minmax.hpp +++ /dev/null @@ -1,47 +0,0 @@ -// (C) Copyright Herve Bronnimann 2004. -// Use, modification and distribution are 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) - -/* - 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 // for using pairs with boost::cref -#include - -namespace boost { - - template - tuple< T const&, T const& > - minmax(T const& a, T const& b) { - return (b - 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 diff --git a/include/boost/algorithm/minmax_element.hpp b/include/boost/algorithm/minmax_element.hpp deleted file mode 100644 index 6c88b63..0000000 --- a/include/boost/algorithm/minmax_element.hpp +++ /dev/null @@ -1,551 +0,0 @@ -// (C) Copyright Herve Bronnimann 2004. -// Use, modification and distribution are 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) - -/* - 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 // for std::pair and std::make_pair - -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 - struct less_over_iter { - bool operator()(Iterator const& it1, - Iterator const& it2) const { return *it1 < *it2; } - }; - - template - 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 - std::pair - 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 - std::pair - minmax_element(ForwardIter first, ForwardIter last) - { - return detail::basic_minmax_element(first, last, - detail::less_over_iter() ); - } - - template - std::pair - minmax_element(ForwardIter first, ForwardIter last, BinaryPredicate comp) - { - return detail::basic_minmax_element(first, last, - detail::binary_pred_over_iter(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 - 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 - 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 - 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 - 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 - ForwardIter - first_min_element(ForwardIter first, ForwardIter last) - { - return detail::basic_first_min_element(first, last, - detail::less_over_iter() ); - } - - template - ForwardIter - first_min_element(ForwardIter first, ForwardIter last, BinaryPredicate comp) - { - return detail::basic_first_min_element(first, last, - detail::binary_pred_over_iter(comp) ); - } - - template - ForwardIter - last_min_element(ForwardIter first, ForwardIter last) - { - return detail::basic_last_min_element(first, last, - detail::less_over_iter() ); - } - - template - ForwardIter - last_min_element(ForwardIter first, ForwardIter last, BinaryPredicate comp) - { - return detail::basic_last_min_element(first, last, - detail::binary_pred_over_iter(comp) ); - } - - template - ForwardIter - first_max_element(ForwardIter first, ForwardIter last) - { - return detail::basic_first_max_element(first, last, - detail::less_over_iter() ); - } - - template - ForwardIter - first_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp) - { - return detail::basic_first_max_element(first, last, - detail::binary_pred_over_iter(comp) ); - } - - template - ForwardIter - last_max_element(ForwardIter first, ForwardIter last) - { - return detail::basic_last_max_element(first, last, - detail::less_over_iter() ); - } - - template - ForwardIter - last_max_element(ForwardIter first, ForwardIter last, BinaryPredicate comp) - { - return detail::basic_last_max_element(first, last, - detail::binary_pred_over_iter(comp) ); - } - - - // Minmax_element variants -- comments removed - - namespace detail { - - template - std::pair - 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 - std::pair - 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 - std::pair - 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 - inline std::pair - first_min_first_max_element(ForwardIter first, ForwardIter last) - { - return minmax_element(first, last); - } - - template - inline std::pair - first_min_first_max_element(ForwardIter first, ForwardIter last, - BinaryPredicate comp) - { - return minmax_element(first, last, comp); - } - - template - std::pair - first_min_last_max_element(ForwardIter first, ForwardIter last) - { - return detail::basic_first_min_last_max_element(first, last, - detail::less_over_iter() ); - } - - template - inline std::pair - 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(comp) ); - } - - template - std::pair - last_min_first_max_element(ForwardIter first, ForwardIter last) - { - return detail::basic_last_min_first_max_element(first, last, - detail::less_over_iter() ); - } - - template - inline std::pair - 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(comp) ); - } - - template - std::pair - last_min_last_max_element(ForwardIter first, ForwardIter last) - { - return detail::basic_last_min_last_max_element(first, last, - detail::less_over_iter() ); - } - - template - inline std::pair - 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(comp) ); - } - -} // namespace boost - -#endif // BOOST_ALGORITHM_MINMAX_ELEMENT_HPP diff --git a/include/boost/algorithm/string.hpp b/include/boost/algorithm/string.hpp deleted file mode 100644 index c3fa794..0000000 --- a/include/boost/algorithm/string.hpp +++ /dev/null @@ -1,30 +0,0 @@ -// Boost string_algo library string_algo.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2004. 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) - -// 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 -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - - -#endif // BOOST_STRING_ALGO_HPP diff --git a/include/boost/algorithm/string/case_conv.hpp b/include/boost/algorithm/string/case_conv.hpp deleted file mode 100644 index d027637..0000000 --- a/include/boost/algorithm/string/case_conv.hpp +++ /dev/null @@ -1,187 +0,0 @@ -// Boost string_algo library case_conv.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// See http://www.boost.org for updates, documentation, and revision history. - -#ifndef BOOST_STRING_CASE_CONV_HPP -#define BOOST_STRING_CASE_CONV_HPP - -#include -#include -#include -#include -#include -#include - -/*! \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 collection - \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 - inline OutputIteratorT - to_lower_copy( - OutputIteratorT Output, - const CollectionT& Input, - const std::locale& Loc=std::locale()) - { - return std::transform( - begin(Input), - end(Input), - Output, - detail::to_lowerF< - typename value_type_of::type >(Loc)); - } - - //! Convert to lower case - /*! - \overload - */ - template - inline SequenceT to_lower_copy( - const SequenceT& Input, - const std::locale& Loc=std::locale()) - { - return SequenceT( - make_transform_iterator( - begin(Input), - detail::to_lowerF< - typename value_type_of::type >(Loc)), - make_transform_iterator( - end(Input), - detail::to_lowerF< - typename value_type_of::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 collection - \param Loc a locale used for conversion - */ - template - inline void to_lower( - MutableCollectionT& Input, - const std::locale& Loc=std::locale()) - { - std::transform( - begin(Input), - end(Input), - begin(Input), - detail::to_lowerF< - typename value_type_of::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 collection - \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 - inline OutputIteratorT - to_upper_copy( - OutputIteratorT Output, - const CollectionT& Input, - const std::locale& Loc=std::locale()) - { - return std::transform( - begin(Input), - end(Input), - Output, - detail::to_upperF< - typename value_type_of::type >(Loc)); - } - - //! Convert to upper case - /*! - \overload - */ - template - inline SequenceT to_upper_copy( - const SequenceT& Input, - const std::locale& Loc=std::locale()) - { - return SequenceT( - make_transform_iterator( - begin(Input), - detail::to_upperF< - typename value_type_of::type >(Loc)), - make_transform_iterator( - end(Input), - detail::to_upperF< - typename value_type_of::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 collection - \param Loc a locale used for conversion - */ - template - inline void to_upper( - MutableCollectionT& Input, - const std::locale& Loc=std::locale()) - { - std::transform( - begin(Input), - end(Input), - begin(Input), - detail::to_upperF< - typename value_type_of::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 diff --git a/include/boost/algorithm/string/classification.hpp b/include/boost/algorithm/string/classification.hpp deleted file mode 100644 index e2d7c39..0000000 --- a/include/boost/algorithm/string/classification.hpp +++ /dev/null @@ -1,308 +0,0 @@ -// Boost string_algo library classification.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// See http://www.boost.org for updates, documentation, and revision history. - -#ifndef BOOST_STRING_CLASSIFICATION_HPP -#define BOOST_STRING_CLASSIFICATION_HPP - -#include -#include -#include -#include - -/*! \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 - inline detail::is_any_ofF< - BOOST_STRING_TYPENAME value_type_of::type> - is_any_of( const ContainerT& Set ) - { - return detail::is_any_ofF< - BOOST_STRING_TYPENAME value_type_of::type>(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 - inline detail::is_from_rangeF is_from_range(CharT From, CharT To) - { - return detail::is_from_rangeF(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 - inline detail::pred_andF - operator&&( - const predicate_facade& Pred1, - const predicate_facade& 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( - *static_cast(&Pred1), - *static_cast(&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 - inline detail::pred_orF - operator||( - const predicate_facade& Pred1, - const predicate_facade& 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( - *static_cast(&Pred1), - *static_cast(&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 - inline detail::pred_notF - operator!( const predicate_facade& 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(*static_cast(&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 diff --git a/include/boost/algorithm/string/collection_traits.hpp b/include/boost/algorithm/string/collection_traits.hpp deleted file mode 100644 index b76e0f1..0000000 --- a/include/boost/algorithm/string/collection_traits.hpp +++ /dev/null @@ -1,266 +0,0 @@ -// Boost string_algo library collection_traits.hpp header file -------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// (C) Copyright Thorsten Ottosen 2002-2003. 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) - -// (C) Copyright Jeremy Siek 2001. 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) - -// Original idea of container traits was proposed by Jeremy Siek and -// Thorsten Ottosen. This implementation is lightweighted version -// of container_traits adapter for usage with string_algo library - -#ifndef BOOST_STRING_COLLECTION_TRAITS_HPP -#define BOOST_STRING_COLLECTION_TRAITS_HPP - -#include -#include -#include -#include - -// Implementation -#include - -/*! \file - Defines collection_traits class and related free-standing functions. - This facility is used to unify the access to different types of collections. - It allows the algorithms in the library to work with STL collections, c-style - array, null-terminated c-strings (and more) using the same interface. -*/ - -namespace boost { - namespace algorithm { - -// collection_traits template class -----------------------------------------// - - //! collection_traits class - /*! - Collection traits provide uniform access to different types of - collections. This functionality allows to write generic algorithms - which work with several different kinds of collections. - - Currently following collection types are supported: - - containers with STL compatible container interface ( see ContainerConcept ) - ( i.e. \c std::vector<>, \c std::list<>, \c std::string<> ... ) - - c-style array - ( \c char[10], \c int[15] ... ) - - null-terminated c-strings - ( \c char*, \c wchar_T* ) - - std::pair of iterators - ( i.e \c std::pair::iterator,vector::iterator> ) - - Collection traits provide an external collection interface operations. - All are accessible using free-standing functions. - - The following operations are supported: - - \c size() - - \c empty() - - \c begin() - - \c end() - - Container traits have somewhat limited functionality on compilers not - supporting partial template specialization and partial template ordering. - */ - template< typename T > - struct collection_traits - { - private: - typedef BOOST_STRING_TYPENAME ::boost::mpl::eval_if< - ::boost::algorithm::detail::is_pair, - detail::pair_container_traits_selector, - BOOST_STRING_TYPENAME ::boost::mpl::eval_if< - ::boost::is_array, - detail::array_container_traits_selector, - BOOST_STRING_TYPENAME ::boost::mpl::eval_if< - ::boost::is_pointer, - detail::pointer_container_traits_selector, - detail::default_container_traits_selector - > - > - >::type container_helper_type; - public: - //! Function type - typedef container_helper_type function_type; - //! Value type - typedef BOOST_STRING_TYPENAME - container_helper_type::value_type value_type; - //! Size type - typedef BOOST_STRING_TYPENAME - container_helper_type::size_type size_type; - //! Iterator type - typedef BOOST_STRING_TYPENAME - container_helper_type::iterator iterator; - //! Const iterator type - typedef BOOST_STRING_TYPENAME - container_helper_type::const_iterator const_iterator; - //! Result iterator type ( iterator of const_iterator, depending on the constness of the container ) - typedef BOOST_STRING_TYPENAME - container_helper_type::result_iterator result_iterator; - //! Difference type - typedef BOOST_STRING_TYPENAME - container_helper_type::difference_type difference_type; - - }; // 'collection_traits' - -// collection_traits metafunctions -----------------------------------------// - - //! Container value_type trait - /*! - Extract the type of elements contained in a container - */ - template< typename C > - struct value_type_of - { - typedef BOOST_STRING_TYPENAME collection_traits::value_type type; - }; - - //! Container difference trait - /*! - Extract the container's difference type - */ - template< typename C > - struct difference_type_of - { - typedef BOOST_STRING_TYPENAME collection_traits::difference_type type; - }; - - //! Container iterator trait - /*! - Extract the container's iterator type - */ - template< typename C > - struct iterator_of - { - typedef BOOST_STRING_TYPENAME collection_traits::iterator type; - }; - - //! Container const_iterator trait - /*! - Extract the container's const_iterator type - */ - template< typename C > - struct const_iterator_of - { - typedef BOOST_STRING_TYPENAME collection_traits::const_iterator type; - }; - - - //! Container result_iterator - /*! - Extract the container's result_iterator type. This type maps to \c C::iterator - for mutable container and \c C::const_iterator for const containers. - */ - template< typename C > - struct result_iterator_of - { - typedef BOOST_STRING_TYPENAME collection_traits::result_iterator type; - }; - -// collection_traits related functions -----------------------------------------// - - //! Free-standing size() function - /*! - Get the size of the container. Uses collection_traits. - */ - template< typename C > - inline BOOST_STRING_TYPENAME collection_traits::size_type - size( const C& c ) - { - return collection_traits::function_type::size( c ); - } - - //! Free-standing empty() function - /*! - Check whether the container is empty. Uses container traits. - */ - template< typename C > - inline bool empty( const C& c ) - { - return collection_traits::function_type::empty( c ); - } - -#ifndef BOOST_NO_FUNCTION_TEMPLATE_ORDERING - - //! Free-standing begin() function - /*! - Get the begin iterator of the container. Uses collection_traits. - */ - template< typename C > - inline BOOST_STRING_TYPENAME collection_traits::iterator - begin( C& c ) - { - return collection_traits::function_type::begin( c ); - } - - //! Free-standing begin() function - /*! - \overload - */ - template< typename C > - inline BOOST_STRING_TYPENAME collection_traits::const_iterator - begin( const C& c ) - { - return collection_traits::function_type::begin( c ); - } - - //! Free-standing end() function - /*! - Get the begin iterator of the container. Uses collection_traits. - */ - template< typename C > - inline BOOST_STRING_TYPENAME collection_traits::iterator - end( C& c ) - { - return collection_traits::function_type::end( c ); - } - - //! Free-standing end() function - /*! - \overload - */ - template< typename C > - inline BOOST_STRING_TYPENAME collection_traits::const_iterator - end( const C& c ) - { - return collection_traits::function_type::end( c ); - } - -#else // BOOST_NO_FUNCTION_TEMPLATE_ORDERING - - //! Free-standing begin() function - /*! - \overload - */ - template< typename C > - inline BOOST_STRING_TYPENAME collection_traits::result_iterator - begin( C& c ) - { - return collection_traits::function_type::begin( c ); - } - - //! Free-standing end() function - /*! - \overload - */ - template< typename C > - inline BOOST_STRING_TYPENAME collection_traits::result_iterator - end( C& c ) - { - return collection_traits::function_type::end( c ); - } - -#endif // BOOST_NO_FUNCTION_TEMPLATE_ORDERING - - } // namespace algorithm -} // namespace boost - -#endif // BOOST_STRING_COLLECTION_TRAITS_HPP diff --git a/include/boost/algorithm/string/compare.hpp b/include/boost/algorithm/string/compare.hpp deleted file mode 100644 index dc4d521..0000000 --- a/include/boost/algorithm/string/compare.hpp +++ /dev/null @@ -1,83 +0,0 @@ -// Boost string_algo library compare.hpp header file -------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// See http://www.boost.org for updates, documentation, and revision history. - -#ifndef BOOST_STRING_COMPARE_HPP -#define BOOST_STRING_COMPARE_HPP - -#include -#include - -/*! \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 - { - return std::toupper(Arg1,m_Loc)==std::toupper(Arg2,m_Loc); - } - - private: - std::locale m_Loc; - }; - - } // namespace algorithm - - // pull names to the boost namespace - using algorithm::is_equal; - using algorithm::is_iequal; - -} // namespace boost - - -#endif // BOOST_STRING_COMPARE_HPP diff --git a/include/boost/algorithm/string/concept.hpp b/include/boost/algorithm/string/concept.hpp deleted file mode 100644 index 395fe28..0000000 --- a/include/boost/algorithm/string/concept.hpp +++ /dev/null @@ -1,81 +0,0 @@ -// Boost string_algo library concept.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// See http://www.boost.org for updates, documentation, and revision history. - -#ifndef BOOST_STRING_CONCEPT_HPP -#define BOOST_STRING_CONCEPT_HPP - -#include -#include -#include - -/*! \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 - struct FinderConcept - { - private: - typedef iterator_range 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 - struct FormatterConcept - { - public: - void constraints() - { - // Operation - begin((*pFo)( (*pF)(i,i) )); - end((*pFo)( (*pF)(i,i) )); - } - private: - IteratorT i; - FinderT* pF; - FormatterT *pFo; - }; // FormatterConcept; - - } // namespace algorithm -} // namespace boost - - - - -#endif // BOOST_STRING_CONCEPT_HPP diff --git a/include/boost/algorithm/string/config.hpp b/include/boost/algorithm/string/config.hpp deleted file mode 100644 index e97b1a6..0000000 --- a/include/boost/algorithm/string/config.hpp +++ /dev/null @@ -1,31 +0,0 @@ -// Boost string_algo library config.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// See http://www.boost.org for updates, documentation, and revision history. - -#ifndef BOOST_STRING_CONFIG_HPP -#define BOOST_STRING_CONFIG_HPP - -#include -#include - -#ifdef BOOST_STRING_DEDUCED_TYPENAME -# error "macro already defined!" -#endif - -#ifdef __BORLANDC__ -#define BOOST_STRING_TYPENAME -#else -#define BOOST_STRING_TYPENAME BOOST_DEDUCED_TYPENAME -#endif - -// Metrowerks workaround -#if BOOST_WORKAROUND(__MWERKS__, <= 0x3003) // 8.x -#pragma parse_func_templ off -#endif - -#endif // BOOST_STRING_CONFIG_HPP diff --git a/include/boost/algorithm/string/constants.hpp b/include/boost/algorithm/string/constants.hpp deleted file mode 100644 index d9dbe0d..0000000 --- a/include/boost/algorithm/string/constants.hpp +++ /dev/null @@ -1,35 +0,0 @@ -// Boost string_algo library constants.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// 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 - diff --git a/include/boost/algorithm/string/erase.hpp b/include/boost/algorithm/string/erase.hpp deleted file mode 100644 index 32894ca..0000000 --- a/include/boost/algorithm/string/erase.hpp +++ /dev/null @@ -1,826 +0,0 @@ -// Boost string_algo library erase.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// See http://www.boost.org for updates, documentation, and revision history. - -#ifndef BOOST_STRING_ERASE_HPP -#define BOOST_STRING_ERASE_HPP - -#include -#include -#include -#include -#include -#include - -/*! \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 - inline OutputIteratorT erase_range_copy( - OutputIteratorT Output, - const CollectionT& Input, - const iterator_range< - BOOST_STRING_TYPENAME - const_iterator_of::type>& SearchRange ) - { - return find_format_copy( - Output, - Input, - range_finder(SearchRange), - empty_formatter(Input) ); - } - - //! Erase range algorithm - /*! - \overload - */ - template - inline SequenceT erase_range_copy( - const SequenceT& Input, - const iterator_range< - BOOST_STRING_TYPENAME - const_iterator_of::type>& SearchRange ) - { - return find_format_copy( - Input, - range_finder(SearchRange), - 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 - inline void erase_range( - SequenceT& Input, - const iterator_range< - BOOST_STRING_TYPENAME - iterator_of::type>& SearchRange ) - { - find_format( - Input, - range_finder(SearchRange), - empty_formatter(Input) ); - } - -// erase_first --------------------------------------------------------// - - //! Erase first algorithm - /*! - Remove the first occurence 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 Collection1T, - typename Collection2T> - inline OutputIteratorT erase_first_copy( - OutputIteratorT Output, - const Collection1T& Input, - const Collection2T& Search ) - { - return find_format_copy( - Output, - Input, - first_finder(Search), - empty_formatter(Input) ); - } - - //! Erase first algorithm - /*! - \overload - */ - template - inline SequenceT erase_first_copy( - const SequenceT& Input, - const CollectionT& Search ) - { - return find_format_copy( - Input, - first_finder(Search), - empty_formatter(Input) ); - } - - //! Erase first algorithm - /*! - Remove the first occurence 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 - inline void erase_first( - SequenceT& Input, - const CollectionT& Search ) - { - find_format( - Input, - first_finder(Search), - empty_formatter(Input) ); - } - -// erase_first ( case insensitive ) ------------------------------------// - - //! Erase first algorithm ( case insensitive ) - /*! - Remove the first occurence 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 Collection1T, - typename Collection2T> - inline OutputIteratorT ierase_first_copy( - OutputIteratorT Output, - const Collection1T& Input, - const Collection2T& Search, - const std::locale& Loc=std::locale() ) - { - return find_format_copy( - Output, - Input, - first_finder(Search, is_iequal(Loc)), - empty_formatter(Input) ); - } - - //! Erase first algorithm ( case insensitive ) - /*! - \overload - */ - template - inline SequenceT ierase_first_copy( - const SequenceT& Input, - const CollectionT& Search, - const std::locale& Loc=std::locale() ) - { - return find_format_copy( - Input, - first_finder(Search, is_iequal(Loc)), - empty_formatter(Input) ); - } - - //! Erase first algorithm ( case insensitive ) - /*! - Remove the first occurence 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 - inline void ierase_first( - SequenceT& Input, - const CollectionT& Search, - const std::locale& Loc=std::locale() ) - { - find_format( - Input, - first_finder(Search, is_iequal(Loc)), - empty_formatter(Input) ); - } - -// erase_last --------------------------------------------------------// - - //! Erase last algorithm - /*! - Remove the last occurence 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 Collection1T, - typename Collection2T> - inline OutputIteratorT erase_last_copy( - OutputIteratorT Output, - const Collection1T& Input, - const Collection2T& Search ) - { - return find_format_copy( - Output, - Input, - last_finder(Search), - empty_formatter(Input) ); - } - - //! Erase last algorithm - /*! - \overload - */ - template - inline SequenceT erase_last_copy( - const SequenceT& Input, - const CollectionT& Search ) - { - return find_format_copy( - Input, - last_finder(Search), - empty_formatter(Input) ); - } - - //! Erase last algorithm - /*! - Remove the last occurence 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 - inline void erase_last( - SequenceT& Input, - const CollectionT& Search ) - { - find_format( - Input, - last_finder(Search), - empty_formatter(Input) ); - } - -// erase_last ( case insensitive ) ------------------------------------// - - //! Erase last algorithm ( case insensitive ) - /*! - Remove the last occurence 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 Collection1T, - typename Collection2T> - inline OutputIteratorT ierase_last_copy( - OutputIteratorT Output, - const Collection1T& Input, - const Collection2T& Search, - const std::locale& Loc=std::locale() ) - { - return find_format_copy( - Output, - Input, - last_finder(Search, is_iequal(Loc)), - empty_formatter(Input) ); - } - - //! Erase last algorithm ( case insensitive ) - /*! - \overload - */ - template - inline SequenceT ierase_last_copy( - const SequenceT& Input, - const CollectionT& Search, - const std::locale& Loc=std::locale() ) - { - return find_format_copy( - Input, - last_finder(Search, is_iequal(Loc)), - empty_formatter(Input) ); - } - - //! Erase last algorithm ( case insensitive ) - /*! - Remove the last occurence 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 - inline void ierase_last( - SequenceT& Input, - const CollectionT& Search, - const std::locale& Loc=std::locale() ) - { - find_format( - Input, - last_finder(Search, is_iequal(Loc)), - empty_formatter(Input) ); - } - -// erase_nth --------------------------------------------------------------------// - - //! Erase nth algorithm - /*! - Remove the Nth occurence 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. - \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 Collection1T, - typename Collection2T> - inline OutputIteratorT erase_nth_copy( - OutputIteratorT Output, - const Collection1T& Input, - const Collection2T& Search, - unsigned int Nth ) - { - return find_format_copy( - Output, - Input, - nth_finder(Search, Nth), - empty_formatter(Input) ); - } - - //! Erase nth algorithm - /*! - \overload - */ - template - inline SequenceT erase_nth_copy( - const SequenceT& Input, - const CollectionT& Search, - unsigned int Nth ) - { - return find_format_copy( - Input, - nth_finder(Search, Nth), - empty_formatter(Input) ); - } - - //! Erase nth algorithm - /*! - Remove the Nth occurence 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. - */ - template - inline void erase_nth( - SequenceT& Input, - const CollectionT& Search, - unsigned int Nth ) - { - find_format( - Input, - nth_finder(Search, Nth), - empty_formatter(Input) ); - } - -// erase_nth ( case insensitive ) ---------------------------------------------// - - //! Erase nth algorithm ( case insensitive ) - /*! - Remove the Nth occurence 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. - \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 Collection1T, - typename Collection2T> - inline OutputIteratorT ierase_nth_copy( - OutputIteratorT Output, - const Collection1T& Input, - const Collection2T& Search, - unsigned int Nth, - const std::locale& Loc=std::locale() ) - { - return find_format_copy( - Output, - Input, - nth_finder(Search, Nth, is_iequal(Loc)), - empty_formatter(Input) ); - } - - //! Erase nth algorithm - /*! - \overload - */ - template - inline SequenceT ierase_nth_copy( - const SequenceT& Input, - const CollectionT& Search, - unsigned int Nth, - const std::locale& Loc=std::locale() ) - { - return find_format_copy( - Input, - nth_finder(Search, Nth, is_iequal(Loc)), - empty_formatter(Input) ); - } - - //! Erase nth algorithm - /*! - Remove the Nth occurence 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. - \param Loc A locale used for case insensitive comparison - */ - template - inline void ierase_nth( - SequenceT& Input, - const CollectionT& Search, - unsigned int Nth, - const std::locale& Loc=std::locale() ) - { - find_format( - Input, - nth_finder(Search, Nth, is_iequal(Loc)), - 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 Collection1T, - typename Collection2T> - inline OutputIteratorT erase_all_copy( - OutputIteratorT Output, - const Collection1T& Input, - const Collection2T& Search ) - { - return find_format_all_copy( - Output, - Input, - first_finder(Search), - empty_formatter(Input) ); - } - - //! Erase all algorithm - /*! - \overload - */ - template - inline SequenceT erase_all_copy( - const SequenceT& Input, - const CollectionT& Search ) - { - return find_format_all_copy( - Input, - first_finder(Search), - 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 - inline void erase_all( - SequenceT& Input, - const CollectionT& Search ) - { - find_format_all( - Input, - first_finder(Search), - 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 Collection1T, - typename Collection2T> - inline OutputIteratorT ierase_all_copy( - OutputIteratorT Output, - const Collection1T& Input, - const Collection2T& Search, - const std::locale& Loc=std::locale() ) - { - return find_format_all_copy( - Output, - Input, - first_finder(Search, is_iequal(Loc)), - empty_formatter(Input) ); - } - - //! Erase all algorithm ( case insensitive ) - /*! - \overload - */ - template - inline SequenceT ierase_all_copy( - const SequenceT& Input, - const CollectionT& Search, - const std::locale& Loc=std::locale() ) - { - return find_format_all_copy( - Input, - first_finder(Search, is_iequal(Loc)), - 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 - inline void ierase_all( - SequenceT& Input, - const CollectionT& Search, - const std::locale& Loc=std::locale() ) - { - find_format_all( - Input, - first_finder(Search, is_iequal(Loc)), - empty_formatter(Input) ); - } - -// erase_head --------------------------------------------------------------------// - - //! Erase head algorithm - /*! - Remove the head from the input. The head is a prefix of a seqence 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 - \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 CollectionT> - inline OutputIteratorT erase_head_copy( - OutputIteratorT Output, - const CollectionT& Input, - unsigned int N ) - { - return find_format_copy( - Output, - Input, - head_finder(N), - empty_formatter( Input ) ); - } - - //! Erase head algorithm - /*! - \overload - */ - template - inline SequenceT erase_head_copy( - const SequenceT& Input, - unsigned int N ) - { - return find_format_copy( - Input, - head_finder(N), - empty_formatter( Input ) ); - } - - //! Erase head algorithm - /*! - Remove the head from the input. The head is a prefix of a seqence 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 - */ - template - inline void erase_head( - SequenceT& Input, - unsigned int N ) - { - find_format( - Input, - head_finder(N), - empty_formatter( Input ) ); - } - -// erase_tail --------------------------------------------------------------------// - - //! Erase tail algorithm - /*! - Remove the tail from the input. The tail is a suffix of a seqence 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 head - \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 CollectionT> - inline OutputIteratorT erase_tail_copy( - OutputIteratorT Output, - const CollectionT& Input, - unsigned int N ) - { - return find_format_copy( - Output, - Input, - tail_finder(N), - empty_formatter( Input ) ); - } - - //! Erase tail algorithm - /*! - \overload - */ - template - inline SequenceT erase_tail_copy( - const SequenceT& Input, - unsigned int N ) - { - return find_format_copy( - Input, - tail_finder(N), - empty_formatter( Input ) ); - } - - //! Erase tail algorithm - /*! - Remove the tail from the input. The tail is a suffix of a seqence 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 head - */ - template - inline void erase_tail( - SequenceT& Input, - unsigned int N ) - { - find_format( - Input, - tail_finder(N), - 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 diff --git a/include/boost/algorithm/string/find.hpp b/include/boost/algorithm/string/find.hpp deleted file mode 100644 index 4bf92ea..0000000 --- a/include/boost/algorithm/string/find.hpp +++ /dev/null @@ -1,329 +0,0 @@ -// Boost string_algo library find.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// See http://www.boost.org for updates, documentation, and revision history. - -#ifndef BOOST_STRING_FIND_HPP -#define BOOST_STRING_FIND_HPP - -#include -#include -#include -#include -#include -#include - -/*! \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 CollectionT::iterator or - \c CollectionT::const_iterator, depending on the constness of - the input parameter. - */ - template - inline iterator_range< - BOOST_STRING_TYPENAME result_iterator_of::type> - find( - CollectionT& Input, - FinderT Finder) - { - return Finder(begin(Input),end(Input)); - } - -// find_first -----------------------------------------------// - - //! Find first algorithm - /*! - Search for the first occurence 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 CollectionT::iterator or - \c CollectionT::const_iterator, depending on the constness of - the input parameter. - - \note This function provides the strong exception-safety guarantee - */ - template - inline iterator_range< - BOOST_STRING_TYPENAME result_iterator_of::type> - find_first( - Collection1T& Input, - const Collection2T& Search) - { - return first_finder(Search)( - begin(Input),end(Input)); - } - - //! Find first algorithm ( case insensitive ) - /*! - Search for the first occurence 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 Collection1T::iterator or - \c Collection1T::const_iterator, depending on the constness of - the input parameter. - - \note This function provides the strong exception-safety guarantee - */ - template - inline iterator_range< - BOOST_STRING_TYPENAME result_iterator_of::type> - ifind_first( - Collection1T& Input, - const Collection2T& Search, - const std::locale& Loc=std::locale()) - { - return first_finder(Search,is_iequal(Loc))( - begin(Input),end(Input)); - } - -// find_last -----------------------------------------------// - - //! Find last algorithm - /*! - Search for the last occurence 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 Collection1T::iterator or - \c Collection1T::const_iterator, depending on the constness of - the input parameter. - - \note This function provides the strong exception-safety guarantee - */ - template - inline iterator_range< - BOOST_STRING_TYPENAME result_iterator_of::type> - find_last( - Collection1T& Input, - const Collection2T& Search) - { - return last_finder(Search)( - begin(Input),end(Input)); - } - - //! 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 Collection1T::iterator or - \c Collection1T::const_iterator, depending on the constness of - the input parameter. - - \note This function provides the strong exception-safety guarantee - */ - template - inline iterator_range< - BOOST_STRING_TYPENAME result_iterator_of::type> - ifind_last( - Collection1T& Input, - const Collection2T& Search, - const std::locale& Loc=std::locale()) - { - return last_finder(Search, is_iequal(Loc))( - begin(Input),end(Input)); - } - -// find_nth ----------------------------------------------------------------------// - - //! Find n-th algorithm - /*! - Search for the n-th (zero-indexed) occurence 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. - \return - An \c iterator_range delimiting the match. - Returned iterator is either \c Collection1T::iterator or - \c Collection1T::const_iterator, depending on the constness of - the input parameter. - */ - template - inline iterator_range< - BOOST_STRING_TYPENAME result_iterator_of::type> - find_nth( - Collection1T& Input, - const Collection2T& Search, - unsigned int Nth) - { - return nth_finder(Search,Nth)( - begin(Input),end(Input)); - } - - //! Find n-th algorithm ( case insensitive ). - /*! - Search for the n-th (zero-indexed) occurence 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. - \param Loc A locale used for case insensitive comparison - \return - An \c iterator_range delimiting the match. - Returned iterator is either \c Collection1T::iterator or - \c Collection1T::const_iterator, depending on the constness of - the input parameter. - - - \note This function provides the strong exception-safety guarantee - */ - template - inline iterator_range< - BOOST_STRING_TYPENAME result_iterator_of::type> - ifind_nth( - Collection1T& Input, - const Collection2T& Search, - unsigned int Nth, - const std::locale& Loc=std::locale()) - { - return nth_finder(Search,Nth,is_iequal(Loc))( - begin(Input),end(Input)); - } - -// 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 if considered - to be the head. - - \param Input An input string - \param N Length of the head - \return - An \c iterator_range delimiting the match. - Returned iterator is either \c Collection1T::iterator or - \c Collection1T::const_iterator, depending on the constness of - the input parameter. - - \note This function provides the strong exception-safety guarantee - */ - template - inline iterator_range< - BOOST_STRING_TYPENAME result_iterator_of::type> - find_head( - CollectionT& Input, - unsigned int N) - { - return head_finder(N)( - begin(Input),end(Input)); - } - -// find_tail ----------------------------------------------------------------------// - - //! Find tail algorithm - /*! - Get the head of the input. Head is a suffix of the string of the - given size. If the input is shorter then required, whole input if considered - to be the tail. - - \param Input An input string - \param N Length of the tail - \return - An \c iterator_range delimiting the match. - Returned iterator is either \c CollectionT::iterator or - \c CollectionT::const_iterator, depending on the constness of - the input parameter. - - - \note This function provides the strong exception-safety guarantee - */ - template - inline iterator_range< - BOOST_STRING_TYPENAME result_iterator_of::type> - find_tail( - CollectionT& Input, - unsigned int N) - { - return tail_finder(N)( - begin(Input),end(Input)); - } - -// 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 An 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 CollectionT::iterator or - \c CollectionT::const_iterator, depending on the constness of - the input parameter. - - \note This function provides the strong exception-safety guarantee - */ - template - inline iterator_range< - BOOST_STRING_TYPENAME result_iterator_of::type> - find_token( - CollectionT& Input, - PredicateT Pred, - token_compress_mode_type eCompress=token_compress_off) - { - return token_finder(Pred, eCompress)( - begin(Input),end(Input)); - } - - } // 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 diff --git a/include/boost/algorithm/string/find_format.hpp b/include/boost/algorithm/string/find_format.hpp deleted file mode 100644 index 7f6c436..0000000 --- a/include/boost/algorithm/string/find_format.hpp +++ /dev/null @@ -1,263 +0,0 @@ -// Boost string_algo library find_format.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// See http://www.boost.org for updates, documentation, and revision history. - -#ifndef BOOST_STRING_FIND_FORMAT_HPP -#define BOOST_STRING_FIND_FORMAT_HPP - -#include -#include -#include -#include -#include -#include -#include - -/*! \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 CollectionT, - typename FinderT, - typename FormatterT> - inline OutputIteratorT find_format_copy( - OutputIteratorT Output, - const CollectionT& Input, - FinderT Finder, - FormatterT Formatter ) - { - // Concept check - function_requires< - FinderConcept::type> >(); - function_requires< - FormatterConcept< - FormatterT, - FinderT,BOOST_STRING_TYPENAME const_iterator_of::type> >(); - - return detail::find_format_copy_impl( - Output, - Input, - Finder, - Formatter, - Finder( begin(Input), end(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 - function_requires< - FinderConcept::type> >(); - function_requires< - FormatterConcept< - FormatterT, - FinderT,BOOST_STRING_TYPENAME const_iterator_of::type> >(); - - return detail::find_format_copy_impl( - Input, - Finder, - Formatter, - Finder(begin(Input), 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 - function_requires< - FinderConcept::type> >(); - function_requires< - FormatterConcept< - FormatterT, - FinderT,BOOST_STRING_TYPENAME const_iterator_of::type> >(); - - detail::find_format_impl( - Input, - Finder, - Formatter, - Finder(begin(Input), 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 CollectionT, - typename FinderT, - typename FormatterT> - inline OutputIteratorT find_format_all_copy( - OutputIteratorT Output, - const CollectionT& Input, - FinderT Finder, - FormatterT Formatter) - { - // Concept check - function_requires< - FinderConcept::type> >(); - function_requires< - FormatterConcept< - FormatterT, - FinderT,BOOST_STRING_TYPENAME const_iterator_of::type> >(); - - return detail::find_format_all_copy_impl( - Output, - Input, - Finder, - Formatter, - Finder(begin(Input), end(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 - function_requires< - FinderConcept::type> >(); - function_requires< - FormatterConcept< - FormatterT, - FinderT,BOOST_STRING_TYPENAME const_iterator_of::type> >(); - - return detail::find_format_all_copy_impl( - Input, - Finder, - Formatter, - Finder( begin(Input), 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 - function_requires< - FinderConcept::type> >(); - function_requires< - FormatterConcept< - FormatterT, - FinderT,BOOST_STRING_TYPENAME const_iterator_of::type> >(); - - detail::find_format_all_impl( - Input, - Finder, - Formatter, - Finder(begin(Input), 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 diff --git a/include/boost/algorithm/string/find_iterator.hpp b/include/boost/algorithm/string/find_iterator.hpp deleted file mode 100644 index 26d08b6..0000000 --- a/include/boost/algorithm/string/find_iterator.hpp +++ /dev/null @@ -1,367 +0,0 @@ -// Boost string_algo library find_iterator.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2004. 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) -// See http://www.boost.org for updates, documentation, and revision history. - -#ifndef BOOST_STRING_FIND_ITERATOR_HPP -#define BOOST_STRING_FIND_ITERATOR_HPP - - -#include -#include -#include -#include -#include -#include - -/*! \file - Defines find iterator classes. Find iterator repeatly 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 - class find_iterator : - public iterator_facade< - find_iterator, - const iterator_range, - forward_traversal_tag >, - private detail::find_iterator_base - { - private: - // facade support - friend class ::boost::iterator_core_access; - - // base type - typedef iterator_facade< - find_iterator, - const iterator_range, - forward_traversal_tag> facade_type; - - private: - // typedefs - - typedef detail::find_iterator_base 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 - find_iterator( - IteratorT Begin, - IteratorT End, - FinderT Finder ) : - detail::find_iterator_base(Finder,0), - m_Match(Begin,Begin), - m_End(End) - { - increment(); - } - - //! Constructor - /*! - Construct new find_iterator for a given finder - and a collection. - */ - template - find_iterator( - CollectionT& Col, - FinderT Finder ) : - detail::find_iterator_base(Finder,0), - m_Match(begin(Col),begin(Col)), - m_End(end(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 - inline find_iterator< - BOOST_STRING_TYPENAME result_iterator_of::type> - make_find_iterator( - CollectionT& Collection, - FinderT Finder) - { - return find_iterator::type>( - begin(Collection), end(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 - class split_iterator : - public iterator_facade< - split_iterator, - const iterator_range, - forward_traversal_tag >, - private detail::find_iterator_base - { - private: - // facade support - friend class ::boost::iterator_core_access; - - // base type - typedef iterator_facade< - find_iterator, - iterator_range, - forward_traversal_tag> facade_type; - - private: - // typedefs - - typedef detail::find_iterator_base 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() {} - //! 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) {} - - //! Constructor - /*! - Construct new split_iterator for a given finder - and a range. - */ - template - split_iterator( - IteratorT Begin, - IteratorT End, - FinderT Finder ) : - detail::find_iterator_base(Finder,0), - m_Match(Begin,Begin), - m_Next(Begin), - m_End(End) - { - increment(); - } - //! Constructor - /*! - Construct new split_iterator for a given finder - and a collection. - */ - template - split_iterator( - CollectionT& Col, - FinderT Finder ) : - detail::find_iterator_base(Finder,0), - m_Match(begin(Col),begin(Col)), - m_Next(begin(Col)), - m_End(end(Col)) - { - 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 ); - 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_Match.begin() == m_End && - m_Match.end() == m_End - ); - } - - private: - // Attributes - match_type m_Match; - input_iterator_type m_Next; - input_iterator_type m_End; - }; - - //! split iterator construction helper - /*! - * Construct a split iterator to iterate through the specified collection - */ - template - inline split_iterator< - BOOST_STRING_TYPENAME result_iterator_of::type> - make_split_iterator( - CollectionT& Collection, - FinderT Finder) - { - return split_iterator::type>( - begin(Collection), end(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 diff --git a/include/boost/algorithm/string/finder.hpp b/include/boost/algorithm/string/finder.hpp deleted file mode 100644 index 13d3e1f..0000000 --- a/include/boost/algorithm/string/finder.hpp +++ /dev/null @@ -1,264 +0,0 @@ -// Boost string_algo library finder.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// See http://www.boost.org for updates, documentation, and revision history. - -#ifndef BOOST_STRING_FINDER_HPP -#define BOOST_STRING_FINDER_HPP - -#include -#include -#include -#include -#include -#include - -/*! \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. - \param Comp An element comparison predicate - \return An instance of the \c first_finder object - */ - template - inline detail::first_finderF< - BOOST_STRING_TYPENAME const_iterator_of::type, - is_equal> - first_finder( const ContainerT& Search ) - { - return - detail::first_finderF< - BOOST_STRING_TYPENAME - const_iterator_of::type, - is_equal>( Search, is_equal() ) ; - } - - //! "First" finder - /*! - \overload - */ - template - inline detail::first_finderF< - BOOST_STRING_TYPENAME const_iterator_of::type, - PredicateT> - first_finder( - const ContainerT& Search, PredicateT Comp ) - { - return - detail::first_finderF< - BOOST_STRING_TYPENAME - const_iterator_of::type, - PredicateT>( 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. - \param Comp An element comparison predicate - \return An instance of the \c last_finder object - */ - template - inline detail::last_finderF< - BOOST_STRING_TYPENAME const_iterator_of::type, - is_equal> - last_finder( const ContainerT& Search ) - { - return - detail::last_finderF< - BOOST_STRING_TYPENAME - const_iterator_of::type, - is_equal>( Search, is_equal() ); - } - //! "Last" finder - /*! - \overload - */ - template - inline detail::last_finderF< - BOOST_STRING_TYPENAME const_iterator_of::type, - PredicateT> - last_finder( const ContainerT& Search, PredicateT Comp ) - { - return - detail::last_finderF< - BOOST_STRING_TYPENAME - const_iterator_of::type, - PredicateT>( 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 - \param Comp An element comparison predicate - \return An instance of the \c nth_finder object - */ - template - inline detail::nth_finderF< - BOOST_STRING_TYPENAME const_iterator_of::type, - is_equal> - nth_finder( - const ContainerT& Search, - unsigned int Nth) - { - return - detail::nth_finderF< - BOOST_STRING_TYPENAME - const_iterator_of::type, - is_equal>( Search, Nth, is_equal() ) ; - } - //! "Nth" finder - /*! - \overload - */ - template - inline detail::nth_finderF< - BOOST_STRING_TYPENAME const_iterator_of::type, - PredicateT> - nth_finder( - const ContainerT& Search, - unsigned int Nth, - PredicateT Comp ) - { - return - detail::nth_finderF< - BOOST_STRING_TYPENAME - const_iterator_of::type, - PredicateT>( 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( unsigned 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( unsigned 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 - token_finder( - PredicateT Pred, - token_compress_mode_type eCompress=token_compress_off ) - { - return detail::token_finderF( 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 - \param Range The range. - \return An instance of the \c range_finger object - */ - template< typename ForwardIteratorT > - inline detail::range_finderF - range_finder( - ForwardIteratorT Begin, - ForwardIteratorT End ) - { - return detail::range_finderF( Begin, End ); - } - - //! "Range" finder - /*! - \overload - */ - template< typename ForwardIteratorT > - inline detail::range_finderF - range_finder( iterator_range Range ) - { - return detail::range_finderF( 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 diff --git a/include/boost/algorithm/string/formatter.hpp b/include/boost/algorithm/string/formatter.hpp deleted file mode 100644 index daf8752..0000000 --- a/include/boost/algorithm/string/formatter.hpp +++ /dev/null @@ -1,92 +0,0 @@ -// Boost string_algo library formatter.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// See http://www.boost.org for updates, documentation, and revision history. - -#ifndef BOOST_STRING_FORMATTER_HPP -#define BOOST_STRING_FORMATTER_HPP - -#include -#include -#include -#include - -/*! \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 formaters ---------------------------------------------------------------// - - //! Constant formatter - /*! - Construct the \c const_formatter. Const formatter always returns - the same value, regardless of the parameter. - - \param Format A predefined value used as a result for formating - \return An instance of the \c const_formatter object. - */ - template - inline detail::const_formatF - const_formatter(const CollectionT& Format) - { - return detail::const_formatF(Format); - } - - //! Identity formatter - /*! - Construct the \c identity_formatter. Identity formatter always returns - the parameter. - - \return An instance of the \c identity_formatter object. - */ - template - inline detail::identity_formatF - identity_formatter() - { - return detail::identity_formatF(); - } - - //! Empty formatter - /*! - Construct the \c empty_formatter. Empty formater 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 - inline detail::empty_formatF< - BOOST_STRING_TYPENAME value_type_of::type> - empty_formatter(const CollectionT&) - { - return detail::empty_formatF< - BOOST_STRING_TYPENAME value_type_of::type>(); - } - - - } // namespace algorithm - - // pull the names to the boost namespace - using algorithm::const_formatter; - using algorithm::identity_formatter; - using algorithm::empty_formatter; - -} // namespace boost - - -#endif // BOOST_FORMATTER_HPP diff --git a/include/boost/algorithm/string/iter_find.hpp b/include/boost/algorithm/string/iter_find.hpp deleted file mode 100644 index b4f89ea..0000000 --- a/include/boost/algorithm/string/iter_find.hpp +++ /dev/null @@ -1,179 +0,0 @@ -// Boost string_algo library iter_find.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// See http://www.boost.org for updates, documentation, and revision history. - -#ifndef BOOST_STRING_ITER_FIND_HPP -#define BOOST_STRING_ITER_FIND_HPP - -#include -#include -#include -#include -#include -#include -#include -#include -#include - -/*! \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> - (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 the result - - \note Prior content of the result will be overwritten. - */ - template< - typename SequenceSequenceT, - typename CollectionT, - typename FinderT > - inline SequenceSequenceT& - iter_find( - SequenceSequenceT& Result, - CollectionT& Input, - FinderT Finder ) - { - function_requires< - FinderConcept::type> >(); - - typedef BOOST_STRING_TYPENAME - result_iterator_of::type input_iterator_type; - typedef find_iterator find_iterator_type; - typedef detail::copy_iterator_rangeF< - BOOST_STRING_TYPENAME - value_type_of::type, - input_iterator_type> copy_range_type; - - input_iterator_type InputEnd=end(Input); - - typedef transform_iterator - transform_iter_type; - - transform_iter_type itBegin= - make_transform_iterator( - find_iterator_type( begin(Input), InputEnd, Finder ), - copy_range_type()); - - transform_iter_type itEnd= - 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 container 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> - (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 the result - - \note Prior content of the result will be overwritten. - */ - template< - typename SequenceSequenceT, - typename CollectionT, - typename FinderT > - inline SequenceSequenceT& - iter_split( - SequenceSequenceT& Result, - CollectionT& Input, - FinderT Finder ) - { - function_requires< - FinderConcept::type> >(); - - typedef BOOST_STRING_TYPENAME - result_iterator_of::type input_iterator_type; - typedef split_iterator find_iterator_type; - typedef detail::copy_iterator_rangeF< - BOOST_STRING_TYPENAME - value_type_of::type, - input_iterator_type> copy_range_type; - - input_iterator_type InputEnd=end(Input); - - typedef transform_iterator - transform_iter_type; - - transform_iter_type itBegin= - make_transform_iterator( - find_iterator_type( begin(Input), InputEnd, Finder ), - copy_range_type() ); - - transform_iter_type itEnd= - 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 diff --git a/include/boost/algorithm/string/iterator_range.hpp b/include/boost/algorithm/string/iterator_range.hpp deleted file mode 100644 index e3d42d6..0000000 --- a/include/boost/algorithm/string/iterator_range.hpp +++ /dev/null @@ -1,296 +0,0 @@ -// Boost string_algo library iterator_range.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// See http://www.boost.org for updates, documentation, and revision history. - -#ifndef BOOST_STRING_ITERATOR_RANGE_HPP -#define BOOST_STRING_ITERATOR_RANGE_HPP - -#include -#include -#include -#include -#include -#include - -/*! \file - Defines the \c iterator_class and related functions. - \c iterator_range is a simple wrapper of the iterator pair idiom. It provides - a rich subset of the Container interface. -*/ - -namespace boost { - namespace algorithm { - -// iterator range template class -----------------------------------------// - - //! iterator_range class - /*! - An \c iterator_range delimits a range in a sequence by beginning and ending iterators. - An iterator_range can be passed to an algorithm which requires a sequence as an input. - For example, the \c toupper() function may most frequently be used on strings, - but can also be used on iterator_ranges: - - \code - boost::tolower( find( s, "UPPERCASE STRING" ) ); - \endcode - - Many algorithms working with sequences take a pair of iterators, - delimiting a working range, as arguments. The \c iterator_range class is an - encapsulation of a range identified by a pair of iterators. - It provides a collection interface, - so it is possible to pass an instance to an algorithm requiring a collection as an input. - */ - template - class iterator_range - { - public: - //! this type - typedef iterator_range type; - //! Encapsulated value type - typedef BOOST_STRING_TYPENAME boost::detail:: - iterator_traits::value_type value_type; - //! Reference type - typedef BOOST_STRING_TYPENAME boost::detail:: - iterator_traits::reference reference; - //! Difference type - typedef BOOST_STRING_TYPENAME boost::detail:: - iterator_traits::difference_type difference_type; - //! Size type - typedef BOOST_STRING_TYPENAME boost::detail:: - iterator_traits::difference_type size_type; - - //! const_iterator type - /*! - There is no distinction between const_iterator and iterator. - These typedefs are provides to fulfill container interface - */ - typedef IteratorT const_iterator; - //! iterator type - typedef IteratorT iterator; - - //! Empty constructor - iterator_range() : - m_Begin(), m_End() {} - - //! Constructor from a pair of iterators - iterator_range( iterator Begin, iterator End ) : - m_Begin(Begin), m_End(End) {} - - //! Constructor from a std::pair - iterator_range( const std::pair& Range ) : - m_Begin(Range.first), m_End(Range.second) {} - - //! Copy constructor - iterator_range( const iterator_range& Other ) : - m_Begin(Other.begin()), m_End(Other.end()) {} - - //! Templated copy constructor - /*! - This constructor is provided to allow conversion between - const and mutable iterator instances of this class template - */ - template< typename OtherItT > - iterator_range( const iterator_range& Other ) : - m_Begin(Other.begin()), m_End(Other.end()) {} - - //! Assignment operator - iterator_range& operator=( const iterator_range& Other ) - { - m_Begin=Other.begin(); m_End=Other.end(); - return *this; - } - - //! Assignment operator ( templated version ) - template< typename OtherItT > - iterator_range& operator=( const iterator_range& Other ) - { - m_Begin=Other.begin(); m_End=Other.end(); - return *this; - } - - //! Comparison operator ( equal ) - /*! - Compare operands for equality - */ - template< typename OtherItT > - bool operator==( const iterator_range& Other ) const - { - return m_Begin==Other.begin() && m_End==Other.end(); - } - - //! Comparison operator ( not-equal ) - /*! - Compare operands for non-equality - */ - template< typename OtherItT > - bool operator!=( const iterator_range& Other ) const - { - return m_Begin!=Other.begin() || m_End!=Other.end(); - } - - //! begin access - /*! - Retrieve the begin iterator - */ - IteratorT begin() const - { - return m_Begin; - } - - //! end access - /*! - Retrieve the end iterator - */ - IteratorT end() const - { - return m_End; - } - - //! Empty container test - /*! - Test whether the range is empty - */ - bool empty() const - { - return m_Begin==m_End; - } - - //! Size of the range - /*! - Retrieve the size of the range - */ - difference_type size() const - { - return std::distance( m_Begin, m_End ); - } - - //! Swap - /*! - Swap two ranges - */ - void swap( iterator_range& Other ) - { - std::swap( m_Begin, Other.begin() ); - std::swap( m_End, Other.end() ); - } - - //! Safe bool conversion - /*! - Check whether the range is empty. - Allows to use construction like this: - \code - iterator_range r; - if (!r) - { - ... - } - \endcode - */ - typedef iterator (iterator_range::*unspecified_bool_type) () const; - operator unspecified_bool_type() const - { - return empty()? 0: &iterator_range::end; - } - - private: - // begin and end iterators - IteratorT m_Begin; - IteratorT m_End; - }; - -// iterator range free-standing operators ---------------------------// - - //! iterator_range output operator - /*! - Output the range to an ostream. Elements are outputed - in a sequence without separators. - */ - template< typename IteratorT, typename Elem, typename Traits > - std::basic_ostream& operator<<( - std::basic_ostream& Os, - const iterator_range& Range ) - { - std::copy(Range.begin(), Range.end(), std::ostream_iterator(Os)); - - return Os; - } - - -// iterator range utilities -----------------------------------------// - - //! iterator_range construct helper - /*! - Construct an \c iterator_range from a pair of iterators - - \param Begin A begin iterator - \param End An end iterator - \return iterator_range object - */ - template< typename IteratorT > - inline iterator_range< IteratorT > make_iterator_range( IteratorT Begin, IteratorT End ) - { - return iterator_range( Begin, End ); - } - - //! iterator_range construct helper - /*! - Construct an \c iterator_range from a \c std::pair<> containing the begin - and end iterators. - - \param Pair A \c std::pair<> with begin and end iterators - \return \c iterator_range object - */ - template< typename IteratorT > - inline iterator_range< IteratorT > make_iterator_range( const std::pair& Pair ) - { - return iterator_range( Pair.first, Pair.second ); - } - - //! copy a range into a sequence - /*! - Construct a new sequence of the specified type from the elements - in the given range - - \param Range An input range - \return New sequence - */ - template< typename SeqT, typename IteratorT > - inline SeqT copy_iterator_range( const iterator_range& Range ) - { - return SeqT( Range.begin(), Range.end() ); - } - - //! transform a range into a sequence - /*! - Create a new sequence from the elements in the range, transformed - by a function - - \param Range An input range - \param Func Transformation function - \return New sequence - */ - template< typename SeqT, typename IteratorT, typename FuncT > - inline SeqT transform_iterator_range( const iterator_range& Range, FuncT Func ) - { - SeqT Seq; - std::transform( Range.begin(), Range.end(), std::back_inserter(Seq), Func ); - return Seq; - } - - } // namespace algorithm - - // pull names to the namespace boost - using algorithm::iterator_range; - using algorithm::make_iterator_range; - using algorithm::copy_iterator_range; - using algorithm::transform_iterator_range; - -} // namespace boost - - -#endif // BOOST_STRING_ITERATOR_RANGE_HPP diff --git a/include/boost/algorithm/string/predicate.hpp b/include/boost/algorithm/string/predicate.hpp deleted file mode 100644 index a6fea9b..0000000 --- a/include/boost/algorithm/string/predicate.hpp +++ /dev/null @@ -1,377 +0,0 @@ -// Boost string_algo library predicate.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// See http://www.boost.org for updates, documentation, and revision history. - -#ifndef BOOST_STRING_PREDICATE_HPP -#define BOOST_STRING_PREDICATE_HPP - -#include -#include -#include -#include -#include - -/*! \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 collection 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 - inline bool starts_with( - const Collection1T& Input, - const Collection2T& Test, - PredicateT Comp) - { - typedef BOOST_STRING_TYPENAME - const_iterator_of::type Iterator1T; - typedef BOOST_STRING_TYPENAME - const_iterator_of::type Iterator2T; - - Iterator1T InputEnd=end(Input); - Iterator2T TestEnd=end(Test); - - Iterator1T it=begin(Input); - Iterator2T pit=begin(Test); - for(; - it!=InputEnd && pit!=TestEnd; - ++it,++pit) - { - if( !(Comp(*it,*pit)) ) - return false; - } - - return pit==TestEnd; - } - - //! 'Starts with' predicate - /*! - \overload - */ - template - inline bool starts_with( - const Collection1T& Input, - const Collection2T& Test) - { - return starts_with(Input, Test, is_equal()); - } - - //! 'Starts with' predicate ( case insensitive ) - /*! - This predicate holds when the test container 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 - inline bool istarts_with( - const Collection1T& Input, - const Collection2T& Test, - const std::locale& Loc=std::locale()) - { - return starts_with(Input, Test, is_iequal(Loc)); - } - - -// ends_with predicate -----------------------------------------------// - - //! 'Ends with' predicate - /*! - This predicate holds when the test container 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 - inline bool ends_with( - const Collection1T& Input, - const Collection2T& Test, - PredicateT Comp) - { - typedef BOOST_STRING_TYPENAME - const_iterator_of::type Iterator1T; - typedef BOOST_STRING_TYPENAME boost::detail:: - iterator_traits::iterator_category category; - - return detail:: - ends_with_iter_select( - begin(Input), - end(Input), - begin(Test), - end(Test), - Comp, - category()); - } - - - //! 'Ends with' predicate - /*! - \overload - */ - template - inline bool ends_with( - const Collection1T& Input, - const Collection2T& Test) - { - return 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 - inline bool iends_with( - const Collection1T& Input, - const Collection2T& Test, - const std::locale& Loc=std::locale()) - { - return 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 - inline bool contains( - const Collection1T& Input, - const Collection2T& Test, - PredicateT Comp) - { - if (empty(Test)) - { - // Empty range is contained always - return true; - } - - // Use the temporary variable to make VACPP happy - bool bResult=(first_finder(Test,Comp)(begin(Input), end(Input))); - return bResult; - } - - //! 'Contains' predicate - /*! - \overload - */ - template - inline bool contains( - const Collection1T& Input, - const Collection2T& Test) - { - return 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 - inline bool icontains( - const Collection1T& Input, - const Collection2T& Test, - const std::locale& Loc=std::locale()) - { - return 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 - inline bool equals( - const Collection1T& Input, - const Collection2T& Test, - PredicateT Comp) - { - typedef BOOST_STRING_TYPENAME - const_iterator_of::type Iterator1T; - typedef BOOST_STRING_TYPENAME - const_iterator_of::type Iterator2T; - - Iterator1T InputEnd=end(Input); - Iterator2T TestEnd=end(Test); - - Iterator1T it=begin(Input); - Iterator2T pit=begin(Test); - for(; - it!=InputEnd && pit!=TestEnd; - ++it,++pit) - { - if( !(Comp(*it,*pit)) ) - return false; - } - - return (pit==TestEnd) && (it==InputEnd); - } - - //! 'Equals' predicate - /*! - \overload - */ - template - inline bool equals( - const Collection1T& Input, - const Collection2T& Test) - { - return equals(Input, Test, is_equal()); - } - - //! 'Equals' predicate ( casa 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 - inline bool iequals( - const Collection1T& Input, - const Collection2T& Test, - const std::locale& Loc=std::locale()) - { - return equals(Input, Test, is_iequal(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 - inline bool all( - const CollectionT& Input, - PredicateT Pred) - { - typedef BOOST_STRING_TYPENAME - const_iterator_of::type Iterator1T; - - Iterator1T InputEnd=end(Input); - for( Iterator1T It=begin(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; - -} // namespace boost - - -#endif // BOOST_STRING_PREDICATE_HPP diff --git a/include/boost/algorithm/string/predicate_facade.hpp b/include/boost/algorithm/string/predicate_facade.hpp deleted file mode 100644 index 70730f8..0000000 --- a/include/boost/algorithm/string/predicate_facade.hpp +++ /dev/null @@ -1,41 +0,0 @@ -// Boost string_algo library predicate_facade.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// See http://www.boost.org for updates, documentation, and revision history. - -#ifndef BOOST_STRING_PREDICATE_FACADE_HPP -#define BOOST_STRING_PREDICATE_FACADE_HPP - -#include - -/* - \file boost/algorith/string/predicate_facade.hpp - This file containes 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 - struct predicate_facade {}; - - } // namespace algorithm -} // namespace boost - - -#endif // BOOST_STRING_CLASSIFICATION_DETAIL_HPP diff --git a/include/boost/algorithm/string/regex.hpp b/include/boost/algorithm/string/regex.hpp deleted file mode 100644 index ca22da7..0000000 --- a/include/boost/algorithm/string/regex.hpp +++ /dev/null @@ -1,491 +0,0 @@ -// Boost string_algo library regex.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// See http://www.boost.org for updates, documentation, and revision history. - -#ifndef BOOST_STRING_REGEX_HPP -#define BOOST_STRING_REGEX_HPP - -#include -#include -#include -#include -#include -#include -#include -#include - -/*! \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 InputContainerT::iterator or - \c InputContainerT::const_iterator, depending on the constness of - the input parameter. - - \note This function provides the strong exception-safety guarantee - */ - template< - typename CollectionT, - typename CharT, - typename RegexTraitsT, typename RegexAllocatorT> - inline iterator_range< - BOOST_STRING_TYPENAME result_iterator_of::type > - find_regex( - CollectionT& Input, - const reg_expression& Rx, - match_flag_type Flags=match_default ) - { - return regex_finder(Rx,Flags)( - begin(Input), end(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 CollectionT, - typename CharT, - typename RegexTraitsT, typename RegexAllocatorT, - typename FormatStringTraitsT, typename FormatStringAllocatorT > - inline OutputIteratorT replace_regex_copy( - OutputIteratorT Output, - const CollectionT& Input, - const reg_expression& Rx, - const std::basic_string& Format, - match_flag_type Flags=match_default | format_default ) - { - return find_format_copy( - Output, - Input, - regex_finder( Rx, Flags ), - regex_formatter( Format, Flags ) ); - } - - //! Replace regex algorithm - /*! - \overload - */ - template< - typename SequenceT, - typename CharT, - typename RegexTraitsT, typename RegexAllocatorT, - typename FormatStringTraitsT, typename FormatStringAllocatorT > - inline SequenceT replace_regex_copy( - const SequenceT& Input, - const reg_expression& Rx, - const std::basic_string& Format, - match_flag_type Flags=match_default | format_default ) - { - return find_format_copy( - Input, - regex_finder( Rx, Flags ), - 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 RegexAllocatorT, - typename FormatStringTraitsT, typename FormatStringAllocatorT > - inline void replace_regex( - SequenceT& Input, - const reg_expression& Rx, - const std::basic_string& Format, - match_flag_type Flags=match_default | format_default ) - { - find_format( - Input, - regex_finder( Rx, Flags ), - 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 CollectionT, - typename CharT, - typename RegexTraitsT, typename RegexAllocatorT, - typename FormatStringTraitsT, typename FormatStringAllocatorT > - inline OutputIteratorT replace_all_regex_copy( - OutputIteratorT Output, - const CollectionT& Input, - const reg_expression& Rx, - const std::basic_string& Format, - match_flag_type Flags=match_default | format_default ) - { - return find_format_all_copy( - Output, - Input, - regex_finder( Rx, Flags ), - regex_formatter( Format, Flags ) ); - } - - //! Replace all regex algorithm - /*! - \overload - */ - template< - typename SequenceT, - typename CharT, - typename RegexTraitsT, typename RegexAllocatorT, - typename FormatStringTraitsT, typename FormatStringAllocatorT > - inline SequenceT replace_all_regex_copy( - const SequenceT& Input, - const reg_expression& Rx, - const std::basic_string& Format, - match_flag_type Flags=match_default | format_default ) - { - return find_format_all_copy( - Input, - regex_finder( Rx, Flags ), - 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 RegexAllocatorT, - typename FormatStringTraitsT, typename FormatStringAllocatorT > - inline void replace_all_regex( - SequenceT& Input, - const reg_expression& Rx, - const std::basic_string& Format, - match_flag_type Flags=match_default | format_default ) - { - find_format_all( - Input, - regex_finder( Rx, Flags ), - 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 CollectionT, - typename CharT, - typename RegexTraitsT, typename RegexAllocatorT > - inline OutputIteratorT erase_regex_copy( - OutputIteratorT Output, - const CollectionT& Input, - const reg_expression& Rx, - match_flag_type Flags=match_default ) - { - return find_format_copy( - Output, - Input, - regex_finder( Rx, Flags ), - empty_formatter( Input ) ); - } - - //! Erase regex algorithm - /*! - \overload - */ - template< - typename SequenceT, - typename CharT, - typename RegexTraitsT, typename RegexAllocatorT > - inline SequenceT erase_regex_copy( - const SequenceT& Input, - const reg_expression& Rx, - match_flag_type Flags=match_default ) - { - return find_format_copy( - Input, - regex_finder( Rx, Flags ), - 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, typename RegexAllocatorT > - inline void erase_regex( - SequenceT& Input, - const reg_expression& Rx, - match_flag_type Flags=match_default ) - { - find_format( - Input, - regex_finder( Rx, Flags ), - 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 CollectionT, - typename CharT, - typename RegexTraitsT, typename RegexAllocatorT > - inline OutputIteratorT erase_all_regex_copy( - OutputIteratorT Output, - const CollectionT& Input, - const reg_expression& Rx, - match_flag_type Flags=match_default ) - { - return find_format_all_copy( - Output, - Input, - regex_finder( Rx, Flags ), - empty_formatter( Input ) ); - } - - //! Erase all regex algorithm - /*! - \overload - */ - template< - typename SequenceT, - typename CharT, - typename RegexTraitsT, typename RegexAllocatorT > - inline SequenceT erase_all_regex_copy( - const SequenceT& Input, - const reg_expression& Rx, - match_flag_type Flags=match_default ) - { - return find_format_all_copy( - Input, - regex_finder( Rx, Flags ), - 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, typename RegexAllocatorT> - inline void erase_all_regex( - SequenceT& Input, - const reg_expression& Rx, - match_flag_type Flags=match_default ) - { - find_format_all( - Input, - regex_finder( Rx, Flags ), - 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 - or \c std::list> - - \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 CollectionT, - typename CharT, - typename RegexTraitsT, typename RegexAllocatorT > - inline SequenceSequenceT& find_all_regex( - SequenceSequenceT& Result, - const CollectionT& Input, - const reg_expression& Rx, - match_flag_type Flags=match_default ) - { - return iter_find( - Result, - Input, - 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 - or \c std::list> - - \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 CollectionT, - typename CharT, - typename RegexTraitsT, typename RegexAllocatorT > - inline SequenceSequenceT& split_regex( - SequenceSequenceT& Result, - const CollectionT& Input, - const reg_expression& Rx, - match_flag_type Flags=match_default ) - { - return iter_split( - Result, - Input, - regex_finder(Rx,Flags) ); - } - - } // 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; - -} // namespace boost - - -#endif // BOOST_STRING_REGEX_HPP diff --git a/include/boost/algorithm/string/regex_find_format.hpp b/include/boost/algorithm/string/regex_find_format.hpp deleted file mode 100644 index ea30f6d..0000000 --- a/include/boost/algorithm/string/regex_find_format.hpp +++ /dev/null @@ -1,89 +0,0 @@ -// Boost string_algo library regex_find_format.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// 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 -#include -#include -#include - -/*! \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 containes 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, typename RegexAllocatorT> - inline detail::find_regexF< reg_expression > - regex_finder( - const reg_expression& Rx, - match_flag_type MatchFlags=match_default ) - { - return detail:: - find_regexF< - reg_expression >( 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& Format, - match_flag_type Flags=format_default ) - { - return - detail::regex_formatF< std::basic_string >( - 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 diff --git a/include/boost/algorithm/string/replace.hpp b/include/boost/algorithm/string/replace.hpp deleted file mode 100644 index ebd0f08..0000000 --- a/include/boost/algorithm/string/replace.hpp +++ /dev/null @@ -1,910 +0,0 @@ -// Boost string_algo library replace.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// See http://www.boost.org for updates, documentation, and revision history. - -#ifndef BOOST_STRING_REPLACE_HPP -#define BOOST_STRING_REPLACE_HPP - -#include -#include -#include -#include -#include -#include -#include - -/*! \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 Collection1T, - typename Collection2T> - inline OutputIteratorT replace_range_copy( - OutputIteratorT Output, - const Collection1T& Input, - const iterator_range< - BOOST_STRING_TYPENAME - const_iterator_of::type>& SearchRange, - const Collection2T& Format) - { - return find_format_copy( - Output, - Input, - range_finder(SearchRange), - const_formatter(Format)); - } - - //! Replace range algorithm - /*! - \overload - */ - template - inline SequenceT replace_range_copy( - const SequenceT& Input, - const iterator_range< - BOOST_STRING_TYPENAME - const_iterator_of::type>& SearchRange, - const CollectionT& Format) - { - return find_format_copy( - Input, - range_finder(SearchRange), - 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 - inline void replace_range( - SequenceT& Input, - const iterator_range< - BOOST_STRING_TYPENAME - iterator_of::type>& SearchRange, - const CollectionT& Format) - { - find_format( - Input, - range_finder(SearchRange), - 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 Collection1T, - typename Collection2T, - typename Collection3T> - inline OutputIteratorT replace_first_copy( - OutputIteratorT Output, - const Collection1T& Input, - const Collection2T& Search, - const Collection3T& Format) - { - return find_format_copy( - Output, - Input, - first_finder(Search), - const_formatter(Format) ); - } - - //! Replace first algorithm - /*! - \overload - */ - template - inline SequenceT replace_first_copy( - const SequenceT& Input, - const Collection1T& Search, - const Collection2T& Format ) - { - return find_format_copy( - Input, - first_finder(Search), - 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 - inline void replace_first( - SequenceT& Input, - const Collection1T& Search, - const Collection2T& Format ) - { - find_format( - Input, - first_finder(Search), - 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 Collection1T, - typename Collection2T, - typename Collection3T> - inline OutputIteratorT ireplace_first_copy( - OutputIteratorT Output, - const Collection1T& Input, - const Collection2T& Search, - const Collection3T& Format, - const std::locale& Loc=std::locale() ) - { - return find_format_copy( - Output, - Input, - first_finder(Search, is_iequal(Loc)), - const_formatter(Format) ); - } - - //! Replace first algorithm ( case insensitive ) - /*! - \overload - */ - template - inline SequenceT ireplace_first_copy( - const SequenceT& Input, - const Collection2T& Search, - const Collection1T& Format, - const std::locale& Loc=std::locale() ) - { - return find_format_copy( - Input, - first_finder(Search, is_iequal(Loc)), - 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 - inline void ireplace_first( - SequenceT& Input, - const Collection1T& Search, - const Collection2T& Format, - const std::locale& Loc=std::locale() ) - { - find_format( - Input, - first_finder(Search, is_iequal(Loc)), - 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 Collection1T, - typename Collection2T, - typename Collection3T> - inline OutputIteratorT replace_last_copy( - OutputIteratorT Output, - const Collection1T& Input, - const Collection2T& Search, - const Collection3T& Format ) - { - return find_format_copy( - Output, - Input, - last_finder(Search), - const_formatter(Format) ); - } - - //! Replace last algorithm - /*! - \overload - */ - template - inline SequenceT replace_last_copy( - const SequenceT& Input, - const Collection1T& Search, - const Collection2T& Format ) - { - return find_format_copy( - Input, - last_finder(Search), - 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 - inline void replace_last( - SequenceT& Input, - const Collection1T& Search, - const Collection2T& Format ) - { - find_format( - Input, - last_finder(Search), - 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 Collection1T, - typename Collection2T, - typename Collection3T> - inline OutputIteratorT ireplace_last_copy( - OutputIteratorT Output, - const Collection1T& Input, - const Collection2T& Search, - const Collection3T& Format, - const std::locale& Loc=std::locale() ) - { - return find_format_copy( - Output, - Input, - last_finder(Search, is_iequal(Loc)), - const_formatter(Format) ); - } - - //! Replace last algorithm ( case insensitive ) - /*! - \overload - */ - template - inline SequenceT ireplace_last_copy( - const SequenceT& Input, - const Collection1T& Search, - const Collection2T& Format, - const std::locale& Loc=std::locale() ) - { - return find_format_copy( - Input, - last_finder(Search, is_iequal(Loc)), - 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 - \return A reference to the modified input - */ - template - inline void ireplace_last( - SequenceT& Input, - const Collection1T& Search, - const Collection2T& Format, - const std::locale& Loc=std::locale() ) - { - find_format( - Input, - last_finder(Search, is_iequal(Loc)), - 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. - \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 Collection1T, - typename Collection2T, - typename Collection3T> - inline OutputIteratorT replace_nth_copy( - OutputIteratorT Output, - const Collection1T& Input, - const Collection2T& Search, - unsigned int Nth, - const Collection3T& Format ) - { - return find_format_copy( - Output, - Input, - nth_finder(Search, Nth), - const_formatter(Format) ); - } - - //! Replace nth algorithm - /*! - \overload - */ - template - inline SequenceT replace_nth_copy( - const SequenceT& Input, - const Collection1T& Search, - unsigned int Nth, - const Collection2T& Format ) - { - return find_format_copy( - Input, - nth_finder(Search, Nth), - 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. - \param Format A substitute string - */ - template - inline void replace_nth( - SequenceT& Input, - const Collection1T& Search, - unsigned int Nth, - const Collection2T& Format ) - { - find_format( - Input, - nth_finder(Search, Nth), - 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. - \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 Collection1T, - typename Collection2T, - typename Collection3T> - inline OutputIteratorT ireplace_nth_copy( - OutputIteratorT Output, - const Collection1T& Input, - const Collection2T& Search, - unsigned int Nth, - const Collection3T& Format, - const std::locale& Loc=std::locale() ) - { - return find_format_copy( - Output, - Input, - nth_finder(Search, Nth, is_iequal(Loc) ), - const_formatter(Format) ); - } - - //! Replace nth algorithm ( case insensitive ) - /*! - \overload - */ - template - inline SequenceT ireplace_nth_copy( - const SequenceT& Input, - const Collection1T& Search, - unsigned int Nth, - const Collection2T& Format, - const std::locale& Loc=std::locale() ) - { - return find_format_copy( - Input, - nth_finder(Search, Nth, is_iequal(Loc)), - 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. - \param Format A substitute string - \param Loc A locale used for case insensitive comparison - */ - template - inline void ireplace_nth( - SequenceT& Input, - const Collection1T& Search, - unsigned int Nth, - const Collection2T& Format, - const std::locale& Loc=std::locale() ) - { - find_format( - Input, - nth_finder(Search, Nth, is_iequal(Loc)), - 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 Collection1T, - typename Collection2T, - typename Collection3T> - inline OutputIteratorT replace_all_copy( - OutputIteratorT Output, - const Collection1T& Input, - const Collection2T& Search, - const Collection3T& Format ) - { - return find_format_all_copy( - Output, - Input, - first_finder(Search), - const_formatter(Format) ); - } - - //! Replace all algorithm - /*! - \overload - */ - template - inline SequenceT replace_all_copy( - const SequenceT& Input, - const Collection1T& Search, - const Collection2T& Format ) - { - return find_format_all_copy( - Input, - first_finder(Search), - 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 - \return A reference to the modified input - */ - template - inline void replace_all( - SequenceT& Input, - const Collection1T& Search, - const Collection2T& Format ) - { - find_format_all( - Input, - first_finder(Search), - 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 Collection1T, - typename Collection2T, - typename Collection3T> - inline OutputIteratorT ireplace_all_copy( - OutputIteratorT Output, - const Collection1T& Input, - const Collection2T& Search, - const Collection3T& Format, - const std::locale& Loc=std::locale() ) - { - return find_format_all_copy( - Output, - Input, - first_finder(Search, is_iequal(Loc)), - const_formatter(Format) ); - } - - //! Replace all algorithm ( case insensitive ) - /*! - \overload - */ - template - inline SequenceT ireplace_all_copy( - const SequenceT& Input, - const Collection1T& Search, - const Collection2T& Format, - const std::locale& Loc=std::locale() ) - { - return find_format_all_copy( - Input, - first_finder(Search, is_iequal(Loc)), - 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 - inline void ireplace_all( - SequenceT& Input, - const Collection1T& Search, - const Collection2T& Format, - const std::locale& Loc=std::locale() ) - { - find_format_all( - Input, - first_finder(Search, is_iequal(Loc)), - 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 - \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 Collection1T, - typename Collection2T> - inline OutputIteratorT replace_head_copy( - OutputIteratorT Output, - const Collection1T& Input, - unsigned int N, - const Collection2T& Format ) - { - return find_format_copy( - Output, - Input, - head_finder(N), - const_formatter(Format) ); - } - - //! Replace head algorithm - /*! - \overload - */ - template - inline SequenceT replace_head_copy( - const SequenceT& Input, - unsigned int N, - const CollectionT& Format ) - { - return find_format_copy( - Input, - head_finder(N), - 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 - \param Format A substitute string - */ - template - inline void replace_head( - SequenceT& Input, - unsigned int N, - const CollectionT& Format ) - { - find_format( - Input, - head_finder(N), - 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 - \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 Collection1T, - typename Collection2T> - inline OutputIteratorT replace_tail_copy( - OutputIteratorT Output, - const Collection1T& Input, - unsigned int N, - const Collection2T& Format ) - { - return find_format_copy( - Output, - Input, - tail_finder(N), - const_formatter(Format) ); - } - - //! Replace tail algorithm - /*! - \overload - */ - template - inline SequenceT replace_tail_copy( - const SequenceT& Input, - unsigned int N, - const CollectionT& Format ) - { - return find_format_copy( - Input, - tail_finder(N), - 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 - \param Format A substitute string - */ - template - inline void replace_tail( - SequenceT& Input, - unsigned int N, - const CollectionT& Format ) - { - find_format( - Input, - tail_finder(N), - 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 diff --git a/include/boost/algorithm/string/sequence_traits.hpp b/include/boost/algorithm/string/sequence_traits.hpp deleted file mode 100644 index a9ba473..0000000 --- a/include/boost/algorithm/string/sequence_traits.hpp +++ /dev/null @@ -1,192 +0,0 @@ -// Boost string_algo library sequence_traits.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// See http://www.boost.org for updates, documentation, and revision history. - -#ifndef BOOST_STRING_SEQUENCE_TRAITS_HPP -#define BOOST_STRING_SEQUENCE_TRAITS_HPP - -#include -#include -#include - -/*! \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 -----------------------------------------------// - -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - //! Native replace tester - /*! - Declare an override of this tester function with return - type boost::string_algo::yes_type for a sequence with this property. - - \return yes_type if the container has basic_string like native replace - method. - */ - no_type has_native_replace_tester(...); - - //! Stable iterators tester - /*! - Declare an override of this tester function with return - type boost::string_algo::yes_type for a sequence with this property. - - \return yes_type if the sequence's insert/replace/erase methods do not invalidate - existing iterators. - */ - no_type has_stable_iterators_tester(...); - - //! const time insert tester - /*! - Declare an override of this tester function with return - type boost::string_algo::yes_type for a sequence with this property. - - \return yes_type if the sequence's insert method is working in constant time - */ - no_type has_const_time_insert_tester(...); - - //! const time erase tester - /*! - Declare an override of this tester function with return - type boost::string_algo::yes_type for a sequence with this property. - - \return yes_type if the sequence's erase method is working in constant time - */ - no_type has_const_time_erase_tester(...); - -#endif //BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - //! Native replace trait - /*! - This trait specifies that the sequence has \c std::string like replace method - */ - template< typename T > - class has_native_replace - { - -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - private: - static T* t; - public: - BOOST_STATIC_CONSTANT(bool, value=( - sizeof(has_native_replace_tester(t))==sizeof(yes_type) ) ); -#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - public: -# if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - enum { value = false }; -# else - BOOST_STATIC_CONSTANT(bool, value=false); -# endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - - typedef mpl::bool_ 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 - { -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - private: - static T* t; - public: - BOOST_STATIC_CONSTANT(bool, value=( - sizeof(has_stable_iterators_tester(t))==sizeof(yes_type) ) ); -#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - public: -# if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - enum { value = false }; -# else - BOOST_STATIC_CONSTANT(bool, value=false); -# endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - typedef mpl::bool_ 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 - { -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - private: - static T* t; - public: - BOOST_STATIC_CONSTANT(bool, value=( - sizeof(has_const_time_insert_tester(t))==sizeof(yes_type) ) ); -#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - public: -# if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - enum { value = false }; -# else - BOOST_STATIC_CONSTANT(bool, value=false); -# endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - typedef mpl::bool_ 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 - { -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - private: - static T* t; - public: - BOOST_STATIC_CONSTANT(bool, value=( - sizeof(has_const_time_erase_tester(t))==sizeof(yes_type) ) ); -#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - public: -# if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - enum { value = false }; -# else - BOOST_STATIC_CONSTANT(bool, value=false); -# endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - typedef mpl::bool_ type; - }; - - } // namespace algorithm -} // namespace boost - - -#endif // BOOST_STRING_SEQUENCE_TRAITS_HPP diff --git a/include/boost/algorithm/string/split.hpp b/include/boost/algorithm/string/split.hpp deleted file mode 100644 index 6e15590..0000000 --- a/include/boost/algorithm/string/split.hpp +++ /dev/null @@ -1,163 +0,0 @@ -// Boost string_algo library find.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// See http://www.boost.org for updates, documentation, and revision history. - -#ifndef BOOST_STRING_SPLIT_HPP -#define BOOST_STRING_SPLIT_HPP - -#include -#include -#include -#include -#include -#include - -/*! \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 - or \c std::list> -*/ - -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 - or \c std::list> - - \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 Collection1T, typename Collection2T > - inline SequenceSequenceT& find_all( - SequenceSequenceT& Result, - Collection1T& Input, - const Collection2T& Search) - { - return iter_find( - Result, - Input, - 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 - or \c std::list> - - 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 Collection1T, typename Collection2T > - inline SequenceSequenceT& ifind_all( - SequenceSequenceT& Result, - Collection1T& Input, - const Collection2T& Search, - const std::locale& Loc=std::locale() ) - { - return iter_find( - Result, - Input, - 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 - or \c std::list> - - \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 CollectionT, typename PredicateT > - inline SequenceSequenceT& split( - SequenceSequenceT& Result, - CollectionT& Input, - PredicateT Pred, - token_compress_mode_type eCompress=token_compress_off ) - { - return iter_split( - Result, - Input, - 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 - diff --git a/include/boost/algorithm/string/std/list_traits.hpp b/include/boost/algorithm/string/std/list_traits.hpp deleted file mode 100644 index 92e4b5c..0000000 --- a/include/boost/algorithm/string/std/list_traits.hpp +++ /dev/null @@ -1,84 +0,0 @@ -// Boost string_algo library list_traits.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// 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 -#include -#include - -namespace boost { - namespace algorithm { - -// std::list<> traits -----------------------------------------------// - -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - // stable iterators tester - template - yes_type has_stable_iterators_tester( const ::std::list* ); - - // const time insert tester - template - yes_type has_const_time_insert_tester( const ::std::list* ); - - // const time erase tester - template - yes_type has_const_time_erase_tester( const ::std::list* ); - - -#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - // stable iterators trait - template - class has_stable_iterators< ::std::list > - { - public: -#if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - enum { value = true }; -#else - BOOST_STATIC_CONSTANT(bool, value=true); -#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - typedef mpl::bool_ type; - }; - - // const time insert trait - template - class has_const_time_insert< ::std::list > - { - public: -#if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - enum { value = true }; -#else - BOOST_STATIC_CONSTANT(bool, value=true); -#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - typedef mpl::bool_ type; - }; - - // const time erase trait - template - class has_const_time_erase< ::std::list > - { - public: -#if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - enum { value = true }; -#else - BOOST_STATIC_CONSTANT(bool, value=true); -#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - typedef mpl::bool_ type; - }; -#endif - - - } // namespace algorithm -} // namespace boost - - -#endif // BOOST_STRING_STD_LIST_TRAITS_HPP diff --git a/include/boost/algorithm/string/std/rope_traits.hpp b/include/boost/algorithm/string/std/rope_traits.hpp deleted file mode 100644 index 98f3451..0000000 --- a/include/boost/algorithm/string/std/rope_traits.hpp +++ /dev/null @@ -1,100 +0,0 @@ -// Boost string_algo library string_traits.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// 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 -#include -#include - -namespace boost { - namespace algorithm { - -// SGI's std::rope<> traits -----------------------------------------------// - -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - // native replace tester - template - yes_type has_native_replace_tester( const std::rope* ); - - // stable iterators tester - template - yes_type has_stable_iterators_tester( const std::rope* ); - - // const time insert tester - template - yes_type has_const_time_insert_tester( const std::rope* ); - - // const time erase tester - template - yes_type has_const_time_erase_tester( const std::rope* ); - -#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - // native replace trait - template - class has_native_replace< std::rope > - { - public: -#if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - enum { value = true }; -#else - BOOST_STATIC_CONSTANT(bool, value=true); -#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - typedef mpl::bool_ type; - }; - - // stable iterators trait - template - class has_stable_iterators< std::rope > - { - public: -#if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - enum { value = true }; -#else - BOOST_STATIC_CONSTANT(bool, value=true); -#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - typedef mpl::bool_ type; - }; - - // const time insert trait - template - class has_const_time_insert< std::rope > - { - public: -#if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - enum { value = true }; -#else - BOOST_STATIC_CONSTANT(bool, value=true); -#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - typedef mpl::bool_ type; - }; - - // const time erase trait - template - class has_const_time_erase< std::rope > - { - public: -#if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - enum { value = true }; -#else - BOOST_STATIC_CONSTANT(bool, value=true); -#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - typedef mpl::bool_ type; - }; -#endif - - - } // namespace algorithm -} // namespace boost - - -#endif // BOOST_STRING_ROPE_TRAITS_HPP diff --git a/include/boost/algorithm/string/std/slist_traits.hpp b/include/boost/algorithm/string/std/slist_traits.hpp deleted file mode 100644 index 13d23ac..0000000 --- a/include/boost/algorithm/string/std/slist_traits.hpp +++ /dev/null @@ -1,83 +0,0 @@ -// Boost string_algo library slist_traits.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// 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 -#include -#include - -namespace boost { - namespace algorithm { - -// SGI's std::slist<> traits -----------------------------------------------// - -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - // stable iterators tester - template - yes_type has_stable_iterators_tester( const std::slist* ); - - // const time insert tester - template - yes_type has_const_time_insert_tester( const std::slist* ); - - // const time erase tester - template - yes_type has_const_time_erase_tester( const std::slist* ); - -#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - // stable iterators trait - template - class has_stable_iterators< std::slist > - { - public: -#if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - enum { value = true }; -#else - BOOST_STATIC_CONSTANT(bool, value=true); -#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - typedef mpl::bool_ type; - }; - - // const time insert trait - template - class has_const_time_insert< std::slist > - { - public: -#if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - enum { value = true }; -#else - BOOST_STATIC_CONSTANT(bool, value=true); -#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - typedef mpl::bool_ type; - }; - - // const time erase trait - template - class has_const_time_erase< std::slist > - { - public: -#if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - enum { value = true }; -#else - BOOST_STATIC_CONSTANT(bool, value=true); -#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - typedef mpl::bool_ type; - }; -#endif - - - } // namespace algorithm -} // namespace boost - - -#endif // BOOST_STRING_STD_LIST_TRAITS_HPP diff --git a/include/boost/algorithm/string/std/string_traits.hpp b/include/boost/algorithm/string/std/string_traits.hpp deleted file mode 100644 index 89b7543..0000000 --- a/include/boost/algorithm/string/std/string_traits.hpp +++ /dev/null @@ -1,51 +0,0 @@ -// Boost string_algo library string_traits.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// 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 -#include -#include - -namespace boost { - namespace algorithm { - -// std::basic_string<> traits -----------------------------------------------// - -#ifdef BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - // native replace tester - template - yes_type has_native_replace_tester( const std::basic_string* ); - -#else // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - // native replace trait - template - class has_native_replace< std::basic_string > - { - public: -#if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - enum { value = true } ; -#else - BOOST_STATIC_CONSTANT(bool, value=true); -#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) - - typedef mpl::bool_ type; - }; - - -#endif // BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION - - } // namespace algorithm -} // namespace boost - - -#endif // BOOST_STRING_LIST_TRAITS_HPP diff --git a/include/boost/algorithm/string/std_containers_traits.hpp b/include/boost/algorithm/string/std_containers_traits.hpp deleted file mode 100644 index ab0cf3f..0000000 --- a/include/boost/algorithm/string/std_containers_traits.hpp +++ /dev/null @@ -1,25 +0,0 @@ -// Boost string_algo library std_containers_traits.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// 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 -#include -#include - -#ifdef BOOST_HAS_SLIST -# include -#endif - -#endif // BOOST_STRING_STD_CONTAINERS_TRAITS_HPP diff --git a/include/boost/algorithm/string/trim.hpp b/include/boost/algorithm/string/trim.hpp deleted file mode 100644 index 9aa597d..0000000 --- a/include/boost/algorithm/string/trim.hpp +++ /dev/null @@ -1,385 +0,0 @@ -// Boost string_algo library trim.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// See http://www.boost.org for updates, documentation, and revision history. - -#ifndef BOOST_STRING_TRIM_HPP -#define BOOST_STRING_TRIM_HPP - -#include -#include -#include -#include -#include - -/*! \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 collection - \param IsSpace An 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 - inline OutputIteratorT trim_left_copy_if( - OutputIteratorT Output, - const CollectionT& Input, - PredicateT IsSpace) - { - std::copy( - detail::trim_begin( - begin(Input), - end(Input), - IsSpace ), - end(Input), - Output); - - return Output; - } - - //! Left trim - parametric - /*! - \overload - */ - template - inline SequenceT trim_left_copy_if(const SequenceT& Input, PredicateT IsSpace) - { - return SequenceT( - detail::trim_begin( - begin(Input), - end(Input), - IsSpace ), - 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 - inline SequenceT trim_left_copy(const SequenceT& Input, const std::locale& Loc=std::locale()) - { - return - 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 An unary predicate identifying spaces - */ - template - inline void trim_left_if(SequenceT& Input, PredicateT IsSpace) - { - Input.erase( - begin(Input), - detail::trim_begin( - begin(Input), - 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 - inline void trim_left(SequenceT& Input, const std::locale& Loc=std::locale()) - { - 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 collection - \param IsSpace An 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 - inline OutputIteratorT trim_right_copy_if( - OutputIteratorT Output, - const CollectionT& Input, - PredicateT IsSpace ) - { - std::copy( - begin(Input), - detail::trim_end( - begin(Input), - end(Input), - IsSpace ), - Output ); - - return Output; - } - - //! Right trim - parametric - /*! - \overload - */ - template - inline SequenceT trim_right_copy_if(const SequenceT& Input, PredicateT IsSpace) - { - return SequenceT( - begin(Input), - detail::trim_end( - begin(Input), - 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 - inline SequenceT trim_right_copy(const SequenceT& Input, const std::locale& Loc=std::locale()) - { - return - 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 An unary predicate identifying spaces - */ - template - inline void trim_right_if(SequenceT& Input, PredicateT IsSpace) - { - Input.erase( - detail::trim_end( - begin(Input), - end(Input), - IsSpace ), - 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 - inline void trim_right(SequenceT& Input, const std::locale& Loc=std::locale()) - { - 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 collection - \param IsSpace An 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 - inline OutputIteratorT trim_copy_if( - OutputIteratorT Output, - const CollectionT& Input, - PredicateT IsSpace) - { - BOOST_STRING_TYPENAME - const_iterator_of::type TrimEnd= - detail::trim_end( - begin(Input), - end(Input), - IsSpace); - - std::copy( - detail::trim_begin( - begin(Input), TrimEnd, IsSpace), - TrimEnd, - Output - ); - - return Output; - } - - //! Trim - parametric - /*! - \overload - */ - template - inline SequenceT trim_copy_if(const SequenceT& Input, PredicateT IsSpace) - { - BOOST_STRING_TYPENAME - const_iterator_of::type TrimEnd= - detail::trim_end( - begin(Input), - end(Input), - IsSpace); - - return SequenceT( - detail::trim_begin( - 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 - inline SequenceT trim_copy( const SequenceT& Input, const std::locale& Loc=std::locale() ) - { - return - 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 An unary predicate identifying spaces - */ - template - inline void trim_if(SequenceT& Input, PredicateT IsSpace) - { - trim_right_if( Input, IsSpace ); - 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 - inline void trim(SequenceT& Input, const std::locale& Loc=std::locale()) - { - 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 diff --git a/include/boost/algorithm/string/yes_no_type.hpp b/include/boost/algorithm/string/yes_no_type.hpp deleted file mode 100644 index dc3da7a..0000000 --- a/include/boost/algorithm/string/yes_no_type.hpp +++ /dev/null @@ -1,32 +0,0 @@ -// Boost string_algo library yes_no_type.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2003. 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) - -// 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 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 diff --git a/include/boost/algorithm/string_regex.hpp b/include/boost/algorithm/string_regex.hpp deleted file mode 100644 index c91b3a7..0000000 --- a/include/boost/algorithm/string_regex.hpp +++ /dev/null @@ -1,22 +0,0 @@ -// Boost string_algo library string_regex.hpp header file ---------------------------// - -// Copyright Pavol Droba 2002-2004. 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) - -// 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 addtion to string.hpp contains also regex-related stuff. -*/ - -#include -#include -#include - -#endif // BOOST_STRING_ALGO_REGEX_HPP