diff options
Diffstat (limited to 'contrib/src/boost/algorithm/string')
38 files changed, 8305 insertions, 8303 deletions
diff --git a/contrib/src/boost/algorithm/string/case_conv.hpp b/contrib/src/boost/algorithm/string/case_conv.hpp index 40543d0..683340b 100644 --- a/contrib/src/boost/algorithm/string/case_conv.hpp +++ b/contrib/src/boost/algorithm/string/case_conv.hpp @@ -1,176 +1,176 @@ -// Boost string_algo library case_conv.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_CASE_CONV_HPP
-#define BOOST_STRING_CASE_CONV_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <algorithm>
-#include <locale>
-#include <boost/iterator/transform_iterator.hpp>
-
-#include <boost/range/as_literal.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/range/value_type.hpp>
-
-#include <boost/algorithm/string/detail/case_conv.hpp>
-
-/*! \file
- Defines sequence case-conversion algorithms.
- Algorithms convert each element in the input sequence to the
- desired case using provided locales.
-*/
-
-namespace boost {
- namespace algorithm {
-
-// to_lower -----------------------------------------------//
-
- //! Convert to lower case
- /*!
- Each element of the input sequence is converted to lower
- case. The result is a copy of the input converted to lower case.
- It is returned as a sequence or copied to the output iterator.
-
- \param Output An output iterator to which the result will be copied
- \param Input An input range
- \param Loc A locale used for conversion
- \return
- An output iterator pointing just after the last inserted character or
- a copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
-
- */
- template<typename OutputIteratorT, typename RangeT>
- inline OutputIteratorT
- to_lower_copy(
- OutputIteratorT Output,
- const RangeT& Input,
- const std::locale& Loc=std::locale())
- {
- return ::boost::algorithm::detail::transform_range_copy(
- Output,
- ::boost::as_literal(Input),
- ::boost::algorithm::detail::to_lowerF<
- typename range_value<RangeT>::type >(Loc));
- }
-
- //! Convert to lower case
- /*!
- \overload
- */
- template<typename SequenceT>
- inline SequenceT to_lower_copy(
- const SequenceT& Input,
- const std::locale& Loc=std::locale())
- {
- return ::boost::algorithm::detail::transform_range_copy<SequenceT>(
- Input,
- ::boost::algorithm::detail::to_lowerF<
- typename range_value<SequenceT>::type >(Loc));
- }
-
- //! Convert to lower case
- /*!
- Each element of the input sequence is converted to lower
- case. The input sequence is modified in-place.
-
- \param Input A range
- \param Loc a locale used for conversion
- */
- template<typename WritableRangeT>
- inline void to_lower(
- WritableRangeT& Input,
- const std::locale& Loc=std::locale())
- {
- ::boost::algorithm::detail::transform_range(
- ::boost::as_literal(Input),
- ::boost::algorithm::detail::to_lowerF<
- typename range_value<WritableRangeT>::type >(Loc));
- }
-
-// to_upper -----------------------------------------------//
-
- //! Convert to upper case
- /*!
- Each element of the input sequence is converted to upper
- case. The result is a copy of the input converted to upper case.
- It is returned as a sequence or copied to the output iterator
-
- \param Output An output iterator to which the result will be copied
- \param Input An input range
- \param Loc A locale used for conversion
- \return
- An output iterator pointing just after the last inserted character or
- a copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<typename OutputIteratorT, typename RangeT>
- inline OutputIteratorT
- to_upper_copy(
- OutputIteratorT Output,
- const RangeT& Input,
- const std::locale& Loc=std::locale())
- {
- return ::boost::algorithm::detail::transform_range_copy(
- Output,
- ::boost::as_literal(Input),
- ::boost::algorithm::detail::to_upperF<
- typename range_value<RangeT>::type >(Loc));
- }
-
- //! Convert to upper case
- /*!
- \overload
- */
- template<typename SequenceT>
- inline SequenceT to_upper_copy(
- const SequenceT& Input,
- const std::locale& Loc=std::locale())
- {
- return ::boost::algorithm::detail::transform_range_copy<SequenceT>(
- Input,
- ::boost::algorithm::detail::to_upperF<
- typename range_value<SequenceT>::type >(Loc));
- }
-
- //! Convert to upper case
- /*!
- Each element of the input sequence is converted to upper
- case. The input sequence is modified in-place.
-
- \param Input An input range
- \param Loc a locale used for conversion
- */
- template<typename WritableRangeT>
- inline void to_upper(
- WritableRangeT& Input,
- const std::locale& Loc=std::locale())
- {
- ::boost::algorithm::detail::transform_range(
- ::boost::as_literal(Input),
- ::boost::algorithm::detail::to_upperF<
- typename range_value<WritableRangeT>::type >(Loc));
- }
-
- } // namespace algorithm
-
- // pull names to the boost namespace
- using algorithm::to_lower;
- using algorithm::to_lower_copy;
- using algorithm::to_upper;
- using algorithm::to_upper_copy;
-
-} // namespace boost
-
-#endif // BOOST_STRING_CASE_CONV_HPP
+// Boost string_algo library case_conv.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_CASE_CONV_HPP +#define BOOST_STRING_CASE_CONV_HPP + +#include <boost/algorithm/string/config.hpp> +#include <algorithm> +#include <locale> +#include <boost/iterator/transform_iterator.hpp> + +#include <boost/range/as_literal.hpp> +#include <boost/range/begin.hpp> +#include <boost/range/end.hpp> +#include <boost/range/value_type.hpp> + +#include <boost/algorithm/string/detail/case_conv.hpp> + +/*! \file + Defines sequence case-conversion algorithms. + Algorithms convert each element in the input sequence to the + desired case using provided locales. +*/ + +namespace boost { + namespace algorithm { + +// to_lower -----------------------------------------------// + + //! Convert to lower case + /*! + Each element of the input sequence is converted to lower + case. The result is a copy of the input converted to lower case. + It is returned as a sequence or copied to the output iterator. + + \param Output An output iterator to which the result will be copied + \param Input An input range + \param Loc A locale used for conversion + \return + An output iterator pointing just after the last inserted character or + a copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + + */ + template<typename OutputIteratorT, typename RangeT> + inline OutputIteratorT + to_lower_copy( + OutputIteratorT Output, + const RangeT& Input, + const std::locale& Loc=std::locale()) + { + return ::boost::algorithm::detail::transform_range_copy( + Output, + ::boost::as_literal(Input), + ::boost::algorithm::detail::to_lowerF< + typename range_value<RangeT>::type >(Loc)); + } + + //! Convert to lower case + /*! + \overload + */ + template<typename SequenceT> + inline SequenceT to_lower_copy( + const SequenceT& Input, + const std::locale& Loc=std::locale()) + { + return ::boost::algorithm::detail::transform_range_copy<SequenceT>( + Input, + ::boost::algorithm::detail::to_lowerF< + typename range_value<SequenceT>::type >(Loc)); + } + + //! Convert to lower case + /*! + Each element of the input sequence is converted to lower + case. The input sequence is modified in-place. + + \param Input A range + \param Loc a locale used for conversion + */ + template<typename WritableRangeT> + inline void to_lower( + WritableRangeT& Input, + const std::locale& Loc=std::locale()) + { + ::boost::algorithm::detail::transform_range( + ::boost::as_literal(Input), + ::boost::algorithm::detail::to_lowerF< + typename range_value<WritableRangeT>::type >(Loc)); + } + +// to_upper -----------------------------------------------// + + //! Convert to upper case + /*! + Each element of the input sequence is converted to upper + case. The result is a copy of the input converted to upper case. + It is returned as a sequence or copied to the output iterator + + \param Output An output iterator to which the result will be copied + \param Input An input range + \param Loc A locale used for conversion + \return + An output iterator pointing just after the last inserted character or + a copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template<typename OutputIteratorT, typename RangeT> + inline OutputIteratorT + to_upper_copy( + OutputIteratorT Output, + const RangeT& Input, + const std::locale& Loc=std::locale()) + { + return ::boost::algorithm::detail::transform_range_copy( + Output, + ::boost::as_literal(Input), + ::boost::algorithm::detail::to_upperF< + typename range_value<RangeT>::type >(Loc)); + } + + //! Convert to upper case + /*! + \overload + */ + template<typename SequenceT> + inline SequenceT to_upper_copy( + const SequenceT& Input, + const std::locale& Loc=std::locale()) + { + return ::boost::algorithm::detail::transform_range_copy<SequenceT>( + Input, + ::boost::algorithm::detail::to_upperF< + typename range_value<SequenceT>::type >(Loc)); + } + + //! Convert to upper case + /*! + Each element of the input sequence is converted to upper + case. The input sequence is modified in-place. + + \param Input An input range + \param Loc a locale used for conversion + */ + template<typename WritableRangeT> + inline void to_upper( + WritableRangeT& Input, + const std::locale& Loc=std::locale()) + { + ::boost::algorithm::detail::transform_range( + ::boost::as_literal(Input), + ::boost::algorithm::detail::to_upperF< + typename range_value<WritableRangeT>::type >(Loc)); + } + + } // namespace algorithm + + // pull names to the boost namespace + using algorithm::to_lower; + using algorithm::to_lower_copy; + using algorithm::to_upper; + using algorithm::to_upper_copy; + +} // namespace boost + +#endif // BOOST_STRING_CASE_CONV_HPP diff --git a/contrib/src/boost/algorithm/string/classification.hpp b/contrib/src/boost/algorithm/string/classification.hpp index e868b88..ca43602 100644 --- a/contrib/src/boost/algorithm/string/classification.hpp +++ b/contrib/src/boost/algorithm/string/classification.hpp @@ -1,312 +1,312 @@ -// Boost string_algo library classification.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_CLASSIFICATION_HPP
-#define BOOST_STRING_CLASSIFICATION_HPP
-
-#include <algorithm>
-#include <locale>
-#include <boost/range/value_type.hpp>
-#include <boost/range/as_literal.hpp>
-#include <boost/algorithm/string/detail/classification.hpp>
-#include <boost/algorithm/string/predicate_facade.hpp>
-
-
-/*! \file
- Classification predicates are included in the library to give
- some more convenience when using algorithms like \c trim() and \c all().
- They wrap functionality of STL classification functions ( e.g. \c std::isspace() )
- into generic functors.
-*/
-
-namespace boost {
- namespace algorithm {
-
-// classification functor generator -------------------------------------//
-
- //! is_classified predicate
- /*!
- Construct the \c is_classified predicate. This predicate holds if the input is
- of specified \c std::ctype category.
-
- \param Type A \c std::ctype category
- \param Loc A locale used for classification
- \return An instance of the \c is_classified predicate
- */
- inline detail::is_classifiedF
- is_classified(std::ctype_base::mask Type, const std::locale& Loc=std::locale())
- {
- return detail::is_classifiedF(Type, Loc);
- }
-
- //! is_space predicate
- /*!
- Construct the \c is_classified predicate for the \c ctype_base::space category.
-
- \param Loc A locale used for classification
- \return An instance of the \c is_classified predicate
- */
- inline detail::is_classifiedF
- is_space(const std::locale& Loc=std::locale())
- {
- return detail::is_classifiedF(std::ctype_base::space, Loc);
- }
-
- //! is_alnum predicate
- /*!
- Construct the \c is_classified predicate for the \c ctype_base::alnum category.
-
- \param Loc A locale used for classification
- \return An instance of the \c is_classified predicate
- */
- inline detail::is_classifiedF
- is_alnum(const std::locale& Loc=std::locale())
- {
- return detail::is_classifiedF(std::ctype_base::alnum, Loc);
- }
-
- //! is_alpha predicate
- /*!
- Construct the \c is_classified predicate for the \c ctype_base::alpha category.
-
- \param Loc A locale used for classification
- \return An instance of the \c is_classified predicate
- */
- inline detail::is_classifiedF
- is_alpha(const std::locale& Loc=std::locale())
- {
- return detail::is_classifiedF(std::ctype_base::alpha, Loc);
- }
-
- //! is_cntrl predicate
- /*!
- Construct the \c is_classified predicate for the \c ctype_base::cntrl category.
-
- \param Loc A locale used for classification
- \return An instance of the \c is_classified predicate
- */
- inline detail::is_classifiedF
- is_cntrl(const std::locale& Loc=std::locale())
- {
- return detail::is_classifiedF(std::ctype_base::cntrl, Loc);
- }
-
- //! is_digit predicate
- /*!
- Construct the \c is_classified predicate for the \c ctype_base::digit category.
-
- \param Loc A locale used for classification
- \return An instance of the \c is_classified predicate
- */
- inline detail::is_classifiedF
- is_digit(const std::locale& Loc=std::locale())
- {
- return detail::is_classifiedF(std::ctype_base::digit, Loc);
- }
-
- //! is_graph predicate
- /*!
- Construct the \c is_classified predicate for the \c ctype_base::graph category.
-
- \param Loc A locale used for classification
- \return An instance of the \c is_classified predicate
- */
- inline detail::is_classifiedF
- is_graph(const std::locale& Loc=std::locale())
- {
- return detail::is_classifiedF(std::ctype_base::graph, Loc);
- }
-
- //! is_lower predicate
- /*!
- Construct the \c is_classified predicate for the \c ctype_base::lower category.
-
- \param Loc A locale used for classification
- \return An instance of \c is_classified predicate
- */
- inline detail::is_classifiedF
- is_lower(const std::locale& Loc=std::locale())
- {
- return detail::is_classifiedF(std::ctype_base::lower, Loc);
- }
-
- //! is_print predicate
- /*!
- Construct the \c is_classified predicate for the \c ctype_base::print category.
-
- \param Loc A locale used for classification
- \return An instance of the \c is_classified predicate
- */
- inline detail::is_classifiedF
- is_print(const std::locale& Loc=std::locale())
- {
- return detail::is_classifiedF(std::ctype_base::print, Loc);
- }
-
- //! is_punct predicate
- /*!
- Construct the \c is_classified predicate for the \c ctype_base::punct category.
-
- \param Loc A locale used for classification
- \return An instance of the \c is_classified predicate
- */
- inline detail::is_classifiedF
- is_punct(const std::locale& Loc=std::locale())
- {
- return detail::is_classifiedF(std::ctype_base::punct, Loc);
- }
-
- //! is_upper predicate
- /*!
- Construct the \c is_classified predicate for the \c ctype_base::upper category.
-
- \param Loc A locale used for classification
- \return An instance of the \c is_classified predicate
- */
- inline detail::is_classifiedF
- is_upper(const std::locale& Loc=std::locale())
- {
- return detail::is_classifiedF(std::ctype_base::upper, Loc);
- }
-
- //! is_xdigit predicate
- /*!
- Construct the \c is_classified predicate for the \c ctype_base::xdigit category.
-
- \param Loc A locale used for classification
- \return An instance of the \c is_classified predicate
- */
- inline detail::is_classifiedF
- is_xdigit(const std::locale& Loc=std::locale())
- {
- return detail::is_classifiedF(std::ctype_base::xdigit, Loc);
- }
-
- //! is_any_of predicate
- /*!
- Construct the \c is_any_of predicate. The predicate holds if the input
- is included in the specified set of characters.
-
- \param Set A set of characters to be recognized
- \return An instance of the \c is_any_of predicate
- */
- template<typename RangeT>
- inline detail::is_any_ofF<
- BOOST_STRING_TYPENAME range_value<RangeT>::type>
- is_any_of( const RangeT& Set )
- {
- iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_set(boost::as_literal(Set));
- return detail::is_any_ofF<BOOST_STRING_TYPENAME range_value<RangeT>::type>(lit_set);
- }
-
- //! is_from_range predicate
- /*!
- Construct the \c is_from_range predicate. The predicate holds if the input
- is included in the specified range. (i.e. From <= Ch <= To )
-
- \param From The start of the range
- \param To The end of the range
- \return An instance of the \c is_from_range predicate
- */
- template<typename CharT>
- inline detail::is_from_rangeF<CharT> is_from_range(CharT From, CharT To)
- {
- return detail::is_from_rangeF<CharT>(From,To);
- }
-
- // predicate combinators ---------------------------------------------------//
-
- //! predicate 'and' composition predicate
- /*!
- Construct the \c class_and predicate. This predicate can be used
- to logically combine two classification predicates. \c class_and holds,
- if both predicates return true.
-
- \param Pred1 The first predicate
- \param Pred2 The second predicate
- \return An instance of the \c class_and predicate
- */
- template<typename Pred1T, typename Pred2T>
- inline detail::pred_andF<Pred1T, Pred2T>
- operator&&(
- const predicate_facade<Pred1T>& Pred1,
- const predicate_facade<Pred2T>& Pred2 )
- {
- // Doing the static_cast with the pointer instead of the reference
- // is a workaround for some compilers which have problems with
- // static_cast's of template references, i.e. CW8. /grafik/
- return detail::pred_andF<Pred1T,Pred2T>(
- *static_cast<const Pred1T*>(&Pred1),
- *static_cast<const Pred2T*>(&Pred2) );
- }
-
- //! predicate 'or' composition predicate
- /*!
- Construct the \c class_or predicate. This predicate can be used
- to logically combine two classification predicates. \c class_or holds,
- if one of the predicates return true.
-
- \param Pred1 The first predicate
- \param Pred2 The second predicate
- \return An instance of the \c class_or predicate
- */
- template<typename Pred1T, typename Pred2T>
- inline detail::pred_orF<Pred1T, Pred2T>
- operator||(
- const predicate_facade<Pred1T>& Pred1,
- const predicate_facade<Pred2T>& Pred2 )
- {
- // Doing the static_cast with the pointer instead of the reference
- // is a workaround for some compilers which have problems with
- // static_cast's of template references, i.e. CW8. /grafik/
- return detail::pred_orF<Pred1T,Pred2T>(
- *static_cast<const Pred1T*>(&Pred1),
- *static_cast<const Pred2T*>(&Pred2));
- }
-
- //! predicate negation operator
- /*!
- Construct the \c class_not predicate. This predicate represents a negation.
- \c class_or holds if of the predicates return false.
-
- \param Pred The predicate to be negated
- \return An instance of the \c class_not predicate
- */
- template<typename PredT>
- inline detail::pred_notF<PredT>
- operator!( const predicate_facade<PredT>& Pred )
- {
- // Doing the static_cast with the pointer instead of the reference
- // is a workaround for some compilers which have problems with
- // static_cast's of template references, i.e. CW8. /grafik/
- return detail::pred_notF<PredT>(*static_cast<const PredT*>(&Pred));
- }
-
- } // namespace algorithm
-
- // pull names to the boost namespace
- using algorithm::is_classified;
- using algorithm::is_space;
- using algorithm::is_alnum;
- using algorithm::is_alpha;
- using algorithm::is_cntrl;
- using algorithm::is_digit;
- using algorithm::is_graph;
- using algorithm::is_lower;
- using algorithm::is_upper;
- using algorithm::is_print;
- using algorithm::is_punct;
- using algorithm::is_xdigit;
- using algorithm::is_any_of;
- using algorithm::is_from_range;
-
-} // namespace boost
-
-#endif // BOOST_STRING_PREDICATE_HPP
+// Boost string_algo library classification.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_CLASSIFICATION_HPP +#define BOOST_STRING_CLASSIFICATION_HPP + +#include <algorithm> +#include <locale> +#include <boost/range/value_type.hpp> +#include <boost/range/as_literal.hpp> +#include <boost/algorithm/string/detail/classification.hpp> +#include <boost/algorithm/string/predicate_facade.hpp> + + +/*! \file + Classification predicates are included in the library to give + some more convenience when using algorithms like \c trim() and \c all(). + They wrap functionality of STL classification functions ( e.g. \c std::isspace() ) + into generic functors. +*/ + +namespace boost { + namespace algorithm { + +// classification functor generator -------------------------------------// + + //! is_classified predicate + /*! + Construct the \c is_classified predicate. This predicate holds if the input is + of specified \c std::ctype category. + + \param Type A \c std::ctype category + \param Loc A locale used for classification + \return An instance of the \c is_classified predicate + */ + inline detail::is_classifiedF + is_classified(std::ctype_base::mask Type, const std::locale& Loc=std::locale()) + { + return detail::is_classifiedF(Type, Loc); + } + + //! is_space predicate + /*! + Construct the \c is_classified predicate for the \c ctype_base::space category. + + \param Loc A locale used for classification + \return An instance of the \c is_classified predicate + */ + inline detail::is_classifiedF + is_space(const std::locale& Loc=std::locale()) + { + return detail::is_classifiedF(std::ctype_base::space, Loc); + } + + //! is_alnum predicate + /*! + Construct the \c is_classified predicate for the \c ctype_base::alnum category. + + \param Loc A locale used for classification + \return An instance of the \c is_classified predicate + */ + inline detail::is_classifiedF + is_alnum(const std::locale& Loc=std::locale()) + { + return detail::is_classifiedF(std::ctype_base::alnum, Loc); + } + + //! is_alpha predicate + /*! + Construct the \c is_classified predicate for the \c ctype_base::alpha category. + + \param Loc A locale used for classification + \return An instance of the \c is_classified predicate + */ + inline detail::is_classifiedF + is_alpha(const std::locale& Loc=std::locale()) + { + return detail::is_classifiedF(std::ctype_base::alpha, Loc); + } + + //! is_cntrl predicate + /*! + Construct the \c is_classified predicate for the \c ctype_base::cntrl category. + + \param Loc A locale used for classification + \return An instance of the \c is_classified predicate + */ + inline detail::is_classifiedF + is_cntrl(const std::locale& Loc=std::locale()) + { + return detail::is_classifiedF(std::ctype_base::cntrl, Loc); + } + + //! is_digit predicate + /*! + Construct the \c is_classified predicate for the \c ctype_base::digit category. + + \param Loc A locale used for classification + \return An instance of the \c is_classified predicate + */ + inline detail::is_classifiedF + is_digit(const std::locale& Loc=std::locale()) + { + return detail::is_classifiedF(std::ctype_base::digit, Loc); + } + + //! is_graph predicate + /*! + Construct the \c is_classified predicate for the \c ctype_base::graph category. + + \param Loc A locale used for classification + \return An instance of the \c is_classified predicate + */ + inline detail::is_classifiedF + is_graph(const std::locale& Loc=std::locale()) + { + return detail::is_classifiedF(std::ctype_base::graph, Loc); + } + + //! is_lower predicate + /*! + Construct the \c is_classified predicate for the \c ctype_base::lower category. + + \param Loc A locale used for classification + \return An instance of \c is_classified predicate + */ + inline detail::is_classifiedF + is_lower(const std::locale& Loc=std::locale()) + { + return detail::is_classifiedF(std::ctype_base::lower, Loc); + } + + //! is_print predicate + /*! + Construct the \c is_classified predicate for the \c ctype_base::print category. + + \param Loc A locale used for classification + \return An instance of the \c is_classified predicate + */ + inline detail::is_classifiedF + is_print(const std::locale& Loc=std::locale()) + { + return detail::is_classifiedF(std::ctype_base::print, Loc); + } + + //! is_punct predicate + /*! + Construct the \c is_classified predicate for the \c ctype_base::punct category. + + \param Loc A locale used for classification + \return An instance of the \c is_classified predicate + */ + inline detail::is_classifiedF + is_punct(const std::locale& Loc=std::locale()) + { + return detail::is_classifiedF(std::ctype_base::punct, Loc); + } + + //! is_upper predicate + /*! + Construct the \c is_classified predicate for the \c ctype_base::upper category. + + \param Loc A locale used for classification + \return An instance of the \c is_classified predicate + */ + inline detail::is_classifiedF + is_upper(const std::locale& Loc=std::locale()) + { + return detail::is_classifiedF(std::ctype_base::upper, Loc); + } + + //! is_xdigit predicate + /*! + Construct the \c is_classified predicate for the \c ctype_base::xdigit category. + + \param Loc A locale used for classification + \return An instance of the \c is_classified predicate + */ + inline detail::is_classifiedF + is_xdigit(const std::locale& Loc=std::locale()) + { + return detail::is_classifiedF(std::ctype_base::xdigit, Loc); + } + + //! is_any_of predicate + /*! + Construct the \c is_any_of predicate. The predicate holds if the input + is included in the specified set of characters. + + \param Set A set of characters to be recognized + \return An instance of the \c is_any_of predicate + */ + template<typename RangeT> + inline detail::is_any_ofF< + BOOST_STRING_TYPENAME range_value<RangeT>::type> + is_any_of( const RangeT& Set ) + { + iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_set(boost::as_literal(Set)); + return detail::is_any_ofF<BOOST_STRING_TYPENAME range_value<RangeT>::type>(lit_set); + } + + //! is_from_range predicate + /*! + Construct the \c is_from_range predicate. The predicate holds if the input + is included in the specified range. (i.e. From <= Ch <= To ) + + \param From The start of the range + \param To The end of the range + \return An instance of the \c is_from_range predicate + */ + template<typename CharT> + inline detail::is_from_rangeF<CharT> is_from_range(CharT From, CharT To) + { + return detail::is_from_rangeF<CharT>(From,To); + } + + // predicate combinators ---------------------------------------------------// + + //! predicate 'and' composition predicate + /*! + Construct the \c class_and predicate. This predicate can be used + to logically combine two classification predicates. \c class_and holds, + if both predicates return true. + + \param Pred1 The first predicate + \param Pred2 The second predicate + \return An instance of the \c class_and predicate + */ + template<typename Pred1T, typename Pred2T> + inline detail::pred_andF<Pred1T, Pred2T> + operator&&( + const predicate_facade<Pred1T>& Pred1, + const predicate_facade<Pred2T>& Pred2 ) + { + // Doing the static_cast with the pointer instead of the reference + // is a workaround for some compilers which have problems with + // static_cast's of template references, i.e. CW8. /grafik/ + return detail::pred_andF<Pred1T,Pred2T>( + *static_cast<const Pred1T*>(&Pred1), + *static_cast<const Pred2T*>(&Pred2) ); + } + + //! predicate 'or' composition predicate + /*! + Construct the \c class_or predicate. This predicate can be used + to logically combine two classification predicates. \c class_or holds, + if one of the predicates return true. + + \param Pred1 The first predicate + \param Pred2 The second predicate + \return An instance of the \c class_or predicate + */ + template<typename Pred1T, typename Pred2T> + inline detail::pred_orF<Pred1T, Pred2T> + operator||( + const predicate_facade<Pred1T>& Pred1, + const predicate_facade<Pred2T>& Pred2 ) + { + // Doing the static_cast with the pointer instead of the reference + // is a workaround for some compilers which have problems with + // static_cast's of template references, i.e. CW8. /grafik/ + return detail::pred_orF<Pred1T,Pred2T>( + *static_cast<const Pred1T*>(&Pred1), + *static_cast<const Pred2T*>(&Pred2)); + } + + //! predicate negation operator + /*! + Construct the \c class_not predicate. This predicate represents a negation. + \c class_or holds if of the predicates return false. + + \param Pred The predicate to be negated + \return An instance of the \c class_not predicate + */ + template<typename PredT> + inline detail::pred_notF<PredT> + operator!( const predicate_facade<PredT>& Pred ) + { + // Doing the static_cast with the pointer instead of the reference + // is a workaround for some compilers which have problems with + // static_cast's of template references, i.e. CW8. /grafik/ + return detail::pred_notF<PredT>(*static_cast<const PredT*>(&Pred)); + } + + } // namespace algorithm + + // pull names to the boost namespace + using algorithm::is_classified; + using algorithm::is_space; + using algorithm::is_alnum; + using algorithm::is_alpha; + using algorithm::is_cntrl; + using algorithm::is_digit; + using algorithm::is_graph; + using algorithm::is_lower; + using algorithm::is_upper; + using algorithm::is_print; + using algorithm::is_punct; + using algorithm::is_xdigit; + using algorithm::is_any_of; + using algorithm::is_from_range; + +} // namespace boost + +#endif // BOOST_STRING_PREDICATE_HPP diff --git a/contrib/src/boost/algorithm/string/compare.hpp b/contrib/src/boost/algorithm/string/compare.hpp index f610b36..734303a 100644 --- a/contrib/src/boost/algorithm/string/compare.hpp +++ b/contrib/src/boost/algorithm/string/compare.hpp @@ -1,199 +1,199 @@ -// Boost string_algo library compare.hpp header file -------------------------//
-
-// Copyright Pavol Droba 2002-2006.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_COMPARE_HPP
-#define BOOST_STRING_COMPARE_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <locale>
-
-/*! \file
- Defines element comparison predicates. Many algorithms in this library can
- take an additional argument with a predicate used to compare elements.
- This makes it possible, for instance, to have case insensitive versions
- of the algorithms.
-*/
-
-namespace boost {
- namespace algorithm {
-
- // is_equal functor -----------------------------------------------//
-
- //! is_equal functor
- /*!
- Standard STL equal_to only handle comparison between arguments
- of the same type. This is a less restrictive version which wraps operator ==.
- */
- struct is_equal
- {
- //! Function operator
- /*!
- Compare two operands for equality
- */
- template< typename T1, typename T2 >
- bool operator()( const T1& Arg1, const T2& Arg2 ) const
- {
- return Arg1==Arg2;
- }
- };
-
- //! case insensitive version of is_equal
- /*!
- Case insensitive comparison predicate. Comparison is done using
- specified locales.
- */
- struct is_iequal
- {
- //! Constructor
- /*!
- \param Loc locales used for comparison
- */
- is_iequal( const std::locale& Loc=std::locale() ) :
- m_Loc( Loc ) {}
-
- //! Function operator
- /*!
- Compare two operands. Case is ignored.
- */
- template< typename T1, typename T2 >
- bool operator()( const T1& Arg1, const T2& Arg2 ) const
- {
- #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
- return std::toupper(Arg1)==std::toupper(Arg2);
- #else
- return std::toupper<T1>(Arg1,m_Loc)==std::toupper<T2>(Arg2,m_Loc);
- #endif
- }
-
- private:
- std::locale m_Loc;
- };
-
- // is_less functor -----------------------------------------------//
-
- //! is_less functor
- /*!
- Convenient version of standard std::less. Operation is templated, therefore it is
- not required to specify the exact types upon the construction
- */
- struct is_less
- {
- //! Functor operation
- /*!
- Compare two operands using > operator
- */
- template< typename T1, typename T2 >
- bool operator()( const T1& Arg1, const T2& Arg2 ) const
- {
- return Arg1<Arg2;
- }
- };
-
-
- //! case insensitive version of is_less
- /*!
- Case insensitive comparison predicate. Comparison is done using
- specified locales.
- */
- struct is_iless
- {
- //! Constructor
- /*!
- \param Loc locales used for comparison
- */
- is_iless( const std::locale& Loc=std::locale() ) :
- m_Loc( Loc ) {}
-
- //! Function operator
- /*!
- Compare two operands. Case is ignored.
- */
- template< typename T1, typename T2 >
- bool operator()( const T1& Arg1, const T2& Arg2 ) const
- {
- #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
- return std::toupper(Arg1)<std::toupper(Arg2);
- #else
- return std::toupper<T1>(Arg1,m_Loc)<std::toupper<T2>(Arg2,m_Loc);
- #endif
- }
-
- private:
- std::locale m_Loc;
- };
-
- // is_not_greater functor -----------------------------------------------//
-
- //! is_not_greater functor
- /*!
- Convenient version of standard std::not_greater_to. Operation is templated, therefore it is
- not required to specify the exact types upon the construction
- */
- struct is_not_greater
- {
- //! Functor operation
- /*!
- Compare two operands using > operator
- */
- template< typename T1, typename T2 >
- bool operator()( const T1& Arg1, const T2& Arg2 ) const
- {
- return Arg1<=Arg2;
- }
- };
-
-
- //! case insensitive version of is_not_greater
- /*!
- Case insensitive comparison predicate. Comparison is done using
- specified locales.
- */
- struct is_not_igreater
- {
- //! Constructor
- /*!
- \param Loc locales used for comparison
- */
- is_not_igreater( const std::locale& Loc=std::locale() ) :
- m_Loc( Loc ) {}
-
- //! Function operator
- /*!
- Compare two operands. Case is ignored.
- */
- template< typename T1, typename T2 >
- bool operator()( const T1& Arg1, const T2& Arg2 ) const
- {
- #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
- return std::toupper(Arg1)<=std::toupper(Arg2);
- #else
- return std::toupper<T1>(Arg1,m_Loc)<=std::toupper<T2>(Arg2,m_Loc);
- #endif
- }
-
- private:
- std::locale m_Loc;
- };
-
-
- } // namespace algorithm
-
- // pull names to the boost namespace
- using algorithm::is_equal;
- using algorithm::is_iequal;
- using algorithm::is_less;
- using algorithm::is_iless;
- using algorithm::is_not_greater;
- using algorithm::is_not_igreater;
-
-} // namespace boost
-
-
-#endif // BOOST_STRING_COMPARE_HPP
+// Boost string_algo library compare.hpp header file -------------------------// + +// Copyright Pavol Droba 2002-2006. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_COMPARE_HPP +#define BOOST_STRING_COMPARE_HPP + +#include <boost/algorithm/string/config.hpp> +#include <locale> + +/*! \file + Defines element comparison predicates. Many algorithms in this library can + take an additional argument with a predicate used to compare elements. + This makes it possible, for instance, to have case insensitive versions + of the algorithms. +*/ + +namespace boost { + namespace algorithm { + + // is_equal functor -----------------------------------------------// + + //! is_equal functor + /*! + Standard STL equal_to only handle comparison between arguments + of the same type. This is a less restrictive version which wraps operator ==. + */ + struct is_equal + { + //! Function operator + /*! + Compare two operands for equality + */ + template< typename T1, typename T2 > + bool operator()( const T1& Arg1, const T2& Arg2 ) const + { + return Arg1==Arg2; + } + }; + + //! case insensitive version of is_equal + /*! + Case insensitive comparison predicate. Comparison is done using + specified locales. + */ + struct is_iequal + { + //! Constructor + /*! + \param Loc locales used for comparison + */ + is_iequal( const std::locale& Loc=std::locale() ) : + m_Loc( Loc ) {} + + //! Function operator + /*! + Compare two operands. Case is ignored. + */ + template< typename T1, typename T2 > + bool operator()( const T1& Arg1, const T2& Arg2 ) const + { + #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL) + return std::toupper(Arg1)==std::toupper(Arg2); + #else + return std::toupper<T1>(Arg1,m_Loc)==std::toupper<T2>(Arg2,m_Loc); + #endif + } + + private: + std::locale m_Loc; + }; + + // is_less functor -----------------------------------------------// + + //! is_less functor + /*! + Convenient version of standard std::less. Operation is templated, therefore it is + not required to specify the exact types upon the construction + */ + struct is_less + { + //! Functor operation + /*! + Compare two operands using > operator + */ + template< typename T1, typename T2 > + bool operator()( const T1& Arg1, const T2& Arg2 ) const + { + return Arg1<Arg2; + } + }; + + + //! case insensitive version of is_less + /*! + Case insensitive comparison predicate. Comparison is done using + specified locales. + */ + struct is_iless + { + //! Constructor + /*! + \param Loc locales used for comparison + */ + is_iless( const std::locale& Loc=std::locale() ) : + m_Loc( Loc ) {} + + //! Function operator + /*! + Compare two operands. Case is ignored. + */ + template< typename T1, typename T2 > + bool operator()( const T1& Arg1, const T2& Arg2 ) const + { + #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL) + return std::toupper(Arg1)<std::toupper(Arg2); + #else + return std::toupper<T1>(Arg1,m_Loc)<std::toupper<T2>(Arg2,m_Loc); + #endif + } + + private: + std::locale m_Loc; + }; + + // is_not_greater functor -----------------------------------------------// + + //! is_not_greater functor + /*! + Convenient version of standard std::not_greater_to. Operation is templated, therefore it is + not required to specify the exact types upon the construction + */ + struct is_not_greater + { + //! Functor operation + /*! + Compare two operands using > operator + */ + template< typename T1, typename T2 > + bool operator()( const T1& Arg1, const T2& Arg2 ) const + { + return Arg1<=Arg2; + } + }; + + + //! case insensitive version of is_not_greater + /*! + Case insensitive comparison predicate. Comparison is done using + specified locales. + */ + struct is_not_igreater + { + //! Constructor + /*! + \param Loc locales used for comparison + */ + is_not_igreater( const std::locale& Loc=std::locale() ) : + m_Loc( Loc ) {} + + //! Function operator + /*! + Compare two operands. Case is ignored. + */ + template< typename T1, typename T2 > + bool operator()( const T1& Arg1, const T2& Arg2 ) const + { + #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL) + return std::toupper(Arg1)<=std::toupper(Arg2); + #else + return std::toupper<T1>(Arg1,m_Loc)<=std::toupper<T2>(Arg2,m_Loc); + #endif + } + + private: + std::locale m_Loc; + }; + + + } // namespace algorithm + + // pull names to the boost namespace + using algorithm::is_equal; + using algorithm::is_iequal; + using algorithm::is_less; + using algorithm::is_iless; + using algorithm::is_not_greater; + using algorithm::is_not_igreater; + +} // namespace boost + + +#endif // BOOST_STRING_COMPARE_HPP diff --git a/contrib/src/boost/algorithm/string/concept.hpp b/contrib/src/boost/algorithm/string/concept.hpp index efc8d0f..17e8349 100644 --- a/contrib/src/boost/algorithm/string/concept.hpp +++ b/contrib/src/boost/algorithm/string/concept.hpp @@ -1,83 +1,83 @@ -// Boost string_algo library concept.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_CONCEPT_HPP
-#define BOOST_STRING_CONCEPT_HPP
-
-#include <boost/concept_check.hpp>
-#include <boost/range/iterator_range_core.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-/*! \file
- Defines concepts used in string_algo library
-*/
-
-namespace boost {
- namespace algorithm {
-
- //! Finder concept
- /*!
- Defines the Finder concept. Finder is a functor which selects
- an arbitrary part of a string. Search is performed on
- the range specified by starting and ending iterators.
-
- Result of the find operation must be convertible to iterator_range.
- */
- template<typename FinderT, typename IteratorT>
- struct FinderConcept
- {
- private:
- typedef iterator_range<IteratorT> range;
- public:
- void constraints()
- {
- // Operation
- r=(*pF)(i,i);
- }
- private:
- range r;
- IteratorT i;
- FinderT* pF;
- }; // Finder_concept
-
-
- //! Formatter concept
- /*!
- Defines the Formatter concept. Formatter is a functor, which
- takes a result from a finder operation and transforms it
- in a specific way.
-
- Result must be a container supported by container_traits,
- or a reference to it.
- */
- template<typename FormatterT, typename FinderT, typename IteratorT>
- struct FormatterConcept
- {
- public:
- void constraints()
- {
- // Operation
- ::boost::begin((*pFo)( (*pF)(i,i) ));
- ::boost::end((*pFo)( (*pF)(i,i) ));
- }
- private:
- IteratorT i;
- FinderT* pF;
- FormatterT *pFo;
- }; // FormatterConcept;
-
- } // namespace algorithm
-} // namespace boost
-
-
-
-
-#endif // BOOST_STRING_CONCEPT_HPP
+// Boost string_algo library concept.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_CONCEPT_HPP +#define BOOST_STRING_CONCEPT_HPP + +#include <boost/concept_check.hpp> +#include <boost/range/iterator_range_core.hpp> +#include <boost/range/begin.hpp> +#include <boost/range/end.hpp> + +/*! \file + Defines concepts used in string_algo library +*/ + +namespace boost { + namespace algorithm { + + //! Finder concept + /*! + Defines the Finder concept. Finder is a functor which selects + an arbitrary part of a string. Search is performed on + the range specified by starting and ending iterators. + + Result of the find operation must be convertible to iterator_range. + */ + template<typename FinderT, typename IteratorT> + struct FinderConcept + { + private: + typedef iterator_range<IteratorT> range; + public: + void constraints() + { + // Operation + r=(*pF)(i,i); + } + private: + range r; + IteratorT i; + FinderT* pF; + }; // Finder_concept + + + //! Formatter concept + /*! + Defines the Formatter concept. Formatter is a functor, which + takes a result from a finder operation and transforms it + in a specific way. + + Result must be a container supported by container_traits, + or a reference to it. + */ + template<typename FormatterT, typename FinderT, typename IteratorT> + struct FormatterConcept + { + public: + void constraints() + { + // Operation + ::boost::begin((*pFo)( (*pF)(i,i) )); + ::boost::end((*pFo)( (*pF)(i,i) )); + } + private: + IteratorT i; + FinderT* pF; + FormatterT *pFo; + }; // FormatterConcept; + + } // namespace algorithm +} // namespace boost + + + + +#endif // BOOST_STRING_CONCEPT_HPP diff --git a/contrib/src/boost/algorithm/string/config.hpp b/contrib/src/boost/algorithm/string/config.hpp index d10c6f5..559750a 100644 --- a/contrib/src/boost/algorithm/string/config.hpp +++ b/contrib/src/boost/algorithm/string/config.hpp @@ -1,28 +1,28 @@ -// Boost string_algo library config.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_CONFIG_HPP
-#define BOOST_STRING_CONFIG_HPP
-
-#include <boost/config.hpp>
-#include <boost/detail/workaround.hpp>
-
-#ifdef BOOST_STRING_DEDUCED_TYPENAME
-# error "macro already defined!"
-#endif
-
-#define BOOST_STRING_TYPENAME BOOST_DEDUCED_TYPENAME
-
-// Metrowerks workaround
-#if BOOST_WORKAROUND(__MWERKS__, <= 0x3003) // 8.x
-#pragma parse_func_templ off
-#endif
-
-#endif // BOOST_STRING_CONFIG_HPP
+// Boost string_algo library config.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_CONFIG_HPP +#define BOOST_STRING_CONFIG_HPP + +#include <boost/config.hpp> +#include <boost/detail/workaround.hpp> + +#ifdef BOOST_STRING_DEDUCED_TYPENAME +# error "macro already defined!" +#endif + +#define BOOST_STRING_TYPENAME BOOST_DEDUCED_TYPENAME + +// Metrowerks workaround +#if BOOST_WORKAROUND(__MWERKS__, <= 0x3003) // 8.x +#pragma parse_func_templ off +#endif + +#endif // BOOST_STRING_CONFIG_HPP diff --git a/contrib/src/boost/algorithm/string/constants.hpp b/contrib/src/boost/algorithm/string/constants.hpp index 9022d43..6ed70ef 100644 --- a/contrib/src/boost/algorithm/string/constants.hpp +++ b/contrib/src/boost/algorithm/string/constants.hpp @@ -1,36 +1,36 @@ -// Boost string_algo library constants.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_CONSTANTS_HPP
-#define BOOST_STRING_CONSTANTS_HPP
-
-namespace boost {
- namespace algorithm {
-
- //! Token compression mode
- /*!
- Specifies token compression mode for the token_finder.
- */
- enum token_compress_mode_type
- {
- token_compress_on, //!< Compress adjacent tokens
- token_compress_off //!< Do not compress adjacent tokens
- };
-
- } // namespace algorithm
-
- // pull the names to the boost namespace
- using algorithm::token_compress_on;
- using algorithm::token_compress_off;
-
-} // namespace boost
-
-#endif // BOOST_STRING_CONSTANTS_HPP
-
+// Boost string_algo library constants.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_CONSTANTS_HPP +#define BOOST_STRING_CONSTANTS_HPP + +namespace boost { + namespace algorithm { + + //! Token compression mode + /*! + Specifies token compression mode for the token_finder. + */ + enum token_compress_mode_type + { + token_compress_on, //!< Compress adjacent tokens + token_compress_off //!< Do not compress adjacent tokens + }; + + } // namespace algorithm + + // pull the names to the boost namespace + using algorithm::token_compress_on; + using algorithm::token_compress_off; + +} // namespace boost + +#endif // BOOST_STRING_CONSTANTS_HPP + diff --git a/contrib/src/boost/algorithm/string/detail/case_conv.hpp b/contrib/src/boost/algorithm/string/detail/case_conv.hpp index bc0891d..42621c7 100644 --- a/contrib/src/boost/algorithm/string/detail/case_conv.hpp +++ b/contrib/src/boost/algorithm/string/detail/case_conv.hpp @@ -1,123 +1,123 @@ -// Boost string_algo library string_funct.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_CASE_CONV_DETAIL_HPP
-#define BOOST_STRING_CASE_CONV_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <locale>
-#include <functional>
-
-#include <boost/type_traits/make_unsigned.hpp>
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-// case conversion functors -----------------------------------------------//
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(push)
-#pragma warning(disable:4512) //assignment operator could not be generated
-#endif
-
- // a tolower functor
- template<typename CharT>
- struct to_lowerF : public std::unary_function<CharT, CharT>
- {
- // Constructor
- to_lowerF( const std::locale& Loc ) : m_Loc( &Loc ) {}
-
- // Operation
- CharT operator ()( CharT Ch ) const
- {
- #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
- return std::tolower( static_cast<typename boost::make_unsigned <CharT>::type> ( Ch ));
- #else
- return std::tolower<CharT>( Ch, *m_Loc );
- #endif
- }
- private:
- const std::locale* m_Loc;
- };
-
- // a toupper functor
- template<typename CharT>
- struct to_upperF : public std::unary_function<CharT, CharT>
- {
- // Constructor
- to_upperF( const std::locale& Loc ) : m_Loc( &Loc ) {}
-
- // Operation
- CharT operator ()( CharT Ch ) const
- {
- #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL)
- return std::toupper( static_cast<typename boost::make_unsigned <CharT>::type> ( Ch ));
- #else
- return std::toupper<CharT>( Ch, *m_Loc );
- #endif
- }
- private:
- const std::locale* m_Loc;
- };
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(pop)
-#endif
-
-// algorithm implementation -------------------------------------------------------------------------
-
- // Transform a range
- template<typename OutputIteratorT, typename RangeT, typename FunctorT>
- OutputIteratorT transform_range_copy(
- OutputIteratorT Output,
- const RangeT& Input,
- FunctorT Functor)
- {
- return std::transform(
- ::boost::begin(Input),
- ::boost::end(Input),
- Output,
- Functor);
- }
-
- // Transform a range (in-place)
- template<typename RangeT, typename FunctorT>
- void transform_range(
- const RangeT& Input,
- FunctorT Functor)
- {
- std::transform(
- ::boost::begin(Input),
- ::boost::end(Input),
- ::boost::begin(Input),
- Functor);
- }
-
- template<typename SequenceT, typename RangeT, typename FunctorT>
- inline SequenceT transform_range_copy(
- const RangeT& Input,
- FunctorT Functor)
- {
- return SequenceT(
- ::boost::make_transform_iterator(
- ::boost::begin(Input),
- Functor),
- ::boost::make_transform_iterator(
- ::boost::end(Input),
- Functor));
- }
-
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-
-#endif // BOOST_STRING_CASE_CONV_DETAIL_HPP
+// Boost string_algo library string_funct.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_CASE_CONV_DETAIL_HPP +#define BOOST_STRING_CASE_CONV_DETAIL_HPP + +#include <boost/algorithm/string/config.hpp> +#include <locale> +#include <functional> + +#include <boost/type_traits/make_unsigned.hpp> + +namespace boost { + namespace algorithm { + namespace detail { + +// case conversion functors -----------------------------------------------// + +#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) +#pragma warning(push) +#pragma warning(disable:4512) //assignment operator could not be generated +#endif + + // a tolower functor + template<typename CharT> + struct to_lowerF : public std::unary_function<CharT, CharT> + { + // Constructor + to_lowerF( const std::locale& Loc ) : m_Loc( &Loc ) {} + + // Operation + CharT operator ()( CharT Ch ) const + { + #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL) + return std::tolower( static_cast<typename boost::make_unsigned <CharT>::type> ( Ch )); + #else + return std::tolower<CharT>( Ch, *m_Loc ); + #endif + } + private: + const std::locale* m_Loc; + }; + + // a toupper functor + template<typename CharT> + struct to_upperF : public std::unary_function<CharT, CharT> + { + // Constructor + to_upperF( const std::locale& Loc ) : m_Loc( &Loc ) {} + + // Operation + CharT operator ()( CharT Ch ) const + { + #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x564) && !defined(_USE_OLD_RW_STL) + return std::toupper( static_cast<typename boost::make_unsigned <CharT>::type> ( Ch )); + #else + return std::toupper<CharT>( Ch, *m_Loc ); + #endif + } + private: + const std::locale* m_Loc; + }; + +#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) +#pragma warning(pop) +#endif + +// algorithm implementation ------------------------------------------------------------------------- + + // Transform a range + template<typename OutputIteratorT, typename RangeT, typename FunctorT> + OutputIteratorT transform_range_copy( + OutputIteratorT Output, + const RangeT& Input, + FunctorT Functor) + { + return std::transform( + ::boost::begin(Input), + ::boost::end(Input), + Output, + Functor); + } + + // Transform a range (in-place) + template<typename RangeT, typename FunctorT> + void transform_range( + const RangeT& Input, + FunctorT Functor) + { + std::transform( + ::boost::begin(Input), + ::boost::end(Input), + ::boost::begin(Input), + Functor); + } + + template<typename SequenceT, typename RangeT, typename FunctorT> + inline SequenceT transform_range_copy( + const RangeT& Input, + FunctorT Functor) + { + return SequenceT( + ::boost::make_transform_iterator( + ::boost::begin(Input), + Functor), + ::boost::make_transform_iterator( + ::boost::end(Input), + Functor)); + } + + } // namespace detail + } // namespace algorithm +} // namespace boost + + +#endif // BOOST_STRING_CASE_CONV_DETAIL_HPP diff --git a/contrib/src/boost/algorithm/string/detail/classification.hpp b/contrib/src/boost/algorithm/string/detail/classification.hpp index 7fe9d58..704d9d2 100644 --- a/contrib/src/boost/algorithm/string/detail/classification.hpp +++ b/contrib/src/boost/algorithm/string/detail/classification.hpp @@ -1,353 +1,353 @@ -// Boost string_algo library classification.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_CLASSIFICATION_DETAIL_HPP
-#define BOOST_STRING_CLASSIFICATION_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <algorithm>
-#include <functional>
-#include <locale>
-
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-#include <boost/algorithm/string/predicate_facade.hpp>
-#include <boost/type_traits/remove_const.hpp>
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-// classification functors -----------------------------------------------//
-
- // is_classified functor
- struct is_classifiedF :
- public predicate_facade<is_classifiedF>
- {
- // Boost.ResultOf support
- typedef bool result_type;
-
- // Constructor from a locale
- is_classifiedF(std::ctype_base::mask Type, std::locale const & Loc = std::locale()) :
- m_Type(Type), m_Locale(Loc) {}
- // Operation
- template<typename CharT>
- bool operator()( CharT Ch ) const
- {
- return std::use_facet< std::ctype<CharT> >(m_Locale).is( m_Type, Ch );
- }
-
- #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x582) && !defined(_USE_OLD_RW_STL)
- template<>
- bool operator()( char const Ch ) const
- {
- return std::use_facet< std::ctype<char> >(m_Locale).is( m_Type, Ch );
- }
- #endif
-
- private:
- std::ctype_base::mask m_Type;
- std::locale m_Locale;
- };
-
-
- // is_any_of functor
- /*
- returns true if the value is from the specified set
- */
- template<typename CharT>
- struct is_any_ofF :
- public predicate_facade<is_any_ofF<CharT> >
- {
- private:
- // set cannot operate on const value-type
- typedef typename ::boost::remove_const<CharT>::type set_value_type;
-
- public:
- // Boost.ResultOf support
- typedef bool result_type;
-
- // Constructor
- template<typename RangeT>
- is_any_ofF( const RangeT& Range ) : m_Size(0)
- {
- // Prepare storage
- m_Storage.m_dynSet=0;
-
- std::size_t Size=::boost::distance(Range);
- m_Size=Size;
- set_value_type* Storage=0;
-
- if(use_fixed_storage(m_Size))
- {
- // Use fixed storage
- Storage=&m_Storage.m_fixSet[0];
- }
- else
- {
- // Use dynamic storage
- m_Storage.m_dynSet=new set_value_type[m_Size];
- Storage=m_Storage.m_dynSet;
- }
-
- // Use fixed storage
- ::std::copy(::boost::begin(Range), ::boost::end(Range), Storage);
- ::std::sort(Storage, Storage+m_Size);
- }
-
- // Copy constructor
- is_any_ofF(const is_any_ofF& Other) : m_Size(Other.m_Size)
- {
- // Prepare storage
- m_Storage.m_dynSet=0;
- const set_value_type* SrcStorage=0;
- set_value_type* DestStorage=0;
-
- if(use_fixed_storage(m_Size))
- {
- // Use fixed storage
- DestStorage=&m_Storage.m_fixSet[0];
- SrcStorage=&Other.m_Storage.m_fixSet[0];
- }
- else
- {
- // Use dynamic storage
- m_Storage.m_dynSet=new set_value_type[m_Size];
- DestStorage=m_Storage.m_dynSet;
- SrcStorage=Other.m_Storage.m_dynSet;
- }
-
- // Use fixed storage
- ::std::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size);
- }
-
- // Destructor
- ~is_any_ofF()
- {
- if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0)
- {
- delete [] m_Storage.m_dynSet;
- }
- }
-
- // Assignment
- is_any_ofF& operator=(const is_any_ofF& Other)
- {
- // Handle self assignment
- if(this==&Other) return *this;
-
- // Prepare storage
- const set_value_type* SrcStorage;
- set_value_type* DestStorage;
-
- if(use_fixed_storage(Other.m_Size))
- {
- // Use fixed storage
- DestStorage=&m_Storage.m_fixSet[0];
- SrcStorage=&Other.m_Storage.m_fixSet[0];
-
- // Delete old storage if was present
- if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0)
- {
- delete [] m_Storage.m_dynSet;
- }
-
- // Set new size
- m_Size=Other.m_Size;
- }
- else
- {
- // Other uses dynamic storage
- SrcStorage=Other.m_Storage.m_dynSet;
-
- // Check what kind of storage are we using right now
- if(use_fixed_storage(m_Size))
- {
- // Using fixed storage, allocate new
- set_value_type* pTemp=new set_value_type[Other.m_Size];
- DestStorage=pTemp;
- m_Storage.m_dynSet=pTemp;
- m_Size=Other.m_Size;
- }
- else
- {
- // Using dynamic storage, check if can reuse
- if(m_Storage.m_dynSet!=0 && m_Size>=Other.m_Size && m_Size<Other.m_Size*2)
- {
- // Reuse the current storage
- DestStorage=m_Storage.m_dynSet;
- m_Size=Other.m_Size;
- }
- else
- {
- // Allocate the new one
- set_value_type* pTemp=new set_value_type[Other.m_Size];
- DestStorage=pTemp;
-
- // Delete old storage if necessary
- if(m_Storage.m_dynSet!=0)
- {
- delete [] m_Storage.m_dynSet;
- }
- // Store the new storage
- m_Storage.m_dynSet=pTemp;
- // Set new size
- m_Size=Other.m_Size;
- }
- }
- }
-
- // Copy the data
- ::std::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size);
-
- return *this;
- }
-
- // Operation
- template<typename Char2T>
- bool operator()( Char2T Ch ) const
- {
- const set_value_type* Storage=
- (use_fixed_storage(m_Size))
- ? &m_Storage.m_fixSet[0]
- : m_Storage.m_dynSet;
-
- return ::std::binary_search(Storage, Storage+m_Size, Ch);
- }
- private:
- // check if the size is eligible for fixed storage
- static bool use_fixed_storage(std::size_t size)
- {
- return size<=sizeof(set_value_type*)*2;
- }
-
-
- private:
- // storage
- // The actual used storage is selected on the type
- union
- {
- set_value_type* m_dynSet;
- set_value_type m_fixSet[sizeof(set_value_type*)*2];
- }
- m_Storage;
-
- // storage size
- ::std::size_t m_Size;
- };
-
- // is_from_range functor
- /*
- returns true if the value is from the specified range.
- (i.e. x>=From && x>=To)
- */
- template<typename CharT>
- struct is_from_rangeF :
- public predicate_facade< is_from_rangeF<CharT> >
- {
- // Boost.ResultOf support
- typedef bool result_type;
-
- // Constructor
- is_from_rangeF( CharT From, CharT To ) : m_From(From), m_To(To) {}
-
- // Operation
- template<typename Char2T>
- bool operator()( Char2T Ch ) const
- {
- return ( m_From <= Ch ) && ( Ch <= m_To );
- }
-
- private:
- CharT m_From;
- CharT m_To;
- };
-
- // class_and composition predicate
- template<typename Pred1T, typename Pred2T>
- struct pred_andF :
- public predicate_facade< pred_andF<Pred1T,Pred2T> >
- {
- public:
-
- // Boost.ResultOf support
- typedef bool result_type;
-
- // Constructor
- pred_andF( Pred1T Pred1, Pred2T Pred2 ) :
- m_Pred1(Pred1), m_Pred2(Pred2) {}
-
- // Operation
- template<typename CharT>
- bool operator()( CharT Ch ) const
- {
- return m_Pred1(Ch) && m_Pred2(Ch);
- }
-
- private:
- Pred1T m_Pred1;
- Pred2T m_Pred2;
- };
-
- // class_or composition predicate
- template<typename Pred1T, typename Pred2T>
- struct pred_orF :
- public predicate_facade< pred_orF<Pred1T,Pred2T> >
- {
- public:
- // Boost.ResultOf support
- typedef bool result_type;
-
- // Constructor
- pred_orF( Pred1T Pred1, Pred2T Pred2 ) :
- m_Pred1(Pred1), m_Pred2(Pred2) {}
-
- // Operation
- template<typename CharT>
- bool operator()( CharT Ch ) const
- {
- return m_Pred1(Ch) || m_Pred2(Ch);
- }
-
- private:
- Pred1T m_Pred1;
- Pred2T m_Pred2;
- };
-
- // class_not composition predicate
- template< typename PredT >
- struct pred_notF :
- public predicate_facade< pred_notF<PredT> >
- {
- public:
- // Boost.ResultOf support
- typedef bool result_type;
-
- // Constructor
- pred_notF( PredT Pred ) : m_Pred(Pred) {}
-
- // Operation
- template<typename CharT>
- bool operator()( CharT Ch ) const
- {
- return !m_Pred(Ch);
- }
-
- private:
- PredT m_Pred;
- };
-
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-
-#endif // BOOST_STRING_CLASSIFICATION_DETAIL_HPP
+// Boost string_algo library classification.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_CLASSIFICATION_DETAIL_HPP +#define BOOST_STRING_CLASSIFICATION_DETAIL_HPP + +#include <boost/algorithm/string/config.hpp> +#include <algorithm> +#include <functional> +#include <locale> + +#include <boost/range/begin.hpp> +#include <boost/range/end.hpp> + +#include <boost/algorithm/string/predicate_facade.hpp> +#include <boost/type_traits/remove_const.hpp> + +namespace boost { + namespace algorithm { + namespace detail { + +// classification functors -----------------------------------------------// + + // is_classified functor + struct is_classifiedF : + public predicate_facade<is_classifiedF> + { + // Boost.ResultOf support + typedef bool result_type; + + // Constructor from a locale + is_classifiedF(std::ctype_base::mask Type, std::locale const & Loc = std::locale()) : + m_Type(Type), m_Locale(Loc) {} + // Operation + template<typename CharT> + bool operator()( CharT Ch ) const + { + return std::use_facet< std::ctype<CharT> >(m_Locale).is( m_Type, Ch ); + } + + #if defined(__BORLANDC__) && (__BORLANDC__ >= 0x560) && (__BORLANDC__ <= 0x582) && !defined(_USE_OLD_RW_STL) + template<> + bool operator()( char const Ch ) const + { + return std::use_facet< std::ctype<char> >(m_Locale).is( m_Type, Ch ); + } + #endif + + private: + std::ctype_base::mask m_Type; + std::locale m_Locale; + }; + + + // is_any_of functor + /* + returns true if the value is from the specified set + */ + template<typename CharT> + struct is_any_ofF : + public predicate_facade<is_any_ofF<CharT> > + { + private: + // set cannot operate on const value-type + typedef typename ::boost::remove_const<CharT>::type set_value_type; + + public: + // Boost.ResultOf support + typedef bool result_type; + + // Constructor + template<typename RangeT> + is_any_ofF( const RangeT& Range ) : m_Size(0) + { + // Prepare storage + m_Storage.m_dynSet=0; + + std::size_t Size=::boost::distance(Range); + m_Size=Size; + set_value_type* Storage=0; + + if(use_fixed_storage(m_Size)) + { + // Use fixed storage + Storage=&m_Storage.m_fixSet[0]; + } + else + { + // Use dynamic storage + m_Storage.m_dynSet=new set_value_type[m_Size]; + Storage=m_Storage.m_dynSet; + } + + // Use fixed storage + ::std::copy(::boost::begin(Range), ::boost::end(Range), Storage); + ::std::sort(Storage, Storage+m_Size); + } + + // Copy constructor + is_any_ofF(const is_any_ofF& Other) : m_Size(Other.m_Size) + { + // Prepare storage + m_Storage.m_dynSet=0; + const set_value_type* SrcStorage=0; + set_value_type* DestStorage=0; + + if(use_fixed_storage(m_Size)) + { + // Use fixed storage + DestStorage=&m_Storage.m_fixSet[0]; + SrcStorage=&Other.m_Storage.m_fixSet[0]; + } + else + { + // Use dynamic storage + m_Storage.m_dynSet=new set_value_type[m_Size]; + DestStorage=m_Storage.m_dynSet; + SrcStorage=Other.m_Storage.m_dynSet; + } + + // Use fixed storage + ::std::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size); + } + + // Destructor + ~is_any_ofF() + { + if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0) + { + delete [] m_Storage.m_dynSet; + } + } + + // Assignment + is_any_ofF& operator=(const is_any_ofF& Other) + { + // Handle self assignment + if(this==&Other) return *this; + + // Prepare storage + const set_value_type* SrcStorage; + set_value_type* DestStorage; + + if(use_fixed_storage(Other.m_Size)) + { + // Use fixed storage + DestStorage=&m_Storage.m_fixSet[0]; + SrcStorage=&Other.m_Storage.m_fixSet[0]; + + // Delete old storage if was present + if(!use_fixed_storage(m_Size) && m_Storage.m_dynSet!=0) + { + delete [] m_Storage.m_dynSet; + } + + // Set new size + m_Size=Other.m_Size; + } + else + { + // Other uses dynamic storage + SrcStorage=Other.m_Storage.m_dynSet; + + // Check what kind of storage are we using right now + if(use_fixed_storage(m_Size)) + { + // Using fixed storage, allocate new + set_value_type* pTemp=new set_value_type[Other.m_Size]; + DestStorage=pTemp; + m_Storage.m_dynSet=pTemp; + m_Size=Other.m_Size; + } + else + { + // Using dynamic storage, check if can reuse + if(m_Storage.m_dynSet!=0 && m_Size>=Other.m_Size && m_Size<Other.m_Size*2) + { + // Reuse the current storage + DestStorage=m_Storage.m_dynSet; + m_Size=Other.m_Size; + } + else + { + // Allocate the new one + set_value_type* pTemp=new set_value_type[Other.m_Size]; + DestStorage=pTemp; + + // Delete old storage if necessary + if(m_Storage.m_dynSet!=0) + { + delete [] m_Storage.m_dynSet; + } + // Store the new storage + m_Storage.m_dynSet=pTemp; + // Set new size + m_Size=Other.m_Size; + } + } + } + + // Copy the data + ::std::memcpy(DestStorage, SrcStorage, sizeof(set_value_type)*m_Size); + + return *this; + } + + // Operation + template<typename Char2T> + bool operator()( Char2T Ch ) const + { + const set_value_type* Storage= + (use_fixed_storage(m_Size)) + ? &m_Storage.m_fixSet[0] + : m_Storage.m_dynSet; + + return ::std::binary_search(Storage, Storage+m_Size, Ch); + } + private: + // check if the size is eligible for fixed storage + static bool use_fixed_storage(std::size_t size) + { + return size<=sizeof(set_value_type*)*2; + } + + + private: + // storage + // The actual used storage is selected on the type + union + { + set_value_type* m_dynSet; + set_value_type m_fixSet[sizeof(set_value_type*)*2]; + } + m_Storage; + + // storage size + ::std::size_t m_Size; + }; + + // is_from_range functor + /* + returns true if the value is from the specified range. + (i.e. x>=From && x>=To) + */ + template<typename CharT> + struct is_from_rangeF : + public predicate_facade< is_from_rangeF<CharT> > + { + // Boost.ResultOf support + typedef bool result_type; + + // Constructor + is_from_rangeF( CharT From, CharT To ) : m_From(From), m_To(To) {} + + // Operation + template<typename Char2T> + bool operator()( Char2T Ch ) const + { + return ( m_From <= Ch ) && ( Ch <= m_To ); + } + + private: + CharT m_From; + CharT m_To; + }; + + // class_and composition predicate + template<typename Pred1T, typename Pred2T> + struct pred_andF : + public predicate_facade< pred_andF<Pred1T,Pred2T> > + { + public: + + // Boost.ResultOf support + typedef bool result_type; + + // Constructor + pred_andF( Pred1T Pred1, Pred2T Pred2 ) : + m_Pred1(Pred1), m_Pred2(Pred2) {} + + // Operation + template<typename CharT> + bool operator()( CharT Ch ) const + { + return m_Pred1(Ch) && m_Pred2(Ch); + } + + private: + Pred1T m_Pred1; + Pred2T m_Pred2; + }; + + // class_or composition predicate + template<typename Pred1T, typename Pred2T> + struct pred_orF : + public predicate_facade< pred_orF<Pred1T,Pred2T> > + { + public: + // Boost.ResultOf support + typedef bool result_type; + + // Constructor + pred_orF( Pred1T Pred1, Pred2T Pred2 ) : + m_Pred1(Pred1), m_Pred2(Pred2) {} + + // Operation + template<typename CharT> + bool operator()( CharT Ch ) const + { + return m_Pred1(Ch) || m_Pred2(Ch); + } + + private: + Pred1T m_Pred1; + Pred2T m_Pred2; + }; + + // class_not composition predicate + template< typename PredT > + struct pred_notF : + public predicate_facade< pred_notF<PredT> > + { + public: + // Boost.ResultOf support + typedef bool result_type; + + // Constructor + pred_notF( PredT Pred ) : m_Pred(Pred) {} + + // Operation + template<typename CharT> + bool operator()( CharT Ch ) const + { + return !m_Pred(Ch); + } + + private: + PredT m_Pred; + }; + + } // namespace detail + } // namespace algorithm +} // namespace boost + + +#endif // BOOST_STRING_CLASSIFICATION_DETAIL_HPP diff --git a/contrib/src/boost/algorithm/string/detail/find_format.hpp b/contrib/src/boost/algorithm/string/detail/find_format.hpp index b9b495d..b398750 100644 --- a/contrib/src/boost/algorithm/string/detail/find_format.hpp +++ b/contrib/src/boost/algorithm/string/detail/find_format.hpp @@ -1,204 +1,204 @@ -// Boost string_algo library find_format.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_FIND_FORMAT_DETAIL_HPP
-#define BOOST_STRING_FIND_FORMAT_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/range/iterator_range_core.hpp>
-#include <boost/range/const_iterator.hpp>
-#include <boost/range/iterator.hpp>
-#include <boost/algorithm/string/detail/find_format_store.hpp>
-#include <boost/algorithm/string/detail/replace_storage.hpp>
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-// find_format_copy (iterator variant) implementation -------------------------------//
-
- template<
- typename OutputIteratorT,
- typename InputT,
- typename FormatterT,
- typename FindResultT,
- typename FormatResultT >
- inline OutputIteratorT find_format_copy_impl2(
- OutputIteratorT Output,
- const InputT& Input,
- FormatterT Formatter,
- const FindResultT& FindResult,
- const FormatResultT& FormatResult )
- {
- typedef find_format_store<
- BOOST_STRING_TYPENAME
- range_const_iterator<InputT>::type,
- FormatterT,
- FormatResultT > store_type;
-
- // Create store for the find result
- store_type M( FindResult, FormatResult, Formatter );
-
- if ( !M )
- {
- // Match not found - return original sequence
- Output = std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
- return Output;
- }
-
- // Copy the beginning of the sequence
- Output = std::copy( ::boost::begin(Input), ::boost::begin(M), Output );
- // Format find result
- // Copy formatted result
- Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
- // Copy the rest of the sequence
- Output = std::copy( M.end(), ::boost::end(Input), Output );
-
- return Output;
- }
-
- template<
- typename OutputIteratorT,
- typename InputT,
- typename FormatterT,
- typename FindResultT >
- inline OutputIteratorT find_format_copy_impl(
- OutputIteratorT Output,
- const InputT& Input,
- FormatterT Formatter,
- const FindResultT& FindResult )
- {
- if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
- return ::boost::algorithm::detail::find_format_copy_impl2(
- Output,
- Input,
- Formatter,
- FindResult,
- Formatter(FindResult) );
- } else {
- return std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
- }
- }
-
-
-// find_format_copy implementation --------------------------------------------------//
-
- template<
- typename InputT,
- typename FormatterT,
- typename FindResultT,
- typename FormatResultT >
- inline InputT find_format_copy_impl2(
- const InputT& Input,
- FormatterT Formatter,
- const FindResultT& FindResult,
- const FormatResultT& FormatResult)
- {
- typedef find_format_store<
- BOOST_STRING_TYPENAME
- range_const_iterator<InputT>::type,
- FormatterT,
- FormatResultT > store_type;
-
- // Create store for the find result
- store_type M( FindResult, FormatResult, Formatter );
-
- if ( !M )
- {
- // Match not found - return original sequence
- return InputT( Input );
- }
-
- InputT Output;
- // Copy the beginning of the sequence
- boost::algorithm::detail::insert( Output, ::boost::end(Output), ::boost::begin(Input), M.begin() );
- // Copy formatted result
- boost::algorithm::detail::insert( Output, ::boost::end(Output), M.format_result() );
- // Copy the rest of the sequence
- boost::algorithm::detail::insert( Output, ::boost::end(Output), M.end(), ::boost::end(Input) );
-
- return Output;
- }
-
- template<
- typename InputT,
- typename FormatterT,
- typename FindResultT >
- inline InputT find_format_copy_impl(
- const InputT& Input,
- FormatterT Formatter,
- const FindResultT& FindResult)
- {
- if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
- return ::boost::algorithm::detail::find_format_copy_impl2(
- Input,
- Formatter,
- FindResult,
- Formatter(FindResult) );
- } else {
- return Input;
- }
- }
-
- // replace implementation ----------------------------------------------------//
-
- template<
- typename InputT,
- typename FormatterT,
- typename FindResultT,
- typename FormatResultT >
- inline void find_format_impl2(
- InputT& Input,
- FormatterT Formatter,
- const FindResultT& FindResult,
- const FormatResultT& FormatResult)
- {
- typedef find_format_store<
- BOOST_STRING_TYPENAME
- range_iterator<InputT>::type,
- FormatterT,
- FormatResultT > store_type;
-
- // Create store for the find result
- store_type M( FindResult, FormatResult, Formatter );
-
- if ( !M )
- {
- // Search not found - return original sequence
- return;
- }
-
- // Replace match
- ::boost::algorithm::detail::replace( Input, M.begin(), M.end(), M.format_result() );
- }
-
- template<
- typename InputT,
- typename FormatterT,
- typename FindResultT >
- inline void find_format_impl(
- InputT& Input,
- FormatterT Formatter,
- const FindResultT& FindResult)
- {
- if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
- ::boost::algorithm::detail::find_format_impl2(
- Input,
- Formatter,
- FindResult,
- Formatter(FindResult) );
- }
- }
-
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-#endif // BOOST_STRING_FIND_FORMAT_DETAIL_HPP
+// Boost string_algo library find_format.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_FIND_FORMAT_DETAIL_HPP +#define BOOST_STRING_FIND_FORMAT_DETAIL_HPP + +#include <boost/algorithm/string/config.hpp> +#include <boost/range/iterator_range_core.hpp> +#include <boost/range/const_iterator.hpp> +#include <boost/range/iterator.hpp> +#include <boost/algorithm/string/detail/find_format_store.hpp> +#include <boost/algorithm/string/detail/replace_storage.hpp> + +namespace boost { + namespace algorithm { + namespace detail { + +// find_format_copy (iterator variant) implementation -------------------------------// + + template< + typename OutputIteratorT, + typename InputT, + typename FormatterT, + typename FindResultT, + typename FormatResultT > + inline OutputIteratorT find_format_copy_impl2( + OutputIteratorT Output, + const InputT& Input, + FormatterT Formatter, + const FindResultT& FindResult, + const FormatResultT& FormatResult ) + { + typedef find_format_store< + BOOST_STRING_TYPENAME + range_const_iterator<InputT>::type, + FormatterT, + FormatResultT > store_type; + + // Create store for the find result + store_type M( FindResult, FormatResult, Formatter ); + + if ( !M ) + { + // Match not found - return original sequence + Output = std::copy( ::boost::begin(Input), ::boost::end(Input), Output ); + return Output; + } + + // Copy the beginning of the sequence + Output = std::copy( ::boost::begin(Input), ::boost::begin(M), Output ); + // Format find result + // Copy formatted result + Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output ); + // Copy the rest of the sequence + Output = std::copy( M.end(), ::boost::end(Input), Output ); + + return Output; + } + + template< + typename OutputIteratorT, + typename InputT, + typename FormatterT, + typename FindResultT > + inline OutputIteratorT find_format_copy_impl( + OutputIteratorT Output, + const InputT& Input, + FormatterT Formatter, + const FindResultT& FindResult ) + { + if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) { + return ::boost::algorithm::detail::find_format_copy_impl2( + Output, + Input, + Formatter, + FindResult, + Formatter(FindResult) ); + } else { + return std::copy( ::boost::begin(Input), ::boost::end(Input), Output ); + } + } + + +// find_format_copy implementation --------------------------------------------------// + + template< + typename InputT, + typename FormatterT, + typename FindResultT, + typename FormatResultT > + inline InputT find_format_copy_impl2( + const InputT& Input, + FormatterT Formatter, + const FindResultT& FindResult, + const FormatResultT& FormatResult) + { + typedef find_format_store< + BOOST_STRING_TYPENAME + range_const_iterator<InputT>::type, + FormatterT, + FormatResultT > store_type; + + // Create store for the find result + store_type M( FindResult, FormatResult, Formatter ); + + if ( !M ) + { + // Match not found - return original sequence + return InputT( Input ); + } + + InputT Output; + // Copy the beginning of the sequence + boost::algorithm::detail::insert( Output, ::boost::end(Output), ::boost::begin(Input), M.begin() ); + // Copy formatted result + boost::algorithm::detail::insert( Output, ::boost::end(Output), M.format_result() ); + // Copy the rest of the sequence + boost::algorithm::detail::insert( Output, ::boost::end(Output), M.end(), ::boost::end(Input) ); + + return Output; + } + + template< + typename InputT, + typename FormatterT, + typename FindResultT > + inline InputT find_format_copy_impl( + const InputT& Input, + FormatterT Formatter, + const FindResultT& FindResult) + { + if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) { + return ::boost::algorithm::detail::find_format_copy_impl2( + Input, + Formatter, + FindResult, + Formatter(FindResult) ); + } else { + return Input; + } + } + + // replace implementation ----------------------------------------------------// + + template< + typename InputT, + typename FormatterT, + typename FindResultT, + typename FormatResultT > + inline void find_format_impl2( + InputT& Input, + FormatterT Formatter, + const FindResultT& FindResult, + const FormatResultT& FormatResult) + { + typedef find_format_store< + BOOST_STRING_TYPENAME + range_iterator<InputT>::type, + FormatterT, + FormatResultT > store_type; + + // Create store for the find result + store_type M( FindResult, FormatResult, Formatter ); + + if ( !M ) + { + // Search not found - return original sequence + return; + } + + // Replace match + ::boost::algorithm::detail::replace( Input, M.begin(), M.end(), M.format_result() ); + } + + template< + typename InputT, + typename FormatterT, + typename FindResultT > + inline void find_format_impl( + InputT& Input, + FormatterT Formatter, + const FindResultT& FindResult) + { + if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) { + ::boost::algorithm::detail::find_format_impl2( + Input, + Formatter, + FindResult, + Formatter(FindResult) ); + } + } + + } // namespace detail + } // namespace algorithm +} // namespace boost + +#endif // BOOST_STRING_FIND_FORMAT_DETAIL_HPP diff --git a/contrib/src/boost/algorithm/string/detail/find_format_all.hpp b/contrib/src/boost/algorithm/string/detail/find_format_all.hpp index ae1e5da..52930c8 100644 --- a/contrib/src/boost/algorithm/string/detail/find_format_all.hpp +++ b/contrib/src/boost/algorithm/string/detail/find_format_all.hpp @@ -1,273 +1,273 @@ -// Boost string_algo library find_format_all.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_FIND_FORMAT_ALL_DETAIL_HPP
-#define BOOST_STRING_FIND_FORMAT_ALL_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/range/iterator_range_core.hpp>
-#include <boost/range/const_iterator.hpp>
-#include <boost/range/value_type.hpp>
-#include <boost/algorithm/string/detail/find_format_store.hpp>
-#include <boost/algorithm/string/detail/replace_storage.hpp>
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-// find_format_all_copy (iterator variant) implementation ---------------------------//
-
- template<
- typename OutputIteratorT,
- typename InputT,
- typename FinderT,
- typename FormatterT,
- typename FindResultT,
- typename FormatResultT >
- inline OutputIteratorT find_format_all_copy_impl2(
- OutputIteratorT Output,
- const InputT& Input,
- FinderT Finder,
- FormatterT Formatter,
- const FindResultT& FindResult,
- const FormatResultT& FormatResult )
- {
- typedef BOOST_STRING_TYPENAME
- range_const_iterator<InputT>::type input_iterator_type;
-
- typedef find_format_store<
- input_iterator_type,
- FormatterT,
- FormatResultT > store_type;
-
- // Create store for the find result
- store_type M( FindResult, FormatResult, Formatter );
-
- // Initialize last match
- input_iterator_type LastMatch=::boost::begin(Input);
-
- // Iterate through all matches
- while( M )
- {
- // Copy the beginning of the sequence
- Output = std::copy( LastMatch, M.begin(), Output );
- // Copy formatted result
- Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output );
-
- // Proceed to the next match
- LastMatch=M.end();
- M=Finder( LastMatch, ::boost::end(Input) );
- }
-
- // Copy the rest of the sequence
- Output = std::copy( LastMatch, ::boost::end(Input), Output );
-
- return Output;
- }
-
- template<
- typename OutputIteratorT,
- typename InputT,
- typename FinderT,
- typename FormatterT,
- typename FindResultT >
- inline OutputIteratorT find_format_all_copy_impl(
- OutputIteratorT Output,
- const InputT& Input,
- FinderT Finder,
- FormatterT Formatter,
- const FindResultT& FindResult )
- {
- if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
- return ::boost::algorithm::detail::find_format_all_copy_impl2(
- Output,
- Input,
- Finder,
- Formatter,
- FindResult,
- Formatter(FindResult) );
- } else {
- return std::copy( ::boost::begin(Input), ::boost::end(Input), Output );
- }
- }
-
- // find_format_all_copy implementation ----------------------------------------------//
-
- template<
- typename InputT,
- typename FinderT,
- typename FormatterT,
- typename FindResultT,
- typename FormatResultT >
- inline InputT find_format_all_copy_impl2(
- const InputT& Input,
- FinderT Finder,
- FormatterT Formatter,
- const FindResultT& FindResult,
- const FormatResultT& FormatResult)
- {
- typedef BOOST_STRING_TYPENAME
- range_const_iterator<InputT>::type input_iterator_type;
-
- typedef find_format_store<
- input_iterator_type,
- FormatterT,
- FormatResultT > store_type;
-
- // Create store for the find result
- store_type M( FindResult, FormatResult, Formatter );
-
- // Initialize last match
- input_iterator_type LastMatch=::boost::begin(Input);
-
- // Output temporary
- InputT Output;
-
- // Iterate through all matches
- while( M )
- {
- // Copy the beginning of the sequence
- boost::algorithm::detail::insert( Output, ::boost::end(Output), LastMatch, M.begin() );
- // Copy formatted result
- boost::algorithm::detail::insert( Output, ::boost::end(Output), M.format_result() );
-
- // Proceed to the next match
- LastMatch=M.end();
- M=Finder( LastMatch, ::boost::end(Input) );
- }
-
- // Copy the rest of the sequence
- ::boost::algorithm::detail::insert( Output, ::boost::end(Output), LastMatch, ::boost::end(Input) );
-
- return Output;
- }
-
- template<
- typename InputT,
- typename FinderT,
- typename FormatterT,
- typename FindResultT >
- inline InputT find_format_all_copy_impl(
- const InputT& Input,
- FinderT Finder,
- FormatterT Formatter,
- const FindResultT& FindResult)
- {
- if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
- return ::boost::algorithm::detail::find_format_all_copy_impl2(
- Input,
- Finder,
- Formatter,
- FindResult,
- Formatter(FindResult) );
- } else {
- return Input;
- }
- }
-
- // find_format_all implementation ------------------------------------------------//
-
- template<
- typename InputT,
- typename FinderT,
- typename FormatterT,
- typename FindResultT,
- typename FormatResultT >
- inline void find_format_all_impl2(
- InputT& Input,
- FinderT Finder,
- FormatterT Formatter,
- FindResultT FindResult,
- FormatResultT FormatResult)
- {
- typedef BOOST_STRING_TYPENAME
- range_iterator<InputT>::type input_iterator_type;
- typedef find_format_store<
- input_iterator_type,
- FormatterT,
- FormatResultT > store_type;
-
- // Create store for the find result
- store_type M( FindResult, FormatResult, Formatter );
-
- // Instantiate replacement storage
- std::deque<
- BOOST_STRING_TYPENAME range_value<InputT>::type> Storage;
-
- // Initialize replacement iterators
- input_iterator_type InsertIt=::boost::begin(Input);
- input_iterator_type SearchIt=::boost::begin(Input);
-
- while( M )
- {
- // process the segment
- InsertIt=process_segment(
- Storage,
- Input,
- InsertIt,
- SearchIt,
- M.begin() );
-
- // Adjust search iterator
- SearchIt=M.end();
-
- // Copy formatted replace to the storage
- ::boost::algorithm::detail::copy_to_storage( Storage, M.format_result() );
-
- // Find range for a next match
- M=Finder( SearchIt, ::boost::end(Input) );
- }
-
- // process the last segment
- InsertIt=::boost::algorithm::detail::process_segment(
- Storage,
- Input,
- InsertIt,
- SearchIt,
- ::boost::end(Input) );
-
- if ( Storage.empty() )
- {
- // Truncate input
- ::boost::algorithm::detail::erase( Input, InsertIt, ::boost::end(Input) );
- }
- else
- {
- // Copy remaining data to the end of input
- ::boost::algorithm::detail::insert( Input, ::boost::end(Input), Storage.begin(), Storage.end() );
- }
- }
-
- template<
- typename InputT,
- typename FinderT,
- typename FormatterT,
- typename FindResultT >
- inline void find_format_all_impl(
- InputT& Input,
- FinderT Finder,
- FormatterT Formatter,
- FindResultT FindResult)
- {
- if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) {
- ::boost::algorithm::detail::find_format_all_impl2(
- Input,
- Finder,
- Formatter,
- FindResult,
- Formatter(FindResult) );
- }
- }
-
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-#endif // BOOST_STRING_FIND_FORMAT_ALL_DETAIL_HPP
+// Boost string_algo library find_format_all.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_FIND_FORMAT_ALL_DETAIL_HPP +#define BOOST_STRING_FIND_FORMAT_ALL_DETAIL_HPP + +#include <boost/algorithm/string/config.hpp> +#include <boost/range/iterator_range_core.hpp> +#include <boost/range/const_iterator.hpp> +#include <boost/range/value_type.hpp> +#include <boost/algorithm/string/detail/find_format_store.hpp> +#include <boost/algorithm/string/detail/replace_storage.hpp> + +namespace boost { + namespace algorithm { + namespace detail { + +// find_format_all_copy (iterator variant) implementation ---------------------------// + + template< + typename OutputIteratorT, + typename InputT, + typename FinderT, + typename FormatterT, + typename FindResultT, + typename FormatResultT > + inline OutputIteratorT find_format_all_copy_impl2( + OutputIteratorT Output, + const InputT& Input, + FinderT Finder, + FormatterT Formatter, + const FindResultT& FindResult, + const FormatResultT& FormatResult ) + { + typedef BOOST_STRING_TYPENAME + range_const_iterator<InputT>::type input_iterator_type; + + typedef find_format_store< + input_iterator_type, + FormatterT, + FormatResultT > store_type; + + // Create store for the find result + store_type M( FindResult, FormatResult, Formatter ); + + // Initialize last match + input_iterator_type LastMatch=::boost::begin(Input); + + // Iterate through all matches + while( M ) + { + // Copy the beginning of the sequence + Output = std::copy( LastMatch, M.begin(), Output ); + // Copy formatted result + Output = std::copy( ::boost::begin(M.format_result()), ::boost::end(M.format_result()), Output ); + + // Proceed to the next match + LastMatch=M.end(); + M=Finder( LastMatch, ::boost::end(Input) ); + } + + // Copy the rest of the sequence + Output = std::copy( LastMatch, ::boost::end(Input), Output ); + + return Output; + } + + template< + typename OutputIteratorT, + typename InputT, + typename FinderT, + typename FormatterT, + typename FindResultT > + inline OutputIteratorT find_format_all_copy_impl( + OutputIteratorT Output, + const InputT& Input, + FinderT Finder, + FormatterT Formatter, + const FindResultT& FindResult ) + { + if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) { + return ::boost::algorithm::detail::find_format_all_copy_impl2( + Output, + Input, + Finder, + Formatter, + FindResult, + Formatter(FindResult) ); + } else { + return std::copy( ::boost::begin(Input), ::boost::end(Input), Output ); + } + } + + // find_format_all_copy implementation ----------------------------------------------// + + template< + typename InputT, + typename FinderT, + typename FormatterT, + typename FindResultT, + typename FormatResultT > + inline InputT find_format_all_copy_impl2( + const InputT& Input, + FinderT Finder, + FormatterT Formatter, + const FindResultT& FindResult, + const FormatResultT& FormatResult) + { + typedef BOOST_STRING_TYPENAME + range_const_iterator<InputT>::type input_iterator_type; + + typedef find_format_store< + input_iterator_type, + FormatterT, + FormatResultT > store_type; + + // Create store for the find result + store_type M( FindResult, FormatResult, Formatter ); + + // Initialize last match + input_iterator_type LastMatch=::boost::begin(Input); + + // Output temporary + InputT Output; + + // Iterate through all matches + while( M ) + { + // Copy the beginning of the sequence + boost::algorithm::detail::insert( Output, ::boost::end(Output), LastMatch, M.begin() ); + // Copy formatted result + boost::algorithm::detail::insert( Output, ::boost::end(Output), M.format_result() ); + + // Proceed to the next match + LastMatch=M.end(); + M=Finder( LastMatch, ::boost::end(Input) ); + } + + // Copy the rest of the sequence + ::boost::algorithm::detail::insert( Output, ::boost::end(Output), LastMatch, ::boost::end(Input) ); + + return Output; + } + + template< + typename InputT, + typename FinderT, + typename FormatterT, + typename FindResultT > + inline InputT find_format_all_copy_impl( + const InputT& Input, + FinderT Finder, + FormatterT Formatter, + const FindResultT& FindResult) + { + if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) { + return ::boost::algorithm::detail::find_format_all_copy_impl2( + Input, + Finder, + Formatter, + FindResult, + Formatter(FindResult) ); + } else { + return Input; + } + } + + // find_format_all implementation ------------------------------------------------// + + template< + typename InputT, + typename FinderT, + typename FormatterT, + typename FindResultT, + typename FormatResultT > + inline void find_format_all_impl2( + InputT& Input, + FinderT Finder, + FormatterT Formatter, + FindResultT FindResult, + FormatResultT FormatResult) + { + typedef BOOST_STRING_TYPENAME + range_iterator<InputT>::type input_iterator_type; + typedef find_format_store< + input_iterator_type, + FormatterT, + FormatResultT > store_type; + + // Create store for the find result + store_type M( FindResult, FormatResult, Formatter ); + + // Instantiate replacement storage + std::deque< + BOOST_STRING_TYPENAME range_value<InputT>::type> Storage; + + // Initialize replacement iterators + input_iterator_type InsertIt=::boost::begin(Input); + input_iterator_type SearchIt=::boost::begin(Input); + + while( M ) + { + // process the segment + InsertIt=process_segment( + Storage, + Input, + InsertIt, + SearchIt, + M.begin() ); + + // Adjust search iterator + SearchIt=M.end(); + + // Copy formatted replace to the storage + ::boost::algorithm::detail::copy_to_storage( Storage, M.format_result() ); + + // Find range for a next match + M=Finder( SearchIt, ::boost::end(Input) ); + } + + // process the last segment + InsertIt=::boost::algorithm::detail::process_segment( + Storage, + Input, + InsertIt, + SearchIt, + ::boost::end(Input) ); + + if ( Storage.empty() ) + { + // Truncate input + ::boost::algorithm::detail::erase( Input, InsertIt, ::boost::end(Input) ); + } + else + { + // Copy remaining data to the end of input + ::boost::algorithm::detail::insert( Input, ::boost::end(Input), Storage.begin(), Storage.end() ); + } + } + + template< + typename InputT, + typename FinderT, + typename FormatterT, + typename FindResultT > + inline void find_format_all_impl( + InputT& Input, + FinderT Finder, + FormatterT Formatter, + FindResultT FindResult) + { + if( ::boost::algorithm::detail::check_find_result(Input, FindResult) ) { + ::boost::algorithm::detail::find_format_all_impl2( + Input, + Finder, + Formatter, + FindResult, + Formatter(FindResult) ); + } + } + + } // namespace detail + } // namespace algorithm +} // namespace boost + +#endif // BOOST_STRING_FIND_FORMAT_ALL_DETAIL_HPP diff --git a/contrib/src/boost/algorithm/string/detail/find_format_store.hpp b/contrib/src/boost/algorithm/string/detail/find_format_store.hpp index 89d2ba4..b9f4a88 100644 --- a/contrib/src/boost/algorithm/string/detail/find_format_store.hpp +++ b/contrib/src/boost/algorithm/string/detail/find_format_store.hpp @@ -1,89 +1,89 @@ -// Boost string_algo library find_format_store.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_FIND_FORMAT_STORE_DETAIL_HPP
-#define BOOST_STRING_FIND_FORMAT_STORE_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/range/iterator_range_core.hpp>
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-// temporary format and find result storage --------------------------------//
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(push)
-#pragma warning(disable:4512) //assignment operator could not be generated
-#endif
- template<
- typename ForwardIteratorT,
- typename FormatterT,
- typename FormatResultT >
- class find_format_store :
- public iterator_range<ForwardIteratorT>
- {
- public:
- // typedefs
- typedef iterator_range<ForwardIteratorT> base_type;
- typedef FormatterT formatter_type;
- typedef FormatResultT format_result_type;
-
- public:
- // Construction
- find_format_store(
- const base_type& FindResult,
- const format_result_type& FormatResult,
- const formatter_type& Formatter ) :
- base_type(FindResult),
- m_FormatResult(FormatResult),
- m_Formatter(Formatter) {}
-
- // Assignment
- template< typename FindResultT >
- find_format_store& operator=( FindResultT FindResult )
- {
- iterator_range<ForwardIteratorT>::operator=(FindResult);
- if( !this->empty() ) {
- m_FormatResult=m_Formatter(FindResult);
- }
-
- return *this;
- }
-
- // Retrieve format result
- const format_result_type& format_result()
- {
- return m_FormatResult;
- }
-
- private:
- format_result_type m_FormatResult;
- const formatter_type& m_Formatter;
- };
-
- template<typename InputT, typename FindResultT>
- bool check_find_result(InputT&, FindResultT& FindResult)
- {
- typedef BOOST_STRING_TYPENAME
- range_const_iterator<InputT>::type input_iterator_type;
- iterator_range<input_iterator_type> ResultRange(FindResult);
- return !ResultRange.empty();
- }
-
-#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400)
-#pragma warning(pop)
-#endif
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-#endif // BOOST_STRING_FIND_FORMAT_STORE_DETAIL_HPP
+// Boost string_algo library find_format_store.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_FIND_FORMAT_STORE_DETAIL_HPP +#define BOOST_STRING_FIND_FORMAT_STORE_DETAIL_HPP + +#include <boost/algorithm/string/config.hpp> +#include <boost/range/iterator_range_core.hpp> + +namespace boost { + namespace algorithm { + namespace detail { + +// temporary format and find result storage --------------------------------// + +#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) +#pragma warning(push) +#pragma warning(disable:4512) //assignment operator could not be generated +#endif + template< + typename ForwardIteratorT, + typename FormatterT, + typename FormatResultT > + class find_format_store : + public iterator_range<ForwardIteratorT> + { + public: + // typedefs + typedef iterator_range<ForwardIteratorT> base_type; + typedef FormatterT formatter_type; + typedef FormatResultT format_result_type; + + public: + // Construction + find_format_store( + const base_type& FindResult, + const format_result_type& FormatResult, + const formatter_type& Formatter ) : + base_type(FindResult), + m_FormatResult(FormatResult), + m_Formatter(Formatter) {} + + // Assignment + template< typename FindResultT > + find_format_store& operator=( FindResultT FindResult ) + { + iterator_range<ForwardIteratorT>::operator=(FindResult); + if( !this->empty() ) { + m_FormatResult=m_Formatter(FindResult); + } + + return *this; + } + + // Retrieve format result + const format_result_type& format_result() + { + return m_FormatResult; + } + + private: + format_result_type m_FormatResult; + const formatter_type& m_Formatter; + }; + + template<typename InputT, typename FindResultT> + bool check_find_result(InputT&, FindResultT& FindResult) + { + typedef BOOST_STRING_TYPENAME + range_const_iterator<InputT>::type input_iterator_type; + iterator_range<input_iterator_type> ResultRange(FindResult); + return !ResultRange.empty(); + } + +#if BOOST_WORKAROUND(BOOST_MSVC, >= 1400) +#pragma warning(pop) +#endif + } // namespace detail + } // namespace algorithm +} // namespace boost + +#endif // BOOST_STRING_FIND_FORMAT_STORE_DETAIL_HPP diff --git a/contrib/src/boost/algorithm/string/detail/find_iterator.hpp b/contrib/src/boost/algorithm/string/detail/find_iterator.hpp index 505f290..9b78a0f 100644 --- a/contrib/src/boost/algorithm/string/detail/find_iterator.hpp +++ b/contrib/src/boost/algorithm/string/detail/find_iterator.hpp @@ -1,87 +1,87 @@ -// Boost string_algo library find_iterator.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_FIND_ITERATOR_DETAIL_HPP
-#define BOOST_STRING_FIND_ITERATOR_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/range/iterator_range_core.hpp>
-#include <boost/iterator/iterator_facade.hpp>
-#include <boost/iterator/iterator_categories.hpp>
-#include <boost/function.hpp>
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-// find_iterator base -----------------------------------------------//
-
- // Find iterator base
- template<typename IteratorT>
- class find_iterator_base
- {
- protected:
- // typedefs
- typedef IteratorT input_iterator_type;
- typedef iterator_range<IteratorT> match_type;
- typedef function2<
- match_type,
- input_iterator_type,
- input_iterator_type> finder_type;
-
- protected:
- // Protected construction/destruction
-
- // Default constructor
- find_iterator_base() {};
- // Copy construction
- find_iterator_base( const find_iterator_base& Other ) :
- m_Finder(Other.m_Finder) {}
-
- // Constructor
- template<typename FinderT>
- find_iterator_base( FinderT Finder, int ) :
- m_Finder(Finder) {}
-
- // Destructor
- ~find_iterator_base() {}
-
- // Find operation
- match_type do_find(
- input_iterator_type Begin,
- input_iterator_type End ) const
- {
- if (!m_Finder.empty())
- {
- return m_Finder(Begin,End);
- }
- else
- {
- return match_type(End,End);
- }
- }
-
- // Check
- bool is_null() const
- {
- return m_Finder.empty();
- }
-
- private:
- // Finder
- finder_type m_Finder;
- };
-
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-
-#endif // BOOST_STRING_FIND_ITERATOR_DETAIL_HPP
+// Boost string_algo library find_iterator.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_FIND_ITERATOR_DETAIL_HPP +#define BOOST_STRING_FIND_ITERATOR_DETAIL_HPP + +#include <boost/algorithm/string/config.hpp> +#include <boost/range/iterator_range_core.hpp> +#include <boost/iterator/iterator_facade.hpp> +#include <boost/iterator/iterator_categories.hpp> +#include <boost/function.hpp> + +namespace boost { + namespace algorithm { + namespace detail { + +// find_iterator base -----------------------------------------------// + + // Find iterator base + template<typename IteratorT> + class find_iterator_base + { + protected: + // typedefs + typedef IteratorT input_iterator_type; + typedef iterator_range<IteratorT> match_type; + typedef function2< + match_type, + input_iterator_type, + input_iterator_type> finder_type; + + protected: + // Protected construction/destruction + + // Default constructor + find_iterator_base() {}; + // Copy construction + find_iterator_base( const find_iterator_base& Other ) : + m_Finder(Other.m_Finder) {} + + // Constructor + template<typename FinderT> + find_iterator_base( FinderT Finder, int ) : + m_Finder(Finder) {} + + // Destructor + ~find_iterator_base() {} + + // Find operation + match_type do_find( + input_iterator_type Begin, + input_iterator_type End ) const + { + if (!m_Finder.empty()) + { + return m_Finder(Begin,End); + } + else + { + return match_type(End,End); + } + } + + // Check + bool is_null() const + { + return m_Finder.empty(); + } + + private: + // Finder + finder_type m_Finder; + }; + + } // namespace detail + } // namespace algorithm +} // namespace boost + + +#endif // BOOST_STRING_FIND_ITERATOR_DETAIL_HPP diff --git a/contrib/src/boost/algorithm/string/detail/finder.hpp b/contrib/src/boost/algorithm/string/detail/finder.hpp index 5bf36a9..a2a9582 100644 --- a/contrib/src/boost/algorithm/string/detail/finder.hpp +++ b/contrib/src/boost/algorithm/string/detail/finder.hpp @@ -1,639 +1,639 @@ -// Boost string_algo library finder.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2006.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_FINDER_DETAIL_HPP
-#define BOOST_STRING_FINDER_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/algorithm/string/constants.hpp>
-#include <boost/detail/iterator.hpp>
-
-#include <boost/range/iterator_range_core.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/range/empty.hpp>
-#include <boost/range/as_literal.hpp>
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-
-// find first functor -----------------------------------------------//
-
- // find a subsequence in the sequence ( functor )
- /*
- Returns a pair <begin,end> marking the subsequence in the sequence.
- If the find fails, functor returns <End,End>
- */
- template<typename SearchIteratorT,typename PredicateT>
- struct first_finderF
- {
- typedef SearchIteratorT search_iterator_type;
-
- // Construction
- template< typename SearchT >
- first_finderF( const SearchT& Search, PredicateT Comp ) :
- m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {}
- first_finderF(
- search_iterator_type SearchBegin,
- search_iterator_type SearchEnd,
- PredicateT Comp ) :
- m_Search(SearchBegin, SearchEnd), m_Comp(Comp) {}
-
- // Operation
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- operator()(
- ForwardIteratorT Begin,
- ForwardIteratorT End ) const
- {
- typedef iterator_range<ForwardIteratorT> result_type;
- typedef ForwardIteratorT input_iterator_type;
-
- // Outer loop
- for(input_iterator_type OuterIt=Begin;
- OuterIt!=End;
- ++OuterIt)
- {
- // Sanity check
- if( boost::empty(m_Search) )
- return result_type( End, End );
-
- input_iterator_type InnerIt=OuterIt;
- search_iterator_type SubstrIt=m_Search.begin();
- for(;
- InnerIt!=End && SubstrIt!=m_Search.end();
- ++InnerIt,++SubstrIt)
- {
- if( !( m_Comp(*InnerIt,*SubstrIt) ) )
- break;
- }
-
- // Substring matching succeeded
- if ( SubstrIt==m_Search.end() )
- return result_type( OuterIt, InnerIt );
- }
-
- return result_type( End, End );
- }
-
- private:
- iterator_range<search_iterator_type> m_Search;
- PredicateT m_Comp;
- };
-
-// find last functor -----------------------------------------------//
-
- // find the last match a subsequence in the sequence ( functor )
- /*
- Returns a pair <begin,end> marking the subsequence in the sequence.
- If the find fails, returns <End,End>
- */
- template<typename SearchIteratorT, typename PredicateT>
- struct last_finderF
- {
- typedef SearchIteratorT search_iterator_type;
- typedef first_finderF<
- search_iterator_type,
- PredicateT> first_finder_type;
-
- // Construction
- template< typename SearchT >
- last_finderF( const SearchT& Search, PredicateT Comp ) :
- m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {}
- last_finderF(
- search_iterator_type SearchBegin,
- search_iterator_type SearchEnd,
- PredicateT Comp ) :
- m_Search(SearchBegin, SearchEnd), m_Comp(Comp) {}
-
- // Operation
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- operator()(
- ForwardIteratorT Begin,
- ForwardIteratorT End ) const
- {
- typedef iterator_range<ForwardIteratorT> result_type;
-
- if( boost::empty(m_Search) )
- return result_type( End, End );
-
- typedef BOOST_STRING_TYPENAME boost::detail::
- iterator_traits<ForwardIteratorT>::iterator_category category;
-
- return findit( Begin, End, category() );
- }
-
- private:
- // forward iterator
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- findit(
- ForwardIteratorT Begin,
- ForwardIteratorT End,
- std::forward_iterator_tag ) const
- {
- typedef iterator_range<ForwardIteratorT> result_type;
-
- first_finder_type first_finder(
- m_Search.begin(), m_Search.end(), m_Comp );
-
- result_type M=first_finder( Begin, End );
- result_type Last=M;
-
- while( M )
- {
- Last=M;
- M=first_finder( ::boost::end(M), End );
- }
-
- return Last;
- }
-
- // bidirectional iterator
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- findit(
- ForwardIteratorT Begin,
- ForwardIteratorT End,
- std::bidirectional_iterator_tag ) const
- {
- typedef iterator_range<ForwardIteratorT> result_type;
- typedef ForwardIteratorT input_iterator_type;
-
- // Outer loop
- for(input_iterator_type OuterIt=End;
- OuterIt!=Begin; )
- {
- input_iterator_type OuterIt2=--OuterIt;
-
- input_iterator_type InnerIt=OuterIt2;
- search_iterator_type SubstrIt=m_Search.begin();
- for(;
- InnerIt!=End && SubstrIt!=m_Search.end();
- ++InnerIt,++SubstrIt)
- {
- if( !( m_Comp(*InnerIt,*SubstrIt) ) )
- break;
- }
-
- // Substring matching succeeded
- if( SubstrIt==m_Search.end() )
- return result_type( OuterIt2, InnerIt );
- }
-
- return result_type( End, End );
- }
-
- private:
- iterator_range<search_iterator_type> m_Search;
- PredicateT m_Comp;
- };
-
-// find n-th functor -----------------------------------------------//
-
- // find the n-th match of a subsequence in the sequence ( functor )
- /*
- Returns a pair <begin,end> marking the subsequence in the sequence.
- If the find fails, returns <End,End>
- */
- template<typename SearchIteratorT, typename PredicateT>
- struct nth_finderF
- {
- typedef SearchIteratorT search_iterator_type;
- typedef first_finderF<
- search_iterator_type,
- PredicateT> first_finder_type;
- typedef last_finderF<
- search_iterator_type,
- PredicateT> last_finder_type;
-
- // Construction
- template< typename SearchT >
- nth_finderF(
- const SearchT& Search,
- int Nth,
- PredicateT Comp) :
- m_Search(::boost::begin(Search), ::boost::end(Search)),
- m_Nth(Nth),
- m_Comp(Comp) {}
- nth_finderF(
- search_iterator_type SearchBegin,
- search_iterator_type SearchEnd,
- int Nth,
- PredicateT Comp) :
- m_Search(SearchBegin, SearchEnd),
- m_Nth(Nth),
- m_Comp(Comp) {}
-
- // Operation
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- operator()(
- ForwardIteratorT Begin,
- ForwardIteratorT End ) const
- {
- if(m_Nth>=0)
- {
- return find_forward(Begin, End, m_Nth);
- }
- else
- {
- return find_backward(Begin, End, -m_Nth);
- }
-
- }
-
- private:
- // Implementation helpers
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- find_forward(
- ForwardIteratorT Begin,
- ForwardIteratorT End,
- unsigned int N) const
- {
- typedef iterator_range<ForwardIteratorT> result_type;
-
- // Sanity check
- if( boost::empty(m_Search) )
- return result_type( End, End );
-
- // Instantiate find functor
- first_finder_type first_finder(
- m_Search.begin(), m_Search.end(), m_Comp );
-
- result_type M( Begin, Begin );
-
- for( unsigned int n=0; n<=N; ++n )
- {
- // find next match
- M=first_finder( ::boost::end(M), End );
-
- if ( !M )
- {
- // Subsequence not found, return
- return M;
- }
- }
-
- return M;
- }
-
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- find_backward(
- ForwardIteratorT Begin,
- ForwardIteratorT End,
- unsigned int N) const
- {
- typedef iterator_range<ForwardIteratorT> result_type;
-
- // Sanity check
- if( boost::empty(m_Search) )
- return result_type( End, End );
-
- // Instantiate find functor
- last_finder_type last_finder(
- m_Search.begin(), m_Search.end(), m_Comp );
-
- result_type M( End, End );
-
- for( unsigned int n=1; n<=N; ++n )
- {
- // find next match
- M=last_finder( Begin, ::boost::begin(M) );
-
- if ( !M )
- {
- // Subsequence not found, return
- return M;
- }
- }
-
- return M;
- }
-
-
- private:
- iterator_range<search_iterator_type> m_Search;
- int m_Nth;
- PredicateT m_Comp;
- };
-
-// find head/tail implementation helpers ---------------------------//
-
- template<typename ForwardIteratorT>
- iterator_range<ForwardIteratorT>
- find_head_impl(
- ForwardIteratorT Begin,
- ForwardIteratorT End,
- unsigned int N,
- std::forward_iterator_tag )
- {
- typedef ForwardIteratorT input_iterator_type;
- typedef iterator_range<ForwardIteratorT> result_type;
-
- input_iterator_type It=Begin;
- for(
- unsigned int Index=0;
- Index<N && It!=End; ++Index,++It ) {};
-
- return result_type( Begin, It );
- }
-
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- find_head_impl(
- ForwardIteratorT Begin,
- ForwardIteratorT End,
- unsigned int N,
- std::random_access_iterator_tag )
- {
- typedef iterator_range<ForwardIteratorT> result_type;
-
- if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < N ) )
- return result_type( Begin, End );
-
- return result_type(Begin,Begin+N);
- }
-
- // Find head implementation
- template<typename ForwardIteratorT>
- iterator_range<ForwardIteratorT>
- find_head_impl(
- ForwardIteratorT Begin,
- ForwardIteratorT End,
- unsigned int N )
- {
- typedef BOOST_STRING_TYPENAME boost::detail::
- iterator_traits<ForwardIteratorT>::iterator_category category;
-
- return ::boost::algorithm::detail::find_head_impl( Begin, End, N, category() );
- }
-
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- find_tail_impl(
- ForwardIteratorT Begin,
- ForwardIteratorT End,
- unsigned int N,
- std::forward_iterator_tag )
- {
- typedef ForwardIteratorT input_iterator_type;
- typedef iterator_range<ForwardIteratorT> result_type;
-
- unsigned int Index=0;
- input_iterator_type It=Begin;
- input_iterator_type It2=Begin;
-
- // Advance It2 by N increments
- for( Index=0; Index<N && It2!=End; ++Index,++It2 ) {};
-
- // Advance It, It2 to the end
- for(; It2!=End; ++It,++It2 ) {};
-
- return result_type( It, It2 );
- }
-
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- find_tail_impl(
- ForwardIteratorT Begin,
- ForwardIteratorT End,
- unsigned int N,
- std::bidirectional_iterator_tag )
- {
- typedef ForwardIteratorT input_iterator_type;
- typedef iterator_range<ForwardIteratorT> result_type;
-
- input_iterator_type It=End;
- for(
- unsigned int Index=0;
- Index<N && It!=Begin; ++Index,--It ) {};
-
- return result_type( It, End );
- }
-
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- find_tail_impl(
- ForwardIteratorT Begin,
- ForwardIteratorT End,
- unsigned int N,
- std::random_access_iterator_tag )
- {
- typedef iterator_range<ForwardIteratorT> result_type;
-
- if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < N ) )
- return result_type( Begin, End );
-
- return result_type( End-N, End );
- }
-
- // Operation
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- find_tail_impl(
- ForwardIteratorT Begin,
- ForwardIteratorT End,
- unsigned int N )
- {
- typedef BOOST_STRING_TYPENAME boost::detail::
- iterator_traits<ForwardIteratorT>::iterator_category category;
-
- return ::boost::algorithm::detail::find_tail_impl( Begin, End, N, category() );
- }
-
-
-
-// find head functor -----------------------------------------------//
-
-
- // find a head in the sequence ( functor )
- /*
- This functor find a head of the specified range. For
- a specified N, the head is a subsequence of N starting
- elements of the range.
- */
- struct head_finderF
- {
- // Construction
- head_finderF( int N ) : m_N(N) {}
-
- // Operation
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- operator()(
- ForwardIteratorT Begin,
- ForwardIteratorT End ) const
- {
- if(m_N>=0)
- {
- return ::boost::algorithm::detail::find_head_impl( Begin, End, m_N );
- }
- else
- {
- iterator_range<ForwardIteratorT> Res=
- ::boost::algorithm::detail::find_tail_impl( Begin, End, -m_N );
-
- return ::boost::make_iterator_range(Begin, Res.begin());
- }
- }
-
- private:
- int m_N;
- };
-
-// find tail functor -----------------------------------------------//
-
-
- // find a tail in the sequence ( functor )
- /*
- This functor find a tail of the specified range. For
- a specified N, the head is a subsequence of N starting
- elements of the range.
- */
- struct tail_finderF
- {
- // Construction
- tail_finderF( int N ) : m_N(N) {}
-
- // Operation
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- operator()(
- ForwardIteratorT Begin,
- ForwardIteratorT End ) const
- {
- if(m_N>=0)
- {
- return ::boost::algorithm::detail::find_tail_impl( Begin, End, m_N );
- }
- else
- {
- iterator_range<ForwardIteratorT> Res=
- ::boost::algorithm::detail::find_head_impl( Begin, End, -m_N );
-
- return ::boost::make_iterator_range(Res.end(), End);
- }
- }
-
- private:
- int m_N;
- };
-
-// find token functor -----------------------------------------------//
-
- // find a token in a sequence ( functor )
- /*
- This find functor finds a token specified be a predicate
- in a sequence. It is equivalent of std::find algorithm,
- with an exception that it return range instead of a single
- iterator.
-
- If bCompress is set to true, adjacent matching tokens are
- concatenated into one match.
- */
- template< typename PredicateT >
- struct token_finderF
- {
- // Construction
- token_finderF(
- PredicateT Pred,
- token_compress_mode_type eCompress=token_compress_off ) :
- m_Pred(Pred), m_eCompress(eCompress) {}
-
- // Operation
- template< typename ForwardIteratorT >
- iterator_range<ForwardIteratorT>
- operator()(
- ForwardIteratorT Begin,
- ForwardIteratorT End ) const
- {
- typedef iterator_range<ForwardIteratorT> result_type;
-
- ForwardIteratorT It=std::find_if( Begin, End, m_Pred );
-
- if( It==End )
- {
- return result_type( End, End );
- }
- else
- {
- ForwardIteratorT It2=It;
-
- if( m_eCompress==token_compress_on )
- {
- // Find first non-matching character
- while( It2!=End && m_Pred(*It2) ) ++It2;
- }
- else
- {
- // Advance by one position
- ++It2;
- }
-
- return result_type( It, It2 );
- }
- }
-
- private:
- PredicateT m_Pred;
- token_compress_mode_type m_eCompress;
- };
-
-// find range functor -----------------------------------------------//
-
- // find a range in the sequence ( functor )
- /*
- This functor actually does not perform any find operation.
- It always returns given iterator range as a result.
- */
- template<typename ForwardIterator1T>
- struct range_finderF
- {
- typedef ForwardIterator1T input_iterator_type;
- typedef iterator_range<input_iterator_type> result_type;
-
- // Construction
- range_finderF(
- input_iterator_type Begin,
- input_iterator_type End ) : m_Range(Begin, End) {}
-
- range_finderF(const iterator_range<input_iterator_type>& Range) :
- m_Range(Range) {}
-
- // Operation
- template< typename ForwardIterator2T >
- iterator_range<ForwardIterator2T>
- operator()(
- ForwardIterator2T,
- ForwardIterator2T ) const
- {
-#if BOOST_WORKAROUND( __MWERKS__, <= 0x3003 )
- return iterator_range<const ForwardIterator2T>(this->m_Range);
-#else
- return m_Range;
-#endif
- }
-
- private:
- iterator_range<input_iterator_type> m_Range;
- };
-
-
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-#endif // BOOST_STRING_FINDER_DETAIL_HPP
+// Boost string_algo library finder.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2006. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_FINDER_DETAIL_HPP +#define BOOST_STRING_FINDER_DETAIL_HPP + +#include <boost/algorithm/string/config.hpp> +#include <boost/algorithm/string/constants.hpp> +#include <boost/detail/iterator.hpp> + +#include <boost/range/iterator_range_core.hpp> +#include <boost/range/begin.hpp> +#include <boost/range/end.hpp> +#include <boost/range/empty.hpp> +#include <boost/range/as_literal.hpp> + +namespace boost { + namespace algorithm { + namespace detail { + + +// find first functor -----------------------------------------------// + + // find a subsequence in the sequence ( functor ) + /* + Returns a pair <begin,end> marking the subsequence in the sequence. + If the find fails, functor returns <End,End> + */ + template<typename SearchIteratorT,typename PredicateT> + struct first_finderF + { + typedef SearchIteratorT search_iterator_type; + + // Construction + template< typename SearchT > + first_finderF( const SearchT& Search, PredicateT Comp ) : + m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {} + first_finderF( + search_iterator_type SearchBegin, + search_iterator_type SearchEnd, + PredicateT Comp ) : + m_Search(SearchBegin, SearchEnd), m_Comp(Comp) {} + + // Operation + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + operator()( + ForwardIteratorT Begin, + ForwardIteratorT End ) const + { + typedef iterator_range<ForwardIteratorT> result_type; + typedef ForwardIteratorT input_iterator_type; + + // Outer loop + for(input_iterator_type OuterIt=Begin; + OuterIt!=End; + ++OuterIt) + { + // Sanity check + if( boost::empty(m_Search) ) + return result_type( End, End ); + + input_iterator_type InnerIt=OuterIt; + search_iterator_type SubstrIt=m_Search.begin(); + for(; + InnerIt!=End && SubstrIt!=m_Search.end(); + ++InnerIt,++SubstrIt) + { + if( !( m_Comp(*InnerIt,*SubstrIt) ) ) + break; + } + + // Substring matching succeeded + if ( SubstrIt==m_Search.end() ) + return result_type( OuterIt, InnerIt ); + } + + return result_type( End, End ); + } + + private: + iterator_range<search_iterator_type> m_Search; + PredicateT m_Comp; + }; + +// find last functor -----------------------------------------------// + + // find the last match a subsequence in the sequence ( functor ) + /* + Returns a pair <begin,end> marking the subsequence in the sequence. + If the find fails, returns <End,End> + */ + template<typename SearchIteratorT, typename PredicateT> + struct last_finderF + { + typedef SearchIteratorT search_iterator_type; + typedef first_finderF< + search_iterator_type, + PredicateT> first_finder_type; + + // Construction + template< typename SearchT > + last_finderF( const SearchT& Search, PredicateT Comp ) : + m_Search(::boost::begin(Search), ::boost::end(Search)), m_Comp(Comp) {} + last_finderF( + search_iterator_type SearchBegin, + search_iterator_type SearchEnd, + PredicateT Comp ) : + m_Search(SearchBegin, SearchEnd), m_Comp(Comp) {} + + // Operation + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + operator()( + ForwardIteratorT Begin, + ForwardIteratorT End ) const + { + typedef iterator_range<ForwardIteratorT> result_type; + + if( boost::empty(m_Search) ) + return result_type( End, End ); + + typedef BOOST_STRING_TYPENAME boost::detail:: + iterator_traits<ForwardIteratorT>::iterator_category category; + + return findit( Begin, End, category() ); + } + + private: + // forward iterator + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + findit( + ForwardIteratorT Begin, + ForwardIteratorT End, + std::forward_iterator_tag ) const + { + typedef iterator_range<ForwardIteratorT> result_type; + + first_finder_type first_finder( + m_Search.begin(), m_Search.end(), m_Comp ); + + result_type M=first_finder( Begin, End ); + result_type Last=M; + + while( M ) + { + Last=M; + M=first_finder( ::boost::end(M), End ); + } + + return Last; + } + + // bidirectional iterator + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + findit( + ForwardIteratorT Begin, + ForwardIteratorT End, + std::bidirectional_iterator_tag ) const + { + typedef iterator_range<ForwardIteratorT> result_type; + typedef ForwardIteratorT input_iterator_type; + + // Outer loop + for(input_iterator_type OuterIt=End; + OuterIt!=Begin; ) + { + input_iterator_type OuterIt2=--OuterIt; + + input_iterator_type InnerIt=OuterIt2; + search_iterator_type SubstrIt=m_Search.begin(); + for(; + InnerIt!=End && SubstrIt!=m_Search.end(); + ++InnerIt,++SubstrIt) + { + if( !( m_Comp(*InnerIt,*SubstrIt) ) ) + break; + } + + // Substring matching succeeded + if( SubstrIt==m_Search.end() ) + return result_type( OuterIt2, InnerIt ); + } + + return result_type( End, End ); + } + + private: + iterator_range<search_iterator_type> m_Search; + PredicateT m_Comp; + }; + +// find n-th functor -----------------------------------------------// + + // find the n-th match of a subsequence in the sequence ( functor ) + /* + Returns a pair <begin,end> marking the subsequence in the sequence. + If the find fails, returns <End,End> + */ + template<typename SearchIteratorT, typename PredicateT> + struct nth_finderF + { + typedef SearchIteratorT search_iterator_type; + typedef first_finderF< + search_iterator_type, + PredicateT> first_finder_type; + typedef last_finderF< + search_iterator_type, + PredicateT> last_finder_type; + + // Construction + template< typename SearchT > + nth_finderF( + const SearchT& Search, + int Nth, + PredicateT Comp) : + m_Search(::boost::begin(Search), ::boost::end(Search)), + m_Nth(Nth), + m_Comp(Comp) {} + nth_finderF( + search_iterator_type SearchBegin, + search_iterator_type SearchEnd, + int Nth, + PredicateT Comp) : + m_Search(SearchBegin, SearchEnd), + m_Nth(Nth), + m_Comp(Comp) {} + + // Operation + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + operator()( + ForwardIteratorT Begin, + ForwardIteratorT End ) const + { + if(m_Nth>=0) + { + return find_forward(Begin, End, m_Nth); + } + else + { + return find_backward(Begin, End, -m_Nth); + } + + } + + private: + // Implementation helpers + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + find_forward( + ForwardIteratorT Begin, + ForwardIteratorT End, + unsigned int N) const + { + typedef iterator_range<ForwardIteratorT> result_type; + + // Sanity check + if( boost::empty(m_Search) ) + return result_type( End, End ); + + // Instantiate find functor + first_finder_type first_finder( + m_Search.begin(), m_Search.end(), m_Comp ); + + result_type M( Begin, Begin ); + + for( unsigned int n=0; n<=N; ++n ) + { + // find next match + M=first_finder( ::boost::end(M), End ); + + if ( !M ) + { + // Subsequence not found, return + return M; + } + } + + return M; + } + + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + find_backward( + ForwardIteratorT Begin, + ForwardIteratorT End, + unsigned int N) const + { + typedef iterator_range<ForwardIteratorT> result_type; + + // Sanity check + if( boost::empty(m_Search) ) + return result_type( End, End ); + + // Instantiate find functor + last_finder_type last_finder( + m_Search.begin(), m_Search.end(), m_Comp ); + + result_type M( End, End ); + + for( unsigned int n=1; n<=N; ++n ) + { + // find next match + M=last_finder( Begin, ::boost::begin(M) ); + + if ( !M ) + { + // Subsequence not found, return + return M; + } + } + + return M; + } + + + private: + iterator_range<search_iterator_type> m_Search; + int m_Nth; + PredicateT m_Comp; + }; + +// find head/tail implementation helpers ---------------------------// + + template<typename ForwardIteratorT> + iterator_range<ForwardIteratorT> + find_head_impl( + ForwardIteratorT Begin, + ForwardIteratorT End, + unsigned int N, + std::forward_iterator_tag ) + { + typedef ForwardIteratorT input_iterator_type; + typedef iterator_range<ForwardIteratorT> result_type; + + input_iterator_type It=Begin; + for( + unsigned int Index=0; + Index<N && It!=End; ++Index,++It ) {}; + + return result_type( Begin, It ); + } + + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + find_head_impl( + ForwardIteratorT Begin, + ForwardIteratorT End, + unsigned int N, + std::random_access_iterator_tag ) + { + typedef iterator_range<ForwardIteratorT> result_type; + + if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < N ) ) + return result_type( Begin, End ); + + return result_type(Begin,Begin+N); + } + + // Find head implementation + template<typename ForwardIteratorT> + iterator_range<ForwardIteratorT> + find_head_impl( + ForwardIteratorT Begin, + ForwardIteratorT End, + unsigned int N ) + { + typedef BOOST_STRING_TYPENAME boost::detail:: + iterator_traits<ForwardIteratorT>::iterator_category category; + + return ::boost::algorithm::detail::find_head_impl( Begin, End, N, category() ); + } + + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + find_tail_impl( + ForwardIteratorT Begin, + ForwardIteratorT End, + unsigned int N, + std::forward_iterator_tag ) + { + typedef ForwardIteratorT input_iterator_type; + typedef iterator_range<ForwardIteratorT> result_type; + + unsigned int Index=0; + input_iterator_type It=Begin; + input_iterator_type It2=Begin; + + // Advance It2 by N increments + for( Index=0; Index<N && It2!=End; ++Index,++It2 ) {}; + + // Advance It, It2 to the end + for(; It2!=End; ++It,++It2 ) {}; + + return result_type( It, It2 ); + } + + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + find_tail_impl( + ForwardIteratorT Begin, + ForwardIteratorT End, + unsigned int N, + std::bidirectional_iterator_tag ) + { + typedef ForwardIteratorT input_iterator_type; + typedef iterator_range<ForwardIteratorT> result_type; + + input_iterator_type It=End; + for( + unsigned int Index=0; + Index<N && It!=Begin; ++Index,--It ) {}; + + return result_type( It, End ); + } + + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + find_tail_impl( + ForwardIteratorT Begin, + ForwardIteratorT End, + unsigned int N, + std::random_access_iterator_tag ) + { + typedef iterator_range<ForwardIteratorT> result_type; + + if ( (End<=Begin) || ( static_cast<unsigned int>(End-Begin) < N ) ) + return result_type( Begin, End ); + + return result_type( End-N, End ); + } + + // Operation + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + find_tail_impl( + ForwardIteratorT Begin, + ForwardIteratorT End, + unsigned int N ) + { + typedef BOOST_STRING_TYPENAME boost::detail:: + iterator_traits<ForwardIteratorT>::iterator_category category; + + return ::boost::algorithm::detail::find_tail_impl( Begin, End, N, category() ); + } + + + +// find head functor -----------------------------------------------// + + + // find a head in the sequence ( functor ) + /* + This functor find a head of the specified range. For + a specified N, the head is a subsequence of N starting + elements of the range. + */ + struct head_finderF + { + // Construction + head_finderF( int N ) : m_N(N) {} + + // Operation + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + operator()( + ForwardIteratorT Begin, + ForwardIteratorT End ) const + { + if(m_N>=0) + { + return ::boost::algorithm::detail::find_head_impl( Begin, End, m_N ); + } + else + { + iterator_range<ForwardIteratorT> Res= + ::boost::algorithm::detail::find_tail_impl( Begin, End, -m_N ); + + return ::boost::make_iterator_range(Begin, Res.begin()); + } + } + + private: + int m_N; + }; + +// find tail functor -----------------------------------------------// + + + // find a tail in the sequence ( functor ) + /* + This functor find a tail of the specified range. For + a specified N, the head is a subsequence of N starting + elements of the range. + */ + struct tail_finderF + { + // Construction + tail_finderF( int N ) : m_N(N) {} + + // Operation + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + operator()( + ForwardIteratorT Begin, + ForwardIteratorT End ) const + { + if(m_N>=0) + { + return ::boost::algorithm::detail::find_tail_impl( Begin, End, m_N ); + } + else + { + iterator_range<ForwardIteratorT> Res= + ::boost::algorithm::detail::find_head_impl( Begin, End, -m_N ); + + return ::boost::make_iterator_range(Res.end(), End); + } + } + + private: + int m_N; + }; + +// find token functor -----------------------------------------------// + + // find a token in a sequence ( functor ) + /* + This find functor finds a token specified be a predicate + in a sequence. It is equivalent of std::find algorithm, + with an exception that it return range instead of a single + iterator. + + If bCompress is set to true, adjacent matching tokens are + concatenated into one match. + */ + template< typename PredicateT > + struct token_finderF + { + // Construction + token_finderF( + PredicateT Pred, + token_compress_mode_type eCompress=token_compress_off ) : + m_Pred(Pred), m_eCompress(eCompress) {} + + // Operation + template< typename ForwardIteratorT > + iterator_range<ForwardIteratorT> + operator()( + ForwardIteratorT Begin, + ForwardIteratorT End ) const + { + typedef iterator_range<ForwardIteratorT> result_type; + + ForwardIteratorT It=std::find_if( Begin, End, m_Pred ); + + if( It==End ) + { + return result_type( End, End ); + } + else + { + ForwardIteratorT It2=It; + + if( m_eCompress==token_compress_on ) + { + // Find first non-matching character + while( It2!=End && m_Pred(*It2) ) ++It2; + } + else + { + // Advance by one position + ++It2; + } + + return result_type( It, It2 ); + } + } + + private: + PredicateT m_Pred; + token_compress_mode_type m_eCompress; + }; + +// find range functor -----------------------------------------------// + + // find a range in the sequence ( functor ) + /* + This functor actually does not perform any find operation. + It always returns given iterator range as a result. + */ + template<typename ForwardIterator1T> + struct range_finderF + { + typedef ForwardIterator1T input_iterator_type; + typedef iterator_range<input_iterator_type> result_type; + + // Construction + range_finderF( + input_iterator_type Begin, + input_iterator_type End ) : m_Range(Begin, End) {} + + range_finderF(const iterator_range<input_iterator_type>& Range) : + m_Range(Range) {} + + // Operation + template< typename ForwardIterator2T > + iterator_range<ForwardIterator2T> + operator()( + ForwardIterator2T, + ForwardIterator2T ) const + { +#if BOOST_WORKAROUND( __MWERKS__, <= 0x3003 ) + return iterator_range<const ForwardIterator2T>(this->m_Range); +#else + return m_Range; +#endif + } + + private: + iterator_range<input_iterator_type> m_Range; + }; + + + } // namespace detail + } // namespace algorithm +} // namespace boost + +#endif // BOOST_STRING_FINDER_DETAIL_HPP diff --git a/contrib/src/boost/algorithm/string/detail/formatter.hpp b/contrib/src/boost/algorithm/string/detail/formatter.hpp index 9fd16e2..c071822 100644 --- a/contrib/src/boost/algorithm/string/detail/formatter.hpp +++ b/contrib/src/boost/algorithm/string/detail/formatter.hpp @@ -1,119 +1,119 @@ -// Boost string_algo library formatter.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_FORMATTER_DETAIL_HPP
-#define BOOST_STRING_FORMATTER_DETAIL_HPP
-
-
-#include <boost/range/iterator_range_core.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/range/const_iterator.hpp>
-
-#include <boost/algorithm/string/detail/util.hpp>
-
-// generic replace functors -----------------------------------------------//
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-// const format functor ----------------------------------------------------//
-
- // constant format functor
- template<typename RangeT>
- struct const_formatF
- {
- private:
- typedef BOOST_STRING_TYPENAME
- range_const_iterator<RangeT>::type format_iterator;
- typedef iterator_range<format_iterator> result_type;
-
- public:
- // Construction
- const_formatF(const RangeT& Format) :
- m_Format(::boost::begin(Format), ::boost::end(Format)) {}
-
- // Operation
-#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564))
- template<typename Range2T>
- result_type& operator()(const Range2T&)
- {
- return m_Format;
- }
-#endif
-
- template<typename Range2T>
- const result_type& operator()(const Range2T&) const
- {
- return m_Format;
- }
-
- private:
- result_type m_Format;
- };
-
-// identity format functor ----------------------------------------------------//
-
- // identity format functor
- template<typename RangeT>
- struct identity_formatF
- {
- // Operation
- template< typename Range2T >
- const RangeT& operator()(const Range2T& Replace) const
- {
- return RangeT(::boost::begin(Replace), ::boost::end(Replace));
- }
- };
-
-// empty format functor ( used by erase ) ------------------------------------//
-
- // empty format functor
- template< typename CharT >
- struct empty_formatF
- {
- template< typename ReplaceT >
- empty_container<CharT> operator()(const ReplaceT&) const
- {
- return empty_container<CharT>();
- }
- };
-
-// dissect format functor ----------------------------------------------------//
-
- // dissect format functor
- template<typename FinderT>
- struct dissect_formatF
- {
- public:
- // Construction
- dissect_formatF(FinderT Finder) :
- m_Finder(Finder) {}
-
- // Operation
- template<typename RangeT>
- inline iterator_range<
- BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
- operator()(const RangeT& Replace) const
- {
- return m_Finder(::boost::begin(Replace), ::boost::end(Replace));
- }
-
- private:
- FinderT m_Finder;
- };
-
-
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-#endif // BOOST_STRING_FORMATTER_DETAIL_HPP
+// Boost string_algo library formatter.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org for updates, documentation, and revision history. + +#ifndef BOOST_STRING_FORMATTER_DETAIL_HPP +#define BOOST_STRING_FORMATTER_DETAIL_HPP + + +#include <boost/range/iterator_range_core.hpp> +#include <boost/range/begin.hpp> +#include <boost/range/end.hpp> +#include <boost/range/const_iterator.hpp> + +#include <boost/algorithm/string/detail/util.hpp> + +// generic replace functors -----------------------------------------------// + +namespace boost { + namespace algorithm { + namespace detail { + +// const format functor ----------------------------------------------------// + + // constant format functor + template<typename RangeT> + struct const_formatF + { + private: + typedef BOOST_STRING_TYPENAME + range_const_iterator<RangeT>::type format_iterator; + typedef iterator_range<format_iterator> result_type; + + public: + // Construction + const_formatF(const RangeT& Format) : + m_Format(::boost::begin(Format), ::boost::end(Format)) {} + + // Operation +#if BOOST_WORKAROUND(__BORLANDC__, BOOST_TESTED_AT(0x564)) + template<typename Range2T> + result_type& operator()(const Range2T&) + { + return m_Format; + } +#endif + + template<typename Range2T> + const result_type& operator()(const Range2T&) const + { + return m_Format; + } + + private: + result_type m_Format; + }; + +// identity format functor ----------------------------------------------------// + + // identity format functor + template<typename RangeT> + struct identity_formatF + { + // Operation + template< typename Range2T > + const RangeT& operator()(const Range2T& Replace) const + { + return RangeT(::boost::begin(Replace), ::boost::end(Replace)); + } + }; + +// empty format functor ( used by erase ) ------------------------------------// + + // empty format functor + template< typename CharT > + struct empty_formatF + { + template< typename ReplaceT > + empty_container<CharT> operator()(const ReplaceT&) const + { + return empty_container<CharT>(); + } + }; + +// dissect format functor ----------------------------------------------------// + + // dissect format functor + template<typename FinderT> + struct dissect_formatF + { + public: + // Construction + dissect_formatF(FinderT Finder) : + m_Finder(Finder) {} + + // Operation + template<typename RangeT> + inline iterator_range< + BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> + operator()(const RangeT& Replace) const + { + return m_Finder(::boost::begin(Replace), ::boost::end(Replace)); + } + + private: + FinderT m_Finder; + }; + + + } // namespace detail + } // namespace algorithm +} // namespace boost + +#endif // BOOST_STRING_FORMATTER_DETAIL_HPP diff --git a/contrib/src/boost/algorithm/string/detail/predicate.hpp b/contrib/src/boost/algorithm/string/detail/predicate.hpp index bd95d40..5acf3cc 100644 --- a/contrib/src/boost/algorithm/string/detail/predicate.hpp +++ b/contrib/src/boost/algorithm/string/detail/predicate.hpp @@ -1,77 +1,77 @@ -// Boost string_algo library predicate.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_PREDICATE_DETAIL_HPP
-#define BOOST_STRING_PREDICATE_DETAIL_HPP
-
-#include <iterator>
-#include <boost/algorithm/string/find.hpp>
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-// ends_with predicate implementation ----------------------------------//
-
- template<
- typename ForwardIterator1T,
- typename ForwardIterator2T,
- typename PredicateT>
- inline bool ends_with_iter_select(
- ForwardIterator1T Begin,
- ForwardIterator1T End,
- ForwardIterator2T SubBegin,
- ForwardIterator2T SubEnd,
- PredicateT Comp,
- std::bidirectional_iterator_tag)
- {
- ForwardIterator1T it=End;
- ForwardIterator2T pit=SubEnd;
- for(;it!=Begin && pit!=SubBegin;)
- {
- if( !(Comp(*(--it),*(--pit))) )
- return false;
- }
-
- return pit==SubBegin;
- }
-
- template<
- typename ForwardIterator1T,
- typename ForwardIterator2T,
- typename PredicateT>
- inline bool ends_with_iter_select(
- ForwardIterator1T Begin,
- ForwardIterator1T End,
- ForwardIterator2T SubBegin,
- ForwardIterator2T SubEnd,
- PredicateT Comp,
- std::forward_iterator_tag)
- {
- if ( SubBegin==SubEnd )
- {
- // empty subsequence check
- return true;
- }
-
- iterator_range<ForwardIterator1T> Result
- =last_finder(
- ::boost::make_iterator_range(SubBegin, SubEnd),
- Comp)(Begin, End);
-
- return !Result.empty() && Result.end()==End;
- }
-
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-
-#endif // BOOST_STRING_PREDICATE_DETAIL_HPP
+// Boost string_algo library predicate.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_PREDICATE_DETAIL_HPP +#define BOOST_STRING_PREDICATE_DETAIL_HPP + +#include <iterator> +#include <boost/algorithm/string/find.hpp> + +namespace boost { + namespace algorithm { + namespace detail { + +// ends_with predicate implementation ----------------------------------// + + template< + typename ForwardIterator1T, + typename ForwardIterator2T, + typename PredicateT> + inline bool ends_with_iter_select( + ForwardIterator1T Begin, + ForwardIterator1T End, + ForwardIterator2T SubBegin, + ForwardIterator2T SubEnd, + PredicateT Comp, + std::bidirectional_iterator_tag) + { + ForwardIterator1T it=End; + ForwardIterator2T pit=SubEnd; + for(;it!=Begin && pit!=SubBegin;) + { + if( !(Comp(*(--it),*(--pit))) ) + return false; + } + + return pit==SubBegin; + } + + template< + typename ForwardIterator1T, + typename ForwardIterator2T, + typename PredicateT> + inline bool ends_with_iter_select( + ForwardIterator1T Begin, + ForwardIterator1T End, + ForwardIterator2T SubBegin, + ForwardIterator2T SubEnd, + PredicateT Comp, + std::forward_iterator_tag) + { + if ( SubBegin==SubEnd ) + { + // empty subsequence check + return true; + } + + iterator_range<ForwardIterator1T> Result + =last_finder( + ::boost::make_iterator_range(SubBegin, SubEnd), + Comp)(Begin, End); + + return !Result.empty() && Result.end()==End; + } + + } // namespace detail + } // namespace algorithm +} // namespace boost + + +#endif // BOOST_STRING_PREDICATE_DETAIL_HPP diff --git a/contrib/src/boost/algorithm/string/detail/replace_storage.hpp b/contrib/src/boost/algorithm/string/detail/replace_storage.hpp index 13f4e08..db35e4c 100644 --- a/contrib/src/boost/algorithm/string/detail/replace_storage.hpp +++ b/contrib/src/boost/algorithm/string/detail/replace_storage.hpp @@ -1,159 +1,159 @@ -// Boost string_algo library replace_storage.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_REPLACE_STORAGE_DETAIL_HPP
-#define BOOST_STRING_REPLACE_STORAGE_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <algorithm>
-#include <boost/mpl/bool.hpp>
-#include <boost/algorithm/string/sequence_traits.hpp>
-#include <boost/algorithm/string/detail/sequence.hpp>
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-// storage handling routines -----------------------------------------------//
-
- template< typename StorageT, typename OutputIteratorT >
- inline OutputIteratorT move_from_storage(
- StorageT& Storage,
- OutputIteratorT DestBegin,
- OutputIteratorT DestEnd )
- {
- OutputIteratorT OutputIt=DestBegin;
-
- while( !Storage.empty() && OutputIt!=DestEnd )
- {
- *OutputIt=Storage.front();
- Storage.pop_front();
- ++OutputIt;
- }
-
- return OutputIt;
- }
-
- template< typename StorageT, typename WhatT >
- inline void copy_to_storage(
- StorageT& Storage,
- const WhatT& What )
- {
- Storage.insert( Storage.end(), ::boost::begin(What), ::boost::end(What) );
- }
-
-
-// process segment routine -----------------------------------------------//
-
- template< bool HasStableIterators >
- struct process_segment_helper
- {
- // Optimized version of process_segment for generic sequence
- template<
- typename StorageT,
- typename InputT,
- typename ForwardIteratorT >
- ForwardIteratorT operator()(
- StorageT& Storage,
- InputT& /*Input*/,
- ForwardIteratorT InsertIt,
- ForwardIteratorT SegmentBegin,
- ForwardIteratorT SegmentEnd )
- {
- // Copy data from the storage until the beginning of the segment
- ForwardIteratorT It=::boost::algorithm::detail::move_from_storage( Storage, InsertIt, SegmentBegin );
-
- // 3 cases are possible :
- // a) Storage is empty, It==SegmentBegin
- // b) Storage is empty, It!=SegmentBegin
- // c) Storage is not empty
-
- if( Storage.empty() )
- {
- if( It==SegmentBegin )
- {
- // Case a) everything is grand, just return end of segment
- return SegmentEnd;
- }
- else
- {
- // Case b) move the segment backwards
- return std::copy( SegmentBegin, SegmentEnd, It );
- }
- }
- else
- {
- // Case c) -> shift the segment to the left and keep the overlap in the storage
- while( It!=SegmentEnd )
- {
- // Store value into storage
- Storage.push_back( *It );
- // Get the top from the storage and put it here
- *It=Storage.front();
- Storage.pop_front();
-
- // Advance
- ++It;
- }
-
- return It;
- }
- }
- };
-
- template<>
- struct process_segment_helper< true >
- {
- // Optimized version of process_segment for list-like sequence
- template<
- typename StorageT,
- typename InputT,
- typename ForwardIteratorT >
- ForwardIteratorT operator()(
- StorageT& Storage,
- InputT& Input,
- ForwardIteratorT InsertIt,
- ForwardIteratorT SegmentBegin,
- ForwardIteratorT SegmentEnd )
-
- {
- // Call replace to do the job
- ::boost::algorithm::detail::replace( Input, InsertIt, SegmentBegin, Storage );
- // Empty the storage
- Storage.clear();
- // Iterators were not changed, simply return the end of segment
- return SegmentEnd;
- }
- };
-
- // Process one segment in the replace_all algorithm
- template<
- typename StorageT,
- typename InputT,
- typename ForwardIteratorT >
- inline ForwardIteratorT process_segment(
- StorageT& Storage,
- InputT& Input,
- ForwardIteratorT InsertIt,
- ForwardIteratorT SegmentBegin,
- ForwardIteratorT SegmentEnd )
- {
- return
- process_segment_helper<
- has_stable_iterators<InputT>::value>()(
- Storage, Input, InsertIt, SegmentBegin, SegmentEnd );
- }
-
-
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-#endif // BOOST_STRING_REPLACE_STORAGE_DETAIL_HPP
+// Boost string_algo library replace_storage.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_REPLACE_STORAGE_DETAIL_HPP +#define BOOST_STRING_REPLACE_STORAGE_DETAIL_HPP + +#include <boost/algorithm/string/config.hpp> +#include <algorithm> +#include <boost/mpl/bool.hpp> +#include <boost/algorithm/string/sequence_traits.hpp> +#include <boost/algorithm/string/detail/sequence.hpp> + +namespace boost { + namespace algorithm { + namespace detail { + +// storage handling routines -----------------------------------------------// + + template< typename StorageT, typename OutputIteratorT > + inline OutputIteratorT move_from_storage( + StorageT& Storage, + OutputIteratorT DestBegin, + OutputIteratorT DestEnd ) + { + OutputIteratorT OutputIt=DestBegin; + + while( !Storage.empty() && OutputIt!=DestEnd ) + { + *OutputIt=Storage.front(); + Storage.pop_front(); + ++OutputIt; + } + + return OutputIt; + } + + template< typename StorageT, typename WhatT > + inline void copy_to_storage( + StorageT& Storage, + const WhatT& What ) + { + Storage.insert( Storage.end(), ::boost::begin(What), ::boost::end(What) ); + } + + +// process segment routine -----------------------------------------------// + + template< bool HasStableIterators > + struct process_segment_helper + { + // Optimized version of process_segment for generic sequence + template< + typename StorageT, + typename InputT, + typename ForwardIteratorT > + ForwardIteratorT operator()( + StorageT& Storage, + InputT& /*Input*/, + ForwardIteratorT InsertIt, + ForwardIteratorT SegmentBegin, + ForwardIteratorT SegmentEnd ) + { + // Copy data from the storage until the beginning of the segment + ForwardIteratorT It=::boost::algorithm::detail::move_from_storage( Storage, InsertIt, SegmentBegin ); + + // 3 cases are possible : + // a) Storage is empty, It==SegmentBegin + // b) Storage is empty, It!=SegmentBegin + // c) Storage is not empty + + if( Storage.empty() ) + { + if( It==SegmentBegin ) + { + // Case a) everything is grand, just return end of segment + return SegmentEnd; + } + else + { + // Case b) move the segment backwards + return std::copy( SegmentBegin, SegmentEnd, It ); + } + } + else + { + // Case c) -> shift the segment to the left and keep the overlap in the storage + while( It!=SegmentEnd ) + { + // Store value into storage + Storage.push_back( *It ); + // Get the top from the storage and put it here + *It=Storage.front(); + Storage.pop_front(); + + // Advance + ++It; + } + + return It; + } + } + }; + + template<> + struct process_segment_helper< true > + { + // Optimized version of process_segment for list-like sequence + template< + typename StorageT, + typename InputT, + typename ForwardIteratorT > + ForwardIteratorT operator()( + StorageT& Storage, + InputT& Input, + ForwardIteratorT InsertIt, + ForwardIteratorT SegmentBegin, + ForwardIteratorT SegmentEnd ) + + { + // Call replace to do the job + ::boost::algorithm::detail::replace( Input, InsertIt, SegmentBegin, Storage ); + // Empty the storage + Storage.clear(); + // Iterators were not changed, simply return the end of segment + return SegmentEnd; + } + }; + + // Process one segment in the replace_all algorithm + template< + typename StorageT, + typename InputT, + typename ForwardIteratorT > + inline ForwardIteratorT process_segment( + StorageT& Storage, + InputT& Input, + ForwardIteratorT InsertIt, + ForwardIteratorT SegmentBegin, + ForwardIteratorT SegmentEnd ) + { + return + process_segment_helper< + has_stable_iterators<InputT>::value>()( + Storage, Input, InsertIt, SegmentBegin, SegmentEnd ); + } + + + } // namespace detail + } // namespace algorithm +} // namespace boost + +#endif // BOOST_STRING_REPLACE_STORAGE_DETAIL_HPP diff --git a/contrib/src/boost/algorithm/string/detail/sequence.hpp b/contrib/src/boost/algorithm/string/detail/sequence.hpp index 8c8bd97..dc47409 100644 --- a/contrib/src/boost/algorithm/string/detail/sequence.hpp +++ b/contrib/src/boost/algorithm/string/detail/sequence.hpp @@ -1,200 +1,200 @@ -// Boost string_algo library sequence.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_DETAIL_SEQUENCE_HPP
-#define BOOST_STRING_DETAIL_SEQUENCE_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/mpl/logical.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-
-#include <boost/algorithm/string/sequence_traits.hpp>
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-// insert helpers -------------------------------------------------//
-
- template< typename InputT, typename ForwardIteratorT >
- inline void insert(
- InputT& Input,
- BOOST_STRING_TYPENAME InputT::iterator At,
- ForwardIteratorT Begin,
- ForwardIteratorT End )
- {
- Input.insert( At, Begin, End );
- }
-
- template< typename InputT, typename InsertT >
- inline void insert(
- InputT& Input,
- BOOST_STRING_TYPENAME InputT::iterator At,
- const InsertT& Insert )
- {
- ::boost::algorithm::detail::insert( Input, At, ::boost::begin(Insert), ::boost::end(Insert) );
- }
-
-// erase helper ---------------------------------------------------//
-
- // Erase a range in the sequence
- /*
- Returns the iterator pointing just after the erase subrange
- */
- template< typename InputT >
- inline typename InputT::iterator erase(
- InputT& Input,
- BOOST_STRING_TYPENAME InputT::iterator From,
- BOOST_STRING_TYPENAME InputT::iterator To )
- {
- return Input.erase( From, To );
- }
-
-// replace helper implementation ----------------------------------//
-
- // Optimized version of replace for generic sequence containers
- // Assumption: insert and erase are expensive
- template< bool HasConstTimeOperations >
- struct replace_const_time_helper
- {
- template< typename InputT, typename ForwardIteratorT >
- void operator()(
- InputT& Input,
- BOOST_STRING_TYPENAME InputT::iterator From,
- BOOST_STRING_TYPENAME InputT::iterator To,
- ForwardIteratorT Begin,
- ForwardIteratorT End )
- {
- // Copy data to the container ( as much as possible )
- ForwardIteratorT InsertIt=Begin;
- BOOST_STRING_TYPENAME InputT::iterator InputIt=From;
- for(; InsertIt!=End && InputIt!=To; InsertIt++, InputIt++ )
- {
- *InputIt=*InsertIt;
- }
-
- if ( InsertIt!=End )
- {
- // Replace sequence is longer, insert it
- Input.insert( InputIt, InsertIt, End );
- }
- else
- {
- if ( InputIt!=To )
- {
- // Replace sequence is shorter, erase the rest
- Input.erase( InputIt, To );
- }
- }
- }
- };
-
- template<>
- struct replace_const_time_helper< true >
- {
- // Const-time erase and insert methods -> use them
- template< typename InputT, typename ForwardIteratorT >
- void operator()(
- InputT& Input,
- BOOST_STRING_TYPENAME InputT::iterator From,
- BOOST_STRING_TYPENAME InputT::iterator To,
- ForwardIteratorT Begin,
- ForwardIteratorT End )
- {
- BOOST_STRING_TYPENAME InputT::iterator At=Input.erase( From, To );
- if ( Begin!=End )
- {
- if(!Input.empty())
- {
- Input.insert( At, Begin, End );
- }
- else
- {
- Input.insert( Input.begin(), Begin, End );
- }
- }
- }
- };
-
- // No native replace method
- template< bool HasNative >
- struct replace_native_helper
- {
- template< typename InputT, typename ForwardIteratorT >
- void operator()(
- InputT& Input,
- BOOST_STRING_TYPENAME InputT::iterator From,
- BOOST_STRING_TYPENAME InputT::iterator To,
- ForwardIteratorT Begin,
- ForwardIteratorT End )
- {
- replace_const_time_helper<
- boost::mpl::and_<
- has_const_time_insert<InputT>,
- has_const_time_erase<InputT> >::value >()(
- Input, From, To, Begin, End );
- }
- };
-
- // Container has native replace method
- template<>
- struct replace_native_helper< true >
- {
- template< typename InputT, typename ForwardIteratorT >
- void operator()(
- InputT& Input,
- BOOST_STRING_TYPENAME InputT::iterator From,
- BOOST_STRING_TYPENAME InputT::iterator To,
- ForwardIteratorT Begin,
- ForwardIteratorT End )
- {
- Input.replace( From, To, Begin, End );
- }
- };
-
-// replace helper -------------------------------------------------//
-
- template< typename InputT, typename ForwardIteratorT >
- inline void replace(
- InputT& Input,
- BOOST_STRING_TYPENAME InputT::iterator From,
- BOOST_STRING_TYPENAME InputT::iterator To,
- ForwardIteratorT Begin,
- ForwardIteratorT End )
- {
- replace_native_helper< has_native_replace<InputT>::value >()(
- Input, From, To, Begin, End );
- }
-
- template< typename InputT, typename InsertT >
- inline void replace(
- InputT& Input,
- BOOST_STRING_TYPENAME InputT::iterator From,
- BOOST_STRING_TYPENAME InputT::iterator To,
- const InsertT& Insert )
- {
- if(From!=To)
- {
- ::boost::algorithm::detail::replace( Input, From, To, ::boost::begin(Insert), ::boost::end(Insert) );
- }
- else
- {
- ::boost::algorithm::detail::insert( Input, From, ::boost::begin(Insert), ::boost::end(Insert) );
- }
- }
-
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-
-#endif // BOOST_STRING_DETAIL_SEQUENCE_HPP
+// Boost string_algo library sequence.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_DETAIL_SEQUENCE_HPP +#define BOOST_STRING_DETAIL_SEQUENCE_HPP + +#include <boost/algorithm/string/config.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/mpl/logical.hpp> +#include <boost/range/begin.hpp> +#include <boost/range/end.hpp> + +#include <boost/algorithm/string/sequence_traits.hpp> + +namespace boost { + namespace algorithm { + namespace detail { + +// insert helpers -------------------------------------------------// + + template< typename InputT, typename ForwardIteratorT > + inline void insert( + InputT& Input, + BOOST_STRING_TYPENAME InputT::iterator At, + ForwardIteratorT Begin, + ForwardIteratorT End ) + { + Input.insert( At, Begin, End ); + } + + template< typename InputT, typename InsertT > + inline void insert( + InputT& Input, + BOOST_STRING_TYPENAME InputT::iterator At, + const InsertT& Insert ) + { + ::boost::algorithm::detail::insert( Input, At, ::boost::begin(Insert), ::boost::end(Insert) ); + } + +// erase helper ---------------------------------------------------// + + // Erase a range in the sequence + /* + Returns the iterator pointing just after the erase subrange + */ + template< typename InputT > + inline typename InputT::iterator erase( + InputT& Input, + BOOST_STRING_TYPENAME InputT::iterator From, + BOOST_STRING_TYPENAME InputT::iterator To ) + { + return Input.erase( From, To ); + } + +// replace helper implementation ----------------------------------// + + // Optimized version of replace for generic sequence containers + // Assumption: insert and erase are expensive + template< bool HasConstTimeOperations > + struct replace_const_time_helper + { + template< typename InputT, typename ForwardIteratorT > + void operator()( + InputT& Input, + BOOST_STRING_TYPENAME InputT::iterator From, + BOOST_STRING_TYPENAME InputT::iterator To, + ForwardIteratorT Begin, + ForwardIteratorT End ) + { + // Copy data to the container ( as much as possible ) + ForwardIteratorT InsertIt=Begin; + BOOST_STRING_TYPENAME InputT::iterator InputIt=From; + for(; InsertIt!=End && InputIt!=To; InsertIt++, InputIt++ ) + { + *InputIt=*InsertIt; + } + + if ( InsertIt!=End ) + { + // Replace sequence is longer, insert it + Input.insert( InputIt, InsertIt, End ); + } + else + { + if ( InputIt!=To ) + { + // Replace sequence is shorter, erase the rest + Input.erase( InputIt, To ); + } + } + } + }; + + template<> + struct replace_const_time_helper< true > + { + // Const-time erase and insert methods -> use them + template< typename InputT, typename ForwardIteratorT > + void operator()( + InputT& Input, + BOOST_STRING_TYPENAME InputT::iterator From, + BOOST_STRING_TYPENAME InputT::iterator To, + ForwardIteratorT Begin, + ForwardIteratorT End ) + { + BOOST_STRING_TYPENAME InputT::iterator At=Input.erase( From, To ); + if ( Begin!=End ) + { + if(!Input.empty()) + { + Input.insert( At, Begin, End ); + } + else + { + Input.insert( Input.begin(), Begin, End ); + } + } + } + }; + + // No native replace method + template< bool HasNative > + struct replace_native_helper + { + template< typename InputT, typename ForwardIteratorT > + void operator()( + InputT& Input, + BOOST_STRING_TYPENAME InputT::iterator From, + BOOST_STRING_TYPENAME InputT::iterator To, + ForwardIteratorT Begin, + ForwardIteratorT End ) + { + replace_const_time_helper< + boost::mpl::and_< + has_const_time_insert<InputT>, + has_const_time_erase<InputT> >::value >()( + Input, From, To, Begin, End ); + } + }; + + // Container has native replace method + template<> + struct replace_native_helper< true > + { + template< typename InputT, typename ForwardIteratorT > + void operator()( + InputT& Input, + BOOST_STRING_TYPENAME InputT::iterator From, + BOOST_STRING_TYPENAME InputT::iterator To, + ForwardIteratorT Begin, + ForwardIteratorT End ) + { + Input.replace( From, To, Begin, End ); + } + }; + +// replace helper -------------------------------------------------// + + template< typename InputT, typename ForwardIteratorT > + inline void replace( + InputT& Input, + BOOST_STRING_TYPENAME InputT::iterator From, + BOOST_STRING_TYPENAME InputT::iterator To, + ForwardIteratorT Begin, + ForwardIteratorT End ) + { + replace_native_helper< has_native_replace<InputT>::value >()( + Input, From, To, Begin, End ); + } + + template< typename InputT, typename InsertT > + inline void replace( + InputT& Input, + BOOST_STRING_TYPENAME InputT::iterator From, + BOOST_STRING_TYPENAME InputT::iterator To, + const InsertT& Insert ) + { + if(From!=To) + { + ::boost::algorithm::detail::replace( Input, From, To, ::boost::begin(Insert), ::boost::end(Insert) ); + } + else + { + ::boost::algorithm::detail::insert( Input, From, ::boost::begin(Insert), ::boost::end(Insert) ); + } + } + + } // namespace detail + } // namespace algorithm +} // namespace boost + + +#endif // BOOST_STRING_DETAIL_SEQUENCE_HPP diff --git a/contrib/src/boost/algorithm/string/detail/trim.hpp b/contrib/src/boost/algorithm/string/detail/trim.hpp index b53072c..1233e49 100644 --- a/contrib/src/boost/algorithm/string/detail/trim.hpp +++ b/contrib/src/boost/algorithm/string/detail/trim.hpp @@ -1,95 +1,95 @@ -// Boost string_algo library trim.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_TRIM_DETAIL_HPP
-#define BOOST_STRING_TRIM_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/detail/iterator.hpp>
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-// trim iterator helper -----------------------------------------------//
-
- template< typename ForwardIteratorT, typename PredicateT >
- inline ForwardIteratorT trim_end_iter_select(
- ForwardIteratorT InBegin,
- ForwardIteratorT InEnd,
- PredicateT IsSpace,
- std::forward_iterator_tag )
- {
- ForwardIteratorT TrimIt=InBegin;
-
- for( ForwardIteratorT It=InBegin; It!=InEnd; ++It )
- {
- if ( !IsSpace(*It) )
- {
- TrimIt=It;
- ++TrimIt;
- }
- }
-
- return TrimIt;
- }
-
- template< typename ForwardIteratorT, typename PredicateT >
- inline ForwardIteratorT trim_end_iter_select(
- ForwardIteratorT InBegin,
- ForwardIteratorT InEnd,
- PredicateT IsSpace,
- std::bidirectional_iterator_tag )
- {
- for( ForwardIteratorT It=InEnd; It!=InBegin; )
- {
- if ( !IsSpace(*(--It)) )
- return ++It;
- }
-
- return InBegin;
- }
- // Search for first non matching character from the beginning of the sequence
- template< typename ForwardIteratorT, typename PredicateT >
- inline ForwardIteratorT trim_begin(
- ForwardIteratorT InBegin,
- ForwardIteratorT InEnd,
- PredicateT IsSpace )
- {
- ForwardIteratorT It=InBegin;
- for(; It!=InEnd; ++It )
- {
- if (!IsSpace(*It))
- return It;
- }
-
- return It;
- }
-
- // Search for first non matching character from the end of the sequence
- template< typename ForwardIteratorT, typename PredicateT >
- inline ForwardIteratorT trim_end(
- ForwardIteratorT InBegin,
- ForwardIteratorT InEnd,
- PredicateT IsSpace )
- {
- typedef BOOST_STRING_TYPENAME boost::detail::
- iterator_traits<ForwardIteratorT>::iterator_category category;
-
- return ::boost::algorithm::detail::trim_end_iter_select( InBegin, InEnd, IsSpace, category() );
- }
-
-
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-
-#endif // BOOST_STRING_TRIM_DETAIL_HPP
+// Boost string_algo library trim.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_TRIM_DETAIL_HPP +#define BOOST_STRING_TRIM_DETAIL_HPP + +#include <boost/algorithm/string/config.hpp> +#include <boost/detail/iterator.hpp> + +namespace boost { + namespace algorithm { + namespace detail { + +// trim iterator helper -----------------------------------------------// + + template< typename ForwardIteratorT, typename PredicateT > + inline ForwardIteratorT trim_end_iter_select( + ForwardIteratorT InBegin, + ForwardIteratorT InEnd, + PredicateT IsSpace, + std::forward_iterator_tag ) + { + ForwardIteratorT TrimIt=InBegin; + + for( ForwardIteratorT It=InBegin; It!=InEnd; ++It ) + { + if ( !IsSpace(*It) ) + { + TrimIt=It; + ++TrimIt; + } + } + + return TrimIt; + } + + template< typename ForwardIteratorT, typename PredicateT > + inline ForwardIteratorT trim_end_iter_select( + ForwardIteratorT InBegin, + ForwardIteratorT InEnd, + PredicateT IsSpace, + std::bidirectional_iterator_tag ) + { + for( ForwardIteratorT It=InEnd; It!=InBegin; ) + { + if ( !IsSpace(*(--It)) ) + return ++It; + } + + return InBegin; + } + // Search for first non matching character from the beginning of the sequence + template< typename ForwardIteratorT, typename PredicateT > + inline ForwardIteratorT trim_begin( + ForwardIteratorT InBegin, + ForwardIteratorT InEnd, + PredicateT IsSpace ) + { + ForwardIteratorT It=InBegin; + for(; It!=InEnd; ++It ) + { + if (!IsSpace(*It)) + return It; + } + + return It; + } + + // Search for first non matching character from the end of the sequence + template< typename ForwardIteratorT, typename PredicateT > + inline ForwardIteratorT trim_end( + ForwardIteratorT InBegin, + ForwardIteratorT InEnd, + PredicateT IsSpace ) + { + typedef BOOST_STRING_TYPENAME boost::detail:: + iterator_traits<ForwardIteratorT>::iterator_category category; + + return ::boost::algorithm::detail::trim_end_iter_select( InBegin, InEnd, IsSpace, category() ); + } + + + } // namespace detail + } // namespace algorithm +} // namespace boost + + +#endif // BOOST_STRING_TRIM_DETAIL_HPP diff --git a/contrib/src/boost/algorithm/string/detail/util.hpp b/contrib/src/boost/algorithm/string/detail/util.hpp index 4954fc2..cf4a8b1 100644 --- a/contrib/src/boost/algorithm/string/detail/util.hpp +++ b/contrib/src/boost/algorithm/string/detail/util.hpp @@ -1,106 +1,106 @@ -// Boost string_algo library util.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_UTIL_DETAIL_HPP
-#define BOOST_STRING_UTIL_DETAIL_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <functional>
-#include <boost/range/iterator_range_core.hpp>
-
-namespace boost {
- namespace algorithm {
- namespace detail {
-
-// empty container -----------------------------------------------//
-
- // empty_container
- /*
- This class represents always empty container,
- containing elements of type CharT.
-
- It is supposed to be used in a const version only
- */
- template< typename CharT >
- struct empty_container
- {
- typedef empty_container<CharT> type;
- typedef CharT value_type;
- typedef std::size_t size_type;
- typedef std::ptrdiff_t difference_type;
- typedef const value_type& reference;
- typedef const value_type& const_reference;
- typedef const value_type* iterator;
- typedef const value_type* const_iterator;
-
-
- // Operations
- const_iterator begin() const
- {
- return reinterpret_cast<const_iterator>(0);
- }
-
- const_iterator end() const
- {
- return reinterpret_cast<const_iterator>(0);
- }
-
- bool empty() const
- {
- return false;
- }
-
- size_type size() const
- {
- return 0;
- }
- };
-
-// bounded copy algorithm -----------------------------------------------//
-
- // Bounded version of the std::copy algorithm
- template<typename InputIteratorT, typename OutputIteratorT>
- inline OutputIteratorT bounded_copy(
- InputIteratorT First,
- InputIteratorT Last,
- OutputIteratorT DestFirst,
- OutputIteratorT DestLast )
- {
- InputIteratorT InputIt=First;
- OutputIteratorT OutputIt=DestFirst;
- for(; InputIt!=Last && OutputIt!=DestLast; InputIt++, OutputIt++ )
- {
- *OutputIt=*InputIt;
- }
-
- return OutputIt;
- }
-
-// iterator range utilities -----------------------------------------//
-
- // copy range functor
- template<
- typename SeqT,
- typename IteratorT=BOOST_STRING_TYPENAME SeqT::const_iterator >
- struct copy_iterator_rangeF :
- public std::unary_function< iterator_range<IteratorT>, SeqT >
- {
- SeqT operator()( const iterator_range<IteratorT>& Range ) const
- {
- return copy_range<SeqT>(Range);
- }
- };
-
- } // namespace detail
- } // namespace algorithm
-} // namespace boost
-
-
-#endif // BOOST_STRING_UTIL_DETAIL_HPP
+// Boost string_algo library util.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_UTIL_DETAIL_HPP +#define BOOST_STRING_UTIL_DETAIL_HPP + +#include <boost/algorithm/string/config.hpp> +#include <functional> +#include <boost/range/iterator_range_core.hpp> + +namespace boost { + namespace algorithm { + namespace detail { + +// empty container -----------------------------------------------// + + // empty_container + /* + This class represents always empty container, + containing elements of type CharT. + + It is supposed to be used in a const version only + */ + template< typename CharT > + struct empty_container + { + typedef empty_container<CharT> type; + typedef CharT value_type; + typedef std::size_t size_type; + typedef std::ptrdiff_t difference_type; + typedef const value_type& reference; + typedef const value_type& const_reference; + typedef const value_type* iterator; + typedef const value_type* const_iterator; + + + // Operations + const_iterator begin() const + { + return reinterpret_cast<const_iterator>(0); + } + + const_iterator end() const + { + return reinterpret_cast<const_iterator>(0); + } + + bool empty() const + { + return false; + } + + size_type size() const + { + return 0; + } + }; + +// bounded copy algorithm -----------------------------------------------// + + // Bounded version of the std::copy algorithm + template<typename InputIteratorT, typename OutputIteratorT> + inline OutputIteratorT bounded_copy( + InputIteratorT First, + InputIteratorT Last, + OutputIteratorT DestFirst, + OutputIteratorT DestLast ) + { + InputIteratorT InputIt=First; + OutputIteratorT OutputIt=DestFirst; + for(; InputIt!=Last && OutputIt!=DestLast; InputIt++, OutputIt++ ) + { + *OutputIt=*InputIt; + } + + return OutputIt; + } + +// iterator range utilities -----------------------------------------// + + // copy range functor + template< + typename SeqT, + typename IteratorT=BOOST_STRING_TYPENAME SeqT::const_iterator > + struct copy_iterator_rangeF : + public std::unary_function< iterator_range<IteratorT>, SeqT > + { + SeqT operator()( const iterator_range<IteratorT>& Range ) const + { + return copy_range<SeqT>(Range); + } + }; + + } // namespace detail + } // namespace algorithm +} // namespace boost + + +#endif // BOOST_STRING_UTIL_DETAIL_HPP diff --git a/contrib/src/boost/algorithm/string/erase.hpp b/contrib/src/boost/algorithm/string/erase.hpp index 9611bb3..6883790 100644 --- a/contrib/src/boost/algorithm/string/erase.hpp +++ b/contrib/src/boost/algorithm/string/erase.hpp @@ -1,844 +1,844 @@ -// Boost string_algo library erase.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2006.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_ERASE_HPP
-#define BOOST_STRING_ERASE_HPP
-
-#include <boost/algorithm/string/config.hpp>
-
-#include <boost/range/iterator_range_core.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/range/iterator.hpp>
-#include <boost/range/const_iterator.hpp>
-
-#include <boost/algorithm/string/find_format.hpp>
-#include <boost/algorithm/string/finder.hpp>
-#include <boost/algorithm/string/formatter.hpp>
-
-/*! \file
- Defines various erase algorithms. Each algorithm removes
- part(s) of the input according to a searching criteria.
-*/
-
-namespace boost {
- namespace algorithm {
-
-// erase_range -------------------------------------------------------//
-
- //! Erase range algorithm
- /*!
- Remove the given range from the input. The result is a modified copy of
- the input. It is returned as a sequence or copied to the output iterator.
-
- \param Output An output iterator to which the result will be copied
- \param Input An input sequence
- \param SearchRange A range in the input to be removed
- \return An output iterator pointing just after the last inserted character or
- a modified copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<typename OutputIteratorT, typename RangeT>
- inline OutputIteratorT erase_range_copy(
- OutputIteratorT Output,
- const RangeT& Input,
- const iterator_range<
- BOOST_STRING_TYPENAME
- range_const_iterator<RangeT>::type>& SearchRange )
- {
- return ::boost::algorithm::find_format_copy(
- Output,
- Input,
- ::boost::algorithm::range_finder(SearchRange),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
- //! Erase range algorithm
- /*!
- \overload
- */
- template<typename SequenceT>
- inline SequenceT erase_range_copy(
- const SequenceT& Input,
- const iterator_range<
- BOOST_STRING_TYPENAME
- range_const_iterator<SequenceT>::type>& SearchRange )
- {
- return ::boost::algorithm::find_format_copy(
- Input,
- ::boost::algorithm::range_finder(SearchRange),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
- //! Erase range algorithm
- /*!
- Remove the given range from the input.
- The input sequence is modified in-place.
-
- \param Input An input sequence
- \param SearchRange A range in the input to be removed
- */
- template<typename SequenceT>
- inline void erase_range(
- SequenceT& Input,
- const iterator_range<
- BOOST_STRING_TYPENAME
- range_iterator<SequenceT>::type>& SearchRange )
- {
- ::boost::algorithm::find_format(
- Input,
- ::boost::algorithm::range_finder(SearchRange),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
-// erase_first --------------------------------------------------------//
-
- //! Erase first algorithm
- /*!
- Remove the first occurrence of the substring from the input.
- The result is a modified copy of the input. It is returned as a sequence
- or copied to the output iterator.
-
- \param Output An output iterator to which the result will be copied
- \param Input An input string
- \param Search A substring to be searched for
- \return An output iterator pointing just after the last inserted character or
- a modified copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<
- typename OutputIteratorT,
- typename Range1T,
- typename Range2T>
- inline OutputIteratorT erase_first_copy(
- OutputIteratorT Output,
- const Range1T& Input,
- const Range2T& Search )
- {
- return ::boost::algorithm::find_format_copy(
- Output,
- Input,
- ::boost::algorithm::first_finder(Search),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
- //! Erase first algorithm
- /*!
- \overload
- */
- template<typename SequenceT, typename RangeT>
- inline SequenceT erase_first_copy(
- const SequenceT& Input,
- const RangeT& Search )
- {
- return ::boost::algorithm::find_format_copy(
- Input,
- ::boost::algorithm::first_finder(Search),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
- //! Erase first algorithm
- /*!
- Remove the first occurrence of the substring from the input.
- The input sequence is modified in-place.
-
- \param Input An input string
- \param Search A substring to be searched for.
- */
- template<typename SequenceT, typename RangeT>
- inline void erase_first(
- SequenceT& Input,
- const RangeT& Search )
- {
- ::boost::algorithm::find_format(
- Input,
- ::boost::algorithm::first_finder(Search),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
-// erase_first ( case insensitive ) ------------------------------------//
-
- //! Erase first algorithm ( case insensitive )
- /*!
- Remove the first occurrence of the substring from the input.
- The result is a modified copy of the input. It is returned as a sequence
- or copied to the output iterator.
- Searching is case insensitive.
-
- \param Output An output iterator to which the result will be copied
- \param Input An input string
- \param Search A substring to be searched for
- \param Loc A locale used for case insensitive comparison
- \return An output iterator pointing just after the last inserted character or
- a modified copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<
- typename OutputIteratorT,
- typename Range1T,
- typename Range2T>
- inline OutputIteratorT ierase_first_copy(
- OutputIteratorT Output,
- const Range1T& Input,
- const Range2T& Search,
- const std::locale& Loc=std::locale() )
- {
- return ::boost::algorithm::find_format_copy(
- Output,
- Input,
- ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
- //! Erase first algorithm ( case insensitive )
- /*!
- \overload
- */
- template<typename SequenceT, typename RangeT>
- inline SequenceT ierase_first_copy(
- const SequenceT& Input,
- const RangeT& Search,
- const std::locale& Loc=std::locale() )
- {
- return ::boost::algorithm::find_format_copy(
- Input,
- ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
- //! Erase first algorithm ( case insensitive )
- /*!
- Remove the first occurrence of the substring from the input.
- The input sequence is modified in-place. Searching is case insensitive.
-
- \param Input An input string
- \param Search A substring to be searched for
- \param Loc A locale used for case insensitive comparison
- */
- template<typename SequenceT, typename RangeT>
- inline void ierase_first(
- SequenceT& Input,
- const RangeT& Search,
- const std::locale& Loc=std::locale() )
- {
- ::boost::algorithm::find_format(
- Input,
- ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
-// erase_last --------------------------------------------------------//
-
- //! Erase last algorithm
- /*!
- Remove the last occurrence of the substring from the input.
- The result is a modified copy of the input. It is returned as a sequence
- or copied to the output iterator.
-
- \param Output An output iterator to which the result will be copied
- \param Input An input string
- \param Search A substring to be searched for.
- \return An output iterator pointing just after the last inserted character or
- a modified copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<
- typename OutputIteratorT,
- typename Range1T,
- typename Range2T>
- inline OutputIteratorT erase_last_copy(
- OutputIteratorT Output,
- const Range1T& Input,
- const Range2T& Search )
- {
- return ::boost::algorithm::find_format_copy(
- Output,
- Input,
- ::boost::algorithm::last_finder(Search),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
- //! Erase last algorithm
- /*!
- \overload
- */
- template<typename SequenceT, typename RangeT>
- inline SequenceT erase_last_copy(
- const SequenceT& Input,
- const RangeT& Search )
- {
- return ::boost::algorithm::find_format_copy(
- Input,
- ::boost::algorithm::last_finder(Search),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
- //! Erase last algorithm
- /*!
- Remove the last occurrence of the substring from the input.
- The input sequence is modified in-place.
-
- \param Input An input string
- \param Search A substring to be searched for
- */
- template<typename SequenceT, typename RangeT>
- inline void erase_last(
- SequenceT& Input,
- const RangeT& Search )
- {
- ::boost::algorithm::find_format(
- Input,
- ::boost::algorithm::last_finder(Search),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
-// erase_last ( case insensitive ) ------------------------------------//
-
- //! Erase last algorithm ( case insensitive )
- /*!
- Remove the last occurrence of the substring from the input.
- The result is a modified copy of the input. It is returned as a sequence
- or copied to the output iterator.
- Searching is case insensitive.
-
- \param Output An output iterator to which the result will be copied
- \param Input An input string
- \param Search A substring to be searched for
- \param Loc A locale used for case insensitive comparison
- \return An output iterator pointing just after the last inserted character or
- a modified copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<
- typename OutputIteratorT,
- typename Range1T,
- typename Range2T>
- inline OutputIteratorT ierase_last_copy(
- OutputIteratorT Output,
- const Range1T& Input,
- const Range2T& Search,
- const std::locale& Loc=std::locale() )
- {
- return ::boost::algorithm::find_format_copy(
- Output,
- Input,
- ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
- //! Erase last algorithm ( case insensitive )
- /*!
- \overload
- */
- template<typename SequenceT, typename RangeT>
- inline SequenceT ierase_last_copy(
- const SequenceT& Input,
- const RangeT& Search,
- const std::locale& Loc=std::locale() )
- {
- return ::boost::algorithm::find_format_copy(
- Input,
- ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
- //! Erase last algorithm ( case insensitive )
- /*!
- Remove the last occurrence of the substring from the input.
- The input sequence is modified in-place. Searching is case insensitive.
-
- \param Input An input string
- \param Search A substring to be searched for
- \param Loc A locale used for case insensitive comparison
- */
- template<typename SequenceT, typename RangeT>
- inline void ierase_last(
- SequenceT& Input,
- const RangeT& Search,
- const std::locale& Loc=std::locale() )
- {
- ::boost::algorithm::find_format(
- Input,
- ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
-// erase_nth --------------------------------------------------------------------//
-
- //! Erase nth algorithm
- /*!
- Remove the Nth occurrence of the substring in the input.
- The result is a modified copy of the input. It is returned as a sequence
- or copied to the output iterator.
-
-
- \param Output An output iterator to which the result will be copied
- \param Input An input string
- \param Search A substring to be searched for
- \param Nth An index of the match to be replaced. The index is 0-based.
- For negative N, matches are counted from the end of string.
- \return An output iterator pointing just after the last inserted character or
- a modified copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<
- typename OutputIteratorT,
- typename Range1T,
- typename Range2T>
- inline OutputIteratorT erase_nth_copy(
- OutputIteratorT Output,
- const Range1T& Input,
- const Range2T& Search,
- int Nth )
- {
- return ::boost::algorithm::find_format_copy(
- Output,
- Input,
- ::boost::algorithm::nth_finder(Search, Nth),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
- //! Erase nth algorithm
- /*!
- \overload
- */
- template<typename SequenceT, typename RangeT>
- inline SequenceT erase_nth_copy(
- const SequenceT& Input,
- const RangeT& Search,
- int Nth )
- {
- return ::boost::algorithm::find_format_copy(
- Input,
- ::boost::algorithm::nth_finder(Search, Nth),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
- //! Erase nth algorithm
- /*!
- Remove the Nth occurrence of the substring in the input.
- The input sequence is modified in-place.
-
- \param Input An input string
- \param Search A substring to be searched for.
- \param Nth An index of the match to be replaced. The index is 0-based.
- For negative N, matches are counted from the end of string.
- */
- template<typename SequenceT, typename RangeT>
- inline void erase_nth(
- SequenceT& Input,
- const RangeT& Search,
- int Nth )
- {
- ::boost::algorithm::find_format(
- Input,
- ::boost::algorithm::nth_finder(Search, Nth),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
-// erase_nth ( case insensitive ) ---------------------------------------------//
-
- //! Erase nth algorithm ( case insensitive )
- /*!
- Remove the Nth occurrence of the substring in the input.
- The result is a modified copy of the input. It is returned as a sequence
- or copied to the output iterator.
- Searching is case insensitive.
-
- \param Output An output iterator to which the result will be copied
- \param Input An input string
- \param Search A substring to be searched for.
- \param Nth An index of the match to be replaced. The index is 0-based.
- For negative N, matches are counted from the end of string.
- \param Loc A locale used for case insensitive comparison
- \return An output iterator pointing just after the last inserted character or
- a modified copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<
- typename OutputIteratorT,
- typename Range1T,
- typename Range2T>
- inline OutputIteratorT ierase_nth_copy(
- OutputIteratorT Output,
- const Range1T& Input,
- const Range2T& Search,
- int Nth,
- const std::locale& Loc=std::locale() )
- {
- return ::boost::algorithm::find_format_copy(
- Output,
- Input,
- ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
- //! Erase nth algorithm
- /*!
- \overload
- */
- template<typename SequenceT, typename RangeT>
- inline SequenceT ierase_nth_copy(
- const SequenceT& Input,
- const RangeT& Search,
- int Nth,
- const std::locale& Loc=std::locale() )
- {
- return ::boost::algorithm::find_format_copy(
- Input,
- ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
- empty_formatter(Input) );
- }
-
- //! Erase nth algorithm
- /*!
- Remove the Nth occurrence of the substring in the input.
- The input sequence is modified in-place. Searching is case insensitive.
-
- \param Input An input string
- \param Search A substring to be searched for.
- \param Nth An index of the match to be replaced. The index is 0-based.
- For negative N, matches are counted from the end of string.
- \param Loc A locale used for case insensitive comparison
- */
- template<typename SequenceT, typename RangeT>
- inline void ierase_nth(
- SequenceT& Input,
- const RangeT& Search,
- int Nth,
- const std::locale& Loc=std::locale() )
- {
- ::boost::algorithm::find_format(
- Input,
- ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
-
-// erase_all --------------------------------------------------------//
-
- //! Erase all algorithm
- /*!
- Remove all the occurrences of the string from the input.
- The result is a modified copy of the input. It is returned as a sequence
- or copied to the output iterator.
-
-
- \param Output An output iterator to which the result will be copied
- \param Input An input sequence
- \param Search A substring to be searched for.
- \return An output iterator pointing just after the last inserted character or
- a modified copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<
- typename OutputIteratorT,
- typename Range1T,
- typename Range2T>
- inline OutputIteratorT erase_all_copy(
- OutputIteratorT Output,
- const Range1T& Input,
- const Range2T& Search )
- {
- return ::boost::algorithm::find_format_all_copy(
- Output,
- Input,
- ::boost::algorithm::first_finder(Search),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
- //! Erase all algorithm
- /*!
- \overload
- */
- template<typename SequenceT, typename RangeT>
- inline SequenceT erase_all_copy(
- const SequenceT& Input,
- const RangeT& Search )
- {
- return ::boost::algorithm::find_format_all_copy(
- Input,
- ::boost::algorithm::first_finder(Search),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
- //! Erase all algorithm
- /*!
- Remove all the occurrences of the string from the input.
- The input sequence is modified in-place.
-
- \param Input An input string
- \param Search A substring to be searched for.
- */
- template<typename SequenceT, typename RangeT>
- inline void erase_all(
- SequenceT& Input,
- const RangeT& Search )
- {
- ::boost::algorithm::find_format_all(
- Input,
- ::boost::algorithm::first_finder(Search),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
-// erase_all ( case insensitive ) ------------------------------------//
-
- //! Erase all algorithm ( case insensitive )
- /*!
- Remove all the occurrences of the string from the input.
- The result is a modified copy of the input. It is returned as a sequence
- or copied to the output iterator.
- Searching is case insensitive.
-
- \param Output An output iterator to which the result will be copied
- \param Input An input string
- \param Search A substring to be searched for
- \param Loc A locale used for case insensitive comparison
- \return An output iterator pointing just after the last inserted character or
- a modified copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<
- typename OutputIteratorT,
- typename Range1T,
- typename Range2T>
- inline OutputIteratorT ierase_all_copy(
- OutputIteratorT Output,
- const Range1T& Input,
- const Range2T& Search,
- const std::locale& Loc=std::locale() )
- {
- return ::boost::algorithm::find_format_all_copy(
- Output,
- Input,
- ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
- //! Erase all algorithm ( case insensitive )
- /*!
- \overload
- */
- template<typename SequenceT, typename RangeT>
- inline SequenceT ierase_all_copy(
- const SequenceT& Input,
- const RangeT& Search,
- const std::locale& Loc=std::locale() )
- {
- return ::boost::algorithm::find_format_all_copy(
- Input,
- ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
- //! Erase all algorithm ( case insensitive )
- /*!
- Remove all the occurrences of the string from the input.
- The input sequence is modified in-place. Searching is case insensitive.
-
- \param Input An input string
- \param Search A substring to be searched for.
- \param Loc A locale used for case insensitive comparison
- */
- template<typename SequenceT, typename RangeT>
- inline void ierase_all(
- SequenceT& Input,
- const RangeT& Search,
- const std::locale& Loc=std::locale() )
- {
- ::boost::algorithm::find_format_all(
- Input,
- ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
- ::boost::algorithm::empty_formatter(Input) );
- }
-
-// erase_head --------------------------------------------------------------------//
-
- //! Erase head algorithm
- /*!
- Remove the head from the input. The head is a prefix of a sequence of given size.
- If the sequence is shorter then required, the whole string is
- considered to be the head. The result is a modified copy of the input.
- It is returned as a sequence or copied to the output iterator.
-
-
- \param Output An output iterator to which the result will be copied
- \param Input An input string
- \param N Length of the head.
- For N>=0, at most N characters are extracted.
- For N<0, size(Input)-|N| characters are extracted.
- \return An output iterator pointing just after the last inserted character or
- a modified copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<
- typename OutputIteratorT,
- typename RangeT>
- inline OutputIteratorT erase_head_copy(
- OutputIteratorT Output,
- const RangeT& Input,
- int N )
- {
- return ::boost::algorithm::find_format_copy(
- Output,
- Input,
- ::boost::algorithm::head_finder(N),
- ::boost::algorithm::empty_formatter( Input ) );
- }
-
- //! Erase head algorithm
- /*!
- \overload
- */
- template<typename SequenceT>
- inline SequenceT erase_head_copy(
- const SequenceT& Input,
- int N )
- {
- return ::boost::algorithm::find_format_copy(
- Input,
- ::boost::algorithm::head_finder(N),
- ::boost::algorithm::empty_formatter( Input ) );
- }
-
- //! Erase head algorithm
- /*!
- Remove the head from the input. The head is a prefix of a sequence of given size.
- If the sequence is shorter then required, the whole string is
- considered to be the head. The input sequence is modified in-place.
-
- \param Input An input string
- \param N Length of the head
- For N>=0, at most N characters are extracted.
- For N<0, size(Input)-|N| characters are extracted.
- */
- template<typename SequenceT>
- inline void erase_head(
- SequenceT& Input,
- int N )
- {
- ::boost::algorithm::find_format(
- Input,
- ::boost::algorithm::head_finder(N),
- ::boost::algorithm::empty_formatter( Input ) );
- }
-
-// erase_tail --------------------------------------------------------------------//
-
- //! Erase tail algorithm
- /*!
- Remove the tail from the input. The tail is a suffix of a sequence of given size.
- If the sequence is shorter then required, the whole string is
- considered to be the tail.
- The result is a modified copy of the input. It is returned as a sequence
- or copied to the output iterator.
-
- \param Output An output iterator to which the result will be copied
- \param Input An input string
- \param N Length of the tail.
- For N>=0, at most N characters are extracted.
- For N<0, size(Input)-|N| characters are extracted.
- \return An output iterator pointing just after the last inserted character or
- a modified copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<
- typename OutputIteratorT,
- typename RangeT>
- inline OutputIteratorT erase_tail_copy(
- OutputIteratorT Output,
- const RangeT& Input,
- int N )
- {
- return ::boost::algorithm::find_format_copy(
- Output,
- Input,
- ::boost::algorithm::tail_finder(N),
- ::boost::algorithm::empty_formatter( Input ) );
- }
-
- //! Erase tail algorithm
- /*!
- \overload
- */
- template<typename SequenceT>
- inline SequenceT erase_tail_copy(
- const SequenceT& Input,
- int N )
- {
- return ::boost::algorithm::find_format_copy(
- Input,
- ::boost::algorithm::tail_finder(N),
- ::boost::algorithm::empty_formatter( Input ) );
- }
-
- //! Erase tail algorithm
- /*!
- Remove the tail from the input. The tail is a suffix of a sequence of given size.
- If the sequence is shorter then required, the whole string is
- considered to be the tail. The input sequence is modified in-place.
-
- \param Input An input string
- \param N Length of the tail
- For N>=0, at most N characters are extracted.
- For N<0, size(Input)-|N| characters are extracted.
- */
- template<typename SequenceT>
- inline void erase_tail(
- SequenceT& Input,
- int N )
- {
- ::boost::algorithm::find_format(
- Input,
- ::boost::algorithm::tail_finder(N),
- ::boost::algorithm::empty_formatter( Input ) );
- }
-
- } // namespace algorithm
-
- // pull names into the boost namespace
- using algorithm::erase_range_copy;
- using algorithm::erase_range;
- using algorithm::erase_first_copy;
- using algorithm::erase_first;
- using algorithm::ierase_first_copy;
- using algorithm::ierase_first;
- using algorithm::erase_last_copy;
- using algorithm::erase_last;
- using algorithm::ierase_last_copy;
- using algorithm::ierase_last;
- using algorithm::erase_nth_copy;
- using algorithm::erase_nth;
- using algorithm::ierase_nth_copy;
- using algorithm::ierase_nth;
- using algorithm::erase_all_copy;
- using algorithm::erase_all;
- using algorithm::ierase_all_copy;
- using algorithm::ierase_all;
- using algorithm::erase_head_copy;
- using algorithm::erase_head;
- using algorithm::erase_tail_copy;
- using algorithm::erase_tail;
-
-} // namespace boost
-
-
-#endif // BOOST_ERASE_HPP
+// Boost string_algo library erase.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2006. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_ERASE_HPP +#define BOOST_STRING_ERASE_HPP + +#include <boost/algorithm/string/config.hpp> + +#include <boost/range/iterator_range_core.hpp> +#include <boost/range/begin.hpp> +#include <boost/range/end.hpp> +#include <boost/range/iterator.hpp> +#include <boost/range/const_iterator.hpp> + +#include <boost/algorithm/string/find_format.hpp> +#include <boost/algorithm/string/finder.hpp> +#include <boost/algorithm/string/formatter.hpp> + +/*! \file + Defines various erase algorithms. Each algorithm removes + part(s) of the input according to a searching criteria. +*/ + +namespace boost { + namespace algorithm { + +// erase_range -------------------------------------------------------// + + //! Erase range algorithm + /*! + Remove the given range from the input. The result is a modified copy of + the input. It is returned as a sequence or copied to the output iterator. + + \param Output An output iterator to which the result will be copied + \param Input An input sequence + \param SearchRange A range in the input to be removed + \return An output iterator pointing just after the last inserted character or + a modified copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template<typename OutputIteratorT, typename RangeT> + inline OutputIteratorT erase_range_copy( + OutputIteratorT Output, + const RangeT& Input, + const iterator_range< + BOOST_STRING_TYPENAME + range_const_iterator<RangeT>::type>& SearchRange ) + { + return ::boost::algorithm::find_format_copy( + Output, + Input, + ::boost::algorithm::range_finder(SearchRange), + ::boost::algorithm::empty_formatter(Input) ); + } + + //! Erase range algorithm + /*! + \overload + */ + template<typename SequenceT> + inline SequenceT erase_range_copy( + const SequenceT& Input, + const iterator_range< + BOOST_STRING_TYPENAME + range_const_iterator<SequenceT>::type>& SearchRange ) + { + return ::boost::algorithm::find_format_copy( + Input, + ::boost::algorithm::range_finder(SearchRange), + ::boost::algorithm::empty_formatter(Input) ); + } + + //! Erase range algorithm + /*! + Remove the given range from the input. + The input sequence is modified in-place. + + \param Input An input sequence + \param SearchRange A range in the input to be removed + */ + template<typename SequenceT> + inline void erase_range( + SequenceT& Input, + const iterator_range< + BOOST_STRING_TYPENAME + range_iterator<SequenceT>::type>& SearchRange ) + { + ::boost::algorithm::find_format( + Input, + ::boost::algorithm::range_finder(SearchRange), + ::boost::algorithm::empty_formatter(Input) ); + } + +// erase_first --------------------------------------------------------// + + //! Erase first algorithm + /*! + Remove the first occurrence of the substring from the input. + The result is a modified copy of the input. It is returned as a sequence + or copied to the output iterator. + + \param Output An output iterator to which the result will be copied + \param Input An input string + \param Search A substring to be searched for + \return An output iterator pointing just after the last inserted character or + a modified copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template< + typename OutputIteratorT, + typename Range1T, + typename Range2T> + inline OutputIteratorT erase_first_copy( + OutputIteratorT Output, + const Range1T& Input, + const Range2T& Search ) + { + return ::boost::algorithm::find_format_copy( + Output, + Input, + ::boost::algorithm::first_finder(Search), + ::boost::algorithm::empty_formatter(Input) ); + } + + //! Erase first algorithm + /*! + \overload + */ + template<typename SequenceT, typename RangeT> + inline SequenceT erase_first_copy( + const SequenceT& Input, + const RangeT& Search ) + { + return ::boost::algorithm::find_format_copy( + Input, + ::boost::algorithm::first_finder(Search), + ::boost::algorithm::empty_formatter(Input) ); + } + + //! Erase first algorithm + /*! + Remove the first occurrence of the substring from the input. + The input sequence is modified in-place. + + \param Input An input string + \param Search A substring to be searched for. + */ + template<typename SequenceT, typename RangeT> + inline void erase_first( + SequenceT& Input, + const RangeT& Search ) + { + ::boost::algorithm::find_format( + Input, + ::boost::algorithm::first_finder(Search), + ::boost::algorithm::empty_formatter(Input) ); + } + +// erase_first ( case insensitive ) ------------------------------------// + + //! Erase first algorithm ( case insensitive ) + /*! + Remove the first occurrence of the substring from the input. + The result is a modified copy of the input. It is returned as a sequence + or copied to the output iterator. + Searching is case insensitive. + + \param Output An output iterator to which the result will be copied + \param Input An input string + \param Search A substring to be searched for + \param Loc A locale used for case insensitive comparison + \return An output iterator pointing just after the last inserted character or + a modified copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template< + typename OutputIteratorT, + typename Range1T, + typename Range2T> + inline OutputIteratorT ierase_first_copy( + OutputIteratorT Output, + const Range1T& Input, + const Range2T& Search, + const std::locale& Loc=std::locale() ) + { + return ::boost::algorithm::find_format_copy( + Output, + Input, + ::boost::algorithm::first_finder(Search, is_iequal(Loc)), + ::boost::algorithm::empty_formatter(Input) ); + } + + //! Erase first algorithm ( case insensitive ) + /*! + \overload + */ + template<typename SequenceT, typename RangeT> + inline SequenceT ierase_first_copy( + const SequenceT& Input, + const RangeT& Search, + const std::locale& Loc=std::locale() ) + { + return ::boost::algorithm::find_format_copy( + Input, + ::boost::algorithm::first_finder(Search, is_iequal(Loc)), + ::boost::algorithm::empty_formatter(Input) ); + } + + //! Erase first algorithm ( case insensitive ) + /*! + Remove the first occurrence of the substring from the input. + The input sequence is modified in-place. Searching is case insensitive. + + \param Input An input string + \param Search A substring to be searched for + \param Loc A locale used for case insensitive comparison + */ + template<typename SequenceT, typename RangeT> + inline void ierase_first( + SequenceT& Input, + const RangeT& Search, + const std::locale& Loc=std::locale() ) + { + ::boost::algorithm::find_format( + Input, + ::boost::algorithm::first_finder(Search, is_iequal(Loc)), + ::boost::algorithm::empty_formatter(Input) ); + } + +// erase_last --------------------------------------------------------// + + //! Erase last algorithm + /*! + Remove the last occurrence of the substring from the input. + The result is a modified copy of the input. It is returned as a sequence + or copied to the output iterator. + + \param Output An output iterator to which the result will be copied + \param Input An input string + \param Search A substring to be searched for. + \return An output iterator pointing just after the last inserted character or + a modified copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template< + typename OutputIteratorT, + typename Range1T, + typename Range2T> + inline OutputIteratorT erase_last_copy( + OutputIteratorT Output, + const Range1T& Input, + const Range2T& Search ) + { + return ::boost::algorithm::find_format_copy( + Output, + Input, + ::boost::algorithm::last_finder(Search), + ::boost::algorithm::empty_formatter(Input) ); + } + + //! Erase last algorithm + /*! + \overload + */ + template<typename SequenceT, typename RangeT> + inline SequenceT erase_last_copy( + const SequenceT& Input, + const RangeT& Search ) + { + return ::boost::algorithm::find_format_copy( + Input, + ::boost::algorithm::last_finder(Search), + ::boost::algorithm::empty_formatter(Input) ); + } + + //! Erase last algorithm + /*! + Remove the last occurrence of the substring from the input. + The input sequence is modified in-place. + + \param Input An input string + \param Search A substring to be searched for + */ + template<typename SequenceT, typename RangeT> + inline void erase_last( + SequenceT& Input, + const RangeT& Search ) + { + ::boost::algorithm::find_format( + Input, + ::boost::algorithm::last_finder(Search), + ::boost::algorithm::empty_formatter(Input) ); + } + +// erase_last ( case insensitive ) ------------------------------------// + + //! Erase last algorithm ( case insensitive ) + /*! + Remove the last occurrence of the substring from the input. + The result is a modified copy of the input. It is returned as a sequence + or copied to the output iterator. + Searching is case insensitive. + + \param Output An output iterator to which the result will be copied + \param Input An input string + \param Search A substring to be searched for + \param Loc A locale used for case insensitive comparison + \return An output iterator pointing just after the last inserted character or + a modified copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template< + typename OutputIteratorT, + typename Range1T, + typename Range2T> + inline OutputIteratorT ierase_last_copy( + OutputIteratorT Output, + const Range1T& Input, + const Range2T& Search, + const std::locale& Loc=std::locale() ) + { + return ::boost::algorithm::find_format_copy( + Output, + Input, + ::boost::algorithm::last_finder(Search, is_iequal(Loc)), + ::boost::algorithm::empty_formatter(Input) ); + } + + //! Erase last algorithm ( case insensitive ) + /*! + \overload + */ + template<typename SequenceT, typename RangeT> + inline SequenceT ierase_last_copy( + const SequenceT& Input, + const RangeT& Search, + const std::locale& Loc=std::locale() ) + { + return ::boost::algorithm::find_format_copy( + Input, + ::boost::algorithm::last_finder(Search, is_iequal(Loc)), + ::boost::algorithm::empty_formatter(Input) ); + } + + //! Erase last algorithm ( case insensitive ) + /*! + Remove the last occurrence of the substring from the input. + The input sequence is modified in-place. Searching is case insensitive. + + \param Input An input string + \param Search A substring to be searched for + \param Loc A locale used for case insensitive comparison + */ + template<typename SequenceT, typename RangeT> + inline void ierase_last( + SequenceT& Input, + const RangeT& Search, + const std::locale& Loc=std::locale() ) + { + ::boost::algorithm::find_format( + Input, + ::boost::algorithm::last_finder(Search, is_iequal(Loc)), + ::boost::algorithm::empty_formatter(Input) ); + } + +// erase_nth --------------------------------------------------------------------// + + //! Erase nth algorithm + /*! + Remove the Nth occurrence of the substring in the input. + The result is a modified copy of the input. It is returned as a sequence + or copied to the output iterator. + + + \param Output An output iterator to which the result will be copied + \param Input An input string + \param Search A substring to be searched for + \param Nth An index of the match to be replaced. The index is 0-based. + For negative N, matches are counted from the end of string. + \return An output iterator pointing just after the last inserted character or + a modified copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template< + typename OutputIteratorT, + typename Range1T, + typename Range2T> + inline OutputIteratorT erase_nth_copy( + OutputIteratorT Output, + const Range1T& Input, + const Range2T& Search, + int Nth ) + { + return ::boost::algorithm::find_format_copy( + Output, + Input, + ::boost::algorithm::nth_finder(Search, Nth), + ::boost::algorithm::empty_formatter(Input) ); + } + + //! Erase nth algorithm + /*! + \overload + */ + template<typename SequenceT, typename RangeT> + inline SequenceT erase_nth_copy( + const SequenceT& Input, + const RangeT& Search, + int Nth ) + { + return ::boost::algorithm::find_format_copy( + Input, + ::boost::algorithm::nth_finder(Search, Nth), + ::boost::algorithm::empty_formatter(Input) ); + } + + //! Erase nth algorithm + /*! + Remove the Nth occurrence of the substring in the input. + The input sequence is modified in-place. + + \param Input An input string + \param Search A substring to be searched for. + \param Nth An index of the match to be replaced. The index is 0-based. + For negative N, matches are counted from the end of string. + */ + template<typename SequenceT, typename RangeT> + inline void erase_nth( + SequenceT& Input, + const RangeT& Search, + int Nth ) + { + ::boost::algorithm::find_format( + Input, + ::boost::algorithm::nth_finder(Search, Nth), + ::boost::algorithm::empty_formatter(Input) ); + } + +// erase_nth ( case insensitive ) ---------------------------------------------// + + //! Erase nth algorithm ( case insensitive ) + /*! + Remove the Nth occurrence of the substring in the input. + The result is a modified copy of the input. It is returned as a sequence + or copied to the output iterator. + Searching is case insensitive. + + \param Output An output iterator to which the result will be copied + \param Input An input string + \param Search A substring to be searched for. + \param Nth An index of the match to be replaced. The index is 0-based. + For negative N, matches are counted from the end of string. + \param Loc A locale used for case insensitive comparison + \return An output iterator pointing just after the last inserted character or + a modified copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template< + typename OutputIteratorT, + typename Range1T, + typename Range2T> + inline OutputIteratorT ierase_nth_copy( + OutputIteratorT Output, + const Range1T& Input, + const Range2T& Search, + int Nth, + const std::locale& Loc=std::locale() ) + { + return ::boost::algorithm::find_format_copy( + Output, + Input, + ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)), + ::boost::algorithm::empty_formatter(Input) ); + } + + //! Erase nth algorithm + /*! + \overload + */ + template<typename SequenceT, typename RangeT> + inline SequenceT ierase_nth_copy( + const SequenceT& Input, + const RangeT& Search, + int Nth, + const std::locale& Loc=std::locale() ) + { + return ::boost::algorithm::find_format_copy( + Input, + ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)), + empty_formatter(Input) ); + } + + //! Erase nth algorithm + /*! + Remove the Nth occurrence of the substring in the input. + The input sequence is modified in-place. Searching is case insensitive. + + \param Input An input string + \param Search A substring to be searched for. + \param Nth An index of the match to be replaced. The index is 0-based. + For negative N, matches are counted from the end of string. + \param Loc A locale used for case insensitive comparison + */ + template<typename SequenceT, typename RangeT> + inline void ierase_nth( + SequenceT& Input, + const RangeT& Search, + int Nth, + const std::locale& Loc=std::locale() ) + { + ::boost::algorithm::find_format( + Input, + ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)), + ::boost::algorithm::empty_formatter(Input) ); + } + + +// erase_all --------------------------------------------------------// + + //! Erase all algorithm + /*! + Remove all the occurrences of the string from the input. + The result is a modified copy of the input. It is returned as a sequence + or copied to the output iterator. + + + \param Output An output iterator to which the result will be copied + \param Input An input sequence + \param Search A substring to be searched for. + \return An output iterator pointing just after the last inserted character or + a modified copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template< + typename OutputIteratorT, + typename Range1T, + typename Range2T> + inline OutputIteratorT erase_all_copy( + OutputIteratorT Output, + const Range1T& Input, + const Range2T& Search ) + { + return ::boost::algorithm::find_format_all_copy( + Output, + Input, + ::boost::algorithm::first_finder(Search), + ::boost::algorithm::empty_formatter(Input) ); + } + + //! Erase all algorithm + /*! + \overload + */ + template<typename SequenceT, typename RangeT> + inline SequenceT erase_all_copy( + const SequenceT& Input, + const RangeT& Search ) + { + return ::boost::algorithm::find_format_all_copy( + Input, + ::boost::algorithm::first_finder(Search), + ::boost::algorithm::empty_formatter(Input) ); + } + + //! Erase all algorithm + /*! + Remove all the occurrences of the string from the input. + The input sequence is modified in-place. + + \param Input An input string + \param Search A substring to be searched for. + */ + template<typename SequenceT, typename RangeT> + inline void erase_all( + SequenceT& Input, + const RangeT& Search ) + { + ::boost::algorithm::find_format_all( + Input, + ::boost::algorithm::first_finder(Search), + ::boost::algorithm::empty_formatter(Input) ); + } + +// erase_all ( case insensitive ) ------------------------------------// + + //! Erase all algorithm ( case insensitive ) + /*! + Remove all the occurrences of the string from the input. + The result is a modified copy of the input. It is returned as a sequence + or copied to the output iterator. + Searching is case insensitive. + + \param Output An output iterator to which the result will be copied + \param Input An input string + \param Search A substring to be searched for + \param Loc A locale used for case insensitive comparison + \return An output iterator pointing just after the last inserted character or + a modified copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template< + typename OutputIteratorT, + typename Range1T, + typename Range2T> + inline OutputIteratorT ierase_all_copy( + OutputIteratorT Output, + const Range1T& Input, + const Range2T& Search, + const std::locale& Loc=std::locale() ) + { + return ::boost::algorithm::find_format_all_copy( + Output, + Input, + ::boost::algorithm::first_finder(Search, is_iequal(Loc)), + ::boost::algorithm::empty_formatter(Input) ); + } + + //! Erase all algorithm ( case insensitive ) + /*! + \overload + */ + template<typename SequenceT, typename RangeT> + inline SequenceT ierase_all_copy( + const SequenceT& Input, + const RangeT& Search, + const std::locale& Loc=std::locale() ) + { + return ::boost::algorithm::find_format_all_copy( + Input, + ::boost::algorithm::first_finder(Search, is_iequal(Loc)), + ::boost::algorithm::empty_formatter(Input) ); + } + + //! Erase all algorithm ( case insensitive ) + /*! + Remove all the occurrences of the string from the input. + The input sequence is modified in-place. Searching is case insensitive. + + \param Input An input string + \param Search A substring to be searched for. + \param Loc A locale used for case insensitive comparison + */ + template<typename SequenceT, typename RangeT> + inline void ierase_all( + SequenceT& Input, + const RangeT& Search, + const std::locale& Loc=std::locale() ) + { + ::boost::algorithm::find_format_all( + Input, + ::boost::algorithm::first_finder(Search, is_iequal(Loc)), + ::boost::algorithm::empty_formatter(Input) ); + } + +// erase_head --------------------------------------------------------------------// + + //! Erase head algorithm + /*! + Remove the head from the input. The head is a prefix of a sequence of given size. + If the sequence is shorter then required, the whole string is + considered to be the head. The result is a modified copy of the input. + It is returned as a sequence or copied to the output iterator. + + + \param Output An output iterator to which the result will be copied + \param Input An input string + \param N Length of the head. + For N>=0, at most N characters are extracted. + For N<0, size(Input)-|N| characters are extracted. + \return An output iterator pointing just after the last inserted character or + a modified copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template< + typename OutputIteratorT, + typename RangeT> + inline OutputIteratorT erase_head_copy( + OutputIteratorT Output, + const RangeT& Input, + int N ) + { + return ::boost::algorithm::find_format_copy( + Output, + Input, + ::boost::algorithm::head_finder(N), + ::boost::algorithm::empty_formatter( Input ) ); + } + + //! Erase head algorithm + /*! + \overload + */ + template<typename SequenceT> + inline SequenceT erase_head_copy( + const SequenceT& Input, + int N ) + { + return ::boost::algorithm::find_format_copy( + Input, + ::boost::algorithm::head_finder(N), + ::boost::algorithm::empty_formatter( Input ) ); + } + + //! Erase head algorithm + /*! + Remove the head from the input. The head is a prefix of a sequence of given size. + If the sequence is shorter then required, the whole string is + considered to be the head. The input sequence is modified in-place. + + \param Input An input string + \param N Length of the head + For N>=0, at most N characters are extracted. + For N<0, size(Input)-|N| characters are extracted. + */ + template<typename SequenceT> + inline void erase_head( + SequenceT& Input, + int N ) + { + ::boost::algorithm::find_format( + Input, + ::boost::algorithm::head_finder(N), + ::boost::algorithm::empty_formatter( Input ) ); + } + +// erase_tail --------------------------------------------------------------------// + + //! Erase tail algorithm + /*! + Remove the tail from the input. The tail is a suffix of a sequence of given size. + If the sequence is shorter then required, the whole string is + considered to be the tail. + The result is a modified copy of the input. It is returned as a sequence + or copied to the output iterator. + + \param Output An output iterator to which the result will be copied + \param Input An input string + \param N Length of the tail. + For N>=0, at most N characters are extracted. + For N<0, size(Input)-|N| characters are extracted. + \return An output iterator pointing just after the last inserted character or + a modified copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template< + typename OutputIteratorT, + typename RangeT> + inline OutputIteratorT erase_tail_copy( + OutputIteratorT Output, + const RangeT& Input, + int N ) + { + return ::boost::algorithm::find_format_copy( + Output, + Input, + ::boost::algorithm::tail_finder(N), + ::boost::algorithm::empty_formatter( Input ) ); + } + + //! Erase tail algorithm + /*! + \overload + */ + template<typename SequenceT> + inline SequenceT erase_tail_copy( + const SequenceT& Input, + int N ) + { + return ::boost::algorithm::find_format_copy( + Input, + ::boost::algorithm::tail_finder(N), + ::boost::algorithm::empty_formatter( Input ) ); + } + + //! Erase tail algorithm + /*! + Remove the tail from the input. The tail is a suffix of a sequence of given size. + If the sequence is shorter then required, the whole string is + considered to be the tail. The input sequence is modified in-place. + + \param Input An input string + \param N Length of the tail + For N>=0, at most N characters are extracted. + For N<0, size(Input)-|N| characters are extracted. + */ + template<typename SequenceT> + inline void erase_tail( + SequenceT& Input, + int N ) + { + ::boost::algorithm::find_format( + Input, + ::boost::algorithm::tail_finder(N), + ::boost::algorithm::empty_formatter( Input ) ); + } + + } // namespace algorithm + + // pull names into the boost namespace + using algorithm::erase_range_copy; + using algorithm::erase_range; + using algorithm::erase_first_copy; + using algorithm::erase_first; + using algorithm::ierase_first_copy; + using algorithm::ierase_first; + using algorithm::erase_last_copy; + using algorithm::erase_last; + using algorithm::ierase_last_copy; + using algorithm::ierase_last; + using algorithm::erase_nth_copy; + using algorithm::erase_nth; + using algorithm::ierase_nth_copy; + using algorithm::ierase_nth; + using algorithm::erase_all_copy; + using algorithm::erase_all; + using algorithm::ierase_all_copy; + using algorithm::ierase_all; + using algorithm::erase_head_copy; + using algorithm::erase_head; + using algorithm::erase_tail_copy; + using algorithm::erase_tail; + +} // namespace boost + + +#endif // BOOST_ERASE_HPP diff --git a/contrib/src/boost/algorithm/string/find.hpp b/contrib/src/boost/algorithm/string/find.hpp index 1268bea..f2c2926 100644 --- a/contrib/src/boost/algorithm/string/find.hpp +++ b/contrib/src/boost/algorithm/string/find.hpp @@ -1,334 +1,334 @@ -// Boost string_algo library find.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_FIND_HPP
-#define BOOST_STRING_FIND_HPP
-
-#include <boost/algorithm/string/config.hpp>
-
-#include <boost/range/iterator_range_core.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/range/iterator.hpp>
-#include <boost/range/as_literal.hpp>
-
-#include <boost/algorithm/string/finder.hpp>
-#include <boost/algorithm/string/compare.hpp>
-#include <boost/algorithm/string/constants.hpp>
-
-/*! \file
- Defines a set of find algorithms. The algorithms are searching
- for a substring of the input. The result is given as an \c iterator_range
- delimiting the substring.
-*/
-
-namespace boost {
- namespace algorithm {
-
-// Generic find -----------------------------------------------//
-
- //! Generic find algorithm
- /*!
- Search the input using the given finder.
-
- \param Input A string which will be searched.
- \param Finder Finder object used for searching.
- \return
- An \c iterator_range delimiting the match.
- Returned iterator is either \c RangeT::iterator or
- \c RangeT::const_iterator, depending on the constness of
- the input parameter.
- */
- template<typename RangeT, typename FinderT>
- inline iterator_range<
- BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
- find(
- RangeT& Input,
- const FinderT& Finder)
- {
- iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
-
- return Finder(::boost::begin(lit_input),::boost::end(lit_input));
- }
-
-// find_first -----------------------------------------------//
-
- //! Find first algorithm
- /*!
- Search for the first occurrence of the substring in the input.
-
- \param Input A string which will be searched.
- \param Search A substring to be searched for.
- \return
- An \c iterator_range delimiting the match.
- Returned iterator is either \c RangeT::iterator or
- \c RangeT::const_iterator, depending on the constness of
- the input parameter.
-
- \note This function provides the strong exception-safety guarantee
- */
- template<typename Range1T, typename Range2T>
- inline iterator_range<
- BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
- find_first(
- Range1T& Input,
- const Range2T& Search)
- {
- return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search));
- }
-
- //! Find first algorithm ( case insensitive )
- /*!
- Search for the first occurrence of the substring in the input.
- Searching is case insensitive.
-
- \param Input A string which will be searched.
- \param Search A substring to be searched for.
- \param Loc A locale used for case insensitive comparison
- \return
- An \c iterator_range delimiting the match.
- Returned iterator is either \c Range1T::iterator or
- \c Range1T::const_iterator, depending on the constness of
- the input parameter.
-
- \note This function provides the strong exception-safety guarantee
- */
- template<typename Range1T, typename Range2T>
- inline iterator_range<
- BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
- ifind_first(
- Range1T& Input,
- const Range2T& Search,
- const std::locale& Loc=std::locale())
- {
- return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search,is_iequal(Loc)));
- }
-
-// find_last -----------------------------------------------//
-
- //! Find last algorithm
- /*!
- Search for the last occurrence of the substring in the input.
-
- \param Input A string which will be searched.
- \param Search A substring to be searched for.
- \return
- An \c iterator_range delimiting the match.
- Returned iterator is either \c Range1T::iterator or
- \c Range1T::const_iterator, depending on the constness of
- the input parameter.
-
- \note This function provides the strong exception-safety guarantee
- */
- template<typename Range1T, typename Range2T>
- inline iterator_range<
- BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
- find_last(
- Range1T& Input,
- const Range2T& Search)
- {
- return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search));
- }
-
- //! Find last algorithm ( case insensitive )
- /*!
- Search for the last match a string in the input.
- Searching is case insensitive.
-
- \param Input A string which will be searched.
- \param Search A substring to be searched for.
- \param Loc A locale used for case insensitive comparison
- \return
- An \c iterator_range delimiting the match.
- Returned iterator is either \c Range1T::iterator or
- \c Range1T::const_iterator, depending on the constness of
- the input parameter.
-
- \note This function provides the strong exception-safety guarantee
- */
- template<typename Range1T, typename Range2T>
- inline iterator_range<
- BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
- ifind_last(
- Range1T& Input,
- const Range2T& Search,
- const std::locale& Loc=std::locale())
- {
- return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search, is_iequal(Loc)));
- }
-
-// find_nth ----------------------------------------------------------------------//
-
- //! Find n-th algorithm
- /*!
- Search for the n-th (zero-indexed) occurrence of the substring in the
- input.
-
- \param Input A string which will be searched.
- \param Search A substring to be searched for.
- \param Nth An index (zero-indexed) of the match to be found.
- For negative N, the matches are counted from the end of string.
- \return
- An \c iterator_range delimiting the match.
- Returned iterator is either \c Range1T::iterator or
- \c Range1T::const_iterator, depending on the constness of
- the input parameter.
- */
- template<typename Range1T, typename Range2T>
- inline iterator_range<
- BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
- find_nth(
- Range1T& Input,
- const Range2T& Search,
- int Nth)
- {
- return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth));
- }
-
- //! Find n-th algorithm ( case insensitive ).
- /*!
- Search for the n-th (zero-indexed) occurrence of the substring in the
- input. Searching is case insensitive.
-
- \param Input A string which will be searched.
- \param Search A substring to be searched for.
- \param Nth An index (zero-indexed) of the match to be found.
- For negative N, the matches are counted from the end of string.
- \param Loc A locale used for case insensitive comparison
- \return
- An \c iterator_range delimiting the match.
- Returned iterator is either \c Range1T::iterator or
- \c Range1T::const_iterator, depending on the constness of
- the input parameter.
-
-
- \note This function provides the strong exception-safety guarantee
- */
- template<typename Range1T, typename Range2T>
- inline iterator_range<
- BOOST_STRING_TYPENAME range_iterator<Range1T>::type>
- ifind_nth(
- Range1T& Input,
- const Range2T& Search,
- int Nth,
- const std::locale& Loc=std::locale())
- {
- return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth,is_iequal(Loc)));
- }
-
-// find_head ----------------------------------------------------------------------//
-
- //! Find head algorithm
- /*!
- Get the head of the input. Head is a prefix of the string of the
- given size. If the input is shorter then required, whole input is considered
- to be the head.
-
- \param Input An input string
- \param N Length of the head
- For N>=0, at most N characters are extracted.
- For N<0, at most size(Input)-|N| characters are extracted.
- \return
- An \c iterator_range delimiting the match.
- Returned iterator is either \c Range1T::iterator or
- \c Range1T::const_iterator, depending on the constness of
- the input parameter.
-
- \note This function provides the strong exception-safety guarantee
- */
- template<typename RangeT>
- inline iterator_range<
- BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
- find_head(
- RangeT& Input,
- int N)
- {
- return ::boost::algorithm::find(Input, ::boost::algorithm::head_finder(N));
- }
-
-// find_tail ----------------------------------------------------------------------//
-
- //! Find tail algorithm
- /*!
- Get the tail of the input. Tail is a suffix of the string of the
- given size. If the input is shorter then required, whole input is considered
- to be the tail.
-
- \param Input An input string
- \param N Length of the tail.
- For N>=0, at most N characters are extracted.
- For N<0, at most size(Input)-|N| characters are extracted.
- \return
- An \c iterator_range delimiting the match.
- Returned iterator is either \c RangeT::iterator or
- \c RangeT::const_iterator, depending on the constness of
- the input parameter.
-
-
- \note This function provides the strong exception-safety guarantee
- */
- template<typename RangeT>
- inline iterator_range<
- BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
- find_tail(
- RangeT& Input,
- int N)
- {
- return ::boost::algorithm::find(Input, ::boost::algorithm::tail_finder(N));
- }
-
-// find_token --------------------------------------------------------------------//
-
- //! Find token algorithm
- /*!
- Look for a given token in the string. Token is a character that matches the
- given predicate.
- If the "token compress mode" is enabled, adjacent tokens are considered to be one match.
-
- \param Input A input string.
- \param Pred A unary predicate to identify a token
- \param eCompress Enable/Disable compressing of adjacent tokens
- \return
- An \c iterator_range delimiting the match.
- Returned iterator is either \c RangeT::iterator or
- \c RangeT::const_iterator, depending on the constness of
- the input parameter.
-
- \note This function provides the strong exception-safety guarantee
- */
- template<typename RangeT, typename PredicateT>
- inline iterator_range<
- BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
- find_token(
- RangeT& Input,
- PredicateT Pred,
- token_compress_mode_type eCompress=token_compress_off)
- {
- return ::boost::algorithm::find(Input, ::boost::algorithm::token_finder(Pred, eCompress));
- }
-
- } // namespace algorithm
-
- // pull names to the boost namespace
- using algorithm::find;
- using algorithm::find_first;
- using algorithm::ifind_first;
- using algorithm::find_last;
- using algorithm::ifind_last;
- using algorithm::find_nth;
- using algorithm::ifind_nth;
- using algorithm::find_head;
- using algorithm::find_tail;
- using algorithm::find_token;
-
-} // namespace boost
-
-
-#endif // BOOST_STRING_FIND_HPP
+// Boost string_algo library find.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_FIND_HPP +#define BOOST_STRING_FIND_HPP + +#include <boost/algorithm/string/config.hpp> + +#include <boost/range/iterator_range_core.hpp> +#include <boost/range/begin.hpp> +#include <boost/range/end.hpp> +#include <boost/range/iterator.hpp> +#include <boost/range/as_literal.hpp> + +#include <boost/algorithm/string/finder.hpp> +#include <boost/algorithm/string/compare.hpp> +#include <boost/algorithm/string/constants.hpp> + +/*! \file + Defines a set of find algorithms. The algorithms are searching + for a substring of the input. The result is given as an \c iterator_range + delimiting the substring. +*/ + +namespace boost { + namespace algorithm { + +// Generic find -----------------------------------------------// + + //! Generic find algorithm + /*! + Search the input using the given finder. + + \param Input A string which will be searched. + \param Finder Finder object used for searching. + \return + An \c iterator_range delimiting the match. + Returned iterator is either \c RangeT::iterator or + \c RangeT::const_iterator, depending on the constness of + the input parameter. + */ + template<typename RangeT, typename FinderT> + inline iterator_range< + BOOST_STRING_TYPENAME range_iterator<RangeT>::type> + find( + RangeT& Input, + const FinderT& Finder) + { + iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input)); + + return Finder(::boost::begin(lit_input),::boost::end(lit_input)); + } + +// find_first -----------------------------------------------// + + //! Find first algorithm + /*! + Search for the first occurrence of the substring in the input. + + \param Input A string which will be searched. + \param Search A substring to be searched for. + \return + An \c iterator_range delimiting the match. + Returned iterator is either \c RangeT::iterator or + \c RangeT::const_iterator, depending on the constness of + the input parameter. + + \note This function provides the strong exception-safety guarantee + */ + template<typename Range1T, typename Range2T> + inline iterator_range< + BOOST_STRING_TYPENAME range_iterator<Range1T>::type> + find_first( + Range1T& Input, + const Range2T& Search) + { + return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search)); + } + + //! Find first algorithm ( case insensitive ) + /*! + Search for the first occurrence of the substring in the input. + Searching is case insensitive. + + \param Input A string which will be searched. + \param Search A substring to be searched for. + \param Loc A locale used for case insensitive comparison + \return + An \c iterator_range delimiting the match. + Returned iterator is either \c Range1T::iterator or + \c Range1T::const_iterator, depending on the constness of + the input parameter. + + \note This function provides the strong exception-safety guarantee + */ + template<typename Range1T, typename Range2T> + inline iterator_range< + BOOST_STRING_TYPENAME range_iterator<Range1T>::type> + ifind_first( + Range1T& Input, + const Range2T& Search, + const std::locale& Loc=std::locale()) + { + return ::boost::algorithm::find(Input, ::boost::algorithm::first_finder(Search,is_iequal(Loc))); + } + +// find_last -----------------------------------------------// + + //! Find last algorithm + /*! + Search for the last occurrence of the substring in the input. + + \param Input A string which will be searched. + \param Search A substring to be searched for. + \return + An \c iterator_range delimiting the match. + Returned iterator is either \c Range1T::iterator or + \c Range1T::const_iterator, depending on the constness of + the input parameter. + + \note This function provides the strong exception-safety guarantee + */ + template<typename Range1T, typename Range2T> + inline iterator_range< + BOOST_STRING_TYPENAME range_iterator<Range1T>::type> + find_last( + Range1T& Input, + const Range2T& Search) + { + return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search)); + } + + //! Find last algorithm ( case insensitive ) + /*! + Search for the last match a string in the input. + Searching is case insensitive. + + \param Input A string which will be searched. + \param Search A substring to be searched for. + \param Loc A locale used for case insensitive comparison + \return + An \c iterator_range delimiting the match. + Returned iterator is either \c Range1T::iterator or + \c Range1T::const_iterator, depending on the constness of + the input parameter. + + \note This function provides the strong exception-safety guarantee + */ + template<typename Range1T, typename Range2T> + inline iterator_range< + BOOST_STRING_TYPENAME range_iterator<Range1T>::type> + ifind_last( + Range1T& Input, + const Range2T& Search, + const std::locale& Loc=std::locale()) + { + return ::boost::algorithm::find(Input, ::boost::algorithm::last_finder(Search, is_iequal(Loc))); + } + +// find_nth ----------------------------------------------------------------------// + + //! Find n-th algorithm + /*! + Search for the n-th (zero-indexed) occurrence of the substring in the + input. + + \param Input A string which will be searched. + \param Search A substring to be searched for. + \param Nth An index (zero-indexed) of the match to be found. + For negative N, the matches are counted from the end of string. + \return + An \c iterator_range delimiting the match. + Returned iterator is either \c Range1T::iterator or + \c Range1T::const_iterator, depending on the constness of + the input parameter. + */ + template<typename Range1T, typename Range2T> + inline iterator_range< + BOOST_STRING_TYPENAME range_iterator<Range1T>::type> + find_nth( + Range1T& Input, + const Range2T& Search, + int Nth) + { + return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth)); + } + + //! Find n-th algorithm ( case insensitive ). + /*! + Search for the n-th (zero-indexed) occurrence of the substring in the + input. Searching is case insensitive. + + \param Input A string which will be searched. + \param Search A substring to be searched for. + \param Nth An index (zero-indexed) of the match to be found. + For negative N, the matches are counted from the end of string. + \param Loc A locale used for case insensitive comparison + \return + An \c iterator_range delimiting the match. + Returned iterator is either \c Range1T::iterator or + \c Range1T::const_iterator, depending on the constness of + the input parameter. + + + \note This function provides the strong exception-safety guarantee + */ + template<typename Range1T, typename Range2T> + inline iterator_range< + BOOST_STRING_TYPENAME range_iterator<Range1T>::type> + ifind_nth( + Range1T& Input, + const Range2T& Search, + int Nth, + const std::locale& Loc=std::locale()) + { + return ::boost::algorithm::find(Input, ::boost::algorithm::nth_finder(Search,Nth,is_iequal(Loc))); + } + +// find_head ----------------------------------------------------------------------// + + //! Find head algorithm + /*! + Get the head of the input. Head is a prefix of the string of the + given size. If the input is shorter then required, whole input is considered + to be the head. + + \param Input An input string + \param N Length of the head + For N>=0, at most N characters are extracted. + For N<0, at most size(Input)-|N| characters are extracted. + \return + An \c iterator_range delimiting the match. + Returned iterator is either \c Range1T::iterator or + \c Range1T::const_iterator, depending on the constness of + the input parameter. + + \note This function provides the strong exception-safety guarantee + */ + template<typename RangeT> + inline iterator_range< + BOOST_STRING_TYPENAME range_iterator<RangeT>::type> + find_head( + RangeT& Input, + int N) + { + return ::boost::algorithm::find(Input, ::boost::algorithm::head_finder(N)); + } + +// find_tail ----------------------------------------------------------------------// + + //! Find tail algorithm + /*! + Get the tail of the input. Tail is a suffix of the string of the + given size. If the input is shorter then required, whole input is considered + to be the tail. + + \param Input An input string + \param N Length of the tail. + For N>=0, at most N characters are extracted. + For N<0, at most size(Input)-|N| characters are extracted. + \return + An \c iterator_range delimiting the match. + Returned iterator is either \c RangeT::iterator or + \c RangeT::const_iterator, depending on the constness of + the input parameter. + + + \note This function provides the strong exception-safety guarantee + */ + template<typename RangeT> + inline iterator_range< + BOOST_STRING_TYPENAME range_iterator<RangeT>::type> + find_tail( + RangeT& Input, + int N) + { + return ::boost::algorithm::find(Input, ::boost::algorithm::tail_finder(N)); + } + +// find_token --------------------------------------------------------------------// + + //! Find token algorithm + /*! + Look for a given token in the string. Token is a character that matches the + given predicate. + If the "token compress mode" is enabled, adjacent tokens are considered to be one match. + + \param Input A input string. + \param Pred A unary predicate to identify a token + \param eCompress Enable/Disable compressing of adjacent tokens + \return + An \c iterator_range delimiting the match. + Returned iterator is either \c RangeT::iterator or + \c RangeT::const_iterator, depending on the constness of + the input parameter. + + \note This function provides the strong exception-safety guarantee + */ + template<typename RangeT, typename PredicateT> + inline iterator_range< + BOOST_STRING_TYPENAME range_iterator<RangeT>::type> + find_token( + RangeT& Input, + PredicateT Pred, + token_compress_mode_type eCompress=token_compress_off) + { + return ::boost::algorithm::find(Input, ::boost::algorithm::token_finder(Pred, eCompress)); + } + + } // namespace algorithm + + // pull names to the boost namespace + using algorithm::find; + using algorithm::find_first; + using algorithm::ifind_first; + using algorithm::find_last; + using algorithm::ifind_last; + using algorithm::find_nth; + using algorithm::ifind_nth; + using algorithm::find_head; + using algorithm::find_tail; + using algorithm::find_token; + +} // namespace boost + + +#endif // BOOST_STRING_FIND_HPP diff --git a/contrib/src/boost/algorithm/string/find_format.hpp b/contrib/src/boost/algorithm/string/find_format.hpp index deb4bd9..0e84a4e 100644 --- a/contrib/src/boost/algorithm/string/find_format.hpp +++ b/contrib/src/boost/algorithm/string/find_format.hpp @@ -1,287 +1,287 @@ -// Boost string_algo library find_format.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_FIND_FORMAT_HPP
-#define BOOST_STRING_FIND_FORMAT_HPP
-
-#include <deque>
-#include <boost/detail/iterator.hpp>
-#include <boost/range/iterator_range_core.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/range/const_iterator.hpp>
-#include <boost/range/as_literal.hpp>
-
-#include <boost/algorithm/string/concept.hpp>
-#include <boost/algorithm/string/detail/find_format.hpp>
-#include <boost/algorithm/string/detail/find_format_all.hpp>
-
-/*! \file
- Defines generic replace algorithms. Each algorithm replaces
- part(s) of the input. The part to be replaced is looked up using a Finder object.
- Result of finding is then used by a Formatter object to generate the replacement.
-*/
-
-namespace boost {
- namespace algorithm {
-
-// generic replace -----------------------------------------------------------------//
-
- //! Generic replace algorithm
- /*!
- Use the Finder to search for a substring. Use the Formatter to format
- this substring and replace it in the input.
- The result is a modified copy of the input. It is returned as a sequence
- or copied to the output iterator.
-
- \param Output An output iterator to which the result will be copied
- \param Input An input sequence
- \param Finder A Finder object used to search for a match to be replaced
- \param Formatter A Formatter object used to format a match
- \return An output iterator pointing just after the last inserted character or
- a modified copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<
- typename OutputIteratorT,
- typename RangeT,
- typename FinderT,
- typename FormatterT>
- inline OutputIteratorT find_format_copy(
- OutputIteratorT Output,
- const RangeT& Input,
- FinderT Finder,
- FormatterT Formatter )
- {
- // Concept check
- BOOST_CONCEPT_ASSERT((
- FinderConcept<
- FinderT,
- BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
- ));
- BOOST_CONCEPT_ASSERT((
- FormatterConcept<
- FormatterT,
- FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
- ));
-
- iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
-
- return detail::find_format_copy_impl(
- Output,
- lit_input,
- Formatter,
- Finder( ::boost::begin(lit_input), ::boost::end(lit_input) ) );
- }
-
- //! Generic replace algorithm
- /*!
- \overload
- */
- template<
- typename SequenceT,
- typename FinderT,
- typename FormatterT>
- inline SequenceT find_format_copy(
- const SequenceT& Input,
- FinderT Finder,
- FormatterT Formatter )
- {
- // Concept check
- BOOST_CONCEPT_ASSERT((
- FinderConcept<
- FinderT,
- BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
- ));
- BOOST_CONCEPT_ASSERT((
- FormatterConcept<
- FormatterT,
- FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
- ));
-
- return detail::find_format_copy_impl(
- Input,
- Formatter,
- Finder(::boost::begin(Input), ::boost::end(Input)));
- }
-
- //! Generic replace algorithm
- /*!
- Use the Finder to search for a substring. Use the Formatter to format
- this substring and replace it in the input. The input is modified in-place.
-
- \param Input An input sequence
- \param Finder A Finder object used to search for a match to be replaced
- \param Formatter A Formatter object used to format a match
- */
- template<
- typename SequenceT,
- typename FinderT,
- typename FormatterT>
- inline void find_format(
- SequenceT& Input,
- FinderT Finder,
- FormatterT Formatter)
- {
- // Concept check
- BOOST_CONCEPT_ASSERT((
- FinderConcept<
- FinderT,
- BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
- ));
- BOOST_CONCEPT_ASSERT((
- FormatterConcept<
- FormatterT,
- FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
- ));
-
- detail::find_format_impl(
- Input,
- Formatter,
- Finder(::boost::begin(Input), ::boost::end(Input)));
- }
-
-
-// find_format_all generic ----------------------------------------------------------------//
-
- //! Generic replace all algorithm
- /*!
- Use the Finder to search for a substring. Use the Formatter to format
- this substring and replace it in the input. Repeat this for all matching
- substrings.
- The result is a modified copy of the input. It is returned as a sequence
- or copied to the output iterator.
-
- \param Output An output iterator to which the result will be copied
- \param Input An input sequence
- \param Finder A Finder object used to search for a match to be replaced
- \param Formatter A Formatter object used to format a match
- \return An output iterator pointing just after the last inserted character or
- a modified copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<
- typename OutputIteratorT,
- typename RangeT,
- typename FinderT,
- typename FormatterT>
- inline OutputIteratorT find_format_all_copy(
- OutputIteratorT Output,
- const RangeT& Input,
- FinderT Finder,
- FormatterT Formatter)
- {
- // Concept check
- BOOST_CONCEPT_ASSERT((
- FinderConcept<
- FinderT,
- BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
- ));
- BOOST_CONCEPT_ASSERT((
- FormatterConcept<
- FormatterT,
- FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type>
- ));
-
- iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
-
- return detail::find_format_all_copy_impl(
- Output,
- lit_input,
- Finder,
- Formatter,
- Finder(::boost::begin(lit_input), ::boost::end(lit_input)));
- }
-
- //! Generic replace all algorithm
- /*!
- \overload
- */
- template<
- typename SequenceT,
- typename FinderT,
- typename FormatterT >
- inline SequenceT find_format_all_copy(
- const SequenceT& Input,
- FinderT Finder,
- FormatterT Formatter )
- {
- // Concept check
- BOOST_CONCEPT_ASSERT((
- FinderConcept<
- FinderT,
- BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
- ));
- BOOST_CONCEPT_ASSERT((
- FormatterConcept<
- FormatterT,
- FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
- ));
-
- return detail::find_format_all_copy_impl(
- Input,
- Finder,
- Formatter,
- Finder( ::boost::begin(Input), ::boost::end(Input) ) );
- }
-
- //! Generic replace all algorithm
- /*!
- Use the Finder to search for a substring. Use the Formatter to format
- this substring and replace it in the input. Repeat this for all matching
- substrings.The input is modified in-place.
-
- \param Input An input sequence
- \param Finder A Finder object used to search for a match to be replaced
- \param Formatter A Formatter object used to format a match
- */
- template<
- typename SequenceT,
- typename FinderT,
- typename FormatterT >
- inline void find_format_all(
- SequenceT& Input,
- FinderT Finder,
- FormatterT Formatter )
- {
- // Concept check
- BOOST_CONCEPT_ASSERT((
- FinderConcept<
- FinderT,
- BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
- ));
- BOOST_CONCEPT_ASSERT((
- FormatterConcept<
- FormatterT,
- FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type>
- ));
-
- detail::find_format_all_impl(
- Input,
- Finder,
- Formatter,
- Finder(::boost::begin(Input), ::boost::end(Input)));
-
- }
-
- } // namespace algorithm
-
- // pull the names to the boost namespace
- using algorithm::find_format_copy;
- using algorithm::find_format;
- using algorithm::find_format_all_copy;
- using algorithm::find_format_all;
-
-} // namespace boost
-
-
-#endif // BOOST_STRING_FIND_FORMAT_HPP
+// Boost string_algo library find_format.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_FIND_FORMAT_HPP +#define BOOST_STRING_FIND_FORMAT_HPP + +#include <deque> +#include <boost/detail/iterator.hpp> +#include <boost/range/iterator_range_core.hpp> +#include <boost/range/begin.hpp> +#include <boost/range/end.hpp> +#include <boost/range/const_iterator.hpp> +#include <boost/range/as_literal.hpp> + +#include <boost/algorithm/string/concept.hpp> +#include <boost/algorithm/string/detail/find_format.hpp> +#include <boost/algorithm/string/detail/find_format_all.hpp> + +/*! \file + Defines generic replace algorithms. Each algorithm replaces + part(s) of the input. The part to be replaced is looked up using a Finder object. + Result of finding is then used by a Formatter object to generate the replacement. +*/ + +namespace boost { + namespace algorithm { + +// generic replace -----------------------------------------------------------------// + + //! Generic replace algorithm + /*! + Use the Finder to search for a substring. Use the Formatter to format + this substring and replace it in the input. + The result is a modified copy of the input. It is returned as a sequence + or copied to the output iterator. + + \param Output An output iterator to which the result will be copied + \param Input An input sequence + \param Finder A Finder object used to search for a match to be replaced + \param Formatter A Formatter object used to format a match + \return An output iterator pointing just after the last inserted character or + a modified copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template< + typename OutputIteratorT, + typename RangeT, + typename FinderT, + typename FormatterT> + inline OutputIteratorT find_format_copy( + OutputIteratorT Output, + const RangeT& Input, + FinderT Finder, + FormatterT Formatter ) + { + // Concept check + BOOST_CONCEPT_ASSERT(( + FinderConcept< + FinderT, + BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> + )); + BOOST_CONCEPT_ASSERT(( + FormatterConcept< + FormatterT, + FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> + )); + + iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input)); + + return detail::find_format_copy_impl( + Output, + lit_input, + Formatter, + Finder( ::boost::begin(lit_input), ::boost::end(lit_input) ) ); + } + + //! Generic replace algorithm + /*! + \overload + */ + template< + typename SequenceT, + typename FinderT, + typename FormatterT> + inline SequenceT find_format_copy( + const SequenceT& Input, + FinderT Finder, + FormatterT Formatter ) + { + // Concept check + BOOST_CONCEPT_ASSERT(( + FinderConcept< + FinderT, + BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> + )); + BOOST_CONCEPT_ASSERT(( + FormatterConcept< + FormatterT, + FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> + )); + + return detail::find_format_copy_impl( + Input, + Formatter, + Finder(::boost::begin(Input), ::boost::end(Input))); + } + + //! Generic replace algorithm + /*! + Use the Finder to search for a substring. Use the Formatter to format + this substring and replace it in the input. The input is modified in-place. + + \param Input An input sequence + \param Finder A Finder object used to search for a match to be replaced + \param Formatter A Formatter object used to format a match + */ + template< + typename SequenceT, + typename FinderT, + typename FormatterT> + inline void find_format( + SequenceT& Input, + FinderT Finder, + FormatterT Formatter) + { + // Concept check + BOOST_CONCEPT_ASSERT(( + FinderConcept< + FinderT, + BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> + )); + BOOST_CONCEPT_ASSERT(( + FormatterConcept< + FormatterT, + FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> + )); + + detail::find_format_impl( + Input, + Formatter, + Finder(::boost::begin(Input), ::boost::end(Input))); + } + + +// find_format_all generic ----------------------------------------------------------------// + + //! Generic replace all algorithm + /*! + Use the Finder to search for a substring. Use the Formatter to format + this substring and replace it in the input. Repeat this for all matching + substrings. + The result is a modified copy of the input. It is returned as a sequence + or copied to the output iterator. + + \param Output An output iterator to which the result will be copied + \param Input An input sequence + \param Finder A Finder object used to search for a match to be replaced + \param Formatter A Formatter object used to format a match + \return An output iterator pointing just after the last inserted character or + a modified copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template< + typename OutputIteratorT, + typename RangeT, + typename FinderT, + typename FormatterT> + inline OutputIteratorT find_format_all_copy( + OutputIteratorT Output, + const RangeT& Input, + FinderT Finder, + FormatterT Formatter) + { + // Concept check + BOOST_CONCEPT_ASSERT(( + FinderConcept< + FinderT, + BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> + )); + BOOST_CONCEPT_ASSERT(( + FormatterConcept< + FormatterT, + FinderT,BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> + )); + + iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input)); + + return detail::find_format_all_copy_impl( + Output, + lit_input, + Finder, + Formatter, + Finder(::boost::begin(lit_input), ::boost::end(lit_input))); + } + + //! Generic replace all algorithm + /*! + \overload + */ + template< + typename SequenceT, + typename FinderT, + typename FormatterT > + inline SequenceT find_format_all_copy( + const SequenceT& Input, + FinderT Finder, + FormatterT Formatter ) + { + // Concept check + BOOST_CONCEPT_ASSERT(( + FinderConcept< + FinderT, + BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> + )); + BOOST_CONCEPT_ASSERT(( + FormatterConcept< + FormatterT, + FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> + )); + + return detail::find_format_all_copy_impl( + Input, + Finder, + Formatter, + Finder( ::boost::begin(Input), ::boost::end(Input) ) ); + } + + //! Generic replace all algorithm + /*! + Use the Finder to search for a substring. Use the Formatter to format + this substring and replace it in the input. Repeat this for all matching + substrings.The input is modified in-place. + + \param Input An input sequence + \param Finder A Finder object used to search for a match to be replaced + \param Formatter A Formatter object used to format a match + */ + template< + typename SequenceT, + typename FinderT, + typename FormatterT > + inline void find_format_all( + SequenceT& Input, + FinderT Finder, + FormatterT Formatter ) + { + // Concept check + BOOST_CONCEPT_ASSERT(( + FinderConcept< + FinderT, + BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> + )); + BOOST_CONCEPT_ASSERT(( + FormatterConcept< + FormatterT, + FinderT,BOOST_STRING_TYPENAME range_const_iterator<SequenceT>::type> + )); + + detail::find_format_all_impl( + Input, + Finder, + Formatter, + Finder(::boost::begin(Input), ::boost::end(Input))); + + } + + } // namespace algorithm + + // pull the names to the boost namespace + using algorithm::find_format_copy; + using algorithm::find_format; + using algorithm::find_format_all_copy; + using algorithm::find_format_all; + +} // namespace boost + + +#endif // BOOST_STRING_FIND_FORMAT_HPP diff --git a/contrib/src/boost/algorithm/string/find_iterator.hpp b/contrib/src/boost/algorithm/string/find_iterator.hpp index 831a9d9..5a52d92 100644 --- a/contrib/src/boost/algorithm/string/find_iterator.hpp +++ b/contrib/src/boost/algorithm/string/find_iterator.hpp @@ -1,388 +1,388 @@ -// Boost string_algo library find_iterator.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2004.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_FIND_ITERATOR_HPP
-#define BOOST_STRING_FIND_ITERATOR_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/iterator/iterator_facade.hpp>
-#include <boost/iterator/iterator_categories.hpp>
-
-#include <boost/range/iterator_range_core.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/range/iterator.hpp>
-#include <boost/range/as_literal.hpp>
-
-#include <boost/algorithm/string/detail/find_iterator.hpp>
-
-/*! \file
- Defines find iterator classes. Find iterator repeatedly applies a Finder
- to the specified input string to search for matches. Dereferencing
- the iterator yields the current match or a range between the last and the current
- match depending on the iterator used.
-*/
-
-namespace boost {
- namespace algorithm {
-
-// find_iterator -----------------------------------------------//
-
- //! find_iterator
- /*!
- Find iterator encapsulates a Finder and allows
- for incremental searching in a string.
- Each increment moves the iterator to the next match.
-
- Find iterator is a readable forward traversal iterator.
-
- Dereferencing the iterator yields an iterator_range delimiting
- the current match.
- */
- template<typename IteratorT>
- class find_iterator :
- public iterator_facade<
- find_iterator<IteratorT>,
- const iterator_range<IteratorT>,
- forward_traversal_tag >,
- private detail::find_iterator_base<IteratorT>
- {
- private:
- // facade support
- friend class ::boost::iterator_core_access;
-
- private:
- // typedefs
-
- typedef detail::find_iterator_base<IteratorT> base_type;
- typedef BOOST_STRING_TYPENAME
- base_type::input_iterator_type input_iterator_type;
- typedef BOOST_STRING_TYPENAME
- base_type::match_type match_type;
-
- public:
- //! Default constructor
- /*!
- Construct null iterator. All null iterators are equal.
-
- \post eof()==true
- */
- find_iterator() {}
-
- //! Copy constructor
- /*!
- Construct a copy of the find_iterator
- */
- find_iterator( const find_iterator& Other ) :
- base_type(Other),
- m_Match(Other.m_Match),
- m_End(Other.m_End) {}
-
- //! Constructor
- /*!
- Construct new find_iterator for a given finder
- and a range.
- */
- template<typename FinderT>
- find_iterator(
- IteratorT Begin,
- IteratorT End,
- FinderT Finder ) :
- detail::find_iterator_base<IteratorT>(Finder,0),
- m_Match(Begin,Begin),
- m_End(End)
- {
- increment();
- }
-
- //! Constructor
- /*!
- Construct new find_iterator for a given finder
- and a range.
- */
- template<typename FinderT, typename RangeT>
- find_iterator(
- RangeT& Col,
- FinderT Finder ) :
- detail::find_iterator_base<IteratorT>(Finder,0)
- {
- iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_col(::boost::as_literal(Col));
- m_Match=::boost::make_iterator_range(::boost::begin(lit_col), ::boost::begin(lit_col));
- m_End=::boost::end(lit_col);
-
- increment();
- }
-
- private:
- // iterator operations
-
- // dereference
- const match_type& dereference() const
- {
- return m_Match;
- }
-
- // increment
- void increment()
- {
- m_Match=this->do_find(m_Match.end(),m_End);
- }
-
- // comparison
- bool equal( const find_iterator& Other ) const
- {
- bool bEof=eof();
- bool bOtherEof=Other.eof();
-
- return bEof || bOtherEof ? bEof==bOtherEof :
- (
- m_Match==Other.m_Match &&
- m_End==Other.m_End
- );
- }
-
- public:
- // operations
-
- //! Eof check
- /*!
- Check the eof condition. Eof condition means that
- there is nothing more to be searched i.e. find_iterator
- is after the last match.
- */
- bool eof() const
- {
- return
- this->is_null() ||
- (
- m_Match.begin() == m_End &&
- m_Match.end() == m_End
- );
- }
-
- private:
- // Attributes
- match_type m_Match;
- input_iterator_type m_End;
- };
-
- //! find iterator construction helper
- /*!
- * Construct a find iterator to iterate through the specified string
- */
- template<typename RangeT, typename FinderT>
- inline find_iterator<
- BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
- make_find_iterator(
- RangeT& Collection,
- FinderT Finder)
- {
- return find_iterator<BOOST_STRING_TYPENAME range_iterator<RangeT>::type>(
- Collection, Finder);
- }
-
-// split iterator -----------------------------------------------//
-
- //! split_iterator
- /*!
- Split iterator encapsulates a Finder and allows
- for incremental searching in a string.
- Unlike the find iterator, split iterator iterates
- through gaps between matches.
-
- Find iterator is a readable forward traversal iterator.
-
- Dereferencing the iterator yields an iterator_range delimiting
- the current match.
- */
- template<typename IteratorT>
- class split_iterator :
- public iterator_facade<
- split_iterator<IteratorT>,
- const iterator_range<IteratorT>,
- forward_traversal_tag >,
- private detail::find_iterator_base<IteratorT>
- {
- private:
- // facade support
- friend class ::boost::iterator_core_access;
-
- private:
- // typedefs
-
- typedef detail::find_iterator_base<IteratorT> base_type;
- typedef BOOST_STRING_TYPENAME
- base_type::input_iterator_type input_iterator_type;
- typedef BOOST_STRING_TYPENAME
- base_type::match_type match_type;
-
- public:
- //! Default constructor
- /*!
- Construct null iterator. All null iterators are equal.
-
- \post eof()==true
- */
- split_iterator() :
- m_Next(),
- m_End(),
- m_bEof(true)
- {}
-
- //! Copy constructor
- /*!
- Construct a copy of the split_iterator
- */
- split_iterator( const split_iterator& Other ) :
- base_type(Other),
- m_Match(Other.m_Match),
- m_Next(Other.m_Next),
- m_End(Other.m_End),
- m_bEof(Other.m_bEof)
- {}
-
- //! Constructor
- /*!
- Construct new split_iterator for a given finder
- and a range.
- */
- template<typename FinderT>
- split_iterator(
- IteratorT Begin,
- IteratorT End,
- FinderT Finder ) :
- detail::find_iterator_base<IteratorT>(Finder,0),
- m_Match(Begin,Begin),
- m_Next(Begin),
- m_End(End),
- m_bEof(false)
- {
- // force the correct behavior for empty sequences and yield at least one token
- if(Begin!=End)
- {
- increment();
- }
- }
- //! Constructor
- /*!
- Construct new split_iterator for a given finder
- and a collection.
- */
- template<typename FinderT, typename RangeT>
- split_iterator(
- RangeT& Col,
- FinderT Finder ) :
- detail::find_iterator_base<IteratorT>(Finder,0),
- m_bEof(false)
- {
- iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_col(::boost::as_literal(Col));
- m_Match=make_iterator_range(::boost::begin(lit_col), ::boost::begin(lit_col));
- m_Next=::boost::begin(lit_col);
- m_End=::boost::end(lit_col);
-
- // force the correct behavior for empty sequences and yield at least one token
- if(m_Next!=m_End)
- {
- increment();
- }
- }
-
-
- private:
- // iterator operations
-
- // dereference
- const match_type& dereference() const
- {
- return m_Match;
- }
-
- // increment
- void increment()
- {
- match_type FindMatch=this->do_find( m_Next, m_End );
-
- if(FindMatch.begin()==m_End && FindMatch.end()==m_End)
- {
- if(m_Match.end()==m_End)
- {
- // Mark iterator as eof
- m_bEof=true;
- }
- }
-
- m_Match=match_type( m_Next, FindMatch.begin() );
- m_Next=FindMatch.end();
- }
-
- // comparison
- bool equal( const split_iterator& Other ) const
- {
- bool bEof=eof();
- bool bOtherEof=Other.eof();
-
- return bEof || bOtherEof ? bEof==bOtherEof :
- (
- m_Match==Other.m_Match &&
- m_Next==Other.m_Next &&
- m_End==Other.m_End
- );
- }
-
- public:
- // operations
-
- //! Eof check
- /*!
- Check the eof condition. Eof condition means that
- there is nothing more to be searched i.e. find_iterator
- is after the last match.
- */
- bool eof() const
- {
- return this->is_null() || m_bEof;
- }
-
- private:
- // Attributes
- match_type m_Match;
- input_iterator_type m_Next;
- input_iterator_type m_End;
- bool m_bEof;
- };
-
- //! split iterator construction helper
- /*!
- * Construct a split iterator to iterate through the specified collection
- */
- template<typename RangeT, typename FinderT>
- inline split_iterator<
- BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
- make_split_iterator(
- RangeT& Collection,
- FinderT Finder)
- {
- return split_iterator<BOOST_STRING_TYPENAME range_iterator<RangeT>::type>(
- Collection, Finder);
- }
-
-
- } // namespace algorithm
-
- // pull names to the boost namespace
- using algorithm::find_iterator;
- using algorithm::make_find_iterator;
- using algorithm::split_iterator;
- using algorithm::make_split_iterator;
-
-} // namespace boost
-
-
-#endif // BOOST_STRING_FIND_ITERATOR_HPP
+// Boost string_algo library find_iterator.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2004. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_FIND_ITERATOR_HPP +#define BOOST_STRING_FIND_ITERATOR_HPP + +#include <boost/algorithm/string/config.hpp> +#include <boost/iterator/iterator_facade.hpp> +#include <boost/iterator/iterator_categories.hpp> + +#include <boost/range/iterator_range_core.hpp> +#include <boost/range/begin.hpp> +#include <boost/range/end.hpp> +#include <boost/range/iterator.hpp> +#include <boost/range/as_literal.hpp> + +#include <boost/algorithm/string/detail/find_iterator.hpp> + +/*! \file + Defines find iterator classes. Find iterator repeatedly applies a Finder + to the specified input string to search for matches. Dereferencing + the iterator yields the current match or a range between the last and the current + match depending on the iterator used. +*/ + +namespace boost { + namespace algorithm { + +// find_iterator -----------------------------------------------// + + //! find_iterator + /*! + Find iterator encapsulates a Finder and allows + for incremental searching in a string. + Each increment moves the iterator to the next match. + + Find iterator is a readable forward traversal iterator. + + Dereferencing the iterator yields an iterator_range delimiting + the current match. + */ + template<typename IteratorT> + class find_iterator : + public iterator_facade< + find_iterator<IteratorT>, + const iterator_range<IteratorT>, + forward_traversal_tag >, + private detail::find_iterator_base<IteratorT> + { + private: + // facade support + friend class ::boost::iterator_core_access; + + private: + // typedefs + + typedef detail::find_iterator_base<IteratorT> base_type; + typedef BOOST_STRING_TYPENAME + base_type::input_iterator_type input_iterator_type; + typedef BOOST_STRING_TYPENAME + base_type::match_type match_type; + + public: + //! Default constructor + /*! + Construct null iterator. All null iterators are equal. + + \post eof()==true + */ + find_iterator() {} + + //! Copy constructor + /*! + Construct a copy of the find_iterator + */ + find_iterator( const find_iterator& Other ) : + base_type(Other), + m_Match(Other.m_Match), + m_End(Other.m_End) {} + + //! Constructor + /*! + Construct new find_iterator for a given finder + and a range. + */ + template<typename FinderT> + find_iterator( + IteratorT Begin, + IteratorT End, + FinderT Finder ) : + detail::find_iterator_base<IteratorT>(Finder,0), + m_Match(Begin,Begin), + m_End(End) + { + increment(); + } + + //! Constructor + /*! + Construct new find_iterator for a given finder + and a range. + */ + template<typename FinderT, typename RangeT> + find_iterator( + RangeT& Col, + FinderT Finder ) : + detail::find_iterator_base<IteratorT>(Finder,0) + { + iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_col(::boost::as_literal(Col)); + m_Match=::boost::make_iterator_range(::boost::begin(lit_col), ::boost::begin(lit_col)); + m_End=::boost::end(lit_col); + + increment(); + } + + private: + // iterator operations + + // dereference + const match_type& dereference() const + { + return m_Match; + } + + // increment + void increment() + { + m_Match=this->do_find(m_Match.end(),m_End); + } + + // comparison + bool equal( const find_iterator& Other ) const + { + bool bEof=eof(); + bool bOtherEof=Other.eof(); + + return bEof || bOtherEof ? bEof==bOtherEof : + ( + m_Match==Other.m_Match && + m_End==Other.m_End + ); + } + + public: + // operations + + //! Eof check + /*! + Check the eof condition. Eof condition means that + there is nothing more to be searched i.e. find_iterator + is after the last match. + */ + bool eof() const + { + return + this->is_null() || + ( + m_Match.begin() == m_End && + m_Match.end() == m_End + ); + } + + private: + // Attributes + match_type m_Match; + input_iterator_type m_End; + }; + + //! find iterator construction helper + /*! + * Construct a find iterator to iterate through the specified string + */ + template<typename RangeT, typename FinderT> + inline find_iterator< + BOOST_STRING_TYPENAME range_iterator<RangeT>::type> + make_find_iterator( + RangeT& Collection, + FinderT Finder) + { + return find_iterator<BOOST_STRING_TYPENAME range_iterator<RangeT>::type>( + Collection, Finder); + } + +// split iterator -----------------------------------------------// + + //! split_iterator + /*! + Split iterator encapsulates a Finder and allows + for incremental searching in a string. + Unlike the find iterator, split iterator iterates + through gaps between matches. + + Find iterator is a readable forward traversal iterator. + + Dereferencing the iterator yields an iterator_range delimiting + the current match. + */ + template<typename IteratorT> + class split_iterator : + public iterator_facade< + split_iterator<IteratorT>, + const iterator_range<IteratorT>, + forward_traversal_tag >, + private detail::find_iterator_base<IteratorT> + { + private: + // facade support + friend class ::boost::iterator_core_access; + + private: + // typedefs + + typedef detail::find_iterator_base<IteratorT> base_type; + typedef BOOST_STRING_TYPENAME + base_type::input_iterator_type input_iterator_type; + typedef BOOST_STRING_TYPENAME + base_type::match_type match_type; + + public: + //! Default constructor + /*! + Construct null iterator. All null iterators are equal. + + \post eof()==true + */ + split_iterator() : + m_Next(), + m_End(), + m_bEof(true) + {} + + //! Copy constructor + /*! + Construct a copy of the split_iterator + */ + split_iterator( const split_iterator& Other ) : + base_type(Other), + m_Match(Other.m_Match), + m_Next(Other.m_Next), + m_End(Other.m_End), + m_bEof(Other.m_bEof) + {} + + //! Constructor + /*! + Construct new split_iterator for a given finder + and a range. + */ + template<typename FinderT> + split_iterator( + IteratorT Begin, + IteratorT End, + FinderT Finder ) : + detail::find_iterator_base<IteratorT>(Finder,0), + m_Match(Begin,Begin), + m_Next(Begin), + m_End(End), + m_bEof(false) + { + // force the correct behavior for empty sequences and yield at least one token + if(Begin!=End) + { + increment(); + } + } + //! Constructor + /*! + Construct new split_iterator for a given finder + and a collection. + */ + template<typename FinderT, typename RangeT> + split_iterator( + RangeT& Col, + FinderT Finder ) : + detail::find_iterator_base<IteratorT>(Finder,0), + m_bEof(false) + { + iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_col(::boost::as_literal(Col)); + m_Match=make_iterator_range(::boost::begin(lit_col), ::boost::begin(lit_col)); + m_Next=::boost::begin(lit_col); + m_End=::boost::end(lit_col); + + // force the correct behavior for empty sequences and yield at least one token + if(m_Next!=m_End) + { + increment(); + } + } + + + private: + // iterator operations + + // dereference + const match_type& dereference() const + { + return m_Match; + } + + // increment + void increment() + { + match_type FindMatch=this->do_find( m_Next, m_End ); + + if(FindMatch.begin()==m_End && FindMatch.end()==m_End) + { + if(m_Match.end()==m_End) + { + // Mark iterator as eof + m_bEof=true; + } + } + + m_Match=match_type( m_Next, FindMatch.begin() ); + m_Next=FindMatch.end(); + } + + // comparison + bool equal( const split_iterator& Other ) const + { + bool bEof=eof(); + bool bOtherEof=Other.eof(); + + return bEof || bOtherEof ? bEof==bOtherEof : + ( + m_Match==Other.m_Match && + m_Next==Other.m_Next && + m_End==Other.m_End + ); + } + + public: + // operations + + //! Eof check + /*! + Check the eof condition. Eof condition means that + there is nothing more to be searched i.e. find_iterator + is after the last match. + */ + bool eof() const + { + return this->is_null() || m_bEof; + } + + private: + // Attributes + match_type m_Match; + input_iterator_type m_Next; + input_iterator_type m_End; + bool m_bEof; + }; + + //! split iterator construction helper + /*! + * Construct a split iterator to iterate through the specified collection + */ + template<typename RangeT, typename FinderT> + inline split_iterator< + BOOST_STRING_TYPENAME range_iterator<RangeT>::type> + make_split_iterator( + RangeT& Collection, + FinderT Finder) + { + return split_iterator<BOOST_STRING_TYPENAME range_iterator<RangeT>::type>( + Collection, Finder); + } + + + } // namespace algorithm + + // pull names to the boost namespace + using algorithm::find_iterator; + using algorithm::make_find_iterator; + using algorithm::split_iterator; + using algorithm::make_split_iterator; + +} // namespace boost + + +#endif // BOOST_STRING_FIND_ITERATOR_HPP diff --git a/contrib/src/boost/algorithm/string/finder.hpp b/contrib/src/boost/algorithm/string/finder.hpp index 1f8029f..93f7ec3 100644 --- a/contrib/src/boost/algorithm/string/finder.hpp +++ b/contrib/src/boost/algorithm/string/finder.hpp @@ -1,270 +1,270 @@ -// Boost string_algo library finder.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2006.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_FINDER_HPP
-#define BOOST_STRING_FINDER_HPP
-
-#include <boost/algorithm/string/config.hpp>
-
-#include <boost/range/iterator_range_core.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/range/iterator.hpp>
-#include <boost/range/const_iterator.hpp>
-
-#include <boost/algorithm/string/constants.hpp>
-#include <boost/algorithm/string/detail/finder.hpp>
-#include <boost/algorithm/string/compare.hpp>
-
-/*! \file
- Defines Finder generators. Finder object is a functor which is able to
- find a substring matching a specific criteria in the input.
- Finders are used as a pluggable components for replace, find
- and split facilities. This header contains generator functions
- for finders provided in this library.
-*/
-
-namespace boost {
- namespace algorithm {
-
-// Finder generators ------------------------------------------//
-
- //! "First" finder
- /*!
- Construct the \c first_finder. The finder searches for the first
- occurrence of the string in a given input.
- The result is given as an \c iterator_range delimiting the match.
-
- \param Search A substring to be searched for.
- \param Comp An element comparison predicate
- \return An instance of the \c first_finder object
- */
- template<typename RangeT>
- inline detail::first_finderF<
- BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
- is_equal>
- first_finder( const RangeT& Search )
- {
- return
- detail::first_finderF<
- BOOST_STRING_TYPENAME
- range_const_iterator<RangeT>::type,
- is_equal>( ::boost::as_literal(Search), is_equal() ) ;
- }
-
- //! "First" finder
- /*!
- \overload
- */
- template<typename RangeT,typename PredicateT>
- inline detail::first_finderF<
- BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
- PredicateT>
- first_finder(
- const RangeT& Search, PredicateT Comp )
- {
- return
- detail::first_finderF<
- BOOST_STRING_TYPENAME
- range_const_iterator<RangeT>::type,
- PredicateT>( ::boost::as_literal(Search), Comp );
- }
-
- //! "Last" finder
- /*!
- Construct the \c last_finder. The finder searches for the last
- occurrence of the string in a given input.
- The result is given as an \c iterator_range delimiting the match.
-
- \param Search A substring to be searched for.
- \param Comp An element comparison predicate
- \return An instance of the \c last_finder object
- */
- template<typename RangeT>
- inline detail::last_finderF<
- BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
- is_equal>
- last_finder( const RangeT& Search )
- {
- return
- detail::last_finderF<
- BOOST_STRING_TYPENAME
- range_const_iterator<RangeT>::type,
- is_equal>( ::boost::as_literal(Search), is_equal() );
- }
- //! "Last" finder
- /*!
- \overload
- */
- template<typename RangeT, typename PredicateT>
- inline detail::last_finderF<
- BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
- PredicateT>
- last_finder( const RangeT& Search, PredicateT Comp )
- {
- return
- detail::last_finderF<
- BOOST_STRING_TYPENAME
- range_const_iterator<RangeT>::type,
- PredicateT>( ::boost::as_literal(Search), Comp ) ;
- }
-
- //! "Nth" finder
- /*!
- Construct the \c nth_finder. The finder searches for the n-th (zero-indexed)
- occurrence of the string in a given input.
- The result is given as an \c iterator_range delimiting the match.
-
- \param Search A substring to be searched for.
- \param Nth An index of the match to be find
- \param Comp An element comparison predicate
- \return An instance of the \c nth_finder object
- */
- template<typename RangeT>
- inline detail::nth_finderF<
- BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
- is_equal>
- nth_finder(
- const RangeT& Search,
- int Nth)
- {
- return
- detail::nth_finderF<
- BOOST_STRING_TYPENAME
- range_const_iterator<RangeT>::type,
- is_equal>( ::boost::as_literal(Search), Nth, is_equal() ) ;
- }
- //! "Nth" finder
- /*!
- \overload
- */
- template<typename RangeT, typename PredicateT>
- inline detail::nth_finderF<
- BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type,
- PredicateT>
- nth_finder(
- const RangeT& Search,
- int Nth,
- PredicateT Comp )
- {
- return
- detail::nth_finderF<
- BOOST_STRING_TYPENAME
- range_const_iterator<RangeT>::type,
- PredicateT>( ::boost::as_literal(Search), Nth, Comp );
- }
-
- //! "Head" finder
- /*!
- Construct the \c head_finder. The finder returns a head of a given
- input. The head is a prefix of a string up to n elements in
- size. If an input has less then n elements, whole input is
- considered a head.
- The result is given as an \c iterator_range delimiting the match.
-
- \param N The size of the head
- \return An instance of the \c head_finder object
- */
- inline detail::head_finderF
- head_finder( int N )
- {
- return detail::head_finderF(N);
- }
-
- //! "Tail" finder
- /*!
- Construct the \c tail_finder. The finder returns a tail of a given
- input. The tail is a suffix of a string up to n elements in
- size. If an input has less then n elements, whole input is
- considered a head.
- The result is given as an \c iterator_range delimiting the match.
-
- \param N The size of the head
- \return An instance of the \c tail_finder object
- */
- inline detail::tail_finderF
- tail_finder( int N )
- {
- return detail::tail_finderF(N);
- }
-
- //! "Token" finder
- /*!
- Construct the \c token_finder. The finder searches for a token
- specified by a predicate. It is similar to std::find_if
- algorithm, with an exception that it return a range of
- instead of a single iterator.
-
- If "compress token mode" is enabled, adjacent matching tokens are
- concatenated into one match. Thus the finder can be used to
- search for continuous segments of characters satisfying the
- given predicate.
-
- The result is given as an \c iterator_range delimiting the match.
-
- \param Pred An element selection predicate
- \param eCompress Compress flag
- \return An instance of the \c token_finder object
- */
- template< typename PredicateT >
- inline detail::token_finderF<PredicateT>
- token_finder(
- PredicateT Pred,
- token_compress_mode_type eCompress=token_compress_off )
- {
- return detail::token_finderF<PredicateT>( Pred, eCompress );
- }
-
- //! "Range" finder
- /*!
- Construct the \c range_finder. The finder does not perform
- any operation. It simply returns the given range for
- any input.
-
- \param Begin Beginning of the range
- \param End End of the range
- \param Range The range.
- \return An instance of the \c range_finger object
- */
- template< typename ForwardIteratorT >
- inline detail::range_finderF<ForwardIteratorT>
- range_finder(
- ForwardIteratorT Begin,
- ForwardIteratorT End )
- {
- return detail::range_finderF<ForwardIteratorT>( Begin, End );
- }
-
- //! "Range" finder
- /*!
- \overload
- */
- template< typename ForwardIteratorT >
- inline detail::range_finderF<ForwardIteratorT>
- range_finder( iterator_range<ForwardIteratorT> Range )
- {
- return detail::range_finderF<ForwardIteratorT>( Range );
- }
-
- } // namespace algorithm
-
- // pull the names to the boost namespace
- using algorithm::first_finder;
- using algorithm::last_finder;
- using algorithm::nth_finder;
- using algorithm::head_finder;
- using algorithm::tail_finder;
- using algorithm::token_finder;
- using algorithm::range_finder;
-
-} // namespace boost
-
-
-#endif // BOOST_STRING_FINDER_HPP
+// Boost string_algo library finder.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2006. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_FINDER_HPP +#define BOOST_STRING_FINDER_HPP + +#include <boost/algorithm/string/config.hpp> + +#include <boost/range/iterator_range_core.hpp> +#include <boost/range/begin.hpp> +#include <boost/range/end.hpp> +#include <boost/range/iterator.hpp> +#include <boost/range/const_iterator.hpp> + +#include <boost/algorithm/string/constants.hpp> +#include <boost/algorithm/string/detail/finder.hpp> +#include <boost/algorithm/string/compare.hpp> + +/*! \file + Defines Finder generators. Finder object is a functor which is able to + find a substring matching a specific criteria in the input. + Finders are used as a pluggable components for replace, find + and split facilities. This header contains generator functions + for finders provided in this library. +*/ + +namespace boost { + namespace algorithm { + +// Finder generators ------------------------------------------// + + //! "First" finder + /*! + Construct the \c first_finder. The finder searches for the first + occurrence of the string in a given input. + The result is given as an \c iterator_range delimiting the match. + + \param Search A substring to be searched for. + \param Comp An element comparison predicate + \return An instance of the \c first_finder object + */ + template<typename RangeT> + inline detail::first_finderF< + BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type, + is_equal> + first_finder( const RangeT& Search ) + { + return + detail::first_finderF< + BOOST_STRING_TYPENAME + range_const_iterator<RangeT>::type, + is_equal>( ::boost::as_literal(Search), is_equal() ) ; + } + + //! "First" finder + /*! + \overload + */ + template<typename RangeT,typename PredicateT> + inline detail::first_finderF< + BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type, + PredicateT> + first_finder( + const RangeT& Search, PredicateT Comp ) + { + return + detail::first_finderF< + BOOST_STRING_TYPENAME + range_const_iterator<RangeT>::type, + PredicateT>( ::boost::as_literal(Search), Comp ); + } + + //! "Last" finder + /*! + Construct the \c last_finder. The finder searches for the last + occurrence of the string in a given input. + The result is given as an \c iterator_range delimiting the match. + + \param Search A substring to be searched for. + \param Comp An element comparison predicate + \return An instance of the \c last_finder object + */ + template<typename RangeT> + inline detail::last_finderF< + BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type, + is_equal> + last_finder( const RangeT& Search ) + { + return + detail::last_finderF< + BOOST_STRING_TYPENAME + range_const_iterator<RangeT>::type, + is_equal>( ::boost::as_literal(Search), is_equal() ); + } + //! "Last" finder + /*! + \overload + */ + template<typename RangeT, typename PredicateT> + inline detail::last_finderF< + BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type, + PredicateT> + last_finder( const RangeT& Search, PredicateT Comp ) + { + return + detail::last_finderF< + BOOST_STRING_TYPENAME + range_const_iterator<RangeT>::type, + PredicateT>( ::boost::as_literal(Search), Comp ) ; + } + + //! "Nth" finder + /*! + Construct the \c nth_finder. The finder searches for the n-th (zero-indexed) + occurrence of the string in a given input. + The result is given as an \c iterator_range delimiting the match. + + \param Search A substring to be searched for. + \param Nth An index of the match to be find + \param Comp An element comparison predicate + \return An instance of the \c nth_finder object + */ + template<typename RangeT> + inline detail::nth_finderF< + BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type, + is_equal> + nth_finder( + const RangeT& Search, + int Nth) + { + return + detail::nth_finderF< + BOOST_STRING_TYPENAME + range_const_iterator<RangeT>::type, + is_equal>( ::boost::as_literal(Search), Nth, is_equal() ) ; + } + //! "Nth" finder + /*! + \overload + */ + template<typename RangeT, typename PredicateT> + inline detail::nth_finderF< + BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type, + PredicateT> + nth_finder( + const RangeT& Search, + int Nth, + PredicateT Comp ) + { + return + detail::nth_finderF< + BOOST_STRING_TYPENAME + range_const_iterator<RangeT>::type, + PredicateT>( ::boost::as_literal(Search), Nth, Comp ); + } + + //! "Head" finder + /*! + Construct the \c head_finder. The finder returns a head of a given + input. The head is a prefix of a string up to n elements in + size. If an input has less then n elements, whole input is + considered a head. + The result is given as an \c iterator_range delimiting the match. + + \param N The size of the head + \return An instance of the \c head_finder object + */ + inline detail::head_finderF + head_finder( int N ) + { + return detail::head_finderF(N); + } + + //! "Tail" finder + /*! + Construct the \c tail_finder. The finder returns a tail of a given + input. The tail is a suffix of a string up to n elements in + size. If an input has less then n elements, whole input is + considered a head. + The result is given as an \c iterator_range delimiting the match. + + \param N The size of the head + \return An instance of the \c tail_finder object + */ + inline detail::tail_finderF + tail_finder( int N ) + { + return detail::tail_finderF(N); + } + + //! "Token" finder + /*! + Construct the \c token_finder. The finder searches for a token + specified by a predicate. It is similar to std::find_if + algorithm, with an exception that it return a range of + instead of a single iterator. + + If "compress token mode" is enabled, adjacent matching tokens are + concatenated into one match. Thus the finder can be used to + search for continuous segments of characters satisfying the + given predicate. + + The result is given as an \c iterator_range delimiting the match. + + \param Pred An element selection predicate + \param eCompress Compress flag + \return An instance of the \c token_finder object + */ + template< typename PredicateT > + inline detail::token_finderF<PredicateT> + token_finder( + PredicateT Pred, + token_compress_mode_type eCompress=token_compress_off ) + { + return detail::token_finderF<PredicateT>( Pred, eCompress ); + } + + //! "Range" finder + /*! + Construct the \c range_finder. The finder does not perform + any operation. It simply returns the given range for + any input. + + \param Begin Beginning of the range + \param End End of the range + \param Range The range. + \return An instance of the \c range_finger object + */ + template< typename ForwardIteratorT > + inline detail::range_finderF<ForwardIteratorT> + range_finder( + ForwardIteratorT Begin, + ForwardIteratorT End ) + { + return detail::range_finderF<ForwardIteratorT>( Begin, End ); + } + + //! "Range" finder + /*! + \overload + */ + template< typename ForwardIteratorT > + inline detail::range_finderF<ForwardIteratorT> + range_finder( iterator_range<ForwardIteratorT> Range ) + { + return detail::range_finderF<ForwardIteratorT>( Range ); + } + + } // namespace algorithm + + // pull the names to the boost namespace + using algorithm::first_finder; + using algorithm::last_finder; + using algorithm::nth_finder; + using algorithm::head_finder; + using algorithm::tail_finder; + using algorithm::token_finder; + using algorithm::range_finder; + +} // namespace boost + + +#endif // BOOST_STRING_FINDER_HPP diff --git a/contrib/src/boost/algorithm/string/formatter.hpp b/contrib/src/boost/algorithm/string/formatter.hpp index 1295d67..de8681b 100644 --- a/contrib/src/boost/algorithm/string/formatter.hpp +++ b/contrib/src/boost/algorithm/string/formatter.hpp @@ -1,120 +1,120 @@ -// Boost string_algo library formatter.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_FORMATTER_HPP
-#define BOOST_STRING_FORMATTER_HPP
-
-#include <boost/detail/iterator.hpp>
-#include <boost/range/value_type.hpp>
-#include <boost/range/iterator_range_core.hpp>
-#include <boost/range/as_literal.hpp>
-
-#include <boost/algorithm/string/detail/formatter.hpp>
-
-/*! \file
- Defines Formatter generators. Formatter is a functor which formats
- a string according to given parameters. A Formatter works
- in conjunction with a Finder. A Finder can provide additional information
- for a specific Formatter. An example of such a cooperation is regex_finder
- and regex_formatter.
-
- Formatters are used as pluggable components for replace facilities.
- This header contains generator functions for the Formatters provided in this library.
-*/
-
-namespace boost {
- namespace algorithm {
-
-// generic formatters ---------------------------------------------------------------//
-
- //! Constant formatter
- /*!
- Constructs a \c const_formatter. Const formatter always returns
- the same value, regardless of the parameter.
-
- \param Format A predefined value used as a result for formatting
- \return An instance of the \c const_formatter object.
- */
- template<typename RangeT>
- inline detail::const_formatF<
- iterator_range<
- BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >
- const_formatter(const RangeT& Format)
- {
- return detail::const_formatF<
- iterator_range<
- BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >(::boost::as_literal(Format));
- }
-
- //! Identity formatter
- /*!
- Constructs an \c identity_formatter. Identity formatter always returns
- the parameter.
-
- \return An instance of the \c identity_formatter object.
- */
- template<typename RangeT>
- inline detail::identity_formatF<
- iterator_range<
- BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >
- identity_formatter()
- {
- return detail::identity_formatF<
- iterator_range<
- BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >();
- }
-
- //! Empty formatter
- /*!
- Constructs an \c empty_formatter. Empty formatter always returns an empty
- sequence.
-
- \param Input container used to select a correct value_type for the
- resulting empty_container<>.
- \return An instance of the \c empty_formatter object.
- */
- template<typename RangeT>
- inline detail::empty_formatF<
- BOOST_STRING_TYPENAME range_value<RangeT>::type>
- empty_formatter(const RangeT&)
- {
- return detail::empty_formatF<
- BOOST_STRING_TYPENAME range_value<RangeT>::type>();
- }
-
- //! Empty formatter
- /*!
- Constructs a \c dissect_formatter. Dissect formatter uses a specified finder
- to extract a portion of the formatted sequence. The first finder's match is returned
- as a result
-
- \param Finder a finder used to select a portion of the formatted sequence
- \return An instance of the \c dissect_formatter object.
- */
- template<typename FinderT>
- inline detail::dissect_formatF< FinderT >
- dissect_formatter(const FinderT& Finder)
- {
- return detail::dissect_formatF<FinderT>(Finder);
- }
-
-
- } // namespace algorithm
-
- // pull the names to the boost namespace
- using algorithm::const_formatter;
- using algorithm::identity_formatter;
- using algorithm::empty_formatter;
- using algorithm::dissect_formatter;
-
-} // namespace boost
-
-
-#endif // BOOST_FORMATTER_HPP
+// Boost string_algo library formatter.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_FORMATTER_HPP +#define BOOST_STRING_FORMATTER_HPP + +#include <boost/detail/iterator.hpp> +#include <boost/range/value_type.hpp> +#include <boost/range/iterator_range_core.hpp> +#include <boost/range/as_literal.hpp> + +#include <boost/algorithm/string/detail/formatter.hpp> + +/*! \file + Defines Formatter generators. Formatter is a functor which formats + a string according to given parameters. A Formatter works + in conjunction with a Finder. A Finder can provide additional information + for a specific Formatter. An example of such a cooperation is regex_finder + and regex_formatter. + + Formatters are used as pluggable components for replace facilities. + This header contains generator functions for the Formatters provided in this library. +*/ + +namespace boost { + namespace algorithm { + +// generic formatters ---------------------------------------------------------------// + + //! Constant formatter + /*! + Constructs a \c const_formatter. Const formatter always returns + the same value, regardless of the parameter. + + \param Format A predefined value used as a result for formatting + \return An instance of the \c const_formatter object. + */ + template<typename RangeT> + inline detail::const_formatF< + iterator_range< + BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> > + const_formatter(const RangeT& Format) + { + return detail::const_formatF< + iterator_range< + BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >(::boost::as_literal(Format)); + } + + //! Identity formatter + /*! + Constructs an \c identity_formatter. Identity formatter always returns + the parameter. + + \return An instance of the \c identity_formatter object. + */ + template<typename RangeT> + inline detail::identity_formatF< + iterator_range< + BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> > + identity_formatter() + { + return detail::identity_formatF< + iterator_range< + BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> >(); + } + + //! Empty formatter + /*! + Constructs an \c empty_formatter. Empty formatter always returns an empty + sequence. + + \param Input container used to select a correct value_type for the + resulting empty_container<>. + \return An instance of the \c empty_formatter object. + */ + template<typename RangeT> + inline detail::empty_formatF< + BOOST_STRING_TYPENAME range_value<RangeT>::type> + empty_formatter(const RangeT&) + { + return detail::empty_formatF< + BOOST_STRING_TYPENAME range_value<RangeT>::type>(); + } + + //! Empty formatter + /*! + Constructs a \c dissect_formatter. Dissect formatter uses a specified finder + to extract a portion of the formatted sequence. The first finder's match is returned + as a result + + \param Finder a finder used to select a portion of the formatted sequence + \return An instance of the \c dissect_formatter object. + */ + template<typename FinderT> + inline detail::dissect_formatF< FinderT > + dissect_formatter(const FinderT& Finder) + { + return detail::dissect_formatF<FinderT>(Finder); + } + + + } // namespace algorithm + + // pull the names to the boost namespace + using algorithm::const_formatter; + using algorithm::identity_formatter; + using algorithm::empty_formatter; + using algorithm::dissect_formatter; + +} // namespace boost + + +#endif // BOOST_FORMATTER_HPP diff --git a/contrib/src/boost/algorithm/string/iter_find.hpp b/contrib/src/boost/algorithm/string/iter_find.hpp index 04a56f0..10424ab 100644 --- a/contrib/src/boost/algorithm/string/iter_find.hpp +++ b/contrib/src/boost/algorithm/string/iter_find.hpp @@ -1,193 +1,193 @@ -// Boost string_algo library iter_find.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_ITER_FIND_HPP
-#define BOOST_STRING_ITER_FIND_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <algorithm>
-#include <iterator>
-#include <boost/iterator/transform_iterator.hpp>
-
-#include <boost/range/iterator_range_core.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/range/iterator.hpp>
-#include <boost/range/value_type.hpp>
-#include <boost/range/as_literal.hpp>
-
-#include <boost/algorithm/string/concept.hpp>
-#include <boost/algorithm/string/find_iterator.hpp>
-#include <boost/algorithm/string/detail/util.hpp>
-
-/*! \file
- Defines generic split algorithms. Split algorithms can be
- used to divide a sequence into several part according
- to a given criteria. Result is given as a 'container
- of containers' where elements are copies or references
- to extracted parts.
-
- There are two algorithms provided. One iterates over matching
- substrings, the other one over the gaps between these matches.
-*/
-
-namespace boost {
- namespace algorithm {
-
-// iterate find ---------------------------------------------------//
-
- //! Iter find algorithm
- /*!
- This algorithm executes a given finder in iteration on the input,
- until the end of input is reached, or no match is found.
- Iteration is done using built-in find_iterator, so the real
- searching is performed only when needed.
- In each iteration new match is found and added to the result.
-
- \param Result A 'container container' to contain the result of search.
- Both outer and inner container must have constructor taking a pair
- of iterators as an argument.
- Typical type of the result is
- \c std::vector<boost::iterator_range<iterator>>
- (each element of such a vector will container a range delimiting
- a match).
- \param Input A container which will be searched.
- \param Finder A Finder object used for searching
- \return A reference to the result
-
- \note Prior content of the result will be overwritten.
- */
- template<
- typename SequenceSequenceT,
- typename RangeT,
- typename FinderT >
- inline SequenceSequenceT&
- iter_find(
- SequenceSequenceT& Result,
- RangeT& Input,
- FinderT Finder )
- {
- BOOST_CONCEPT_ASSERT((
- FinderConcept<
- FinderT,
- BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
- ));
-
- iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
-
- typedef BOOST_STRING_TYPENAME
- range_iterator<RangeT>::type input_iterator_type;
- typedef find_iterator<input_iterator_type> find_iterator_type;
- typedef detail::copy_iterator_rangeF<
- BOOST_STRING_TYPENAME
- range_value<SequenceSequenceT>::type,
- input_iterator_type> copy_range_type;
-
- input_iterator_type InputEnd=::boost::end(lit_input);
-
- typedef transform_iterator<copy_range_type, find_iterator_type>
- transform_iter_type;
-
- transform_iter_type itBegin=
- ::boost::make_transform_iterator(
- find_iterator_type( ::boost::begin(lit_input), InputEnd, Finder ),
- copy_range_type());
-
- transform_iter_type itEnd=
- ::boost::make_transform_iterator(
- find_iterator_type(),
- copy_range_type());
-
- SequenceSequenceT Tmp(itBegin, itEnd);
-
- Result.swap(Tmp);
- return Result;
- }
-
-// iterate split ---------------------------------------------------//
-
- //! Split find algorithm
- /*!
- This algorithm executes a given finder in iteration on the input,
- until the end of input is reached, or no match is found.
- Iteration is done using built-in find_iterator, so the real
- searching is performed only when needed.
- Each match is used as a separator of segments. These segments are then
- returned in the result.
-
- \param Result A 'container container' to contain the result of search.
- Both outer and inner container must have constructor taking a pair
- of iterators as an argument.
- Typical type of the result is
- \c std::vector<boost::iterator_range<iterator>>
- (each element of such a vector will container a range delimiting
- a match).
- \param Input A container which will be searched.
- \param Finder A finder object used for searching
- \return A reference to the result
-
- \note Prior content of the result will be overwritten.
- */
- template<
- typename SequenceSequenceT,
- typename RangeT,
- typename FinderT >
- inline SequenceSequenceT&
- iter_split(
- SequenceSequenceT& Result,
- RangeT& Input,
- FinderT Finder )
- {
- BOOST_CONCEPT_ASSERT((
- FinderConcept<FinderT,
- BOOST_STRING_TYPENAME range_iterator<RangeT>::type>
- ));
-
- iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
-
- typedef BOOST_STRING_TYPENAME
- range_iterator<RangeT>::type input_iterator_type;
- typedef split_iterator<input_iterator_type> find_iterator_type;
- typedef detail::copy_iterator_rangeF<
- BOOST_STRING_TYPENAME
- range_value<SequenceSequenceT>::type,
- input_iterator_type> copy_range_type;
-
- input_iterator_type InputEnd=::boost::end(lit_input);
-
- typedef transform_iterator<copy_range_type, find_iterator_type>
- transform_iter_type;
-
- transform_iter_type itBegin=
- ::boost::make_transform_iterator(
- find_iterator_type( ::boost::begin(lit_input), InputEnd, Finder ),
- copy_range_type() );
-
- transform_iter_type itEnd=
- ::boost::make_transform_iterator(
- find_iterator_type(),
- copy_range_type() );
-
- SequenceSequenceT Tmp(itBegin, itEnd);
-
- Result.swap(Tmp);
- return Result;
- }
-
- } // namespace algorithm
-
- // pull names to the boost namespace
- using algorithm::iter_find;
- using algorithm::iter_split;
-
-} // namespace boost
-
-
-#endif // BOOST_STRING_ITER_FIND_HPP
+// Boost string_algo library iter_find.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_ITER_FIND_HPP +#define BOOST_STRING_ITER_FIND_HPP + +#include <boost/algorithm/string/config.hpp> +#include <algorithm> +#include <iterator> +#include <boost/iterator/transform_iterator.hpp> + +#include <boost/range/iterator_range_core.hpp> +#include <boost/range/begin.hpp> +#include <boost/range/end.hpp> +#include <boost/range/iterator.hpp> +#include <boost/range/value_type.hpp> +#include <boost/range/as_literal.hpp> + +#include <boost/algorithm/string/concept.hpp> +#include <boost/algorithm/string/find_iterator.hpp> +#include <boost/algorithm/string/detail/util.hpp> + +/*! \file + Defines generic split algorithms. Split algorithms can be + used to divide a sequence into several part according + to a given criteria. Result is given as a 'container + of containers' where elements are copies or references + to extracted parts. + + There are two algorithms provided. One iterates over matching + substrings, the other one over the gaps between these matches. +*/ + +namespace boost { + namespace algorithm { + +// iterate find ---------------------------------------------------// + + //! Iter find algorithm + /*! + This algorithm executes a given finder in iteration on the input, + until the end of input is reached, or no match is found. + Iteration is done using built-in find_iterator, so the real + searching is performed only when needed. + In each iteration new match is found and added to the result. + + \param Result A 'container container' to contain the result of search. + Both outer and inner container must have constructor taking a pair + of iterators as an argument. + Typical type of the result is + \c std::vector<boost::iterator_range<iterator>> + (each element of such a vector will container a range delimiting + a match). + \param Input A container which will be searched. + \param Finder A Finder object used for searching + \return A reference to the result + + \note Prior content of the result will be overwritten. + */ + template< + typename SequenceSequenceT, + typename RangeT, + typename FinderT > + inline SequenceSequenceT& + iter_find( + SequenceSequenceT& Result, + RangeT& Input, + FinderT Finder ) + { + BOOST_CONCEPT_ASSERT(( + FinderConcept< + FinderT, + BOOST_STRING_TYPENAME range_iterator<RangeT>::type> + )); + + iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input)); + + typedef BOOST_STRING_TYPENAME + range_iterator<RangeT>::type input_iterator_type; + typedef find_iterator<input_iterator_type> find_iterator_type; + typedef detail::copy_iterator_rangeF< + BOOST_STRING_TYPENAME + range_value<SequenceSequenceT>::type, + input_iterator_type> copy_range_type; + + input_iterator_type InputEnd=::boost::end(lit_input); + + typedef transform_iterator<copy_range_type, find_iterator_type> + transform_iter_type; + + transform_iter_type itBegin= + ::boost::make_transform_iterator( + find_iterator_type( ::boost::begin(lit_input), InputEnd, Finder ), + copy_range_type()); + + transform_iter_type itEnd= + ::boost::make_transform_iterator( + find_iterator_type(), + copy_range_type()); + + SequenceSequenceT Tmp(itBegin, itEnd); + + Result.swap(Tmp); + return Result; + } + +// iterate split ---------------------------------------------------// + + //! Split find algorithm + /*! + This algorithm executes a given finder in iteration on the input, + until the end of input is reached, or no match is found. + Iteration is done using built-in find_iterator, so the real + searching is performed only when needed. + Each match is used as a separator of segments. These segments are then + returned in the result. + + \param Result A 'container container' to contain the result of search. + Both outer and inner container must have constructor taking a pair + of iterators as an argument. + Typical type of the result is + \c std::vector<boost::iterator_range<iterator>> + (each element of such a vector will container a range delimiting + a match). + \param Input A container which will be searched. + \param Finder A finder object used for searching + \return A reference to the result + + \note Prior content of the result will be overwritten. + */ + template< + typename SequenceSequenceT, + typename RangeT, + typename FinderT > + inline SequenceSequenceT& + iter_split( + SequenceSequenceT& Result, + RangeT& Input, + FinderT Finder ) + { + BOOST_CONCEPT_ASSERT(( + FinderConcept<FinderT, + BOOST_STRING_TYPENAME range_iterator<RangeT>::type> + )); + + iterator_range<BOOST_STRING_TYPENAME range_iterator<RangeT>::type> lit_input(::boost::as_literal(Input)); + + typedef BOOST_STRING_TYPENAME + range_iterator<RangeT>::type input_iterator_type; + typedef split_iterator<input_iterator_type> find_iterator_type; + typedef detail::copy_iterator_rangeF< + BOOST_STRING_TYPENAME + range_value<SequenceSequenceT>::type, + input_iterator_type> copy_range_type; + + input_iterator_type InputEnd=::boost::end(lit_input); + + typedef transform_iterator<copy_range_type, find_iterator_type> + transform_iter_type; + + transform_iter_type itBegin= + ::boost::make_transform_iterator( + find_iterator_type( ::boost::begin(lit_input), InputEnd, Finder ), + copy_range_type() ); + + transform_iter_type itEnd= + ::boost::make_transform_iterator( + find_iterator_type(), + copy_range_type() ); + + SequenceSequenceT Tmp(itBegin, itEnd); + + Result.swap(Tmp); + return Result; + } + + } // namespace algorithm + + // pull names to the boost namespace + using algorithm::iter_find; + using algorithm::iter_split; + +} // namespace boost + + +#endif // BOOST_STRING_ITER_FIND_HPP diff --git a/contrib/src/boost/algorithm/string/join.hpp b/contrib/src/boost/algorithm/string/join.hpp index cbc98d9..b871eb4 100644 --- a/contrib/src/boost/algorithm/string/join.hpp +++ b/contrib/src/boost/algorithm/string/join.hpp @@ -1,145 +1,145 @@ -// Boost string_algo library join.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2006.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_JOIN_HPP
-#define BOOST_STRING_JOIN_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/algorithm/string/detail/sequence.hpp>
-#include <boost/range/value_type.hpp>
-#include <boost/range/as_literal.hpp>
-
-/*! \file
- Defines join algorithm.
-
- Join algorithm is a counterpart to split algorithms.
- It joins strings from a 'list' by adding user defined separator.
- Additionally there is a version that allows simple filtering
- by providing a predicate.
-*/
-
-namespace boost {
- namespace algorithm {
-
-// join --------------------------------------------------------------//
-
- //! Join algorithm
- /*!
- This algorithm joins all strings in a 'list' into one long string.
- Segments are concatenated by given separator.
-
- \param Input A container that holds the input strings. It must be a container-of-containers.
- \param Separator A string that will separate the joined segments.
- \return Concatenated string.
-
- \note This function provides the strong exception-safety guarantee
- */
- template< typename SequenceSequenceT, typename Range1T>
- inline typename range_value<SequenceSequenceT>::type
- join(
- const SequenceSequenceT& Input,
- const Range1T& Separator)
- {
- // Define working types
- typedef typename range_value<SequenceSequenceT>::type ResultT;
- typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT;
-
- // Parse input
- InputIteratorT itBegin=::boost::begin(Input);
- InputIteratorT itEnd=::boost::end(Input);
-
- // Construct container to hold the result
- ResultT Result;
-
- // Append first element
- if(itBegin!=itEnd)
- {
- detail::insert(Result, ::boost::end(Result), *itBegin);
- ++itBegin;
- }
-
- for(;itBegin!=itEnd; ++itBegin)
- {
- // Add separator
- detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));
- // Add element
- detail::insert(Result, ::boost::end(Result), *itBegin);
- }
-
- return Result;
- }
-
-// join_if ----------------------------------------------------------//
-
- //! Conditional join algorithm
- /*!
- This algorithm joins all strings in a 'list' into one long string.
- Segments are concatenated by given separator. Only segments that
- satisfy the predicate will be added to the result.
-
- \param Input A container that holds the input strings. It must be a container-of-containers.
- \param Separator A string that will separate the joined segments.
- \param Pred A segment selection predicate
- \return Concatenated string.
-
- \note This function provides the strong exception-safety guarantee
- */
- template< typename SequenceSequenceT, typename Range1T, typename PredicateT>
- inline typename range_value<SequenceSequenceT>::type
- join_if(
- const SequenceSequenceT& Input,
- const Range1T& Separator,
- PredicateT Pred)
- {
- // Define working types
- typedef typename range_value<SequenceSequenceT>::type ResultT;
- typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT;
-
- // Parse input
- InputIteratorT itBegin=::boost::begin(Input);
- InputIteratorT itEnd=::boost::end(Input);
-
- // Construct container to hold the result
- ResultT Result;
-
- // Roll to the first element that will be added
- while(itBegin!=itEnd && !Pred(*itBegin)) ++itBegin;
- // Add this element
- if(itBegin!=itEnd)
- {
- detail::insert(Result, ::boost::end(Result), *itBegin);
- ++itBegin;
- }
-
- for(;itBegin!=itEnd; ++itBegin)
- {
- if(Pred(*itBegin))
- {
- // Add separator
- detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator));
- // Add element
- detail::insert(Result, ::boost::end(Result), *itBegin);
- }
- }
-
- return Result;
- }
-
- } // namespace algorithm
-
- // pull names to the boost namespace
- using algorithm::join;
- using algorithm::join_if;
-
-} // namespace boost
-
-
-#endif // BOOST_STRING_JOIN_HPP
-
+// Boost string_algo library join.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2006. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_JOIN_HPP +#define BOOST_STRING_JOIN_HPP + +#include <boost/algorithm/string/config.hpp> +#include <boost/algorithm/string/detail/sequence.hpp> +#include <boost/range/value_type.hpp> +#include <boost/range/as_literal.hpp> + +/*! \file + Defines join algorithm. + + Join algorithm is a counterpart to split algorithms. + It joins strings from a 'list' by adding user defined separator. + Additionally there is a version that allows simple filtering + by providing a predicate. +*/ + +namespace boost { + namespace algorithm { + +// join --------------------------------------------------------------// + + //! Join algorithm + /*! + This algorithm joins all strings in a 'list' into one long string. + Segments are concatenated by given separator. + + \param Input A container that holds the input strings. It must be a container-of-containers. + \param Separator A string that will separate the joined segments. + \return Concatenated string. + + \note This function provides the strong exception-safety guarantee + */ + template< typename SequenceSequenceT, typename Range1T> + inline typename range_value<SequenceSequenceT>::type + join( + const SequenceSequenceT& Input, + const Range1T& Separator) + { + // Define working types + typedef typename range_value<SequenceSequenceT>::type ResultT; + typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT; + + // Parse input + InputIteratorT itBegin=::boost::begin(Input); + InputIteratorT itEnd=::boost::end(Input); + + // Construct container to hold the result + ResultT Result; + + // Append first element + if(itBegin!=itEnd) + { + detail::insert(Result, ::boost::end(Result), *itBegin); + ++itBegin; + } + + for(;itBegin!=itEnd; ++itBegin) + { + // Add separator + detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator)); + // Add element + detail::insert(Result, ::boost::end(Result), *itBegin); + } + + return Result; + } + +// join_if ----------------------------------------------------------// + + //! Conditional join algorithm + /*! + This algorithm joins all strings in a 'list' into one long string. + Segments are concatenated by given separator. Only segments that + satisfy the predicate will be added to the result. + + \param Input A container that holds the input strings. It must be a container-of-containers. + \param Separator A string that will separate the joined segments. + \param Pred A segment selection predicate + \return Concatenated string. + + \note This function provides the strong exception-safety guarantee + */ + template< typename SequenceSequenceT, typename Range1T, typename PredicateT> + inline typename range_value<SequenceSequenceT>::type + join_if( + const SequenceSequenceT& Input, + const Range1T& Separator, + PredicateT Pred) + { + // Define working types + typedef typename range_value<SequenceSequenceT>::type ResultT; + typedef typename range_const_iterator<SequenceSequenceT>::type InputIteratorT; + + // Parse input + InputIteratorT itBegin=::boost::begin(Input); + InputIteratorT itEnd=::boost::end(Input); + + // Construct container to hold the result + ResultT Result; + + // Roll to the first element that will be added + while(itBegin!=itEnd && !Pred(*itBegin)) ++itBegin; + // Add this element + if(itBegin!=itEnd) + { + detail::insert(Result, ::boost::end(Result), *itBegin); + ++itBegin; + } + + for(;itBegin!=itEnd; ++itBegin) + { + if(Pred(*itBegin)) + { + // Add separator + detail::insert(Result, ::boost::end(Result), ::boost::as_literal(Separator)); + // Add element + detail::insert(Result, ::boost::end(Result), *itBegin); + } + } + + return Result; + } + + } // namespace algorithm + + // pull names to the boost namespace + using algorithm::join; + using algorithm::join_if; + +} // namespace boost + + +#endif // BOOST_STRING_JOIN_HPP + diff --git a/contrib/src/boost/algorithm/string/predicate.hpp b/contrib/src/boost/algorithm/string/predicate.hpp index 3e4a511..0879829 100644 --- a/contrib/src/boost/algorithm/string/predicate.hpp +++ b/contrib/src/boost/algorithm/string/predicate.hpp @@ -1,475 +1,475 @@ -// Boost string_algo library predicate.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_PREDICATE_HPP
-#define BOOST_STRING_PREDICATE_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/range/iterator.hpp>
-#include <boost/range/const_iterator.hpp>
-#include <boost/range/as_literal.hpp>
-#include <boost/range/iterator_range_core.hpp>
-
-#include <boost/algorithm/string/compare.hpp>
-#include <boost/algorithm/string/find.hpp>
-#include <boost/algorithm/string/detail/predicate.hpp>
-
-/*! \file boost/algorithm/string/predicate.hpp
- Defines string-related predicates.
- The predicates determine whether a substring is contained in the input string
- under various conditions: a string starts with the substring, ends with the
- substring, simply contains the substring or if both strings are equal.
- Additionaly the algorithm \c all() checks all elements of a container to satisfy a
- condition.
-
- All predicates provide the strong exception guarantee.
-*/
-
-namespace boost {
- namespace algorithm {
-
-// starts_with predicate -----------------------------------------------//
-
- //! 'Starts with' predicate
- /*!
- This predicate holds when the test string is a prefix of the Input.
- In other words, if the input starts with the test.
- When the optional predicate is specified, it is used for character-wise
- comparison.
-
- \param Input An input sequence
- \param Test A test sequence
- \param Comp An element comparison predicate
- \return The result of the test
-
- \note This function provides the strong exception-safety guarantee
- */
- template<typename Range1T, typename Range2T, typename PredicateT>
- inline bool starts_with(
- const Range1T& Input,
- const Range2T& Test,
- PredicateT Comp)
- {
- iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
- iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));
-
- typedef BOOST_STRING_TYPENAME
- range_const_iterator<Range1T>::type Iterator1T;
- typedef BOOST_STRING_TYPENAME
- range_const_iterator<Range2T>::type Iterator2T;
-
- Iterator1T InputEnd=::boost::end(lit_input);
- Iterator2T TestEnd=::boost::end(lit_test);
-
- Iterator1T it=::boost::begin(lit_input);
- Iterator2T pit=::boost::begin(lit_test);
- for(;
- it!=InputEnd && pit!=TestEnd;
- ++it,++pit)
- {
- if( !(Comp(*it,*pit)) )
- return false;
- }
-
- return pit==TestEnd;
- }
-
- //! 'Starts with' predicate
- /*!
- \overload
- */
- template<typename Range1T, typename Range2T>
- inline bool starts_with(
- const Range1T& Input,
- const Range2T& Test)
- {
- return ::boost::algorithm::starts_with(Input, Test, is_equal());
- }
-
- //! 'Starts with' predicate ( case insensitive )
- /*!
- This predicate holds when the test string is a prefix of the Input.
- In other words, if the input starts with the test.
- Elements are compared case insensitively.
-
- \param Input An input sequence
- \param Test A test sequence
- \param Loc A locale used for case insensitive comparison
- \return The result of the test
-
- \note This function provides the strong exception-safety guarantee
- */
- template<typename Range1T, typename Range2T>
- inline bool istarts_with(
- const Range1T& Input,
- const Range2T& Test,
- const std::locale& Loc=std::locale())
- {
- return ::boost::algorithm::starts_with(Input, Test, is_iequal(Loc));
- }
-
-
-// ends_with predicate -----------------------------------------------//
-
- //! 'Ends with' predicate
- /*!
- This predicate holds when the test string is a suffix of the Input.
- In other words, if the input ends with the test.
- When the optional predicate is specified, it is used for character-wise
- comparison.
-
-
- \param Input An input sequence
- \param Test A test sequence
- \param Comp An element comparison predicate
- \return The result of the test
-
- \note This function provides the strong exception-safety guarantee
- */
- template<typename Range1T, typename Range2T, typename PredicateT>
- inline bool ends_with(
- const Range1T& Input,
- const Range2T& Test,
- PredicateT Comp)
- {
- iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
- iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));
-
- typedef BOOST_STRING_TYPENAME
- range_const_iterator<Range1T>::type Iterator1T;
- typedef BOOST_STRING_TYPENAME boost::detail::
- iterator_traits<Iterator1T>::iterator_category category;
-
- return detail::
- ends_with_iter_select(
- ::boost::begin(lit_input),
- ::boost::end(lit_input),
- ::boost::begin(lit_test),
- ::boost::end(lit_test),
- Comp,
- category());
- }
-
-
- //! 'Ends with' predicate
- /*!
- \overload
- */
- template<typename Range1T, typename Range2T>
- inline bool ends_with(
- const Range1T& Input,
- const Range2T& Test)
- {
- return ::boost::algorithm::ends_with(Input, Test, is_equal());
- }
-
- //! 'Ends with' predicate ( case insensitive )
- /*!
- This predicate holds when the test container is a suffix of the Input.
- In other words, if the input ends with the test.
- Elements are compared case insensitively.
-
- \param Input An input sequence
- \param Test A test sequence
- \param Loc A locale used for case insensitive comparison
- \return The result of the test
-
- \note This function provides the strong exception-safety guarantee
- */
- template<typename Range1T, typename Range2T>
- inline bool iends_with(
- const Range1T& Input,
- const Range2T& Test,
- const std::locale& Loc=std::locale())
- {
- return ::boost::algorithm::ends_with(Input, Test, is_iequal(Loc));
- }
-
-// contains predicate -----------------------------------------------//
-
- //! 'Contains' predicate
- /*!
- This predicate holds when the test container is contained in the Input.
- When the optional predicate is specified, it is used for character-wise
- comparison.
-
- \param Input An input sequence
- \param Test A test sequence
- \param Comp An element comparison predicate
- \return The result of the test
-
- \note This function provides the strong exception-safety guarantee
- */
- template<typename Range1T, typename Range2T, typename PredicateT>
- inline bool contains(
- const Range1T& Input,
- const Range2T& Test,
- PredicateT Comp)
- {
- iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
- iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));
-
- if (::boost::empty(lit_test))
- {
- // Empty range is contained always
- return true;
- }
-
- // Use the temporary variable to make VACPP happy
- bool bResult=(::boost::algorithm::first_finder(lit_test,Comp)(::boost::begin(lit_input), ::boost::end(lit_input)));
- return bResult;
- }
-
- //! 'Contains' predicate
- /*!
- \overload
- */
- template<typename Range1T, typename Range2T>
- inline bool contains(
- const Range1T& Input,
- const Range2T& Test)
- {
- return ::boost::algorithm::contains(Input, Test, is_equal());
- }
-
- //! 'Contains' predicate ( case insensitive )
- /*!
- This predicate holds when the test container is contained in the Input.
- Elements are compared case insensitively.
-
- \param Input An input sequence
- \param Test A test sequence
- \param Loc A locale used for case insensitive comparison
- \return The result of the test
-
- \note This function provides the strong exception-safety guarantee
- */
- template<typename Range1T, typename Range2T>
- inline bool icontains(
- const Range1T& Input,
- const Range2T& Test,
- const std::locale& Loc=std::locale())
- {
- return ::boost::algorithm::contains(Input, Test, is_iequal(Loc));
- }
-
-// equals predicate -----------------------------------------------//
-
- //! 'Equals' predicate
- /*!
- This predicate holds when the test container is equal to the
- input container i.e. all elements in both containers are same.
- When the optional predicate is specified, it is used for character-wise
- comparison.
-
- \param Input An input sequence
- \param Test A test sequence
- \param Comp An element comparison predicate
- \return The result of the test
-
- \note This is a two-way version of \c std::equal algorithm
-
- \note This function provides the strong exception-safety guarantee
- */
- template<typename Range1T, typename Range2T, typename PredicateT>
- inline bool equals(
- const Range1T& Input,
- const Range2T& Test,
- PredicateT Comp)
- {
- iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input));
- iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test));
-
- typedef BOOST_STRING_TYPENAME
- range_const_iterator<Range1T>::type Iterator1T;
- typedef BOOST_STRING_TYPENAME
- range_const_iterator<Range2T>::type Iterator2T;
-
- Iterator1T InputEnd=::boost::end(lit_input);
- Iterator2T TestEnd=::boost::end(lit_test);
-
- Iterator1T it=::boost::begin(lit_input);
- Iterator2T pit=::boost::begin(lit_test);
- for(;
- it!=InputEnd && pit!=TestEnd;
- ++it,++pit)
- {
- if( !(Comp(*it,*pit)) )
- return false;
- }
-
- return (pit==TestEnd) && (it==InputEnd);
- }
-
- //! 'Equals' predicate
- /*!
- \overload
- */
- template<typename Range1T, typename Range2T>
- inline bool equals(
- const Range1T& Input,
- const Range2T& Test)
- {
- return ::boost::algorithm::equals(Input, Test, is_equal());
- }
-
- //! 'Equals' predicate ( case insensitive )
- /*!
- This predicate holds when the test container is equal to the
- input container i.e. all elements in both containers are same.
- Elements are compared case insensitively.
-
- \param Input An input sequence
- \param Test A test sequence
- \param Loc A locale used for case insensitive comparison
- \return The result of the test
-
- \note This is a two-way version of \c std::equal algorithm
-
- \note This function provides the strong exception-safety guarantee
- */
- template<typename Range1T, typename Range2T>
- inline bool iequals(
- const Range1T& Input,
- const Range2T& Test,
- const std::locale& Loc=std::locale())
- {
- return ::boost::algorithm::equals(Input, Test, is_iequal(Loc));
- }
-
-// lexicographical_compare predicate -----------------------------//
-
- //! Lexicographical compare predicate
- /*!
- This predicate is an overload of std::lexicographical_compare
- for range arguments
-
- It check whether the first argument is lexicographically less
- then the second one.
-
- If the optional predicate is specified, it is used for character-wise
- comparison
-
- \param Arg1 First argument
- \param Arg2 Second argument
- \param Pred Comparison predicate
- \return The result of the test
-
- \note This function provides the strong exception-safety guarantee
- */
- template<typename Range1T, typename Range2T, typename PredicateT>
- inline bool lexicographical_compare(
- const Range1T& Arg1,
- const Range2T& Arg2,
- PredicateT Pred)
- {
- iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_arg1(::boost::as_literal(Arg1));
- iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_arg2(::boost::as_literal(Arg2));
-
- return std::lexicographical_compare(
- ::boost::begin(lit_arg1),
- ::boost::end(lit_arg1),
- ::boost::begin(lit_arg2),
- ::boost::end(lit_arg2),
- Pred);
- }
-
- //! Lexicographical compare predicate
- /*!
- \overload
- */
- template<typename Range1T, typename Range2T>
- inline bool lexicographical_compare(
- const Range1T& Arg1,
- const Range2T& Arg2)
- {
- return ::boost::algorithm::lexicographical_compare(Arg1, Arg2, is_less());
- }
-
- //! Lexicographical compare predicate (case-insensitive)
- /*!
- This predicate is an overload of std::lexicographical_compare
- for range arguments.
- It check whether the first argument is lexicographically less
- then the second one.
- Elements are compared case insensitively
-
-
- \param Arg1 First argument
- \param Arg2 Second argument
- \param Loc A locale used for case insensitive comparison
- \return The result of the test
-
- \note This function provides the strong exception-safety guarantee
- */
- template<typename Range1T, typename Range2T>
- inline bool ilexicographical_compare(
- const Range1T& Arg1,
- const Range2T& Arg2,
- const std::locale& Loc=std::locale())
- {
- return ::boost::algorithm::lexicographical_compare(Arg1, Arg2, is_iless(Loc));
- }
-
-
-// all predicate -----------------------------------------------//
-
- //! 'All' predicate
- /*!
- This predicate holds it all its elements satisfy a given
- condition, represented by the predicate.
-
- \param Input An input sequence
- \param Pred A predicate
- \return The result of the test
-
- \note This function provides the strong exception-safety guarantee
- */
- template<typename RangeT, typename PredicateT>
- inline bool all(
- const RangeT& Input,
- PredicateT Pred)
- {
- iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input));
-
- typedef BOOST_STRING_TYPENAME
- range_const_iterator<RangeT>::type Iterator1T;
-
- Iterator1T InputEnd=::boost::end(lit_input);
- for( Iterator1T It=::boost::begin(lit_input); It!=InputEnd; ++It)
- {
- if (!Pred(*It))
- return false;
- }
-
- return true;
- }
-
- } // namespace algorithm
-
- // pull names to the boost namespace
- using algorithm::starts_with;
- using algorithm::istarts_with;
- using algorithm::ends_with;
- using algorithm::iends_with;
- using algorithm::contains;
- using algorithm::icontains;
- using algorithm::equals;
- using algorithm::iequals;
- using algorithm::all;
- using algorithm::lexicographical_compare;
- using algorithm::ilexicographical_compare;
-
-} // namespace boost
-
-
-#endif // BOOST_STRING_PREDICATE_HPP
+// Boost string_algo library predicate.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_PREDICATE_HPP +#define BOOST_STRING_PREDICATE_HPP + +#include <boost/algorithm/string/config.hpp> +#include <boost/range/begin.hpp> +#include <boost/range/end.hpp> +#include <boost/range/iterator.hpp> +#include <boost/range/const_iterator.hpp> +#include <boost/range/as_literal.hpp> +#include <boost/range/iterator_range_core.hpp> + +#include <boost/algorithm/string/compare.hpp> +#include <boost/algorithm/string/find.hpp> +#include <boost/algorithm/string/detail/predicate.hpp> + +/*! \file boost/algorithm/string/predicate.hpp + Defines string-related predicates. + The predicates determine whether a substring is contained in the input string + under various conditions: a string starts with the substring, ends with the + substring, simply contains the substring or if both strings are equal. + Additionaly the algorithm \c all() checks all elements of a container to satisfy a + condition. + + All predicates provide the strong exception guarantee. +*/ + +namespace boost { + namespace algorithm { + +// starts_with predicate -----------------------------------------------// + + //! 'Starts with' predicate + /*! + This predicate holds when the test string is a prefix of the Input. + In other words, if the input starts with the test. + When the optional predicate is specified, it is used for character-wise + comparison. + + \param Input An input sequence + \param Test A test sequence + \param Comp An element comparison predicate + \return The result of the test + + \note This function provides the strong exception-safety guarantee + */ + template<typename Range1T, typename Range2T, typename PredicateT> + inline bool starts_with( + const Range1T& Input, + const Range2T& Test, + PredicateT Comp) + { + iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input)); + iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test)); + + typedef BOOST_STRING_TYPENAME + range_const_iterator<Range1T>::type Iterator1T; + typedef BOOST_STRING_TYPENAME + range_const_iterator<Range2T>::type Iterator2T; + + Iterator1T InputEnd=::boost::end(lit_input); + Iterator2T TestEnd=::boost::end(lit_test); + + Iterator1T it=::boost::begin(lit_input); + Iterator2T pit=::boost::begin(lit_test); + for(; + it!=InputEnd && pit!=TestEnd; + ++it,++pit) + { + if( !(Comp(*it,*pit)) ) + return false; + } + + return pit==TestEnd; + } + + //! 'Starts with' predicate + /*! + \overload + */ + template<typename Range1T, typename Range2T> + inline bool starts_with( + const Range1T& Input, + const Range2T& Test) + { + return ::boost::algorithm::starts_with(Input, Test, is_equal()); + } + + //! 'Starts with' predicate ( case insensitive ) + /*! + This predicate holds when the test string is a prefix of the Input. + In other words, if the input starts with the test. + Elements are compared case insensitively. + + \param Input An input sequence + \param Test A test sequence + \param Loc A locale used for case insensitive comparison + \return The result of the test + + \note This function provides the strong exception-safety guarantee + */ + template<typename Range1T, typename Range2T> + inline bool istarts_with( + const Range1T& Input, + const Range2T& Test, + const std::locale& Loc=std::locale()) + { + return ::boost::algorithm::starts_with(Input, Test, is_iequal(Loc)); + } + + +// ends_with predicate -----------------------------------------------// + + //! 'Ends with' predicate + /*! + This predicate holds when the test string is a suffix of the Input. + In other words, if the input ends with the test. + When the optional predicate is specified, it is used for character-wise + comparison. + + + \param Input An input sequence + \param Test A test sequence + \param Comp An element comparison predicate + \return The result of the test + + \note This function provides the strong exception-safety guarantee + */ + template<typename Range1T, typename Range2T, typename PredicateT> + inline bool ends_with( + const Range1T& Input, + const Range2T& Test, + PredicateT Comp) + { + iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input)); + iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test)); + + typedef BOOST_STRING_TYPENAME + range_const_iterator<Range1T>::type Iterator1T; + typedef BOOST_STRING_TYPENAME boost::detail:: + iterator_traits<Iterator1T>::iterator_category category; + + return detail:: + ends_with_iter_select( + ::boost::begin(lit_input), + ::boost::end(lit_input), + ::boost::begin(lit_test), + ::boost::end(lit_test), + Comp, + category()); + } + + + //! 'Ends with' predicate + /*! + \overload + */ + template<typename Range1T, typename Range2T> + inline bool ends_with( + const Range1T& Input, + const Range2T& Test) + { + return ::boost::algorithm::ends_with(Input, Test, is_equal()); + } + + //! 'Ends with' predicate ( case insensitive ) + /*! + This predicate holds when the test container is a suffix of the Input. + In other words, if the input ends with the test. + Elements are compared case insensitively. + + \param Input An input sequence + \param Test A test sequence + \param Loc A locale used for case insensitive comparison + \return The result of the test + + \note This function provides the strong exception-safety guarantee + */ + template<typename Range1T, typename Range2T> + inline bool iends_with( + const Range1T& Input, + const Range2T& Test, + const std::locale& Loc=std::locale()) + { + return ::boost::algorithm::ends_with(Input, Test, is_iequal(Loc)); + } + +// contains predicate -----------------------------------------------// + + //! 'Contains' predicate + /*! + This predicate holds when the test container is contained in the Input. + When the optional predicate is specified, it is used for character-wise + comparison. + + \param Input An input sequence + \param Test A test sequence + \param Comp An element comparison predicate + \return The result of the test + + \note This function provides the strong exception-safety guarantee + */ + template<typename Range1T, typename Range2T, typename PredicateT> + inline bool contains( + const Range1T& Input, + const Range2T& Test, + PredicateT Comp) + { + iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input)); + iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test)); + + if (::boost::empty(lit_test)) + { + // Empty range is contained always + return true; + } + + // Use the temporary variable to make VACPP happy + bool bResult=(::boost::algorithm::first_finder(lit_test,Comp)(::boost::begin(lit_input), ::boost::end(lit_input))); + return bResult; + } + + //! 'Contains' predicate + /*! + \overload + */ + template<typename Range1T, typename Range2T> + inline bool contains( + const Range1T& Input, + const Range2T& Test) + { + return ::boost::algorithm::contains(Input, Test, is_equal()); + } + + //! 'Contains' predicate ( case insensitive ) + /*! + This predicate holds when the test container is contained in the Input. + Elements are compared case insensitively. + + \param Input An input sequence + \param Test A test sequence + \param Loc A locale used for case insensitive comparison + \return The result of the test + + \note This function provides the strong exception-safety guarantee + */ + template<typename Range1T, typename Range2T> + inline bool icontains( + const Range1T& Input, + const Range2T& Test, + const std::locale& Loc=std::locale()) + { + return ::boost::algorithm::contains(Input, Test, is_iequal(Loc)); + } + +// equals predicate -----------------------------------------------// + + //! 'Equals' predicate + /*! + This predicate holds when the test container is equal to the + input container i.e. all elements in both containers are same. + When the optional predicate is specified, it is used for character-wise + comparison. + + \param Input An input sequence + \param Test A test sequence + \param Comp An element comparison predicate + \return The result of the test + + \note This is a two-way version of \c std::equal algorithm + + \note This function provides the strong exception-safety guarantee + */ + template<typename Range1T, typename Range2T, typename PredicateT> + inline bool equals( + const Range1T& Input, + const Range2T& Test, + PredicateT Comp) + { + iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_input(::boost::as_literal(Input)); + iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_test(::boost::as_literal(Test)); + + typedef BOOST_STRING_TYPENAME + range_const_iterator<Range1T>::type Iterator1T; + typedef BOOST_STRING_TYPENAME + range_const_iterator<Range2T>::type Iterator2T; + + Iterator1T InputEnd=::boost::end(lit_input); + Iterator2T TestEnd=::boost::end(lit_test); + + Iterator1T it=::boost::begin(lit_input); + Iterator2T pit=::boost::begin(lit_test); + for(; + it!=InputEnd && pit!=TestEnd; + ++it,++pit) + { + if( !(Comp(*it,*pit)) ) + return false; + } + + return (pit==TestEnd) && (it==InputEnd); + } + + //! 'Equals' predicate + /*! + \overload + */ + template<typename Range1T, typename Range2T> + inline bool equals( + const Range1T& Input, + const Range2T& Test) + { + return ::boost::algorithm::equals(Input, Test, is_equal()); + } + + //! 'Equals' predicate ( case insensitive ) + /*! + This predicate holds when the test container is equal to the + input container i.e. all elements in both containers are same. + Elements are compared case insensitively. + + \param Input An input sequence + \param Test A test sequence + \param Loc A locale used for case insensitive comparison + \return The result of the test + + \note This is a two-way version of \c std::equal algorithm + + \note This function provides the strong exception-safety guarantee + */ + template<typename Range1T, typename Range2T> + inline bool iequals( + const Range1T& Input, + const Range2T& Test, + const std::locale& Loc=std::locale()) + { + return ::boost::algorithm::equals(Input, Test, is_iequal(Loc)); + } + +// lexicographical_compare predicate -----------------------------// + + //! Lexicographical compare predicate + /*! + This predicate is an overload of std::lexicographical_compare + for range arguments + + It check whether the first argument is lexicographically less + then the second one. + + If the optional predicate is specified, it is used for character-wise + comparison + + \param Arg1 First argument + \param Arg2 Second argument + \param Pred Comparison predicate + \return The result of the test + + \note This function provides the strong exception-safety guarantee + */ + template<typename Range1T, typename Range2T, typename PredicateT> + inline bool lexicographical_compare( + const Range1T& Arg1, + const Range2T& Arg2, + PredicateT Pred) + { + iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range1T>::type> lit_arg1(::boost::as_literal(Arg1)); + iterator_range<BOOST_STRING_TYPENAME range_const_iterator<Range2T>::type> lit_arg2(::boost::as_literal(Arg2)); + + return std::lexicographical_compare( + ::boost::begin(lit_arg1), + ::boost::end(lit_arg1), + ::boost::begin(lit_arg2), + ::boost::end(lit_arg2), + Pred); + } + + //! Lexicographical compare predicate + /*! + \overload + */ + template<typename Range1T, typename Range2T> + inline bool lexicographical_compare( + const Range1T& Arg1, + const Range2T& Arg2) + { + return ::boost::algorithm::lexicographical_compare(Arg1, Arg2, is_less()); + } + + //! Lexicographical compare predicate (case-insensitive) + /*! + This predicate is an overload of std::lexicographical_compare + for range arguments. + It check whether the first argument is lexicographically less + then the second one. + Elements are compared case insensitively + + + \param Arg1 First argument + \param Arg2 Second argument + \param Loc A locale used for case insensitive comparison + \return The result of the test + + \note This function provides the strong exception-safety guarantee + */ + template<typename Range1T, typename Range2T> + inline bool ilexicographical_compare( + const Range1T& Arg1, + const Range2T& Arg2, + const std::locale& Loc=std::locale()) + { + return ::boost::algorithm::lexicographical_compare(Arg1, Arg2, is_iless(Loc)); + } + + +// all predicate -----------------------------------------------// + + //! 'All' predicate + /*! + This predicate holds it all its elements satisfy a given + condition, represented by the predicate. + + \param Input An input sequence + \param Pred A predicate + \return The result of the test + + \note This function provides the strong exception-safety guarantee + */ + template<typename RangeT, typename PredicateT> + inline bool all( + const RangeT& Input, + PredicateT Pred) + { + iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_input(::boost::as_literal(Input)); + + typedef BOOST_STRING_TYPENAME + range_const_iterator<RangeT>::type Iterator1T; + + Iterator1T InputEnd=::boost::end(lit_input); + for( Iterator1T It=::boost::begin(lit_input); It!=InputEnd; ++It) + { + if (!Pred(*It)) + return false; + } + + return true; + } + + } // namespace algorithm + + // pull names to the boost namespace + using algorithm::starts_with; + using algorithm::istarts_with; + using algorithm::ends_with; + using algorithm::iends_with; + using algorithm::contains; + using algorithm::icontains; + using algorithm::equals; + using algorithm::iequals; + using algorithm::all; + using algorithm::lexicographical_compare; + using algorithm::ilexicographical_compare; + +} // namespace boost + + +#endif // BOOST_STRING_PREDICATE_HPP diff --git a/contrib/src/boost/algorithm/string/predicate_facade.hpp b/contrib/src/boost/algorithm/string/predicate_facade.hpp index bcb20d1..a9753fc 100644 --- a/contrib/src/boost/algorithm/string/predicate_facade.hpp +++ b/contrib/src/boost/algorithm/string/predicate_facade.hpp @@ -1,42 +1,42 @@ -// Boost string_algo library predicate_facade.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_PREDICATE_FACADE_HPP
-#define BOOST_STRING_PREDICATE_FACADE_HPP
-
-#include <boost/algorithm/string/config.hpp>
-
-/*
- \file boost/algorith/string/predicate_facade.hpp
- This file contains predicate_facade definition. This template class is used
- to identify classification predicates, so they can be combined using
- composition operators.
-*/
-
-namespace boost {
- namespace algorithm {
-
-// predicate facade ------------------------------------------------------//
-
- //! Predicate facade
- /*!
- This class allows to recognize classification
- predicates, so that they can be combined using
- composition operators.
- Every classification predicate must be derived from this class.
- */
- template<typename Derived>
- struct predicate_facade {};
-
- } // namespace algorithm
-} // namespace boost
-
-
-#endif // BOOST_STRING_CLASSIFICATION_DETAIL_HPP
+// Boost string_algo library predicate_facade.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_PREDICATE_FACADE_HPP +#define BOOST_STRING_PREDICATE_FACADE_HPP + +#include <boost/algorithm/string/config.hpp> + +/* + \file boost/algorith/string/predicate_facade.hpp + This file contains predicate_facade definition. This template class is used + to identify classification predicates, so they can be combined using + composition operators. +*/ + +namespace boost { + namespace algorithm { + +// predicate facade ------------------------------------------------------// + + //! Predicate facade + /*! + This class allows to recognize classification + predicates, so that they can be combined using + composition operators. + Every classification predicate must be derived from this class. + */ + template<typename Derived> + struct predicate_facade {}; + + } // namespace algorithm +} // namespace boost + + +#endif // BOOST_STRING_CLASSIFICATION_DETAIL_HPP diff --git a/contrib/src/boost/algorithm/string/replace.hpp b/contrib/src/boost/algorithm/string/replace.hpp index 3eb2be1..0c04e47 100644 --- a/contrib/src/boost/algorithm/string/replace.hpp +++ b/contrib/src/boost/algorithm/string/replace.hpp @@ -1,926 +1,928 @@ -// Boost string_algo library replace.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2006.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_REPLACE_HPP
-#define BOOST_STRING_REPLACE_HPP
-
-#include <boost/algorithm/string/config.hpp>
-
-#include <boost/range/iterator_range_core.hpp>
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/range/iterator.hpp>
-#include <boost/range/const_iterator.hpp>
-
-#include <boost/algorithm/string/find_format.hpp>
-#include <boost/algorithm/string/finder.hpp>
-#include <boost/algorithm/string/formatter.hpp>
-#include <boost/algorithm/string/compare.hpp>
-
-/*! \file
- Defines various replace algorithms. Each algorithm replaces
- part(s) of the input according to set of searching and replace criteria.
-*/
-
-namespace boost {
- namespace algorithm {
-
-// replace_range --------------------------------------------------------------------//
-
- //! Replace range algorithm
- /*!
- Replace the given range in the input string.
- The result is a modified copy of the input. It is returned as a sequence
- or copied to the output iterator.
-
- \param Output An output iterator to which the result will be copied
- \param Input An input string
- \param SearchRange A range in the input to be substituted
- \param Format A substitute string
- \return An output iterator pointing just after the last inserted character or
- a modified copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<
- typename OutputIteratorT,
- typename Range1T,
- typename Range2T>
- inline OutputIteratorT replace_range_copy(
- OutputIteratorT Output,
- const Range1T& Input,
- const iterator_range<
- BOOST_STRING_TYPENAME
- range_const_iterator<Range1T>::type>& SearchRange,
- const Range2T& Format)
- {
- return ::boost::algorithm::find_format_copy(
- Output,
- Input,
- ::boost::algorithm::range_finder(SearchRange),
- ::boost::algorithm::const_formatter(Format));
- }
-
- //! Replace range algorithm
- /*!
- \overload
- */
- template<typename SequenceT, typename RangeT>
- inline SequenceT replace_range_copy(
- const SequenceT& Input,
- const iterator_range<
- BOOST_STRING_TYPENAME
- range_const_iterator<SequenceT>::type>& SearchRange,
- const RangeT& Format)
- {
- return ::boost::algorithm::find_format_copy(
- Input,
- ::boost::algorithm::range_finder(SearchRange),
- ::boost::algorithm::const_formatter(Format));
- }
-
- //! Replace range algorithm
- /*!
- Replace the given range in the input string.
- The input sequence is modified in-place.
-
- \param Input An input string
- \param SearchRange A range in the input to be substituted
- \param Format A substitute string
- */
- template<typename SequenceT, typename RangeT>
- inline void replace_range(
- SequenceT& Input,
- const iterator_range<
- BOOST_STRING_TYPENAME
- range_iterator<SequenceT>::type>& SearchRange,
- const RangeT& Format)
- {
- ::boost::algorithm::find_format(
- Input,
- ::boost::algorithm::range_finder(SearchRange),
- ::boost::algorithm::const_formatter(Format));
- }
-
-// replace_first --------------------------------------------------------------------//
-
- //! Replace first algorithm
- /*!
- Replace the first match of the search substring in the input
- with the format string.
- The result is a modified copy of the input. It is returned as a sequence
- or copied to the output iterator.
-
- \param Output An output iterator to which the result will be copied
- \param Input An input string
- \param Search A substring to be searched for
- \param Format A substitute string
- \return An output iterator pointing just after the last inserted character or
- a modified copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<
- typename OutputIteratorT,
- typename Range1T,
- typename Range2T,
- typename Range3T>
- inline OutputIteratorT replace_first_copy(
- OutputIteratorT Output,
- const Range1T& Input,
- const Range2T& Search,
- const Range3T& Format)
- {
- return ::boost::algorithm::find_format_copy(
- Output,
- Input,
- ::boost::algorithm::first_finder(Search),
- ::boost::algorithm::const_formatter(Format) );
- }
-
- //! Replace first algorithm
- /*!
- \overload
- */
- template<typename SequenceT, typename Range1T, typename Range2T>
- inline SequenceT replace_first_copy(
- const SequenceT& Input,
- const Range1T& Search,
- const Range2T& Format )
- {
- return ::boost::algorithm::find_format_copy(
- Input,
- ::boost::algorithm::first_finder(Search),
- ::boost::algorithm::const_formatter(Format) );
- }
-
- //! Replace first algorithm
- /*!
- replace the first match of the search substring in the input
- with the format string. The input sequence is modified in-place.
-
- \param Input An input string
- \param Search A substring to be searched for
- \param Format A substitute string
- */
- template<typename SequenceT, typename Range1T, typename Range2T>
- inline void replace_first(
- SequenceT& Input,
- const Range1T& Search,
- const Range2T& Format )
- {
- ::boost::algorithm::find_format(
- Input,
- ::boost::algorithm::first_finder(Search),
- ::boost::algorithm::const_formatter(Format) );
- }
-
-// replace_first ( case insensitive ) ---------------------------------------------//
-
- //! Replace first algorithm ( case insensitive )
- /*!
- Replace the first match of the search substring in the input
- with the format string.
- The result is a modified copy of the input. It is returned as a sequence
- or copied to the output iterator.
- Searching is case insensitive.
-
- \param Output An output iterator to which the result will be copied
- \param Input An input string
- \param Search A substring to be searched for
- \param Format A substitute string
- \param Loc A locale used for case insensitive comparison
- \return An output iterator pointing just after the last inserted character or
- a modified copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<
- typename OutputIteratorT,
- typename Range1T,
- typename Range2T,
- typename Range3T>
- inline OutputIteratorT ireplace_first_copy(
- OutputIteratorT Output,
- const Range1T& Input,
- const Range2T& Search,
- const Range3T& Format,
- const std::locale& Loc=std::locale() )
- {
- return ::boost::algorithm::find_format_copy(
- Output,
- Input,
- ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
- ::boost::algorithm::const_formatter(Format) );
- }
-
- //! Replace first algorithm ( case insensitive )
- /*!
- \overload
- */
- template<typename SequenceT, typename Range2T, typename Range1T>
- inline SequenceT ireplace_first_copy(
- const SequenceT& Input,
- const Range2T& Search,
- const Range1T& Format,
- const std::locale& Loc=std::locale() )
- {
- return ::boost::algorithm::find_format_copy(
- Input,
- ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
- ::boost::algorithm::const_formatter(Format) );
- }
-
- //! Replace first algorithm ( case insensitive )
- /*!
- Replace the first match of the search substring in the input
- with the format string. Input sequence is modified in-place.
- Searching is case insensitive.
-
- \param Input An input string
- \param Search A substring to be searched for
- \param Format A substitute string
- \param Loc A locale used for case insensitive comparison
- */
- template<typename SequenceT, typename Range1T, typename Range2T>
- inline void ireplace_first(
- SequenceT& Input,
- const Range1T& Search,
- const Range2T& Format,
- const std::locale& Loc=std::locale() )
- {
- ::boost::algorithm::find_format(
- Input,
- ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
- ::boost::algorithm::const_formatter(Format) );
- }
-
-// replace_last --------------------------------------------------------------------//
-
- //! Replace last algorithm
- /*!
- Replace the last match of the search string in the input
- with the format string.
- The result is a modified copy of the input. It is returned as a sequence
- or copied to the output iterator.
-
- \param Output An output iterator to which the result will be copied
- \param Input An input string
- \param Search A substring to be searched for
- \param Format A substitute string
- \return An output iterator pointing just after the last inserted character or
- a modified copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<
- typename OutputIteratorT,
- typename Range1T,
- typename Range2T,
- typename Range3T>
- inline OutputIteratorT replace_last_copy(
- OutputIteratorT Output,
- const Range1T& Input,
- const Range2T& Search,
- const Range3T& Format )
- {
- return ::boost::algorithm::find_format_copy(
- Output,
- Input,
- ::boost::algorithm::last_finder(Search),
- ::boost::algorithm::const_formatter(Format) );
- }
-
- //! Replace last algorithm
- /*!
- \overload
- */
- template<typename SequenceT, typename Range1T, typename Range2T>
- inline SequenceT replace_last_copy(
- const SequenceT& Input,
- const Range1T& Search,
- const Range2T& Format )
- {
- return ::boost::algorithm::find_format_copy(
- Input,
- ::boost::algorithm::last_finder(Search),
- ::boost::algorithm::const_formatter(Format) );
- }
-
- //! Replace last algorithm
- /*!
- Replace the last match of the search string in the input
- with the format string. Input sequence is modified in-place.
-
- \param Input An input string
- \param Search A substring to be searched for
- \param Format A substitute string
- */
- template<typename SequenceT, typename Range1T, typename Range2T>
- inline void replace_last(
- SequenceT& Input,
- const Range1T& Search,
- const Range2T& Format )
- {
- ::boost::algorithm::find_format(
- Input,
- ::boost::algorithm::last_finder(Search),
- ::boost::algorithm::const_formatter(Format) );
- }
-
-// replace_last ( case insensitive ) -----------------------------------------------//
-
- //! Replace last algorithm ( case insensitive )
- /*!
- Replace the last match of the search string in the input
- with the format string.
- The result is a modified copy of the input. It is returned as a sequence
- or copied to the output iterator.
- Searching is case insensitive.
-
- \param Output An output iterator to which the result will be copied
- \param Input An input string
- \param Search A substring to be searched for
- \param Format A substitute string
- \param Loc A locale used for case insensitive comparison
- \return An output iterator pointing just after the last inserted character or
- a modified copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<
- typename OutputIteratorT,
- typename Range1T,
- typename Range2T,
- typename Range3T>
- inline OutputIteratorT ireplace_last_copy(
- OutputIteratorT Output,
- const Range1T& Input,
- const Range2T& Search,
- const Range3T& Format,
- const std::locale& Loc=std::locale() )
- {
- return ::boost::algorithm::find_format_copy(
- Output,
- Input,
- ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
- ::boost::algorithm::const_formatter(Format) );
- }
-
- //! Replace last algorithm ( case insensitive )
- /*!
- \overload
- */
- template<typename SequenceT, typename Range1T, typename Range2T>
- inline SequenceT ireplace_last_copy(
- const SequenceT& Input,
- const Range1T& Search,
- const Range2T& Format,
- const std::locale& Loc=std::locale() )
- {
- return ::boost::algorithm::find_format_copy(
- Input,
- ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
- ::boost::algorithm::const_formatter(Format) );
- }
-
- //! Replace last algorithm ( case insensitive )
- /*!
- Replace the last match of the search string in the input
- with the format string.The input sequence is modified in-place.
- Searching is case insensitive.
-
- \param Input An input string
- \param Search A substring to be searched for
- \param Format A substitute string
- \param Loc A locale used for case insensitive comparison
- */
- template<typename SequenceT, typename Range1T, typename Range2T>
- inline void ireplace_last(
- SequenceT& Input,
- const Range1T& Search,
- const Range2T& Format,
- const std::locale& Loc=std::locale() )
- {
- ::boost::algorithm::find_format(
- Input,
- ::boost::algorithm::last_finder(Search, is_iequal(Loc)),
- ::boost::algorithm::const_formatter(Format) );
- }
-
-// replace_nth --------------------------------------------------------------------//
-
- //! Replace nth algorithm
- /*!
- Replace an Nth (zero-indexed) match of the search string in the input
- with the format string.
- The result is a modified copy of the input. It is returned as a sequence
- or copied to the output iterator.
-
- \param Output An output iterator to which the result will be copied
- \param Input An input string
- \param Search A substring to be searched for
- \param Nth An index of the match to be replaced. The index is 0-based.
- For negative N, matches are counted from the end of string.
- \param Format A substitute string
- \return An output iterator pointing just after the last inserted character or
- a modified copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<
- typename OutputIteratorT,
- typename Range1T,
- typename Range2T,
- typename Range3T>
- inline OutputIteratorT replace_nth_copy(
- OutputIteratorT Output,
- const Range1T& Input,
- const Range2T& Search,
- int Nth,
- const Range3T& Format )
- {
- return ::boost::algorithm::find_format_copy(
- Output,
- Input,
- ::boost::algorithm::nth_finder(Search, Nth),
- ::boost::algorithm::const_formatter(Format) );
- }
-
- //! Replace nth algorithm
- /*!
- \overload
- */
- template<typename SequenceT, typename Range1T, typename Range2T>
- inline SequenceT replace_nth_copy(
- const SequenceT& Input,
- const Range1T& Search,
- int Nth,
- const Range2T& Format )
- {
- return ::boost::algorithm::find_format_copy(
- Input,
- ::boost::algorithm::nth_finder(Search, Nth),
- ::boost::algorithm::const_formatter(Format) );
- }
-
- //! Replace nth algorithm
- /*!
- Replace an Nth (zero-indexed) match of the search string in the input
- with the format string. Input sequence is modified in-place.
-
- \param Input An input string
- \param Search A substring to be searched for
- \param Nth An index of the match to be replaced. The index is 0-based.
- For negative N, matches are counted from the end of string.
- \param Format A substitute string
- */
- template<typename SequenceT, typename Range1T, typename Range2T>
- inline void replace_nth(
- SequenceT& Input,
- const Range1T& Search,
- int Nth,
- const Range2T& Format )
- {
- ::boost::algorithm::find_format(
- Input,
- ::boost::algorithm::nth_finder(Search, Nth),
- ::boost::algorithm::const_formatter(Format) );
- }
-
-// replace_nth ( case insensitive ) -----------------------------------------------//
-
- //! Replace nth algorithm ( case insensitive )
- /*!
- Replace an Nth (zero-indexed) match of the search string in the input
- with the format string.
- The result is a modified copy of the input. It is returned as a sequence
- or copied to the output iterator.
- Searching is case insensitive.
-
- \param Output An output iterator to which the result will be copied
- \param Input An input string
- \param Search A substring to be searched for
- \param Nth An index of the match to be replaced. The index is 0-based.
- For negative N, matches are counted from the end of string.
- \param Format A substitute string
- \param Loc A locale used for case insensitive comparison
- \return An output iterator pointing just after the last inserted character or
- a modified copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<
- typename OutputIteratorT,
- typename Range1T,
- typename Range2T,
- typename Range3T>
- inline OutputIteratorT ireplace_nth_copy(
- OutputIteratorT Output,
- const Range1T& Input,
- const Range2T& Search,
- int Nth,
- const Range3T& Format,
- const std::locale& Loc=std::locale() )
- {
- return ::boost::algorithm::find_format_copy(
- Output,
- Input,
- ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc) ),
- ::boost::algorithm::const_formatter(Format) );
- }
-
- //! Replace nth algorithm ( case insensitive )
- /*!
- \overload
- */
- template<typename SequenceT, typename Range1T, typename Range2T>
- inline SequenceT ireplace_nth_copy(
- const SequenceT& Input,
- const Range1T& Search,
- int Nth,
- const Range2T& Format,
- const std::locale& Loc=std::locale() )
- {
- return ::boost::algorithm::find_format_copy(
- Input,
- ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
- ::boost::algorithm::const_formatter(Format) );
- }
-
- //! Replace nth algorithm ( case insensitive )
- /*!
- Replace an Nth (zero-indexed) match of the search string in the input
- with the format string. Input sequence is modified in-place.
- Searching is case insensitive.
-
- \param Input An input string
- \param Search A substring to be searched for
- \param Nth An index of the match to be replaced. The index is 0-based.
- For negative N, matches are counted from the end of string.
- \param Format A substitute string
- \param Loc A locale used for case insensitive comparison
- */
- template<typename SequenceT, typename Range1T, typename Range2T>
- inline void ireplace_nth(
- SequenceT& Input,
- const Range1T& Search,
- int Nth,
- const Range2T& Format,
- const std::locale& Loc=std::locale() )
- {
- ::boost::algorithm::find_format(
- Input,
- ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)),
- ::boost::algorithm::const_formatter(Format) );
- }
-
-// replace_all --------------------------------------------------------------------//
-
- //! Replace all algorithm
- /*!
- Replace all occurrences of the search string in the input
- with the format string.
- The result is a modified copy of the input. It is returned as a sequence
- or copied to the output iterator.
-
- \param Output An output iterator to which the result will be copied
- \param Input An input string
- \param Search A substring to be searched for
- \param Format A substitute string
- \return An output iterator pointing just after the last inserted character or
- a modified copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<
- typename OutputIteratorT,
- typename Range1T,
- typename Range2T,
- typename Range3T>
- inline OutputIteratorT replace_all_copy(
- OutputIteratorT Output,
- const Range1T& Input,
- const Range2T& Search,
- const Range3T& Format )
- {
- return ::boost::algorithm::find_format_all_copy(
- Output,
- Input,
- ::boost::algorithm::first_finder(Search),
- ::boost::algorithm::const_formatter(Format) );
- }
-
- //! Replace all algorithm
- /*!
- \overload
- */
- template<typename SequenceT, typename Range1T, typename Range2T>
- inline SequenceT replace_all_copy(
- const SequenceT& Input,
- const Range1T& Search,
- const Range2T& Format )
- {
- return ::boost::algorithm::find_format_all_copy(
- Input,
- ::boost::algorithm::first_finder(Search),
- ::boost::algorithm::const_formatter(Format) );
- }
-
- //! Replace all algorithm
- /*!
- Replace all occurrences of the search string in the input
- with the format string. The input sequence is modified in-place.
-
- \param Input An input string
- \param Search A substring to be searched for
- \param Format A substitute string
- */
- template<typename SequenceT, typename Range1T, typename Range2T>
- inline void replace_all(
- SequenceT& Input,
- const Range1T& Search,
- const Range2T& Format )
- {
- ::boost::algorithm::find_format_all(
- Input,
- ::boost::algorithm::first_finder(Search),
- ::boost::algorithm::const_formatter(Format) );
- }
-
-// replace_all ( case insensitive ) -----------------------------------------------//
-
- //! Replace all algorithm ( case insensitive )
- /*!
- Replace all occurrences of the search string in the input
- with the format string.
- The result is a modified copy of the input. It is returned as a sequence
- or copied to the output iterator.
- Searching is case insensitive.
-
- \param Output An output iterator to which the result will be copied
- \param Input An input string
- \param Search A substring to be searched for
- \param Format A substitute string
- \param Loc A locale used for case insensitive comparison
- \return An output iterator pointing just after the last inserted character or
- a modified copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<
- typename OutputIteratorT,
- typename Range1T,
- typename Range2T,
- typename Range3T>
- inline OutputIteratorT ireplace_all_copy(
- OutputIteratorT Output,
- const Range1T& Input,
- const Range2T& Search,
- const Range3T& Format,
- const std::locale& Loc=std::locale() )
- {
- return ::boost::algorithm::find_format_all_copy(
- Output,
- Input,
- ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
- ::boost::algorithm::const_formatter(Format) );
- }
-
- //! Replace all algorithm ( case insensitive )
- /*!
- \overload
- */
- template<typename SequenceT, typename Range1T, typename Range2T>
- inline SequenceT ireplace_all_copy(
- const SequenceT& Input,
- const Range1T& Search,
- const Range2T& Format,
- const std::locale& Loc=std::locale() )
- {
- return ::boost::algorithm::find_format_all_copy(
- Input,
- ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
- ::boost::algorithm::const_formatter(Format) );
- }
-
- //! Replace all algorithm ( case insensitive )
- /*!
- Replace all occurrences of the search string in the input
- with the format string.The input sequence is modified in-place.
- Searching is case insensitive.
-
- \param Input An input string
- \param Search A substring to be searched for
- \param Format A substitute string
- \param Loc A locale used for case insensitive comparison
- */
- template<typename SequenceT, typename Range1T, typename Range2T>
- inline void ireplace_all(
- SequenceT& Input,
- const Range1T& Search,
- const Range2T& Format,
- const std::locale& Loc=std::locale() )
- {
- ::boost::algorithm::find_format_all(
- Input,
- ::boost::algorithm::first_finder(Search, is_iequal(Loc)),
- ::boost::algorithm::const_formatter(Format) );
- }
-
-// replace_head --------------------------------------------------------------------//
-
- //! Replace head algorithm
- /*!
- Replace the head of the input with the given format string.
- The head is a prefix of a string of given size.
- If the sequence is shorter then required, whole string if
- considered to be the head.
- The result is a modified copy of the input. It is returned as a sequence
- or copied to the output iterator.
-
- \param Output An output iterator to which the result will be copied
- \param Input An input string
- \param N Length of the head.
- For N>=0, at most N characters are extracted.
- For N<0, size(Input)-|N| characters are extracted.
- \param Format A substitute string
- \return An output iterator pointing just after the last inserted character or
- a modified copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<
- typename OutputIteratorT,
- typename Range1T,
- typename Range2T>
- inline OutputIteratorT replace_head_copy(
- OutputIteratorT Output,
- const Range1T& Input,
- int N,
- const Range2T& Format )
- {
- return ::boost::algorithm::find_format_copy(
- Output,
- Input,
- ::boost::algorithm::head_finder(N),
- ::boost::algorithm::const_formatter(Format) );
- }
-
- //! Replace head algorithm
- /*!
- \overload
- */
- template<typename SequenceT, typename RangeT>
- inline SequenceT replace_head_copy(
- const SequenceT& Input,
- int N,
- const RangeT& Format )
- {
- return ::boost::algorithm::find_format_copy(
- Input,
- ::boost::algorithm::head_finder(N),
- ::boost::algorithm::const_formatter(Format) );
- }
-
- //! Replace head algorithm
- /*!
- Replace the head of the input with the given format string.
- The head is a prefix of a string of given size.
- If the sequence is shorter then required, the whole string is
- considered to be the head. The input sequence is modified in-place.
-
- \param Input An input string
- \param N Length of the head.
- For N>=0, at most N characters are extracted.
- For N<0, size(Input)-|N| characters are extracted.
- \param Format A substitute string
- */
- template<typename SequenceT, typename RangeT>
- inline void replace_head(
- SequenceT& Input,
- int N,
- const RangeT& Format )
- {
- ::boost::algorithm::find_format(
- Input,
- ::boost::algorithm::head_finder(N),
- ::boost::algorithm::const_formatter(Format) );
- }
-
-// replace_tail --------------------------------------------------------------------//
-
- //! Replace tail algorithm
- /*!
- Replace the tail of the input with the given format string.
- The tail is a suffix of a string of given size.
- If the sequence is shorter then required, whole string is
- considered to be the tail.
- The result is a modified copy of the input. It is returned as a sequence
- or copied to the output iterator.
-
- \param Output An output iterator to which the result will be copied
- \param Input An input string
- \param N Length of the tail.
- For N>=0, at most N characters are extracted.
- For N<0, size(Input)-|N| characters are extracted.
- \param Format A substitute string
- \return An output iterator pointing just after the last inserted character or
- a modified copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<
- typename OutputIteratorT,
- typename Range1T,
- typename Range2T>
- inline OutputIteratorT replace_tail_copy(
- OutputIteratorT Output,
- const Range1T& Input,
- int N,
- const Range2T& Format )
- {
- return ::boost::algorithm::find_format_copy(
- Output,
- Input,
- ::boost::algorithm::tail_finder(N),
- ::boost::algorithm::const_formatter(Format) );
- }
-
- //! Replace tail algorithm
- /*!
- \overload
- */
- template<typename SequenceT, typename RangeT>
- inline SequenceT replace_tail_copy(
- const SequenceT& Input,
- int N,
- const RangeT& Format )
- {
- return ::boost::algorithm::find_format_copy(
- Input,
- ::boost::algorithm::tail_finder(N),
- ::boost::algorithm::const_formatter(Format) );
- }
-
- //! Replace tail algorithm
- /*!
- Replace the tail of the input with the given format sequence.
- The tail is a suffix of a string of given size.
- If the sequence is shorter then required, the whole string is
- considered to be the tail. The input sequence is modified in-place.
-
- \param Input An input string
- \param N Length of the tail.
- For N>=0, at most N characters are extracted.
- For N<0, size(Input)-|N| characters are extracted.
- \param Format A substitute string
- */
- template<typename SequenceT, typename RangeT>
- inline void replace_tail(
- SequenceT& Input,
- int N,
- const RangeT& Format )
- {
- ::boost::algorithm::find_format(
- Input,
- ::boost::algorithm::tail_finder(N),
- ::boost::algorithm::const_formatter(Format) );
- }
-
- } // namespace algorithm
-
- // pull names to the boost namespace
- using algorithm::replace_range_copy;
- using algorithm::replace_range;
- using algorithm::replace_first_copy;
- using algorithm::replace_first;
- using algorithm::ireplace_first_copy;
- using algorithm::ireplace_first;
- using algorithm::replace_last_copy;
- using algorithm::replace_last;
- using algorithm::ireplace_last_copy;
- using algorithm::ireplace_last;
- using algorithm::replace_nth_copy;
- using algorithm::replace_nth;
- using algorithm::ireplace_nth_copy;
- using algorithm::ireplace_nth;
- using algorithm::replace_all_copy;
- using algorithm::replace_all;
- using algorithm::ireplace_all_copy;
- using algorithm::ireplace_all;
- using algorithm::replace_head_copy;
- using algorithm::replace_head;
- using algorithm::replace_tail_copy;
- using algorithm::replace_tail;
-
-} // namespace boost
-
-#endif // BOOST_REPLACE_HPP
+// Boost string_algo library replace.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2006. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_REPLACE_HPP +#define BOOST_STRING_REPLACE_HPP + +#include <boost/algorithm/string/config.hpp> + +#include <boost/range/iterator_range_core.hpp> +#include <boost/range/begin.hpp> +#include <boost/range/end.hpp> +#include <boost/range/iterator.hpp> +#include <boost/range/const_iterator.hpp> + +#include <boost/algorithm/string/find_format.hpp> +#include <boost/algorithm/string/finder.hpp> +#include <boost/algorithm/string/formatter.hpp> +#include <boost/algorithm/string/compare.hpp> + +/*! \file + Defines various replace algorithms. Each algorithm replaces + part(s) of the input according to set of searching and replace criteria. +*/ + +namespace boost { + namespace algorithm { + +// replace_range --------------------------------------------------------------------// + + //! Replace range algorithm + /*! + Replace the given range in the input string. + The result is a modified copy of the input. It is returned as a sequence + or copied to the output iterator. + + \param Output An output iterator to which the result will be copied + \param Input An input string + \param SearchRange A range in the input to be substituted + \param Format A substitute string + \return An output iterator pointing just after the last inserted character or + a modified copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template< + typename OutputIteratorT, + typename Range1T, + typename Range2T> + inline OutputIteratorT replace_range_copy( + OutputIteratorT Output, + const Range1T& Input, + const iterator_range< + BOOST_STRING_TYPENAME + range_const_iterator<Range1T>::type>& SearchRange, + const Range2T& Format) + { + return ::boost::algorithm::find_format_copy( + Output, + Input, + ::boost::algorithm::range_finder(SearchRange), + ::boost::algorithm::const_formatter(Format)); + } + + //! Replace range algorithm + /*! + \overload + */ + template<typename SequenceT, typename RangeT> + inline SequenceT replace_range_copy( + const SequenceT& Input, + const iterator_range< + BOOST_STRING_TYPENAME + range_const_iterator<SequenceT>::type>& SearchRange, + const RangeT& Format) + { + return ::boost::algorithm::find_format_copy( + Input, + ::boost::algorithm::range_finder(SearchRange), + ::boost::algorithm::const_formatter(Format)); + } + + //! Replace range algorithm + /*! + Replace the given range in the input string. + The input sequence is modified in-place. + + \param Input An input string + \param SearchRange A range in the input to be substituted + \param Format A substitute string + */ + template<typename SequenceT, typename RangeT> + inline void replace_range( + SequenceT& Input, + const iterator_range< + BOOST_STRING_TYPENAME + range_iterator<SequenceT>::type>& SearchRange, + const RangeT& Format) + { + ::boost::algorithm::find_format( + Input, + ::boost::algorithm::range_finder(SearchRange), + ::boost::algorithm::const_formatter(Format)); + } + +// replace_first --------------------------------------------------------------------// + + //! Replace first algorithm + /*! + Replace the first match of the search substring in the input + with the format string. + The result is a modified copy of the input. It is returned as a sequence + or copied to the output iterator. + + \param Output An output iterator to which the result will be copied + \param Input An input string + \param Search A substring to be searched for + \param Format A substitute string + \return An output iterator pointing just after the last inserted character or + a modified copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template< + typename OutputIteratorT, + typename Range1T, + typename Range2T, + typename Range3T> + inline OutputIteratorT replace_first_copy( + OutputIteratorT Output, + const Range1T& Input, + const Range2T& Search, + const Range3T& Format) + { + return ::boost::algorithm::find_format_copy( + Output, + Input, + ::boost::algorithm::first_finder(Search), + ::boost::algorithm::const_formatter(Format) ); + } + + //! Replace first algorithm + /*! + \overload + */ + template<typename SequenceT, typename Range1T, typename Range2T> + inline SequenceT replace_first_copy( + const SequenceT& Input, + const Range1T& Search, + const Range2T& Format ) + { + return ::boost::algorithm::find_format_copy( + Input, + ::boost::algorithm::first_finder(Search), + ::boost::algorithm::const_formatter(Format) ); + } + + //! Replace first algorithm + /*! + replace the first match of the search substring in the input + with the format string. The input sequence is modified in-place. + + \param Input An input string + \param Search A substring to be searched for + \param Format A substitute string + */ + template<typename SequenceT, typename Range1T, typename Range2T> + inline void replace_first( + SequenceT& Input, + const Range1T& Search, + const Range2T& Format ) + { + ::boost::algorithm::find_format( + Input, + ::boost::algorithm::first_finder(Search), + ::boost::algorithm::const_formatter(Format) ); + } + +// replace_first ( case insensitive ) ---------------------------------------------// + + //! Replace first algorithm ( case insensitive ) + /*! + Replace the first match of the search substring in the input + with the format string. + The result is a modified copy of the input. It is returned as a sequence + or copied to the output iterator. + Searching is case insensitive. + + \param Output An output iterator to which the result will be copied + \param Input An input string + \param Search A substring to be searched for + \param Format A substitute string + \param Loc A locale used for case insensitive comparison + \return An output iterator pointing just after the last inserted character or + a modified copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template< + typename OutputIteratorT, + typename Range1T, + typename Range2T, + typename Range3T> + inline OutputIteratorT ireplace_first_copy( + OutputIteratorT Output, + const Range1T& Input, + const Range2T& Search, + const Range3T& Format, + const std::locale& Loc=std::locale() ) + { + return ::boost::algorithm::find_format_copy( + Output, + Input, + ::boost::algorithm::first_finder(Search, is_iequal(Loc)), + ::boost::algorithm::const_formatter(Format) ); + } + + //! Replace first algorithm ( case insensitive ) + /*! + \overload + */ + template<typename SequenceT, typename Range2T, typename Range1T> + inline SequenceT ireplace_first_copy( + const SequenceT& Input, + const Range2T& Search, + const Range1T& Format, + const std::locale& Loc=std::locale() ) + { + return ::boost::algorithm::find_format_copy( + Input, + ::boost::algorithm::first_finder(Search, is_iequal(Loc)), + ::boost::algorithm::const_formatter(Format) ); + } + + //! Replace first algorithm ( case insensitive ) + /*! + Replace the first match of the search substring in the input + with the format string. Input sequence is modified in-place. + Searching is case insensitive. + + \param Input An input string + \param Search A substring to be searched for + \param Format A substitute string + \param Loc A locale used for case insensitive comparison + */ + template<typename SequenceT, typename Range1T, typename Range2T> + inline void ireplace_first( + SequenceT& Input, + const Range1T& Search, + const Range2T& Format, + const std::locale& Loc=std::locale() ) + { + ::boost::algorithm::find_format( + Input, + ::boost::algorithm::first_finder(Search, is_iequal(Loc)), + ::boost::algorithm::const_formatter(Format) ); + } + +// replace_last --------------------------------------------------------------------// + + //! Replace last algorithm + /*! + Replace the last match of the search string in the input + with the format string. + The result is a modified copy of the input. It is returned as a sequence + or copied to the output iterator. + + \param Output An output iterator to which the result will be copied + \param Input An input string + \param Search A substring to be searched for + \param Format A substitute string + \return An output iterator pointing just after the last inserted character or + a modified copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template< + typename OutputIteratorT, + typename Range1T, + typename Range2T, + typename Range3T> + inline OutputIteratorT replace_last_copy( + OutputIteratorT Output, + const Range1T& Input, + const Range2T& Search, + const Range3T& Format ) + { + return ::boost::algorithm::find_format_copy( + Output, + Input, + ::boost::algorithm::last_finder(Search), + ::boost::algorithm::const_formatter(Format) ); + } + + //! Replace last algorithm + /*! + \overload + */ + template<typename SequenceT, typename Range1T, typename Range2T> + inline SequenceT replace_last_copy( + const SequenceT& Input, + const Range1T& Search, + const Range2T& Format ) + { + return ::boost::algorithm::find_format_copy( + Input, + ::boost::algorithm::last_finder(Search), + ::boost::algorithm::const_formatter(Format) ); + } + + //! Replace last algorithm + /*! + Replace the last match of the search string in the input + with the format string. Input sequence is modified in-place. + + \param Input An input string + \param Search A substring to be searched for + \param Format A substitute string + */ + template<typename SequenceT, typename Range1T, typename Range2T> + inline void replace_last( + SequenceT& Input, + const Range1T& Search, + const Range2T& Format ) + { + ::boost::algorithm::find_format( + Input, + ::boost::algorithm::last_finder(Search), + ::boost::algorithm::const_formatter(Format) ); + } + +// replace_last ( case insensitive ) -----------------------------------------------// + + //! Replace last algorithm ( case insensitive ) + /*! + Replace the last match of the search string in the input + with the format string. + The result is a modified copy of the input. It is returned as a sequence + or copied to the output iterator. + Searching is case insensitive. + + \param Output An output iterator to which the result will be copied + \param Input An input string + \param Search A substring to be searched for + \param Format A substitute string + \param Loc A locale used for case insensitive comparison + \return An output iterator pointing just after the last inserted character or + a modified copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template< + typename OutputIteratorT, + typename Range1T, + typename Range2T, + typename Range3T> + inline OutputIteratorT ireplace_last_copy( + OutputIteratorT Output, + const Range1T& Input, + const Range2T& Search, + const Range3T& Format, + const std::locale& Loc=std::locale() ) + { + return ::boost::algorithm::find_format_copy( + Output, + Input, + ::boost::algorithm::last_finder(Search, is_iequal(Loc)), + ::boost::algorithm::const_formatter(Format) ); + } + + //! Replace last algorithm ( case insensitive ) + /*! + \overload + */ + template<typename SequenceT, typename Range1T, typename Range2T> + inline SequenceT ireplace_last_copy( + const SequenceT& Input, + const Range1T& Search, + const Range2T& Format, + const std::locale& Loc=std::locale() ) + { + return ::boost::algorithm::find_format_copy( + Input, + ::boost::algorithm::last_finder(Search, is_iequal(Loc)), + ::boost::algorithm::const_formatter(Format) ); + } + + //! Replace last algorithm ( case insensitive ) + /*! + Replace the last match of the search string in the input + with the format string.The input sequence is modified in-place. + Searching is case insensitive. + + \param Input An input string + \param Search A substring to be searched for + \param Format A substitute string + \param Loc A locale used for case insensitive comparison + \return A reference to the modified input + */ + template<typename SequenceT, typename Range1T, typename Range2T> + inline void ireplace_last( + SequenceT& Input, + const Range1T& Search, + const Range2T& Format, + const std::locale& Loc=std::locale() ) + { + ::boost::algorithm::find_format( + Input, + ::boost::algorithm::last_finder(Search, is_iequal(Loc)), + ::boost::algorithm::const_formatter(Format) ); + } + +// replace_nth --------------------------------------------------------------------// + + //! Replace nth algorithm + /*! + Replace an Nth (zero-indexed) match of the search string in the input + with the format string. + The result is a modified copy of the input. It is returned as a sequence + or copied to the output iterator. + + \param Output An output iterator to which the result will be copied + \param Input An input string + \param Search A substring to be searched for + \param Nth An index of the match to be replaced. The index is 0-based. + For negative N, matches are counted from the end of string. + \param Format A substitute string + \return An output iterator pointing just after the last inserted character or + a modified copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template< + typename OutputIteratorT, + typename Range1T, + typename Range2T, + typename Range3T> + inline OutputIteratorT replace_nth_copy( + OutputIteratorT Output, + const Range1T& Input, + const Range2T& Search, + int Nth, + const Range3T& Format ) + { + return ::boost::algorithm::find_format_copy( + Output, + Input, + ::boost::algorithm::nth_finder(Search, Nth), + ::boost::algorithm::const_formatter(Format) ); + } + + //! Replace nth algorithm + /*! + \overload + */ + template<typename SequenceT, typename Range1T, typename Range2T> + inline SequenceT replace_nth_copy( + const SequenceT& Input, + const Range1T& Search, + int Nth, + const Range2T& Format ) + { + return ::boost::algorithm::find_format_copy( + Input, + ::boost::algorithm::nth_finder(Search, Nth), + ::boost::algorithm::const_formatter(Format) ); + } + + //! Replace nth algorithm + /*! + Replace an Nth (zero-indexed) match of the search string in the input + with the format string. Input sequence is modified in-place. + + \param Input An input string + \param Search A substring to be searched for + \param Nth An index of the match to be replaced. The index is 0-based. + For negative N, matches are counted from the end of string. + \param Format A substitute string + */ + template<typename SequenceT, typename Range1T, typename Range2T> + inline void replace_nth( + SequenceT& Input, + const Range1T& Search, + int Nth, + const Range2T& Format ) + { + ::boost::algorithm::find_format( + Input, + ::boost::algorithm::nth_finder(Search, Nth), + ::boost::algorithm::const_formatter(Format) ); + } + +// replace_nth ( case insensitive ) -----------------------------------------------// + + //! Replace nth algorithm ( case insensitive ) + /*! + Replace an Nth (zero-indexed) match of the search string in the input + with the format string. + The result is a modified copy of the input. It is returned as a sequence + or copied to the output iterator. + Searching is case insensitive. + + \param Output An output iterator to which the result will be copied + \param Input An input string + \param Search A substring to be searched for + \param Nth An index of the match to be replaced. The index is 0-based. + For negative N, matches are counted from the end of string. + \param Format A substitute string + \param Loc A locale used for case insensitive comparison + \return An output iterator pointing just after the last inserted character or + a modified copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template< + typename OutputIteratorT, + typename Range1T, + typename Range2T, + typename Range3T> + inline OutputIteratorT ireplace_nth_copy( + OutputIteratorT Output, + const Range1T& Input, + const Range2T& Search, + int Nth, + const Range3T& Format, + const std::locale& Loc=std::locale() ) + { + return ::boost::algorithm::find_format_copy( + Output, + Input, + ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc) ), + ::boost::algorithm::const_formatter(Format) ); + } + + //! Replace nth algorithm ( case insensitive ) + /*! + \overload + */ + template<typename SequenceT, typename Range1T, typename Range2T> + inline SequenceT ireplace_nth_copy( + const SequenceT& Input, + const Range1T& Search, + int Nth, + const Range2T& Format, + const std::locale& Loc=std::locale() ) + { + return ::boost::algorithm::find_format_copy( + Input, + ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)), + ::boost::algorithm::const_formatter(Format) ); + } + + //! Replace nth algorithm ( case insensitive ) + /*! + Replace an Nth (zero-indexed) match of the search string in the input + with the format string. Input sequence is modified in-place. + Searching is case insensitive. + + \param Input An input string + \param Search A substring to be searched for + \param Nth An index of the match to be replaced. The index is 0-based. + For negative N, matches are counted from the end of string. + \param Format A substitute string + \param Loc A locale used for case insensitive comparison + */ + template<typename SequenceT, typename Range1T, typename Range2T> + inline void ireplace_nth( + SequenceT& Input, + const Range1T& Search, + int Nth, + const Range2T& Format, + const std::locale& Loc=std::locale() ) + { + ::boost::algorithm::find_format( + Input, + ::boost::algorithm::nth_finder(Search, Nth, is_iequal(Loc)), + ::boost::algorithm::const_formatter(Format) ); + } + +// replace_all --------------------------------------------------------------------// + + //! Replace all algorithm + /*! + Replace all occurrences of the search string in the input + with the format string. + The result is a modified copy of the input. It is returned as a sequence + or copied to the output iterator. + + \param Output An output iterator to which the result will be copied + \param Input An input string + \param Search A substring to be searched for + \param Format A substitute string + \return An output iterator pointing just after the last inserted character or + a modified copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template< + typename OutputIteratorT, + typename Range1T, + typename Range2T, + typename Range3T> + inline OutputIteratorT replace_all_copy( + OutputIteratorT Output, + const Range1T& Input, + const Range2T& Search, + const Range3T& Format ) + { + return ::boost::algorithm::find_format_all_copy( + Output, + Input, + ::boost::algorithm::first_finder(Search), + ::boost::algorithm::const_formatter(Format) ); + } + + //! Replace all algorithm + /*! + \overload + */ + template<typename SequenceT, typename Range1T, typename Range2T> + inline SequenceT replace_all_copy( + const SequenceT& Input, + const Range1T& Search, + const Range2T& Format ) + { + return ::boost::algorithm::find_format_all_copy( + Input, + ::boost::algorithm::first_finder(Search), + ::boost::algorithm::const_formatter(Format) ); + } + + //! Replace all algorithm + /*! + Replace all occurrences of the search string in the input + with the format string. The input sequence is modified in-place. + + \param Input An input string + \param Search A substring to be searched for + \param Format A substitute string + \return A reference to the modified input + */ + template<typename SequenceT, typename Range1T, typename Range2T> + inline void replace_all( + SequenceT& Input, + const Range1T& Search, + const Range2T& Format ) + { + ::boost::algorithm::find_format_all( + Input, + ::boost::algorithm::first_finder(Search), + ::boost::algorithm::const_formatter(Format) ); + } + +// replace_all ( case insensitive ) -----------------------------------------------// + + //! Replace all algorithm ( case insensitive ) + /*! + Replace all occurrences of the search string in the input + with the format string. + The result is a modified copy of the input. It is returned as a sequence + or copied to the output iterator. + Searching is case insensitive. + + \param Output An output iterator to which the result will be copied + \param Input An input string + \param Search A substring to be searched for + \param Format A substitute string + \param Loc A locale used for case insensitive comparison + \return An output iterator pointing just after the last inserted character or + a modified copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template< + typename OutputIteratorT, + typename Range1T, + typename Range2T, + typename Range3T> + inline OutputIteratorT ireplace_all_copy( + OutputIteratorT Output, + const Range1T& Input, + const Range2T& Search, + const Range3T& Format, + const std::locale& Loc=std::locale() ) + { + return ::boost::algorithm::find_format_all_copy( + Output, + Input, + ::boost::algorithm::first_finder(Search, is_iequal(Loc)), + ::boost::algorithm::const_formatter(Format) ); + } + + //! Replace all algorithm ( case insensitive ) + /*! + \overload + */ + template<typename SequenceT, typename Range1T, typename Range2T> + inline SequenceT ireplace_all_copy( + const SequenceT& Input, + const Range1T& Search, + const Range2T& Format, + const std::locale& Loc=std::locale() ) + { + return ::boost::algorithm::find_format_all_copy( + Input, + ::boost::algorithm::first_finder(Search, is_iequal(Loc)), + ::boost::algorithm::const_formatter(Format) ); + } + + //! Replace all algorithm ( case insensitive ) + /*! + Replace all occurrences of the search string in the input + with the format string.The input sequence is modified in-place. + Searching is case insensitive. + + \param Input An input string + \param Search A substring to be searched for + \param Format A substitute string + \param Loc A locale used for case insensitive comparison + */ + template<typename SequenceT, typename Range1T, typename Range2T> + inline void ireplace_all( + SequenceT& Input, + const Range1T& Search, + const Range2T& Format, + const std::locale& Loc=std::locale() ) + { + ::boost::algorithm::find_format_all( + Input, + ::boost::algorithm::first_finder(Search, is_iequal(Loc)), + ::boost::algorithm::const_formatter(Format) ); + } + +// replace_head --------------------------------------------------------------------// + + //! Replace head algorithm + /*! + Replace the head of the input with the given format string. + The head is a prefix of a string of given size. + If the sequence is shorter then required, whole string if + considered to be the head. + The result is a modified copy of the input. It is returned as a sequence + or copied to the output iterator. + + \param Output An output iterator to which the result will be copied + \param Input An input string + \param N Length of the head. + For N>=0, at most N characters are extracted. + For N<0, size(Input)-|N| characters are extracted. + \param Format A substitute string + \return An output iterator pointing just after the last inserted character or + a modified copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template< + typename OutputIteratorT, + typename Range1T, + typename Range2T> + inline OutputIteratorT replace_head_copy( + OutputIteratorT Output, + const Range1T& Input, + int N, + const Range2T& Format ) + { + return ::boost::algorithm::find_format_copy( + Output, + Input, + ::boost::algorithm::head_finder(N), + ::boost::algorithm::const_formatter(Format) ); + } + + //! Replace head algorithm + /*! + \overload + */ + template<typename SequenceT, typename RangeT> + inline SequenceT replace_head_copy( + const SequenceT& Input, + int N, + const RangeT& Format ) + { + return ::boost::algorithm::find_format_copy( + Input, + ::boost::algorithm::head_finder(N), + ::boost::algorithm::const_formatter(Format) ); + } + + //! Replace head algorithm + /*! + Replace the head of the input with the given format string. + The head is a prefix of a string of given size. + If the sequence is shorter then required, the whole string is + considered to be the head. The input sequence is modified in-place. + + \param Input An input string + \param N Length of the head. + For N>=0, at most N characters are extracted. + For N<0, size(Input)-|N| characters are extracted. + \param Format A substitute string + */ + template<typename SequenceT, typename RangeT> + inline void replace_head( + SequenceT& Input, + int N, + const RangeT& Format ) + { + ::boost::algorithm::find_format( + Input, + ::boost::algorithm::head_finder(N), + ::boost::algorithm::const_formatter(Format) ); + } + +// replace_tail --------------------------------------------------------------------// + + //! Replace tail algorithm + /*! + Replace the tail of the input with the given format string. + The tail is a suffix of a string of given size. + If the sequence is shorter then required, whole string is + considered to be the tail. + The result is a modified copy of the input. It is returned as a sequence + or copied to the output iterator. + + \param Output An output iterator to which the result will be copied + \param Input An input string + \param N Length of the tail. + For N>=0, at most N characters are extracted. + For N<0, size(Input)-|N| characters are extracted. + \param Format A substitute string + \return An output iterator pointing just after the last inserted character or + a modified copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template< + typename OutputIteratorT, + typename Range1T, + typename Range2T> + inline OutputIteratorT replace_tail_copy( + OutputIteratorT Output, + const Range1T& Input, + int N, + const Range2T& Format ) + { + return ::boost::algorithm::find_format_copy( + Output, + Input, + ::boost::algorithm::tail_finder(N), + ::boost::algorithm::const_formatter(Format) ); + } + + //! Replace tail algorithm + /*! + \overload + */ + template<typename SequenceT, typename RangeT> + inline SequenceT replace_tail_copy( + const SequenceT& Input, + int N, + const RangeT& Format ) + { + return ::boost::algorithm::find_format_copy( + Input, + ::boost::algorithm::tail_finder(N), + ::boost::algorithm::const_formatter(Format) ); + } + + //! Replace tail algorithm + /*! + Replace the tail of the input with the given format sequence. + The tail is a suffix of a string of given size. + If the sequence is shorter then required, the whole string is + considered to be the tail. The input sequence is modified in-place. + + \param Input An input string + \param N Length of the tail. + For N>=0, at most N characters are extracted. + For N<0, size(Input)-|N| characters are extracted. + \param Format A substitute string + */ + template<typename SequenceT, typename RangeT> + inline void replace_tail( + SequenceT& Input, + int N, + const RangeT& Format ) + { + ::boost::algorithm::find_format( + Input, + ::boost::algorithm::tail_finder(N), + ::boost::algorithm::const_formatter(Format) ); + } + + } // namespace algorithm + + // pull names to the boost namespace + using algorithm::replace_range_copy; + using algorithm::replace_range; + using algorithm::replace_first_copy; + using algorithm::replace_first; + using algorithm::ireplace_first_copy; + using algorithm::ireplace_first; + using algorithm::replace_last_copy; + using algorithm::replace_last; + using algorithm::ireplace_last_copy; + using algorithm::ireplace_last; + using algorithm::replace_nth_copy; + using algorithm::replace_nth; + using algorithm::ireplace_nth_copy; + using algorithm::ireplace_nth; + using algorithm::replace_all_copy; + using algorithm::replace_all; + using algorithm::ireplace_all_copy; + using algorithm::ireplace_all; + using algorithm::replace_head_copy; + using algorithm::replace_head; + using algorithm::replace_tail_copy; + using algorithm::replace_tail; + +} // namespace boost + +#endif // BOOST_REPLACE_HPP diff --git a/contrib/src/boost/algorithm/string/sequence_traits.hpp b/contrib/src/boost/algorithm/string/sequence_traits.hpp index 22aa58b..be151f8 100644 --- a/contrib/src/boost/algorithm/string/sequence_traits.hpp +++ b/contrib/src/boost/algorithm/string/sequence_traits.hpp @@ -1,120 +1,120 @@ -// Boost string_algo library sequence_traits.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_SEQUENCE_TRAITS_HPP
-#define BOOST_STRING_SEQUENCE_TRAITS_HPP
-
-#include <boost/config.hpp>
-#include <boost/mpl/bool.hpp>
-#include <boost/algorithm/string/yes_no_type.hpp>
-
-/*! \file
- Traits defined in this header are used by various algorithms to achieve
- better performance for specific containers.
- Traits provide fail-safe defaults. If a container supports some of these
- features, it is possible to specialize the specific trait for this container.
- For lacking compilers, it is possible of define an override for a specific tester
- function.
-
- Due to a language restriction, it is not currently possible to define specializations for
- stl containers without including the corresponding header. To decrease the overhead
- needed by this inclusion, user can selectively include a specialization
- header for a specific container. They are located in boost/algorithm/string/stl
- directory. Alternatively she can include boost/algorithm/string/std_collection_traits.hpp
- header which contains specializations for all stl containers.
-*/
-
-namespace boost {
- namespace algorithm {
-
-// sequence traits -----------------------------------------------//
-
-
- //! Native replace trait
- /*!
- This trait specifies that the sequence has \c std::string like replace method
- */
- template< typename T >
- class has_native_replace
- {
-
- public:
-# if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
- enum { value = false };
-# else
- BOOST_STATIC_CONSTANT(bool, value=false);
-# endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
-
-
- typedef mpl::bool_<has_native_replace<T>::value> type;
- };
-
-
- //! Stable iterators trait
- /*!
- This trait specifies that the sequence has stable iterators. It means
- that operations like insert/erase/replace do not invalidate iterators.
- */
- template< typename T >
- class has_stable_iterators
- {
- public:
-# if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
- enum { value = false };
-# else
- BOOST_STATIC_CONSTANT(bool, value=false);
-# endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
-
- typedef mpl::bool_<has_stable_iterators<T>::value> type;
- };
-
-
- //! Const time insert trait
- /*!
- This trait specifies that the sequence's insert method has
- constant time complexity.
- */
- template< typename T >
- class has_const_time_insert
- {
- public:
-# if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
- enum { value = false };
-# else
- BOOST_STATIC_CONSTANT(bool, value=false);
-# endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
-
- typedef mpl::bool_<has_const_time_insert<T>::value> type;
- };
-
-
- //! Const time erase trait
- /*!
- This trait specifies that the sequence's erase method has
- constant time complexity.
- */
- template< typename T >
- class has_const_time_erase
- {
- public:
-# if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
- enum { value = false };
-# else
- BOOST_STATIC_CONSTANT(bool, value=false);
-# endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
-
- typedef mpl::bool_<has_const_time_erase<T>::value> type;
- };
-
- } // namespace algorithm
-} // namespace boost
-
-
-#endif // BOOST_STRING_SEQUENCE_TRAITS_HPP
+// Boost string_algo library sequence_traits.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_SEQUENCE_TRAITS_HPP +#define BOOST_STRING_SEQUENCE_TRAITS_HPP + +#include <boost/config.hpp> +#include <boost/mpl/bool.hpp> +#include <boost/algorithm/string/yes_no_type.hpp> + +/*! \file + Traits defined in this header are used by various algorithms to achieve + better performance for specific containers. + Traits provide fail-safe defaults. If a container supports some of these + features, it is possible to specialize the specific trait for this container. + For lacking compilers, it is possible of define an override for a specific tester + function. + + Due to a language restriction, it is not currently possible to define specializations for + stl containers without including the corresponding header. To decrease the overhead + needed by this inclusion, user can selectively include a specialization + header for a specific container. They are located in boost/algorithm/string/stl + directory. Alternatively she can include boost/algorithm/string/std_collection_traits.hpp + header which contains specializations for all stl containers. +*/ + +namespace boost { + namespace algorithm { + +// sequence traits -----------------------------------------------// + + + //! Native replace trait + /*! + This trait specifies that the sequence has \c std::string like replace method + */ + template< typename T > + class has_native_replace + { + + public: +# if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) + enum { value = false }; +# else + BOOST_STATIC_CONSTANT(bool, value=false); +# endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) + + + typedef mpl::bool_<has_native_replace<T>::value> type; + }; + + + //! Stable iterators trait + /*! + This trait specifies that the sequence has stable iterators. It means + that operations like insert/erase/replace do not invalidate iterators. + */ + template< typename T > + class has_stable_iterators + { + public: +# if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) + enum { value = false }; +# else + BOOST_STATIC_CONSTANT(bool, value=false); +# endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) + + typedef mpl::bool_<has_stable_iterators<T>::value> type; + }; + + + //! Const time insert trait + /*! + This trait specifies that the sequence's insert method has + constant time complexity. + */ + template< typename T > + class has_const_time_insert + { + public: +# if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) + enum { value = false }; +# else + BOOST_STATIC_CONSTANT(bool, value=false); +# endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) + + typedef mpl::bool_<has_const_time_insert<T>::value> type; + }; + + + //! Const time erase trait + /*! + This trait specifies that the sequence's erase method has + constant time complexity. + */ + template< typename T > + class has_const_time_erase + { + public: +# if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) + enum { value = false }; +# else + BOOST_STATIC_CONSTANT(bool, value=false); +# endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) + + typedef mpl::bool_<has_const_time_erase<T>::value> type; + }; + + } // namespace algorithm +} // namespace boost + + +#endif // BOOST_STRING_SEQUENCE_TRAITS_HPP diff --git a/contrib/src/boost/algorithm/string/split.hpp b/contrib/src/boost/algorithm/string/split.hpp index 21e86c7..cae712c 100644 --- a/contrib/src/boost/algorithm/string/split.hpp +++ b/contrib/src/boost/algorithm/string/split.hpp @@ -1,163 +1,163 @@ -// Boost string_algo library split.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2006.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_SPLIT_HPP
-#define BOOST_STRING_SPLIT_HPP
-
-#include <boost/algorithm/string/config.hpp>
-
-#include <boost/algorithm/string/iter_find.hpp>
-#include <boost/algorithm/string/finder.hpp>
-#include <boost/algorithm/string/compare.hpp>
-
-/*! \file
- Defines basic split algorithms.
- Split algorithms can be used to divide a string
- into several parts according to given criteria.
-
- Each part is copied and added as a new element to the
- output container.
- Thus the result container must be able to hold copies
- of the matches (in a compatible structure like std::string) or
- a reference to it (e.g. using the iterator range class).
- Examples of such a container are \c std::vector<std::string>
- or \c std::list<boost::iterator_range<std::string::iterator>>
-*/
-
-namespace boost {
- namespace algorithm {
-
-// find_all ------------------------------------------------------------//
-
- //! Find all algorithm
- /*!
- This algorithm finds all occurrences of the search string
- in the input.
-
- Each part is copied and added as a new element to the
- output container.
- Thus the result container must be able to hold copies
- of the matches (in a compatible structure like std::string) or
- a reference to it (e.g. using the iterator range class).
- Examples of such a container are \c std::vector<std::string>
- or \c std::list<boost::iterator_range<std::string::iterator>>
-
- \param Result A container that can hold copies of references to the substrings
- \param Input A container which will be searched.
- \param Search A substring to be searched for.
- \return A reference the result
-
- \note Prior content of the result will be overwritten.
-
- \note This function provides the strong exception-safety guarantee
- */
- template< typename SequenceSequenceT, typename Range1T, typename Range2T >
- inline SequenceSequenceT& find_all(
- SequenceSequenceT& Result,
- Range1T& Input,
- const Range2T& Search)
- {
- return ::boost::algorithm::iter_find(
- Result,
- Input,
- ::boost::algorithm::first_finder(Search) );
- }
-
- //! Find all algorithm ( case insensitive )
- /*!
- This algorithm finds all occurrences of the search string
- in the input.
- Each part is copied and added as a new element to the
- output container. Thus the result container must be able to hold copies
- of the matches (in a compatible structure like std::string) or
- a reference to it (e.g. using the iterator range class).
- Examples of such a container are \c std::vector<std::string>
- or \c std::list<boost::iterator_range<std::string::iterator>>
-
- Searching is case insensitive.
-
- \param Result A container that can hold copies of references to the substrings
- \param Input A container which will be searched.
- \param Search A substring to be searched for.
- \param Loc A locale used for case insensitive comparison
- \return A reference the result
-
- \note Prior content of the result will be overwritten.
-
- \note This function provides the strong exception-safety guarantee
- */
- template< typename SequenceSequenceT, typename Range1T, typename Range2T >
- inline SequenceSequenceT& ifind_all(
- SequenceSequenceT& Result,
- Range1T& Input,
- const Range2T& Search,
- const std::locale& Loc=std::locale() )
- {
- return ::boost::algorithm::iter_find(
- Result,
- Input,
- ::boost::algorithm::first_finder(Search, is_iequal(Loc) ) );
- }
-
-
-// tokenize -------------------------------------------------------------//
-
- //! Split algorithm
- /*!
- Tokenize expression. This function is equivalent to C strtok. Input
- sequence is split into tokens, separated by separators. Separators
- are given by means of the predicate.
-
- Each part is copied and added as a new element to the
- output container.
- Thus the result container must be able to hold copies
- of the matches (in a compatible structure like std::string) or
- a reference to it (e.g. using the iterator range class).
- Examples of such a container are \c std::vector<std::string>
- or \c std::list<boost::iterator_range<std::string::iterator>>
-
- \param Result A container that can hold copies of references to the substrings
- \param Input A container which will be searched.
- \param Pred A predicate to identify separators. This predicate is
- supposed to return true if a given element is a separator.
- \param eCompress If eCompress argument is set to token_compress_on, adjacent
- separators are merged together. Otherwise, every two separators
- delimit a token.
- \return A reference the result
-
- \note Prior content of the result will be overwritten.
-
- \note This function provides the strong exception-safety guarantee
- */
- template< typename SequenceSequenceT, typename RangeT, typename PredicateT >
- inline SequenceSequenceT& split(
- SequenceSequenceT& Result,
- RangeT& Input,
- PredicateT Pred,
- token_compress_mode_type eCompress=token_compress_off )
- {
- return ::boost::algorithm::iter_split(
- Result,
- Input,
- ::boost::algorithm::token_finder( Pred, eCompress ) );
- }
-
- } // namespace algorithm
-
- // pull names to the boost namespace
- using algorithm::find_all;
- using algorithm::ifind_all;
- using algorithm::split;
-
-} // namespace boost
-
-
-#endif // BOOST_STRING_SPLIT_HPP
-
+// Boost string_algo library split.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2006. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_SPLIT_HPP +#define BOOST_STRING_SPLIT_HPP + +#include <boost/algorithm/string/config.hpp> + +#include <boost/algorithm/string/iter_find.hpp> +#include <boost/algorithm/string/finder.hpp> +#include <boost/algorithm/string/compare.hpp> + +/*! \file + Defines basic split algorithms. + Split algorithms can be used to divide a string + into several parts according to given criteria. + + Each part is copied and added as a new element to the + output container. + Thus the result container must be able to hold copies + of the matches (in a compatible structure like std::string) or + a reference to it (e.g. using the iterator range class). + Examples of such a container are \c std::vector<std::string> + or \c std::list<boost::iterator_range<std::string::iterator>> +*/ + +namespace boost { + namespace algorithm { + +// find_all ------------------------------------------------------------// + + //! Find all algorithm + /*! + This algorithm finds all occurrences of the search string + in the input. + + Each part is copied and added as a new element to the + output container. + Thus the result container must be able to hold copies + of the matches (in a compatible structure like std::string) or + a reference to it (e.g. using the iterator range class). + Examples of such a container are \c std::vector<std::string> + or \c std::list<boost::iterator_range<std::string::iterator>> + + \param Result A container that can hold copies of references to the substrings + \param Input A container which will be searched. + \param Search A substring to be searched for. + \return A reference the result + + \note Prior content of the result will be overwritten. + + \note This function provides the strong exception-safety guarantee + */ + template< typename SequenceSequenceT, typename Range1T, typename Range2T > + inline SequenceSequenceT& find_all( + SequenceSequenceT& Result, + Range1T& Input, + const Range2T& Search) + { + return ::boost::algorithm::iter_find( + Result, + Input, + ::boost::algorithm::first_finder(Search) ); + } + + //! Find all algorithm ( case insensitive ) + /*! + This algorithm finds all occurrences of the search string + in the input. + Each part is copied and added as a new element to the + output container. Thus the result container must be able to hold copies + of the matches (in a compatible structure like std::string) or + a reference to it (e.g. using the iterator range class). + Examples of such a container are \c std::vector<std::string> + or \c std::list<boost::iterator_range<std::string::iterator>> + + Searching is case insensitive. + + \param Result A container that can hold copies of references to the substrings + \param Input A container which will be searched. + \param Search A substring to be searched for. + \param Loc A locale used for case insensitive comparison + \return A reference the result + + \note Prior content of the result will be overwritten. + + \note This function provides the strong exception-safety guarantee + */ + template< typename SequenceSequenceT, typename Range1T, typename Range2T > + inline SequenceSequenceT& ifind_all( + SequenceSequenceT& Result, + Range1T& Input, + const Range2T& Search, + const std::locale& Loc=std::locale() ) + { + return ::boost::algorithm::iter_find( + Result, + Input, + ::boost::algorithm::first_finder(Search, is_iequal(Loc) ) ); + } + + +// tokenize -------------------------------------------------------------// + + //! Split algorithm + /*! + Tokenize expression. This function is equivalent to C strtok. Input + sequence is split into tokens, separated by separators. Separators + are given by means of the predicate. + + Each part is copied and added as a new element to the + output container. + Thus the result container must be able to hold copies + of the matches (in a compatible structure like std::string) or + a reference to it (e.g. using the iterator range class). + Examples of such a container are \c std::vector<std::string> + or \c std::list<boost::iterator_range<std::string::iterator>> + + \param Result A container that can hold copies of references to the substrings + \param Input A container which will be searched. + \param Pred A predicate to identify separators. This predicate is + supposed to return true if a given element is a separator. + \param eCompress If eCompress argument is set to token_compress_on, adjacent + separators are merged together. Otherwise, every two separators + delimit a token. + \return A reference the result + + \note Prior content of the result will be overwritten. + + \note This function provides the strong exception-safety guarantee + */ + template< typename SequenceSequenceT, typename RangeT, typename PredicateT > + inline SequenceSequenceT& split( + SequenceSequenceT& Result, + RangeT& Input, + PredicateT Pred, + token_compress_mode_type eCompress=token_compress_off ) + { + return ::boost::algorithm::iter_split( + Result, + Input, + ::boost::algorithm::token_finder( Pred, eCompress ) ); + } + + } // namespace algorithm + + // pull names to the boost namespace + using algorithm::find_all; + using algorithm::ifind_all; + using algorithm::split; + +} // namespace boost + + +#endif // BOOST_STRING_SPLIT_HPP + diff --git a/contrib/src/boost/algorithm/string/std/list_traits.hpp b/contrib/src/boost/algorithm/string/std/list_traits.hpp index 31fdbf5..a3cf7bb 100644 --- a/contrib/src/boost/algorithm/string/std/list_traits.hpp +++ b/contrib/src/boost/algorithm/string/std/list_traits.hpp @@ -1,68 +1,68 @@ -// Boost string_algo library list_traits.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_STD_LIST_TRAITS_HPP
-#define BOOST_STRING_STD_LIST_TRAITS_HPP
-
-#include <boost/algorithm/string/yes_no_type.hpp>
-#include <list>
-#include <boost/algorithm/string/sequence_traits.hpp>
-
-namespace boost {
- namespace algorithm {
-
-// std::list<> traits -----------------------------------------------//
-
-
- // stable iterators trait
- template<typename T, typename AllocT>
- class has_stable_iterators< ::std::list<T,AllocT> >
- {
- public:
-#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
- enum { value = true };
-#else
- BOOST_STATIC_CONSTANT(bool, value=true);
-#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
- typedef mpl::bool_<has_stable_iterators<T>::value> type;
- };
-
- // const time insert trait
- template<typename T, typename AllocT>
- class has_const_time_insert< ::std::list<T,AllocT> >
- {
- public:
-#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
- enum { value = true };
-#else
- BOOST_STATIC_CONSTANT(bool, value=true);
-#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
- typedef mpl::bool_<has_const_time_insert<T>::value> type;
- };
-
- // const time erase trait
- template<typename T, typename AllocT>
- class has_const_time_erase< ::std::list<T,AllocT> >
- {
- public:
-#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
- enum { value = true };
-#else
- BOOST_STATIC_CONSTANT(bool, value=true);
-#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
- typedef mpl::bool_<has_const_time_erase<T>::value> type;
- };
-
-
- } // namespace algorithm
-} // namespace boost
-
-
-#endif // BOOST_STRING_STD_LIST_TRAITS_HPP
+// Boost string_algo library list_traits.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_STD_LIST_TRAITS_HPP +#define BOOST_STRING_STD_LIST_TRAITS_HPP + +#include <boost/algorithm/string/yes_no_type.hpp> +#include <list> +#include <boost/algorithm/string/sequence_traits.hpp> + +namespace boost { + namespace algorithm { + +// std::list<> traits -----------------------------------------------// + + + // stable iterators trait + template<typename T, typename AllocT> + class has_stable_iterators< ::std::list<T,AllocT> > + { + public: +#if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) + enum { value = true }; +#else + BOOST_STATIC_CONSTANT(bool, value=true); +#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) + typedef mpl::bool_<has_stable_iterators<T>::value> type; + }; + + // const time insert trait + template<typename T, typename AllocT> + class has_const_time_insert< ::std::list<T,AllocT> > + { + public: +#if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) + enum { value = true }; +#else + BOOST_STATIC_CONSTANT(bool, value=true); +#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) + typedef mpl::bool_<has_const_time_insert<T>::value> type; + }; + + // const time erase trait + template<typename T, typename AllocT> + class has_const_time_erase< ::std::list<T,AllocT> > + { + public: +#if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) + enum { value = true }; +#else + BOOST_STATIC_CONSTANT(bool, value=true); +#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) + typedef mpl::bool_<has_const_time_erase<T>::value> type; + }; + + + } // namespace algorithm +} // namespace boost + + +#endif // BOOST_STRING_STD_LIST_TRAITS_HPP diff --git a/contrib/src/boost/algorithm/string/std/slist_traits.hpp b/contrib/src/boost/algorithm/string/std/slist_traits.hpp index b78fc63..c30b93c 100644 --- a/contrib/src/boost/algorithm/string/std/slist_traits.hpp +++ b/contrib/src/boost/algorithm/string/std/slist_traits.hpp @@ -1,69 +1,69 @@ -// Boost string_algo library slist_traits.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_STD_SLIST_TRAITS_HPP
-#define BOOST_STRING_STD_SLIST_TRAITS_HPP
-
-#include <boost/algorithm/string/config.hpp>
-#include <boost/algorithm/string/yes_no_type.hpp>
-#include BOOST_SLIST_HEADER
-#include <boost/algorithm/string/sequence_traits.hpp>
-
-namespace boost {
- namespace algorithm {
-
-// SGI's std::slist<> traits -----------------------------------------------//
-
-
- // stable iterators trait
- template<typename T, typename AllocT>
- class has_stable_iterators< BOOST_STD_EXTENSION_NAMESPACE::slist<T,AllocT> >
- {
- public:
-#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
- enum { value = true };
-#else
- BOOST_STATIC_CONSTANT(bool, value=true);
-#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
- typedef mpl::bool_<has_stable_iterators<T>::value> type;
- };
-
- // const time insert trait
- template<typename T, typename AllocT>
- class has_const_time_insert< BOOST_STD_EXTENSION_NAMESPACE::slist<T,AllocT> >
- {
- public:
-#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
- enum { value = true };
-#else
- BOOST_STATIC_CONSTANT(bool, value=true);
-#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
- typedef mpl::bool_<has_const_time_insert<T>::value> type;
- };
-
- // const time erase trait
- template<typename T, typename AllocT>
- class has_const_time_erase< BOOST_STD_EXTENSION_NAMESPACE::slist<T,AllocT> >
- {
- public:
-#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
- enum { value = true };
-#else
- BOOST_STATIC_CONSTANT(bool, value=true);
-#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
- typedef mpl::bool_<has_const_time_erase<T>::value> type;
- };
-
-
- } // namespace algorithm
-} // namespace boost
-
-
-#endif // BOOST_STRING_STD_LIST_TRAITS_HPP
+// Boost string_algo library slist_traits.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_STD_SLIST_TRAITS_HPP +#define BOOST_STRING_STD_SLIST_TRAITS_HPP + +#include <boost/algorithm/string/config.hpp> +#include <boost/algorithm/string/yes_no_type.hpp> +#include BOOST_SLIST_HEADER +#include <boost/algorithm/string/sequence_traits.hpp> + +namespace boost { + namespace algorithm { + +// SGI's std::slist<> traits -----------------------------------------------// + + + // stable iterators trait + template<typename T, typename AllocT> + class has_stable_iterators< BOOST_STD_EXTENSION_NAMESPACE::slist<T,AllocT> > + { + public: +#if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) + enum { value = true }; +#else + BOOST_STATIC_CONSTANT(bool, value=true); +#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) + typedef mpl::bool_<has_stable_iterators<T>::value> type; + }; + + // const time insert trait + template<typename T, typename AllocT> + class has_const_time_insert< BOOST_STD_EXTENSION_NAMESPACE::slist<T,AllocT> > + { + public: +#if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) + enum { value = true }; +#else + BOOST_STATIC_CONSTANT(bool, value=true); +#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) + typedef mpl::bool_<has_const_time_insert<T>::value> type; + }; + + // const time erase trait + template<typename T, typename AllocT> + class has_const_time_erase< BOOST_STD_EXTENSION_NAMESPACE::slist<T,AllocT> > + { + public: +#if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) + enum { value = true }; +#else + BOOST_STATIC_CONSTANT(bool, value=true); +#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) + typedef mpl::bool_<has_const_time_erase<T>::value> type; + }; + + + } // namespace algorithm +} // namespace boost + + +#endif // BOOST_STRING_STD_LIST_TRAITS_HPP diff --git a/contrib/src/boost/algorithm/string/std/string_traits.hpp b/contrib/src/boost/algorithm/string/std/string_traits.hpp index 0bb660d..c940830 100644 --- a/contrib/src/boost/algorithm/string/std/string_traits.hpp +++ b/contrib/src/boost/algorithm/string/std/string_traits.hpp @@ -1,44 +1,44 @@ -// Boost string_algo library string_traits.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_STD_STRING_TRAITS_HPP
-#define BOOST_STRING_STD_STRING_TRAITS_HPP
-
-#include <boost/algorithm/string/yes_no_type.hpp>
-#include <string>
-#include <boost/algorithm/string/sequence_traits.hpp>
-
-namespace boost {
- namespace algorithm {
-
-// std::basic_string<> traits -----------------------------------------------//
-
-
- // native replace trait
- template<typename T, typename TraitsT, typename AllocT>
- class has_native_replace< std::basic_string<T, TraitsT, AllocT> >
- {
- public:
-#if BOOST_WORKAROUND( __IBMCPP__, <= 600 )
- enum { value = true } ;
-#else
- BOOST_STATIC_CONSTANT(bool, value=true);
-#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 )
-
- typedef mpl::bool_<has_native_replace<T>::value> type;
- };
-
-
-
- } // namespace algorithm
-} // namespace boost
-
-
-#endif // BOOST_STRING_LIST_TRAITS_HPP
+// Boost string_algo library string_traits.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_STD_STRING_TRAITS_HPP +#define BOOST_STRING_STD_STRING_TRAITS_HPP + +#include <boost/algorithm/string/yes_no_type.hpp> +#include <string> +#include <boost/algorithm/string/sequence_traits.hpp> + +namespace boost { + namespace algorithm { + +// std::basic_string<> traits -----------------------------------------------// + + + // native replace trait + template<typename T, typename TraitsT, typename AllocT> + class has_native_replace< std::basic_string<T, TraitsT, AllocT> > + { + public: +#if BOOST_WORKAROUND( __IBMCPP__, <= 600 ) + enum { value = true } ; +#else + BOOST_STATIC_CONSTANT(bool, value=true); +#endif // BOOST_WORKAROUND( __IBMCPP__, <= 600 ) + + typedef mpl::bool_<has_native_replace<T>::value> type; + }; + + + + } // namespace algorithm +} // namespace boost + + +#endif // BOOST_STRING_LIST_TRAITS_HPP diff --git a/contrib/src/boost/algorithm/string/std_containers_traits.hpp b/contrib/src/boost/algorithm/string/std_containers_traits.hpp index 28dddc7..3f02246 100644 --- a/contrib/src/boost/algorithm/string/std_containers_traits.hpp +++ b/contrib/src/boost/algorithm/string/std_containers_traits.hpp @@ -1,26 +1,26 @@ -// Boost string_algo library std_containers_traits.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_STD_CONTAINERS_TRAITS_HPP
-#define BOOST_STRING_STD_CONTAINERS_TRAITS_HPP
-
-/*!\file
- This file includes sequence traits for stl containers.
-*/
-
-#include <boost/config.hpp>
-#include <boost/algorithm/string/std/string_traits.hpp>
-#include <boost/algorithm/string/std/list_traits.hpp>
-
-#ifdef BOOST_HAS_SLIST
-# include <boost/algorithm/string/std/slist_traits.hpp>
-#endif
-
-#endif // BOOST_STRING_STD_CONTAINERS_TRAITS_HPP
+// Boost string_algo library std_containers_traits.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_STD_CONTAINERS_TRAITS_HPP +#define BOOST_STRING_STD_CONTAINERS_TRAITS_HPP + +/*!\file + This file includes sequence traits for stl containers. +*/ + +#include <boost/config.hpp> +#include <boost/algorithm/string/std/string_traits.hpp> +#include <boost/algorithm/string/std/list_traits.hpp> + +#ifdef BOOST_HAS_SLIST +# include <boost/algorithm/string/std/slist_traits.hpp> +#endif + +#endif // BOOST_STRING_STD_CONTAINERS_TRAITS_HPP diff --git a/contrib/src/boost/algorithm/string/trim.hpp b/contrib/src/boost/algorithm/string/trim.hpp index c8e9c37..e740d57 100644 --- a/contrib/src/boost/algorithm/string/trim.hpp +++ b/contrib/src/boost/algorithm/string/trim.hpp @@ -1,398 +1,398 @@ -// Boost string_algo library trim.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_TRIM_HPP
-#define BOOST_STRING_TRIM_HPP
-
-#include <boost/algorithm/string/config.hpp>
-
-#include <boost/range/begin.hpp>
-#include <boost/range/end.hpp>
-#include <boost/range/const_iterator.hpp>
-#include <boost/range/as_literal.hpp>
-#include <boost/range/iterator_range_core.hpp>
-
-#include <boost/algorithm/string/detail/trim.hpp>
-#include <boost/algorithm/string/classification.hpp>
-#include <locale>
-
-/*! \file
- Defines trim algorithms.
- Trim algorithms are used to remove trailing and leading spaces from a
- sequence (string). Space is recognized using given locales.
-
- Parametric (\c _if) variants use a predicate (functor) to select which characters
- are to be trimmed..
- Functions take a selection predicate as a parameter, which is used to determine
- whether a character is a space. Common predicates are provided in classification.hpp header.
-
-*/
-
-namespace boost {
- namespace algorithm {
-
- // left trim -----------------------------------------------//
-
-
- //! Left trim - parametric
- /*!
- Remove all leading spaces from the input.
- The supplied predicate is used to determine which characters are considered spaces.
- The result is a trimmed copy of the input. It is returned as a sequence
- or copied to the output iterator
-
- \param Output An output iterator to which the result will be copied
- \param Input An input range
- \param IsSpace A unary predicate identifying spaces
- \return
- An output iterator pointing just after the last inserted character or
- a copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<typename OutputIteratorT, typename RangeT, typename PredicateT>
- inline OutputIteratorT trim_left_copy_if(
- OutputIteratorT Output,
- const RangeT& Input,
- PredicateT IsSpace)
- {
- iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input));
-
- std::copy(
- ::boost::algorithm::detail::trim_begin(
- ::boost::begin(lit_range),
- ::boost::end(lit_range),
- IsSpace ),
- ::boost::end(lit_range),
- Output);
-
- return Output;
- }
-
- //! Left trim - parametric
- /*!
- \overload
- */
- template<typename SequenceT, typename PredicateT>
- inline SequenceT trim_left_copy_if(const SequenceT& Input, PredicateT IsSpace)
- {
- return SequenceT(
- ::boost::algorithm::detail::trim_begin(
- ::boost::begin(Input),
- ::boost::end(Input),
- IsSpace ),
- ::boost::end(Input));
- }
-
- //! Left trim - parametric
- /*!
- Remove all leading spaces from the input.
- The result is a trimmed copy of the input.
-
- \param Input An input sequence
- \param Loc a locale used for 'space' classification
- \return A trimmed copy of the input
-
- \note This function provides the strong exception-safety guarantee
- */
- template<typename SequenceT>
- inline SequenceT trim_left_copy(const SequenceT& Input, const std::locale& Loc=std::locale())
- {
- return
- ::boost::algorithm::trim_left_copy_if(
- Input,
- is_space(Loc));
- }
-
- //! Left trim
- /*!
- Remove all leading spaces from the input. The supplied predicate is
- used to determine which characters are considered spaces.
- The input sequence is modified in-place.
-
- \param Input An input sequence
- \param IsSpace A unary predicate identifying spaces
- */
- template<typename SequenceT, typename PredicateT>
- inline void trim_left_if(SequenceT& Input, PredicateT IsSpace)
- {
- Input.erase(
- ::boost::begin(Input),
- ::boost::algorithm::detail::trim_begin(
- ::boost::begin(Input),
- ::boost::end(Input),
- IsSpace));
- }
-
- //! Left trim
- /*!
- Remove all leading spaces from the input.
- The Input sequence is modified in-place.
-
- \param Input An input sequence
- \param Loc A locale used for 'space' classification
- */
- template<typename SequenceT>
- inline void trim_left(SequenceT& Input, const std::locale& Loc=std::locale())
- {
- ::boost::algorithm::trim_left_if(
- Input,
- is_space(Loc));
- }
-
- // right trim -----------------------------------------------//
-
- //! Right trim - parametric
- /*!
- Remove all trailing spaces from the input.
- The supplied predicate is used to determine which characters are considered spaces.
- The result is a trimmed copy of the input. It is returned as a sequence
- or copied to the output iterator
-
- \param Output An output iterator to which the result will be copied
- \param Input An input range
- \param IsSpace A unary predicate identifying spaces
- \return
- An output iterator pointing just after the last inserted character or
- a copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<typename OutputIteratorT, typename RangeT, typename PredicateT>
- inline OutputIteratorT trim_right_copy_if(
- OutputIteratorT Output,
- const RangeT& Input,
- PredicateT IsSpace )
- {
- iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input));
-
- std::copy(
- ::boost::begin(lit_range),
- ::boost::algorithm::detail::trim_end(
- ::boost::begin(lit_range),
- ::boost::end(lit_range),
- IsSpace ),
- Output );
-
- return Output;
- }
-
- //! Right trim - parametric
- /*!
- \overload
- */
- template<typename SequenceT, typename PredicateT>
- inline SequenceT trim_right_copy_if(const SequenceT& Input, PredicateT IsSpace)
- {
- return SequenceT(
- ::boost::begin(Input),
- ::boost::algorithm::detail::trim_end(
- ::boost::begin(Input),
- ::boost::end(Input),
- IsSpace)
- );
- }
-
- //! Right trim
- /*!
- Remove all trailing spaces from the input.
- The result is a trimmed copy of the input
-
- \param Input An input sequence
- \param Loc A locale used for 'space' classification
- \return A trimmed copy of the input
-
- \note This function provides the strong exception-safety guarantee
- */
- template<typename SequenceT>
- inline SequenceT trim_right_copy(const SequenceT& Input, const std::locale& Loc=std::locale())
- {
- return
- ::boost::algorithm::trim_right_copy_if(
- Input,
- is_space(Loc));
- }
-
-
- //! Right trim - parametric
- /*!
- Remove all trailing spaces from the input.
- The supplied predicate is used to determine which characters are considered spaces.
- The input sequence is modified in-place.
-
- \param Input An input sequence
- \param IsSpace A unary predicate identifying spaces
- */
- template<typename SequenceT, typename PredicateT>
- inline void trim_right_if(SequenceT& Input, PredicateT IsSpace)
- {
- Input.erase(
- ::boost::algorithm::detail::trim_end(
- ::boost::begin(Input),
- ::boost::end(Input),
- IsSpace ),
- ::boost::end(Input)
- );
- }
-
-
- //! Right trim
- /*!
- Remove all trailing spaces from the input.
- The input sequence is modified in-place.
-
- \param Input An input sequence
- \param Loc A locale used for 'space' classification
- */
- template<typename SequenceT>
- inline void trim_right(SequenceT& Input, const std::locale& Loc=std::locale())
- {
- ::boost::algorithm::trim_right_if(
- Input,
- is_space(Loc) );
- }
-
- // both side trim -----------------------------------------------//
-
- //! Trim - parametric
- /*!
- Remove all trailing and leading spaces from the input.
- The supplied predicate is used to determine which characters are considered spaces.
- The result is a trimmed copy of the input. It is returned as a sequence
- or copied to the output iterator
-
- \param Output An output iterator to which the result will be copied
- \param Input An input range
- \param IsSpace A unary predicate identifying spaces
- \return
- An output iterator pointing just after the last inserted character or
- a copy of the input
-
- \note The second variant of this function provides the strong exception-safety guarantee
- */
- template<typename OutputIteratorT, typename RangeT, typename PredicateT>
- inline OutputIteratorT trim_copy_if(
- OutputIteratorT Output,
- const RangeT& Input,
- PredicateT IsSpace)
- {
- iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input));
-
- BOOST_STRING_TYPENAME
- range_const_iterator<RangeT>::type TrimEnd=
- ::boost::algorithm::detail::trim_end(
- ::boost::begin(lit_range),
- ::boost::end(lit_range),
- IsSpace);
-
- std::copy(
- detail::trim_begin(
- ::boost::begin(lit_range), TrimEnd, IsSpace),
- TrimEnd,
- Output
- );
-
- return Output;
- }
-
- //! Trim - parametric
- /*!
- \overload
- */
- template<typename SequenceT, typename PredicateT>
- inline SequenceT trim_copy_if(const SequenceT& Input, PredicateT IsSpace)
- {
- BOOST_STRING_TYPENAME
- range_const_iterator<SequenceT>::type TrimEnd=
- ::boost::algorithm::detail::trim_end(
- ::boost::begin(Input),
- ::boost::end(Input),
- IsSpace);
-
- return SequenceT(
- detail::trim_begin(
- ::boost::begin(Input),
- TrimEnd,
- IsSpace),
- TrimEnd
- );
- }
-
- //! Trim
- /*!
- Remove all leading and trailing spaces from the input.
- The result is a trimmed copy of the input
-
- \param Input An input sequence
- \param Loc A locale used for 'space' classification
- \return A trimmed copy of the input
-
- \note This function provides the strong exception-safety guarantee
- */
- template<typename SequenceT>
- inline SequenceT trim_copy( const SequenceT& Input, const std::locale& Loc=std::locale() )
- {
- return
- ::boost::algorithm::trim_copy_if(
- Input,
- is_space(Loc) );
- }
-
- //! Trim
- /*!
- Remove all leading and trailing spaces from the input.
- The supplied predicate is used to determine which characters are considered spaces.
- The input sequence is modified in-place.
-
- \param Input An input sequence
- \param IsSpace A unary predicate identifying spaces
- */
- template<typename SequenceT, typename PredicateT>
- inline void trim_if(SequenceT& Input, PredicateT IsSpace)
- {
- ::boost::algorithm::trim_right_if( Input, IsSpace );
- ::boost::algorithm::trim_left_if( Input, IsSpace );
- }
-
- //! Trim
- /*!
- Remove all leading and trailing spaces from the input.
- The input sequence is modified in-place.
-
- \param Input An input sequence
- \param Loc A locale used for 'space' classification
- */
- template<typename SequenceT>
- inline void trim(SequenceT& Input, const std::locale& Loc=std::locale())
- {
- ::boost::algorithm::trim_if(
- Input,
- is_space( Loc ) );
- }
-
- } // namespace algorithm
-
- // pull names to the boost namespace
- using algorithm::trim_left;
- using algorithm::trim_left_if;
- using algorithm::trim_left_copy;
- using algorithm::trim_left_copy_if;
- using algorithm::trim_right;
- using algorithm::trim_right_if;
- using algorithm::trim_right_copy;
- using algorithm::trim_right_copy_if;
- using algorithm::trim;
- using algorithm::trim_if;
- using algorithm::trim_copy;
- using algorithm::trim_copy_if;
-
-} // namespace boost
-
-#endif // BOOST_STRING_TRIM_HPP
+// Boost string_algo library trim.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_TRIM_HPP +#define BOOST_STRING_TRIM_HPP + +#include <boost/algorithm/string/config.hpp> + +#include <boost/range/begin.hpp> +#include <boost/range/end.hpp> +#include <boost/range/const_iterator.hpp> +#include <boost/range/as_literal.hpp> +#include <boost/range/iterator_range_core.hpp> + +#include <boost/algorithm/string/detail/trim.hpp> +#include <boost/algorithm/string/classification.hpp> +#include <locale> + +/*! \file + Defines trim algorithms. + Trim algorithms are used to remove trailing and leading spaces from a + sequence (string). Space is recognized using given locales. + + Parametric (\c _if) variants use a predicate (functor) to select which characters + are to be trimmed.. + Functions take a selection predicate as a parameter, which is used to determine + whether a character is a space. Common predicates are provided in classification.hpp header. + +*/ + +namespace boost { + namespace algorithm { + + // left trim -----------------------------------------------// + + + //! Left trim - parametric + /*! + Remove all leading spaces from the input. + The supplied predicate is used to determine which characters are considered spaces. + The result is a trimmed copy of the input. It is returned as a sequence + or copied to the output iterator + + \param Output An output iterator to which the result will be copied + \param Input An input range + \param IsSpace A unary predicate identifying spaces + \return + An output iterator pointing just after the last inserted character or + a copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template<typename OutputIteratorT, typename RangeT, typename PredicateT> + inline OutputIteratorT trim_left_copy_if( + OutputIteratorT Output, + const RangeT& Input, + PredicateT IsSpace) + { + iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input)); + + std::copy( + ::boost::algorithm::detail::trim_begin( + ::boost::begin(lit_range), + ::boost::end(lit_range), + IsSpace ), + ::boost::end(lit_range), + Output); + + return Output; + } + + //! Left trim - parametric + /*! + \overload + */ + template<typename SequenceT, typename PredicateT> + inline SequenceT trim_left_copy_if(const SequenceT& Input, PredicateT IsSpace) + { + return SequenceT( + ::boost::algorithm::detail::trim_begin( + ::boost::begin(Input), + ::boost::end(Input), + IsSpace ), + ::boost::end(Input)); + } + + //! Left trim - parametric + /*! + Remove all leading spaces from the input. + The result is a trimmed copy of the input. + + \param Input An input sequence + \param Loc a locale used for 'space' classification + \return A trimmed copy of the input + + \note This function provides the strong exception-safety guarantee + */ + template<typename SequenceT> + inline SequenceT trim_left_copy(const SequenceT& Input, const std::locale& Loc=std::locale()) + { + return + ::boost::algorithm::trim_left_copy_if( + Input, + is_space(Loc)); + } + + //! Left trim + /*! + Remove all leading spaces from the input. The supplied predicate is + used to determine which characters are considered spaces. + The input sequence is modified in-place. + + \param Input An input sequence + \param IsSpace A unary predicate identifying spaces + */ + template<typename SequenceT, typename PredicateT> + inline void trim_left_if(SequenceT& Input, PredicateT IsSpace) + { + Input.erase( + ::boost::begin(Input), + ::boost::algorithm::detail::trim_begin( + ::boost::begin(Input), + ::boost::end(Input), + IsSpace)); + } + + //! Left trim + /*! + Remove all leading spaces from the input. + The Input sequence is modified in-place. + + \param Input An input sequence + \param Loc A locale used for 'space' classification + */ + template<typename SequenceT> + inline void trim_left(SequenceT& Input, const std::locale& Loc=std::locale()) + { + ::boost::algorithm::trim_left_if( + Input, + is_space(Loc)); + } + + // right trim -----------------------------------------------// + + //! Right trim - parametric + /*! + Remove all trailing spaces from the input. + The supplied predicate is used to determine which characters are considered spaces. + The result is a trimmed copy of the input. It is returned as a sequence + or copied to the output iterator + + \param Output An output iterator to which the result will be copied + \param Input An input range + \param IsSpace A unary predicate identifying spaces + \return + An output iterator pointing just after the last inserted character or + a copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template<typename OutputIteratorT, typename RangeT, typename PredicateT> + inline OutputIteratorT trim_right_copy_if( + OutputIteratorT Output, + const RangeT& Input, + PredicateT IsSpace ) + { + iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input)); + + std::copy( + ::boost::begin(lit_range), + ::boost::algorithm::detail::trim_end( + ::boost::begin(lit_range), + ::boost::end(lit_range), + IsSpace ), + Output ); + + return Output; + } + + //! Right trim - parametric + /*! + \overload + */ + template<typename SequenceT, typename PredicateT> + inline SequenceT trim_right_copy_if(const SequenceT& Input, PredicateT IsSpace) + { + return SequenceT( + ::boost::begin(Input), + ::boost::algorithm::detail::trim_end( + ::boost::begin(Input), + ::boost::end(Input), + IsSpace) + ); + } + + //! Right trim + /*! + Remove all trailing spaces from the input. + The result is a trimmed copy of the input + + \param Input An input sequence + \param Loc A locale used for 'space' classification + \return A trimmed copy of the input + + \note This function provides the strong exception-safety guarantee + */ + template<typename SequenceT> + inline SequenceT trim_right_copy(const SequenceT& Input, const std::locale& Loc=std::locale()) + { + return + ::boost::algorithm::trim_right_copy_if( + Input, + is_space(Loc)); + } + + + //! Right trim - parametric + /*! + Remove all trailing spaces from the input. + The supplied predicate is used to determine which characters are considered spaces. + The input sequence is modified in-place. + + \param Input An input sequence + \param IsSpace A unary predicate identifying spaces + */ + template<typename SequenceT, typename PredicateT> + inline void trim_right_if(SequenceT& Input, PredicateT IsSpace) + { + Input.erase( + ::boost::algorithm::detail::trim_end( + ::boost::begin(Input), + ::boost::end(Input), + IsSpace ), + ::boost::end(Input) + ); + } + + + //! Right trim + /*! + Remove all trailing spaces from the input. + The input sequence is modified in-place. + + \param Input An input sequence + \param Loc A locale used for 'space' classification + */ + template<typename SequenceT> + inline void trim_right(SequenceT& Input, const std::locale& Loc=std::locale()) + { + ::boost::algorithm::trim_right_if( + Input, + is_space(Loc) ); + } + + // both side trim -----------------------------------------------// + + //! Trim - parametric + /*! + Remove all trailing and leading spaces from the input. + The supplied predicate is used to determine which characters are considered spaces. + The result is a trimmed copy of the input. It is returned as a sequence + or copied to the output iterator + + \param Output An output iterator to which the result will be copied + \param Input An input range + \param IsSpace A unary predicate identifying spaces + \return + An output iterator pointing just after the last inserted character or + a copy of the input + + \note The second variant of this function provides the strong exception-safety guarantee + */ + template<typename OutputIteratorT, typename RangeT, typename PredicateT> + inline OutputIteratorT trim_copy_if( + OutputIteratorT Output, + const RangeT& Input, + PredicateT IsSpace) + { + iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input)); + + BOOST_STRING_TYPENAME + range_const_iterator<RangeT>::type TrimEnd= + ::boost::algorithm::detail::trim_end( + ::boost::begin(lit_range), + ::boost::end(lit_range), + IsSpace); + + std::copy( + detail::trim_begin( + ::boost::begin(lit_range), TrimEnd, IsSpace), + TrimEnd, + Output + ); + + return Output; + } + + //! Trim - parametric + /*! + \overload + */ + template<typename SequenceT, typename PredicateT> + inline SequenceT trim_copy_if(const SequenceT& Input, PredicateT IsSpace) + { + BOOST_STRING_TYPENAME + range_const_iterator<SequenceT>::type TrimEnd= + ::boost::algorithm::detail::trim_end( + ::boost::begin(Input), + ::boost::end(Input), + IsSpace); + + return SequenceT( + detail::trim_begin( + ::boost::begin(Input), + TrimEnd, + IsSpace), + TrimEnd + ); + } + + //! Trim + /*! + Remove all leading and trailing spaces from the input. + The result is a trimmed copy of the input + + \param Input An input sequence + \param Loc A locale used for 'space' classification + \return A trimmed copy of the input + + \note This function provides the strong exception-safety guarantee + */ + template<typename SequenceT> + inline SequenceT trim_copy( const SequenceT& Input, const std::locale& Loc=std::locale() ) + { + return + ::boost::algorithm::trim_copy_if( + Input, + is_space(Loc) ); + } + + //! Trim + /*! + Remove all leading and trailing spaces from the input. + The supplied predicate is used to determine which characters are considered spaces. + The input sequence is modified in-place. + + \param Input An input sequence + \param IsSpace A unary predicate identifying spaces + */ + template<typename SequenceT, typename PredicateT> + inline void trim_if(SequenceT& Input, PredicateT IsSpace) + { + ::boost::algorithm::trim_right_if( Input, IsSpace ); + ::boost::algorithm::trim_left_if( Input, IsSpace ); + } + + //! Trim + /*! + Remove all leading and trailing spaces from the input. + The input sequence is modified in-place. + + \param Input An input sequence + \param Loc A locale used for 'space' classification + */ + template<typename SequenceT> + inline void trim(SequenceT& Input, const std::locale& Loc=std::locale()) + { + ::boost::algorithm::trim_if( + Input, + is_space( Loc ) ); + } + + } // namespace algorithm + + // pull names to the boost namespace + using algorithm::trim_left; + using algorithm::trim_left_if; + using algorithm::trim_left_copy; + using algorithm::trim_left_copy_if; + using algorithm::trim_right; + using algorithm::trim_right_if; + using algorithm::trim_right_copy; + using algorithm::trim_right_copy_if; + using algorithm::trim; + using algorithm::trim_if; + using algorithm::trim_copy; + using algorithm::trim_copy_if; + +} // namespace boost + +#endif // BOOST_STRING_TRIM_HPP diff --git a/contrib/src/boost/algorithm/string/yes_no_type.hpp b/contrib/src/boost/algorithm/string/yes_no_type.hpp index 4109763..b76cc6c 100644 --- a/contrib/src/boost/algorithm/string/yes_no_type.hpp +++ b/contrib/src/boost/algorithm/string/yes_no_type.hpp @@ -1,33 +1,33 @@ -// Boost string_algo library yes_no_type.hpp header file ---------------------------//
-
-// Copyright Pavol Droba 2002-2003.
-//
-// Distributed under the Boost Software License, Version 1.0.
-// (See accompanying file LICENSE_1_0.txt or copy at
-// http://www.boost.org/LICENSE_1_0.txt)
-
-// See http://www.boost.org/ for updates, documentation, and revision history.
-
-#ifndef BOOST_STRING_YES_NO_TYPE_DETAIL_HPP
-#define BOOST_STRING_YES_NO_TYPE_DETAIL_HPP
-
-namespace boost {
- namespace algorithm {
-
- // taken from boost mailing-list
- // when yes_no_type will become officially
- // a part of boost distribution, this header
- // will be deprecated
- template<int I> struct size_descriptor
- {
- typedef char (& type)[I];
- };
-
- typedef size_descriptor<1>::type yes_type;
- typedef size_descriptor<2>::type no_type;
-
- } // namespace algorithm
-} // namespace boost
-
-
-#endif // BOOST_STRING_YES_NO_TYPE_DETAIL_HPP
+// Boost string_algo library yes_no_type.hpp header file ---------------------------// + +// Copyright Pavol Droba 2002-2003. +// +// Distributed under the Boost Software License, Version 1.0. +// (See accompanying file LICENSE_1_0.txt or copy at +// http://www.boost.org/LICENSE_1_0.txt) + +// See http://www.boost.org/ for updates, documentation, and revision history. + +#ifndef BOOST_STRING_YES_NO_TYPE_DETAIL_HPP +#define BOOST_STRING_YES_NO_TYPE_DETAIL_HPP + +namespace boost { + namespace algorithm { + + // taken from boost mailing-list + // when yes_no_type will become officially + // a part of boost distribution, this header + // will be deprecated + template<int I> struct size_descriptor + { + typedef char (& type)[I]; + }; + + typedef size_descriptor<1>::type yes_type; + typedef size_descriptor<2>::type no_type; + + } // namespace algorithm +} // namespace boost + + +#endif // BOOST_STRING_YES_NO_TYPE_DETAIL_HPP |