x
Yes
No
Do you want to visit DriveHQ English website?
首页
产品服务
价格
免费试用
下载客户端
关于我们
云文件服务
|
云备份服务
|
FTP服务
|
企业邮箱服务
|
网站托管
|
客户端软件
云文件服务
云备份服务
FTP服务
企业级邮箱服务
网站托管
客户端软件
trim.hpp - Hosted on DriveHQ Cloud IT Platform
返回上层目录
上传
下载
共享
发布
新建文件夹
新建文件
复制
剪切
删除
粘贴
评论
升级服务
路径: \\game3dprogramming\materials\GameFactory\GameFactoryDemo\references\boost_1_35_0\boost\algorithm\string\trim.hpp
旋转
特效
属性
历史版本
// 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
#include
#include
#include
#include
#include
#include
#include
#include
/*! \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
inline OutputIteratorT trim_left_copy_if( OutputIteratorT Output, const RangeT& Input, PredicateT IsSpace) { iterator_range
::type> lit_range(as_literal(Input)); std::copy( ::boost::algorithm::detail::trim_begin( begin(lit_range), end(lit_range), IsSpace ), end(lit_range), Output); return Output; } //! Left trim - parametric /*! \overload */ template
inline SequenceT trim_left_copy_if(const SequenceT& Input, PredicateT IsSpace) { return SequenceT( ::boost::algorithm::detail::trim_begin( begin(Input), end(Input), IsSpace ), 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
inline SequenceT trim_left_copy(const SequenceT& Input, const std::locale& Loc=std::locale()) { return 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
inline void trim_left_if(SequenceT& Input, PredicateT IsSpace) { Input.erase( begin(Input), ::boost::algorithm::detail::trim_begin( begin(Input), 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
inline void trim_left(SequenceT& Input, const std::locale& Loc=std::locale()) { 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
inline OutputIteratorT trim_right_copy_if( OutputIteratorT Output, const RangeT& Input, PredicateT IsSpace ) { iterator_range
::type> lit_range(as_literal(Input)); std::copy( begin(lit_range), ::boost::algorithm::detail::trim_end( begin(lit_range), end(lit_range), IsSpace ), Output ); return Output; } //! Right trim - parametric /*! \overload */ template
inline SequenceT trim_right_copy_if(const SequenceT& Input, PredicateT IsSpace) { return SequenceT( begin(Input), ::boost::algorithm::detail::trim_end( begin(Input), 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
inline SequenceT trim_right_copy(const SequenceT& Input, const std::locale& Loc=std::locale()) { return 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
inline void trim_right_if(SequenceT& Input, PredicateT IsSpace) { Input.erase( ::boost::algorithm::detail::trim_end( begin(Input), end(Input), IsSpace ), 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
inline void trim_right(SequenceT& Input, const std::locale& Loc=std::locale()) { 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
inline OutputIteratorT trim_copy_if( OutputIteratorT Output, const RangeT& Input, PredicateT IsSpace) { iterator_range
::type> lit_range(as_literal(Input)); BOOST_STRING_TYPENAME range_const_iterator
::type TrimEnd= ::boost::algorithm::detail::trim_end( begin(lit_range), end(lit_range), IsSpace); std::copy( detail::trim_begin( begin(lit_range), TrimEnd, IsSpace), TrimEnd, Output ); return Output; } //! Trim - parametric /*! \overload */ template
inline SequenceT trim_copy_if(const SequenceT& Input, PredicateT IsSpace) { BOOST_STRING_TYPENAME range_const_iterator
::type TrimEnd= ::boost::algorithm::detail::trim_end( begin(Input), end(Input), IsSpace); return SequenceT( detail::trim_begin( 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
inline SequenceT trim_copy( const SequenceT& Input, const std::locale& Loc=std::locale() ) { return 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
inline void trim_if(SequenceT& Input, PredicateT IsSpace) { trim_right_if( Input, IsSpace ); 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
inline void trim(SequenceT& Input, const std::locale& Loc=std::locale()) { 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
trim.hpp
网页地址
文件地址
上一页
23/24
下一页
下载
( 13 KB )
Comments
Total ratings:
0
Average rating:
无评论
of 10
Would you like to comment?
Join now
, or
Logon
if you are already a member.