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.
217 lines
8.0 KiB
217 lines
8.0 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_ALL_HPP |
|
#define BOOST_STRING_TRIM_ALL_HPP |
|
|
|
#include <boost/algorithm/string/config.hpp> |
|
|
|
#include <boost/algorithm/string/trim.hpp> |
|
#include <boost/algorithm/string/classification.hpp> |
|
#include <boost/algorithm/string/find_format.hpp> |
|
#include <boost/algorithm/string/formatter.hpp> |
|
#include <boost/algorithm/string/finder.hpp> |
|
#include <locale> |
|
|
|
/*! \file |
|
Defines trim_all algorithms. |
|
|
|
Just like \c trim, \c trim_all removes all trailing and leading spaces from a |
|
sequence (string). In addition, spaces in the middle of the sequence are truncated |
|
to just one character. Space is recognized using given locales. |
|
|
|
\c trim_fill acts as trim_all, but the spaces in the middle are replaces with |
|
a user-define sequence of character. |
|
|
|
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 { |
|
|
|
// multi line trim ----------------------------------------------- // |
|
|
|
//! Trim All - parametric |
|
/*! |
|
Remove all leading and trailing spaces from the input and |
|
compress all other spaces to a single character. |
|
The result is a trimmed copy of the input |
|
|
|
\param Input An input sequence |
|
\param IsSpace An unary predicate identifying spaces |
|
\return A trimmed copy of the input |
|
*/ |
|
template<typename SequenceT, typename PredicateT> |
|
inline SequenceT trim_all_copy_if(const SequenceT& Input, PredicateT IsSpace) |
|
{ |
|
return |
|
::boost::find_format_all_copy( |
|
::boost::trim_copy_if(Input, IsSpace), |
|
::boost::token_finder(IsSpace, ::boost::token_compress_on), |
|
::boost::dissect_formatter(::boost::head_finder(1))); |
|
} |
|
|
|
|
|
//! Trim All |
|
/*! |
|
Remove all leading and trailing spaces from the input and |
|
compress all other spaces to a single character. |
|
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_all_if(SequenceT& Input, PredicateT IsSpace) |
|
{ |
|
::boost::trim_if(Input, IsSpace); |
|
::boost::find_format_all( |
|
Input, |
|
::boost::token_finder(IsSpace, ::boost::token_compress_on), |
|
::boost::dissect_formatter(::boost::head_finder(1))); |
|
} |
|
|
|
|
|
//! Trim All |
|
/*! |
|
Remove all leading and trailing spaces from the input and |
|
compress all other spaces to a single character. |
|
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 |
|
*/ |
|
template<typename SequenceT> |
|
inline SequenceT trim_all_copy(const SequenceT& Input, const std::locale& Loc =std::locale()) |
|
{ |
|
return trim_all_copy_if(Input, ::boost::is_space(Loc)); |
|
} |
|
|
|
|
|
//! Trim All |
|
/*! |
|
Remove all leading and trailing spaces from the input and |
|
compress all other spaces to a single character. |
|
The input sequence is modified in-place. |
|
|
|
\param Input An input sequence |
|
\param Loc A locale used for 'space' classification |
|
\return A trimmed copy of the input |
|
*/ |
|
template<typename SequenceT> |
|
inline void trim_all(SequenceT& Input, const std::locale& Loc =std::locale()) |
|
{ |
|
trim_all_if(Input, ::boost::is_space(Loc)); |
|
} |
|
|
|
|
|
//! Trim Fill - parametric |
|
/*! |
|
Remove all leading and trailing spaces from the input and |
|
replace all every block of consecutive spaces with a fill string |
|
defined by user. |
|
The result is a trimmed copy of the input |
|
|
|
\param Input An input sequence |
|
\param Fill A string used to fill the inner spaces |
|
\param IsSpace An unary predicate identifying spaces |
|
\return A trimmed copy of the input |
|
*/ |
|
template<typename SequenceT, typename RangeT, typename PredicateT> |
|
inline SequenceT trim_fill_copy_if(const SequenceT& Input, const RangeT& Fill, PredicateT IsSpace) |
|
{ |
|
return |
|
::boost::find_format_all_copy( |
|
::boost::trim_copy_if(Input, IsSpace), |
|
::boost::token_finder(IsSpace, ::boost::token_compress_on), |
|
::boost::const_formatter(::boost::as_literal(Fill))); |
|
} |
|
|
|
|
|
//! Trim Fill |
|
/*! |
|
Remove all leading and trailing spaces from the input and |
|
replace all every block of consecutive spaces with a fill string |
|
defined by user. |
|
The input sequence is modified in-place. |
|
|
|
\param Input An input sequence |
|
\param Fill A string used to fill the inner spaces |
|
\param IsSpace An unary predicate identifying spaces |
|
*/ |
|
template<typename SequenceT, typename RangeT, typename PredicateT> |
|
inline void trim_fill_if(SequenceT& Input, const RangeT& Fill, PredicateT IsSpace) |
|
{ |
|
::boost::trim_if(Input, IsSpace); |
|
::boost::find_format_all( |
|
Input, |
|
::boost::token_finder(IsSpace, ::boost::token_compress_on), |
|
::boost::const_formatter(::boost::as_literal(Fill))); |
|
} |
|
|
|
|
|
//! Trim Fill |
|
/*! |
|
Remove all leading and trailing spaces from the input and |
|
replace all every block of consecutive spaces with a fill string |
|
defined by user. |
|
The result is a trimmed copy of the input |
|
|
|
\param Input An input sequence |
|
\param Fill A string used to fill the inner spaces |
|
\param Loc A locale used for 'space' classification |
|
\return A trimmed copy of the input |
|
*/ |
|
template<typename SequenceT, typename RangeT> |
|
inline SequenceT trim_fill_copy(const SequenceT& Input, const RangeT& Fill, const std::locale& Loc =std::locale()) |
|
{ |
|
return trim_fill_copy_if(Input, Fill, ::boost::is_space(Loc)); |
|
} |
|
|
|
|
|
//! Trim Fill |
|
/*! |
|
Remove all leading and trailing spaces from the input and |
|
replace all every block of consecutive spaces with a fill string |
|
defined by user. |
|
The input sequence is modified in-place. |
|
|
|
\param Input An input sequence |
|
\param Fill A string used to fill the inner spaces |
|
\param Loc A locale used for 'space' classification |
|
\return A trimmed copy of the input |
|
*/ |
|
template<typename SequenceT, typename RangeT> |
|
inline void trim_fill(SequenceT& Input, const RangeT& Fill, const std::locale& Loc =std::locale()) |
|
{ |
|
trim_fill_if(Input, Fill, ::boost::is_space(Loc)); |
|
} |
|
|
|
|
|
} // namespace algorithm |
|
|
|
// pull names to the boost namespace |
|
using algorithm::trim_all; |
|
using algorithm::trim_all_if; |
|
using algorithm::trim_all_copy; |
|
using algorithm::trim_all_copy_if; |
|
using algorithm::trim_fill; |
|
using algorithm::trim_fill_if; |
|
using algorithm::trim_fill_copy; |
|
using algorithm::trim_fill_copy_if; |
|
|
|
} // namespace boost |
|
|
|
#endif // BOOST_STRING_TRIM_ALL_HPP
|
|
|