Line data Source code
1 : // Boost string_algo library trim.hpp header file ---------------------------//
2 :
3 : // Copyright Pavol Droba 2002-2003.
4 : //
5 : // Distributed under the Boost Software License, Version 1.0.
6 : // (See accompanying file LICENSE_1_0.txt or copy at
7 : // http://www.boost.org/LICENSE_1_0.txt)
8 :
9 : // See http://www.boost.org/ for updates, documentation, and revision history.
10 :
11 : #ifndef BOOST_STRING_TRIM_HPP
12 : #define BOOST_STRING_TRIM_HPP
13 :
14 : #include <boost/algorithm/string/config.hpp>
15 :
16 : #include <boost/range/begin.hpp>
17 : #include <boost/range/end.hpp>
18 : #include <boost/range/const_iterator.hpp>
19 : #include <boost/range/as_literal.hpp>
20 : #include <boost/range/iterator_range_core.hpp>
21 :
22 : #include <boost/algorithm/string/detail/trim.hpp>
23 : #include <boost/algorithm/string/classification.hpp>
24 : #include <locale>
25 :
26 : /*! \file
27 : Defines trim algorithms.
28 : Trim algorithms are used to remove trailing and leading spaces from a
29 : sequence (string). Space is recognized using given locales.
30 :
31 : Parametric (\c _if) variants use a predicate (functor) to select which characters
32 : are to be trimmed..
33 : Functions take a selection predicate as a parameter, which is used to determine
34 : whether a character is a space. Common predicates are provided in classification.hpp header.
35 :
36 : */
37 :
38 : namespace boost {
39 : namespace algorithm {
40 :
41 : // left trim -----------------------------------------------//
42 :
43 :
44 : //! Left trim - parametric
45 : /*!
46 : Remove all leading spaces from the input.
47 : The supplied predicate is used to determine which characters are considered spaces.
48 : The result is a trimmed copy of the input. It is returned as a sequence
49 : or copied to the output iterator
50 :
51 : \param Output An output iterator to which the result will be copied
52 : \param Input An input range
53 : \param IsSpace A unary predicate identifying spaces
54 : \return
55 : An output iterator pointing just after the last inserted character or
56 : a copy of the input
57 :
58 : \note The second variant of this function provides the strong exception-safety guarantee
59 : */
60 : template<typename OutputIteratorT, typename RangeT, typename PredicateT>
61 : inline OutputIteratorT trim_left_copy_if(
62 : OutputIteratorT Output,
63 : const RangeT& Input,
64 : PredicateT IsSpace)
65 : {
66 : iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input));
67 :
68 : std::copy(
69 : ::boost::algorithm::detail::trim_begin(
70 : ::boost::begin(lit_range),
71 : ::boost::end(lit_range),
72 : IsSpace ),
73 : ::boost::end(lit_range),
74 : Output);
75 :
76 : return Output;
77 : }
78 :
79 : //! Left trim - parametric
80 : /*!
81 : \overload
82 : */
83 : template<typename SequenceT, typename PredicateT>
84 : inline SequenceT trim_left_copy_if(const SequenceT& Input, PredicateT IsSpace)
85 : {
86 : return SequenceT(
87 : ::boost::algorithm::detail::trim_begin(
88 : ::boost::begin(Input),
89 : ::boost::end(Input),
90 : IsSpace ),
91 : ::boost::end(Input));
92 : }
93 :
94 : //! Left trim - parametric
95 : /*!
96 : Remove all leading spaces from the input.
97 : The result is a trimmed copy of the input.
98 :
99 : \param Input An input sequence
100 : \param Loc a locale used for 'space' classification
101 : \return A trimmed copy of the input
102 :
103 : \note This function provides the strong exception-safety guarantee
104 : */
105 : template<typename SequenceT>
106 : inline SequenceT trim_left_copy(const SequenceT& Input, const std::locale& Loc=std::locale())
107 : {
108 : return
109 : ::boost::algorithm::trim_left_copy_if(
110 : Input,
111 : is_space(Loc));
112 : }
113 :
114 : //! Left trim
115 : /*!
116 : Remove all leading spaces from the input. The supplied predicate is
117 : used to determine which characters are considered spaces.
118 : The input sequence is modified in-place.
119 :
120 : \param Input An input sequence
121 : \param IsSpace A unary predicate identifying spaces
122 : */
123 : template<typename SequenceT, typename PredicateT>
124 1 : inline void trim_left_if(SequenceT& Input, PredicateT IsSpace)
125 : {
126 1 : Input.erase(
127 1 : ::boost::begin(Input),
128 2 : ::boost::algorithm::detail::trim_begin(
129 : ::boost::begin(Input),
130 : ::boost::end(Input),
131 : IsSpace));
132 1 : }
133 :
134 : //! Left trim
135 : /*!
136 : Remove all leading spaces from the input.
137 : The Input sequence is modified in-place.
138 :
139 : \param Input An input sequence
140 : \param Loc A locale used for 'space' classification
141 : */
142 : template<typename SequenceT>
143 : inline void trim_left(SequenceT& Input, const std::locale& Loc=std::locale())
144 : {
145 : ::boost::algorithm::trim_left_if(
146 : Input,
147 : is_space(Loc));
148 : }
149 :
150 : // right trim -----------------------------------------------//
151 :
152 : //! Right trim - parametric
153 : /*!
154 : Remove all trailing spaces from the input.
155 : The supplied predicate is used to determine which characters are considered spaces.
156 : The result is a trimmed copy of the input. It is returned as a sequence
157 : or copied to the output iterator
158 :
159 : \param Output An output iterator to which the result will be copied
160 : \param Input An input range
161 : \param IsSpace A unary predicate identifying spaces
162 : \return
163 : An output iterator pointing just after the last inserted character or
164 : a copy of the input
165 :
166 : \note The second variant of this function provides the strong exception-safety guarantee
167 : */
168 : template<typename OutputIteratorT, typename RangeT, typename PredicateT>
169 : inline OutputIteratorT trim_right_copy_if(
170 : OutputIteratorT Output,
171 : const RangeT& Input,
172 : PredicateT IsSpace )
173 : {
174 : iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input));
175 :
176 : std::copy(
177 : ::boost::begin(lit_range),
178 : ::boost::algorithm::detail::trim_end(
179 : ::boost::begin(lit_range),
180 : ::boost::end(lit_range),
181 : IsSpace ),
182 : Output );
183 :
184 : return Output;
185 : }
186 :
187 : //! Right trim - parametric
188 : /*!
189 : \overload
190 : */
191 : template<typename SequenceT, typename PredicateT>
192 0 : inline SequenceT trim_right_copy_if(const SequenceT& Input, PredicateT IsSpace)
193 : {
194 : return SequenceT(
195 : ::boost::begin(Input),
196 : ::boost::algorithm::detail::trim_end(
197 : ::boost::begin(Input),
198 : ::boost::end(Input),
199 : IsSpace)
200 0 : );
201 : }
202 :
203 : //! Right trim
204 : /*!
205 : Remove all trailing spaces from the input.
206 : The result is a trimmed copy of the input
207 :
208 : \param Input An input sequence
209 : \param Loc A locale used for 'space' classification
210 : \return A trimmed copy of the input
211 :
212 : \note This function provides the strong exception-safety guarantee
213 : */
214 : template<typename SequenceT>
215 0 : inline SequenceT trim_right_copy(const SequenceT& Input, const std::locale& Loc=std::locale())
216 : {
217 : return
218 : ::boost::algorithm::trim_right_copy_if(
219 : Input,
220 0 : is_space(Loc));
221 : }
222 :
223 :
224 : //! Right trim - parametric
225 : /*!
226 : Remove all trailing spaces from the input.
227 : The supplied predicate is used to determine which characters are considered spaces.
228 : The input sequence is modified in-place.
229 :
230 : \param Input An input sequence
231 : \param IsSpace A unary predicate identifying spaces
232 : */
233 : template<typename SequenceT, typename PredicateT>
234 1 : inline void trim_right_if(SequenceT& Input, PredicateT IsSpace)
235 : {
236 2 : Input.erase(
237 2 : ::boost::algorithm::detail::trim_end(
238 : ::boost::begin(Input),
239 : ::boost::end(Input),
240 : IsSpace ),
241 1 : ::boost::end(Input)
242 : );
243 1 : }
244 :
245 :
246 : //! Right trim
247 : /*!
248 : Remove all trailing spaces from the input.
249 : The input sequence is modified in-place.
250 :
251 : \param Input An input sequence
252 : \param Loc A locale used for 'space' classification
253 : */
254 : template<typename SequenceT>
255 0 : inline void trim_right(SequenceT& Input, const std::locale& Loc=std::locale())
256 : {
257 0 : ::boost::algorithm::trim_right_if(
258 : Input,
259 : is_space(Loc) );
260 0 : }
261 :
262 : // both side trim -----------------------------------------------//
263 :
264 : //! Trim - parametric
265 : /*!
266 : Remove all trailing and leading spaces from the input.
267 : The supplied predicate is used to determine which characters are considered spaces.
268 : The result is a trimmed copy of the input. It is returned as a sequence
269 : or copied to the output iterator
270 :
271 : \param Output An output iterator to which the result will be copied
272 : \param Input An input range
273 : \param IsSpace A unary predicate identifying spaces
274 : \return
275 : An output iterator pointing just after the last inserted character or
276 : a copy of the input
277 :
278 : \note The second variant of this function provides the strong exception-safety guarantee
279 : */
280 : template<typename OutputIteratorT, typename RangeT, typename PredicateT>
281 : inline OutputIteratorT trim_copy_if(
282 : OutputIteratorT Output,
283 : const RangeT& Input,
284 : PredicateT IsSpace)
285 : {
286 : iterator_range<BOOST_STRING_TYPENAME range_const_iterator<RangeT>::type> lit_range(::boost::as_literal(Input));
287 :
288 : BOOST_STRING_TYPENAME
289 : range_const_iterator<RangeT>::type TrimEnd=
290 : ::boost::algorithm::detail::trim_end(
291 : ::boost::begin(lit_range),
292 : ::boost::end(lit_range),
293 : IsSpace);
294 :
295 : std::copy(
296 : detail::trim_begin(
297 : ::boost::begin(lit_range), TrimEnd, IsSpace),
298 : TrimEnd,
299 : Output
300 : );
301 :
302 : return Output;
303 : }
304 :
305 : //! Trim - parametric
306 : /*!
307 : \overload
308 : */
309 : template<typename SequenceT, typename PredicateT>
310 1068 : inline SequenceT trim_copy_if(const SequenceT& Input, PredicateT IsSpace)
311 : {
312 : BOOST_STRING_TYPENAME
313 : range_const_iterator<SequenceT>::type TrimEnd=
314 1068 : ::boost::algorithm::detail::trim_end(
315 : ::boost::begin(Input),
316 : ::boost::end(Input),
317 : IsSpace);
318 :
319 : return SequenceT(
320 : detail::trim_begin(
321 : ::boost::begin(Input),
322 : TrimEnd,
323 : IsSpace),
324 : TrimEnd
325 2136 : );
326 : }
327 :
328 : //! Trim
329 : /*!
330 : Remove all leading and trailing spaces from the input.
331 : The result is a trimmed copy of the input
332 :
333 : \param Input An input sequence
334 : \param Loc A locale used for 'space' classification
335 : \return A trimmed copy of the input
336 :
337 : \note This function provides the strong exception-safety guarantee
338 : */
339 : template<typename SequenceT>
340 1068 : inline SequenceT trim_copy( const SequenceT& Input, const std::locale& Loc=std::locale() )
341 : {
342 : return
343 : ::boost::algorithm::trim_copy_if(
344 : Input,
345 2136 : is_space(Loc) );
346 : }
347 :
348 : //! Trim
349 : /*!
350 : Remove all leading and trailing spaces from the input.
351 : The supplied predicate is used to determine which characters are considered spaces.
352 : The input sequence is modified in-place.
353 :
354 : \param Input An input sequence
355 : \param IsSpace A unary predicate identifying spaces
356 : */
357 : template<typename SequenceT, typename PredicateT>
358 1 : inline void trim_if(SequenceT& Input, PredicateT IsSpace)
359 : {
360 2 : ::boost::algorithm::trim_right_if( Input, IsSpace );
361 1 : ::boost::algorithm::trim_left_if( Input, IsSpace );
362 1 : }
363 :
364 : //! Trim
365 : /*!
366 : Remove all leading and trailing spaces from the input.
367 : The input sequence is modified in-place.
368 :
369 : \param Input An input sequence
370 : \param Loc A locale used for 'space' classification
371 : */
372 : template<typename SequenceT>
373 1 : inline void trim(SequenceT& Input, const std::locale& Loc=std::locale())
374 : {
375 1 : ::boost::algorithm::trim_if(
376 : Input,
377 : is_space( Loc ) );
378 1 : }
379 :
380 : } // namespace algorithm
381 :
382 : // pull names to the boost namespace
383 : using algorithm::trim_left;
384 : using algorithm::trim_left_if;
385 : using algorithm::trim_left_copy;
386 : using algorithm::trim_left_copy_if;
387 : using algorithm::trim_right;
388 : using algorithm::trim_right_if;
389 : using algorithm::trim_right_copy;
390 : using algorithm::trim_right_copy_if;
391 : using algorithm::trim;
392 : using algorithm::trim_if;
393 : using algorithm::trim_copy;
394 : using algorithm::trim_copy_if;
395 :
396 : } // namespace boost
397 :
398 : #endif // BOOST_STRING_TRIM_HPP
|
