summaryrefslogtreecommitdiffstats
diff options
context:
space:
mode:
Diffstat (limited to '3rdParty/Boost/boost/algorithm/string/erase.hpp')
-rw-r--r--3rdParty/Boost/boost/algorithm/string/erase.hpp844
1 files changed, 844 insertions, 0 deletions
diff --git a/3rdParty/Boost/boost/algorithm/string/erase.hpp b/3rdParty/Boost/boost/algorithm/string/erase.hpp
new file mode 100644
index 0000000..b50323b
--- /dev/null
+++ b/3rdParty/Boost/boost/algorithm/string/erase.hpp
@@ -0,0 +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.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 find_format_copy(
+ Output,
+ Input,
+ range_finder(SearchRange),
+ 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 find_format_copy(
+ Input,
+ range_finder(SearchRange),
+ empty_formatter(Input) );
+ }
+
+ //! Erase range algorithm
+ /*!
+ Remove the given range from the input.
+ The input sequence is modified in-place.
+
+ \param Input An input sequence
+ \param SearchRange A range in the input to be removed
+ */
+ template<typename SequenceT>
+ inline void erase_range(
+ SequenceT& Input,
+ const iterator_range<
+ BOOST_STRING_TYPENAME
+ range_iterator<SequenceT>::type>& SearchRange )
+ {
+ find_format(
+ Input,
+ range_finder(SearchRange),
+ 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 find_format_copy(
+ Output,
+ Input,
+ first_finder(Search),
+ empty_formatter(Input) );
+ }
+
+ //! Erase first algorithm
+ /*!
+ \overload
+ */
+ template<typename SequenceT, typename RangeT>
+ inline SequenceT erase_first_copy(
+ const SequenceT& Input,
+ const RangeT& Search )
+ {
+ return find_format_copy(
+ Input,
+ first_finder(Search),
+ 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 )
+ {
+ find_format(
+ Input,
+ first_finder(Search),
+ 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 find_format_copy(
+ Output,
+ Input,
+ first_finder(Search, is_iequal(Loc)),
+ 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 find_format_copy(
+ Input,
+ first_finder(Search, is_iequal(Loc)),
+ 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() )
+ {
+ find_format(
+ Input,
+ first_finder(Search, is_iequal(Loc)),
+ 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 find_format_copy(
+ Output,
+ Input,
+ last_finder(Search),
+ empty_formatter(Input) );
+ }
+
+ //! Erase last algorithm
+ /*!
+ \overload
+ */
+ template<typename SequenceT, typename RangeT>
+ inline SequenceT erase_last_copy(
+ const SequenceT& Input,
+ const RangeT& Search )
+ {
+ return find_format_copy(
+ Input,
+ last_finder(Search),
+ 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 )
+ {
+ find_format(
+ Input,
+ last_finder(Search),
+ 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 find_format_copy(
+ Output,
+ Input,
+ last_finder(Search, is_iequal(Loc)),
+ 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 find_format_copy(
+ Input,
+ last_finder(Search, is_iequal(Loc)),
+ 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() )
+ {
+ find_format(
+ Input,
+ last_finder(Search, is_iequal(Loc)),
+ 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 find_format_copy(
+ Output,
+ Input,
+ nth_finder(Search, Nth),
+ 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 find_format_copy(
+ Input,
+ nth_finder(Search, Nth),
+ 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 )
+ {
+ find_format(
+ Input,
+ nth_finder(Search, Nth),
+ 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 find_format_copy(
+ Output,
+ Input,
+ nth_finder(Search, Nth, is_iequal(Loc)),
+ 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 find_format_copy(
+ Input,
+ 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() )
+ {
+ find_format(
+ Input,
+ nth_finder(Search, Nth, is_iequal(Loc)),
+ empty_formatter(Input) );
+ }
+
+
+// erase_all --------------------------------------------------------//
+
+ //! Erase all algorithm
+ /*!
+ Remove all the occurrences of the string from the input.
+ The result is a modified copy of the input. It is returned as a sequence
+ or copied to the output iterator.
+
+
+ \param Output An output iterator to which the result will be copied
+ \param Input An input sequence
+ \param Search A substring to be searched for.
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename Range1T,
+ typename Range2T>
+ inline OutputIteratorT erase_all_copy(
+ OutputIteratorT Output,
+ const Range1T& Input,
+ const Range2T& Search )
+ {
+ return find_format_all_copy(
+ Output,
+ Input,
+ first_finder(Search),
+ empty_formatter(Input) );
+ }
+
+ //! Erase all algorithm
+ /*!
+ \overload
+ */
+ template<typename SequenceT, typename RangeT>
+ inline SequenceT erase_all_copy(
+ const SequenceT& Input,
+ const RangeT& Search )
+ {
+ return find_format_all_copy(
+ Input,
+ first_finder(Search),
+ empty_formatter(Input) );
+ }
+
+ //! Erase all algorithm
+ /*!
+ Remove all the occurrences of the string from the input.
+ The input sequence is modified in-place.
+
+ \param Input An input string
+ \param Search A substring to be searched for.
+ */
+ template<typename SequenceT, typename RangeT>
+ inline void erase_all(
+ SequenceT& Input,
+ const RangeT& Search )
+ {
+ find_format_all(
+ Input,
+ first_finder(Search),
+ empty_formatter(Input) );
+ }
+
+// erase_all ( case insensitive ) ------------------------------------//
+
+ //! Erase all algorithm ( case insensitive )
+ /*!
+ Remove all the occurrences of the string from the input.
+ The result is a modified copy of the input. It is returned as a sequence
+ or copied to the output iterator.
+ Searching is case insensitive.
+
+ \param Output An output iterator to which the result will be copied
+ \param Input An input string
+ \param Search A substring to be searched for
+ \param Loc A locale used for case insensitive comparison
+ \return An output iterator pointing just after the last inserted character or
+ a modified copy of the input
+
+ \note The second variant of this function provides the strong exception-safety guarantee
+ */
+ template<
+ typename OutputIteratorT,
+ typename Range1T,
+ typename Range2T>
+ inline OutputIteratorT ierase_all_copy(
+ OutputIteratorT Output,
+ const Range1T& Input,
+ const Range2T& Search,
+ const std::locale& Loc=std::locale() )
+ {
+ return find_format_all_copy(
+ Output,
+ Input,
+ first_finder(Search, is_iequal(Loc)),
+ empty_formatter(Input) );
+ }
+
+ //! Erase all algorithm ( case insensitive )
+ /*!
+ \overload
+ */
+ template<typename SequenceT, typename RangeT>
+ inline SequenceT ierase_all_copy(
+ const SequenceT& Input,
+ const RangeT& Search,
+ const std::locale& Loc=std::locale() )
+ {
+ return find_format_all_copy(
+ Input,
+ first_finder(Search, is_iequal(Loc)),
+ empty_formatter(Input) );
+ }
+
+ //! Erase all algorithm ( case insensitive )
+ /*!
+ Remove all the occurrences of the string from the input.
+ The input sequence is modified in-place. Searching is case insensitive.
+
+ \param Input An input string
+ \param Search A substring to be searched for.
+ \param Loc A locale used for case insensitive comparison
+ */
+ template<typename SequenceT, typename RangeT>
+ inline void ierase_all(
+ SequenceT& Input,
+ const RangeT& Search,
+ const std::locale& Loc=std::locale() )
+ {
+ find_format_all(
+ Input,
+ first_finder(Search, is_iequal(Loc)),
+ empty_formatter(Input) );
+ }
+
+// erase_head --------------------------------------------------------------------//
+
+ //! Erase head algorithm
+ /*!
+ Remove the head from the input. The head is a prefix of a 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 find_format_copy(
+ Output,
+ Input,
+ head_finder(N),
+ empty_formatter( Input ) );
+ }
+
+ //! Erase head algorithm
+ /*!
+ \overload
+ */
+ template<typename SequenceT>
+ inline SequenceT erase_head_copy(
+ const SequenceT& Input,
+ int N )
+ {
+ return find_format_copy(
+ Input,
+ head_finder(N),
+ empty_formatter( Input ) );
+ }
+
+ //! Erase head algorithm
+ /*!
+ Remove the head from the input. The head is a prefix of a 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 )
+ {
+ find_format(
+ Input,
+ head_finder(N),
+ empty_formatter( Input ) );
+ }
+
+// erase_tail --------------------------------------------------------------------//
+
+ //! Erase tail algorithm
+ /*!
+ Remove the tail from the input. The tail is a suffix of a 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 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_tail_copy(
+ OutputIteratorT Output,
+ const RangeT& Input,
+ int N )
+ {
+ return find_format_copy(
+ Output,
+ Input,
+ tail_finder(N),
+ empty_formatter( Input ) );
+ }
+
+ //! Erase tail algorithm
+ /*!
+ \overload
+ */
+ template<typename SequenceT>
+ inline SequenceT erase_tail_copy(
+ const SequenceT& Input,
+ int N )
+ {
+ return find_format_copy(
+ Input,
+ tail_finder(N),
+ empty_formatter( Input ) );
+ }
+
+ //! Erase tail algorithm
+ /*!
+ Remove the tail from the input. The tail is a suffix of a 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 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_tail(
+ SequenceT& Input,
+ int N )
+ {
+ find_format(
+ Input,
+ tail_finder(N),
+ empty_formatter( Input ) );
+ }
+
+ } // namespace algorithm
+
+ // pull names into the boost namespace
+ using algorithm::erase_range_copy;
+ using algorithm::erase_range;
+ using algorithm::erase_first_copy;
+ using algorithm::erase_first;
+ using algorithm::ierase_first_copy;
+ using algorithm::ierase_first;
+ using algorithm::erase_last_copy;
+ using algorithm::erase_last;
+ using algorithm::ierase_last_copy;
+ using algorithm::ierase_last;
+ using algorithm::erase_nth_copy;
+ using algorithm::erase_nth;
+ using algorithm::ierase_nth_copy;
+ using algorithm::ierase_nth;
+ using algorithm::erase_all_copy;
+ using algorithm::erase_all;
+ using algorithm::ierase_all_copy;
+ using algorithm::ierase_all;
+ using algorithm::erase_head_copy;
+ using algorithm::erase_head;
+ using algorithm::erase_tail_copy;
+ using algorithm::erase_tail;
+
+} // namespace boost
+
+
+#endif // BOOST_ERASE_HPP