399 lines
14 KiB
Plaintext
399 lines
14 KiB
Plaintext
// 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
|