You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and dots ('.'), can be up to 35 characters long. Letters must be lowercase.
398 lines
14 KiB
398 lines
14 KiB
// 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.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 An unary predicate identifying spaces |
|
\return |
|
An output iterator pointing just after the last inserted character or |
|
a copy of the input |
|
|
|
\note The second variant of this function provides the strong exception-safety guarantee |
|
*/ |
|
template<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 An 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 An unary predicate identifying spaces |
|
\return |
|
An output iterator pointing just after the last inserted character or |
|
a copy of the input |
|
|
|
\note The second variant of this function provides the strong exception-safety guarantee |
|
*/ |
|
template<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 An 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 An unary predicate identifying spaces |
|
\return |
|
An output iterator pointing just after the last inserted character or |
|
a copy of the input |
|
|
|
\note The second variant of this function provides the strong exception-safety guarantee |
|
*/ |
|
template<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 An 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
|
|
|