1// Boost string_algo library split.hpp header file ---------------------------//
2
3// Copyright Pavol Droba 2002-2006.
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_SPLIT_HPP
12#define BOOST_STRING_SPLIT_HPP
13
14#include <boost/algorithm/string/config.hpp>
15
16#include <boost/algorithm/string/iter_find.hpp>
17#include <boost/algorithm/string/finder.hpp>
18#include <boost/algorithm/string/compare.hpp>
19
20/*! \file
21 Defines basic split algorithms.
22 Split algorithms can be used to divide a string
23 into several parts according to given criteria.
24
25 Each part is copied and added as a new element to the
26 output container.
27 Thus the result container must be able to hold copies
28 of the matches (in a compatible structure like std::string) or
29 a reference to it (e.g. using the iterator range class).
30 Examples of such a container are \c std::vector<std::string>
31 or \c std::list<boost::iterator_range<std::string::iterator>>
32*/
33
34namespace boost {
35 namespace algorithm {
36
37// find_all ------------------------------------------------------------//
38
39 //! Find all algorithm
40 /*!
41 This algorithm finds all occurrences of the search string
42 in the input.
43
44 Each part is copied and added as a new element to the
45 output container.
46 Thus the result container must be able to hold copies
47 of the matches (in a compatible structure like std::string) or
48 a reference to it (e.g. using the iterator range class).
49 Examples of such a container are \c std::vector<std::string>
50 or \c std::list<boost::iterator_range<std::string::iterator>>
51
52 \param Result A container that can hold copies of references to the substrings
53 \param Input A container which will be searched.
54 \param Search A substring to be searched for.
55 \return A reference the result
56
57 \note Prior content of the result will be overwritten.
58
59 \note This function provides the strong exception-safety guarantee
60 */
61 template< typename SequenceSequenceT, typename Range1T, typename Range2T >
62 inline SequenceSequenceT& find_all(
63 SequenceSequenceT& Result,
64 Range1T& Input,
65 const Range2T& Search)
66 {
67 return ::boost::algorithm::iter_find(
68 Result,
69 Input,
70 ::boost::algorithm::first_finder(Search) );
71 }
72
73 //! Find all algorithm ( case insensitive )
74 /*!
75 This algorithm finds all occurrences of the search string
76 in the input.
77 Each part is copied and added as a new element to the
78 output container. Thus the result container must be able to hold copies
79 of the matches (in a compatible structure like std::string) or
80 a reference to it (e.g. using the iterator range class).
81 Examples of such a container are \c std::vector<std::string>
82 or \c std::list<boost::iterator_range<std::string::iterator>>
83
84 Searching is case insensitive.
85
86 \param Result A container that can hold copies of references to the substrings
87 \param Input A container which will be searched.
88 \param Search A substring to be searched for.
89 \param Loc A locale used for case insensitive comparison
90 \return A reference the result
91
92 \note Prior content of the result will be overwritten.
93
94 \note This function provides the strong exception-safety guarantee
95 */
96 template< typename SequenceSequenceT, typename Range1T, typename Range2T >
97 inline SequenceSequenceT& ifind_all(
98 SequenceSequenceT& Result,
99 Range1T& Input,
100 const Range2T& Search,
101 const std::locale& Loc=std::locale() )
102 {
103 return ::boost::algorithm::iter_find(
104 Result,
105 Input,
106 ::boost::algorithm::first_finder(Search, is_iequal(Loc) ) );
107 }
108
109
110// tokenize -------------------------------------------------------------//
111
112 //! Split algorithm
113 /*!
114 Tokenize expression. This function is equivalent to C strtok. Input
115 sequence is split into tokens, separated by separators. Separators
116 are given by means of the predicate.
117
118 Each part is copied and added as a new element to the
119 output container.
120 Thus the result container must be able to hold copies
121 of the matches (in a compatible structure like std::string) or
122 a reference to it (e.g. using the iterator range class).
123 Examples of such a container are \c std::vector<std::string>
124 or \c std::list<boost::iterator_range<std::string::iterator>>
125
126 \param Result A container that can hold copies of references to the substrings
127 \param Input A container which will be searched.
128 \param Pred A predicate to identify separators. This predicate is
129 supposed to return true if a given element is a separator.
130 \param eCompress If eCompress argument is set to token_compress_on, adjacent
131 separators are merged together. Otherwise, every two separators
132 delimit a token.
133 \return A reference the result
134
135 \note Prior content of the result will be overwritten.
136
137 \note This function provides the strong exception-safety guarantee
138 */
139 template< typename SequenceSequenceT, typename RangeT, typename PredicateT >
140 inline SequenceSequenceT& split(
141 SequenceSequenceT& Result,
142 RangeT& Input,
143 PredicateT Pred,
144 token_compress_mode_type eCompress=token_compress_off )
145 {
146 return ::boost::algorithm::iter_split(
147 Result,
148 Input,
149 ::boost::algorithm::token_finder( Pred, eCompress ) );
150 }
151
152 } // namespace algorithm
153
154 // pull names to the boost namespace
155 using algorithm::find_all;
156 using algorithm::ifind_all;
157 using algorithm::split;
158
159} // namespace boost
160
161
162#endif // BOOST_STRING_SPLIT_HPP
163
164