| // 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 |
