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 | |
---|
34 | namespace 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 | |
---|