acme
Foundational cross-platform layer of the ca2 framework
Loading...
Searching...
No Matches
iterable.h
1#pragma once
2
3
4#include "collection_map_association.h"
5#include "collection_sort.h"
6
7
8
9
10namespace iter
11{
12
13 template < typename ITERABLE, typename ITYPE >
14 bool icontains(const ITERABLE & iterable, const ITYPE & t, index first = 0, ::collection::count count = -1);
15
16 template < typename ITERABLE, typename ITYPE >
17 bool contains(const ITERABLE & iterable, const ITYPE & t, typename ITERABLE::const_iterator pos, typename ITERABLE::const_iterator posLast = nullptr, ::collection::count countMin = 0, ::collection::count countMax = -1);
18
19 template < typename ITERABLE, typename ITYPE >
20 bool contains(ITERABLE & iterable, const ITYPE & t, typename ITERABLE::iterator pos, typename ITERABLE::iterator posLast = nullptr, ::collection::count countMin = 0, ::collection::count countMax = -1);
21
22 template < typename ITERABLE, typename ITERABLE2 >
23 void copy(ITERABLE & iterable, const ITERABLE2 & iterable2);
24
25
26 template < typename ITERABLE, typename ITYPE >
27 ITERABLE & add_lines(ITERABLE & iterable, const ITYPE & str, bool bAddEmpty = true);
28
29 template < typename ITERABLE, typename ITYPE >
30 bool add_unique(ITERABLE & iterable, const ITYPE & pcsz);
31
32 template < typename ITERABLE, typename ITYPE >
33 bool case_insensitive_add_unique(ITERABLE & iterable, const ITYPE & pcsz);
34
35 template < typename ITERABLE, typename ITERABLE2, typename ITYPE >
36 typename ::collection::count add_unique_iter(ITERABLE & iterable, const ITERABLE & stra);
37
38 template < typename ITERABLE, typename ITERABLE2, typename ITYPE >
39 typename ::collection::count case_insensitive_add_unique_iter(ITERABLE & iterable, const ITERABLE & stra);
40
41 template < typename ITERABLE, typename ITERABLE2 >
42 ITERABLE & add(ITERABLE & iterable, const ITERABLE2 & iterable2);
43
44 template < typename ITERABLE, typename ITERABLE2 >
45 ITERABLE & copy_iter(ITERABLE & iterable, const ITERABLE2 & iterable2);
46
47 template < typename ITERABLE, typename ITERABLE2 >
48 ITERABLE & insert_iter_at(ITERABLE & iterable, typename ITERABLE::iterator nStartIndex, const ITERABLE2 & iterable2);
49
50 template < typename ITERABLE >
51 ::collection::count erase_empty(ITERABLE & iterable);
52
53 template < typename ITERABLE, typename ITYPE, typename ITYPE2 >
54 ITERABLE & replace(ITERABLE & iterable, const ITYPE & lpszSearch, const ITYPE2 & lpszReplace);
55
56 // if ITYPE is found, transfer it to specified position
57 template < typename ITERABLE, typename ITYPE, typename ITERABLE2 >
58 bool case_insensitive_move(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator iIndex);
59
60 template < typename ITERABLE >
61 ITERABLE & copy(ITERABLE & iterable, const ::payload payload);
62
63 template < typename ITERABLE, typename ITYPE, typename ITERABLE2 >
64 ITERABLE & add_shortest_tokens(ITERABLE & iterable, const ITYPE & pcsz, const ITERABLE2 & iterableSeparator, bool bAddEmpty = true, bool bWithSeparator = false);
65
66 template < typename ITERABLE, typename ITERABLE2 >
67 ITERABLE2 & slice(ITERABLE & iterable, ITERABLE2 & iterable2, typename ITERABLE::iterator first, typename ITERABLE::iterator last = nullptr);
68
69 template < typename ITERABLE, typename ITERABLE2 >
70 ITERABLE2 & islice(ITERABLE & iterable, ITERABLE2 & iterable2, index first, ::collection::count count = -1);
71
72 template < typename ITERABLE, typename ITERABLE2 >
73 ITERABLE & add_iter(ITERABLE & iterable, const ITERABLE2 & iterable2);
74
75 template < typename ITERABLE, typename ITERABLE2 >
76 ITERABLE diff(const ITERABLE & iterable, const ITERABLE2 & iterable2);
77
78 template < typename ITERABLE, typename ITERABLE2 >
79 ITERABLE sum(const ITERABLE & iterable, const ITERABLE2 & iterable2);
80
81 template < typename ITERABLE >
82 void make_lower(ITERABLE & iterable);
83
84 template < typename ITERABLE >
85 void make_upper(ITERABLE & iterable);
86
87 template < typename ITERABLE >
88 void erase(ITERABLE & iterable, typename ITERABLE::iterator typename first = nullptr, typename ITERABLE::iterator typename last = nullptr);
89
90 template < typename ITERABLE, typename ITYPE, typename ITYPE2 >
91 void implode(const ITERABLE & iterable, ITYPE & rwstr, const ITYPE2 & lpcszSeparator = "", typename ITERABLE::const_iterator iStart = 0, typename ITERABLE::const_iterator iEnd = nullptr);
92
93 template < typename ITERABLE, typename ITYPE, typename ITYPE2 >
94 void reverse_implode(const ITERABLE & iterable, ITYPE & rwstr, const ITYPE & lpcszSeparator = "", typename ITERABLE::const_iterator iStart = 0, typename ITERABLE::const_iterator iEnd = nullptr);
95
96 template < typename ITERABLE, typename ITYPE, typename ITYPE2, typename ITYPE3 >
97 void implode_ex(const ITERABLE & iterable, ITYPE & rwstr, const ITYPE2 & lpcszSeparator = "", const ITYPE3 & lpcszLastSeparator = nullptr, typename ITERABLE::const_iterator iStart = 0, typename ITERABLE::const_iterator iEnd = nullptr);
98
99 template < typename ITERABLE, typename ITYPE >
100 void if_prefix_implode_ex(const ITERABLE & iterable, ITYPE & rwstr, const ITYPE & lpcszIfHasElementPrefix = nullptr, const ITYPE & lpcszSeparator = nullptr, const ITYPE & lpcszLastSeparator = nullptr, bool bUseLast = true, typename ITERABLE::iterator iStart = 0, typename ITERABLE::const_iterator iEnd = nullptr);
101
102 template < typename ITERABLE, typename ITERABLE2, typename ITYPE >
103 void prefix(ITERABLE & iterable, const ITERABLE2 & iterable2, const ITYPE & pszPrefix, typename ITERABLE2::const_iterator first = nullptr, typename ITERABLE2::const_iterator last = nullptr);
104
105 template < typename ITERABLE, typename ITERABLE2, typename ITYPE >
106 void suffix(ITERABLE & iterable, const ITERABLE2 & iterable2, const ITYPE & pszSuffix, typename ITERABLE2::const_iterator first = nullptr, typename ITERABLE2::const_iterator last = nullptr);
107
108 template < typename ITERABLE, typename ITERABLE2, typename ITYPE, typename ITYPE2 >
109 void surround(ITERABLE & iterable, const ITERABLE2 & iterable2, const ITYPE & pszPrefix = "", const ITYPE2 & pszSuffix = "", typename ITERABLE2::const_iterator first = nullptr, typename ITERABLE2::const_iterator last = nullptr);
110
111 template < typename ITERABLE, typename ITYPE >
112 void prefix(ITERABLE & iterable, const ITYPE & pszPrefix, typename ITERABLE::iterator first = nullptr, typename ITERABLE::iterator last = nullptr);
113
114 template < typename ITERABLE, typename ITYPE >
115 void suffix(ITERABLE & iterable, const ITYPE & pszSuffix, typename ITERABLE::iterator first = nullptr, typename ITERABLE::iterator last = nullptr);
116
117 template < typename ITERABLE, typename ITYPE, typename ITYPE2 >
118 void surround(ITERABLE & iterable, const ITYPE & pszPrefix = "", const ITYPE2 & pszSuffix = "", typename ITERABLE::iterator first = nullptr, typename ITERABLE::iterator last = nullptr);
119
120 template < typename ITERABLE, typename ITYPE, typename ITYPE2, typename ITYPE3, typename ITYPE4 >
121 void surround_and_implode(const ITERABLE & iterable, ITYPE & str, const ITYPE2 & lpcszSeparator = "", const ITYPE3 & pszPrefix = "", const ITYPE4 & pszSuffix = "", typename ITERABLE::iterator first = nullptr, typename ITERABLE::iterator last = nullptr);
122
123 //template < typename ITERABLE, typename ITERABLE2>
124 //void get_comparable_ida(const ITERABLE & iterable, ITERABLE2 & iterable2);
125
126 template < typename ITERABLE, typename ITYPE >
127 ::collection::count explode_command_line(const ITERABLE & iterable, const ITYPE & str, char_pointer * argv = nullptr);
128
129 template < typename ITERABLE, typename ITERABLE2 >
130 bool operator == (const ITERABLE & iterable, const ITERABLE & iterable2);
131
132 template < typename ITERABLE, typename ITERABLE2 >
133 bool operator != (const ITERABLE & iterable, const ITERABLE & iterable2);
134
135 template < typename ITERABLE, typename ITERABLE2 >
136 ::collection::count case_insensitive_erase_iter(ITERABLE & iterable, const ITERABLE & iterableRemove);
137
138 template < typename ITERABLE, typename ITERABLE2 >
139 ::collection::count erase_iter(ITERABLE & iterable, const ITERABLE2 & iterableRemove);
140
141 template < typename ITERABLE, typename ITYPE >
142 ITERABLE & trim_right(ITERABLE & iterable, const ITYPE & pszChars);
143
144 template < typename ITERABLE, typename ITYPE >
145 ITERABLE & trim_left(ITERABLE & iterable, const ITYPE & pszChars);
146
147 template < typename ITERABLE, typename ITYPE >
148 ITERABLE & trim(ITERABLE & iterable, const ITYPE & pszChars);
149
150 template < typename ITERABLE >
151 ITERABLE & trim_right(ITERABLE & iterable);
152
153 template < typename ITERABLE >
154 ITERABLE & trim_left(ITERABLE & iterable);
155
156 template < typename ITERABLE >
157 ITERABLE & trim(ITERABLE & iterable);
158
159 // transfer preferred in order
160 template < typename ITERABLE, typename ITYPE >
161 ITERABLE & preferred(ITERABLE & iterable, const ITYPE & pcsz);
162
163 template < typename ITERABLE, typename ITERABLE2 >
164 ITERABLE & preferred_iter(ITERABLE & iterable, const ITERABLE2 & iterable2);
165
166 template < typename ITERABLE, typename PRED >
167 bool predicate_erase_first(ITERABLE & iterable, PRED pred);
168
169 template < typename ITERABLE, typename PRED >
170 typename ITERABLE::const_iterator predicate_find_first(const ITERABLE & iterable, PRED pred, typename ITERABLE::const_iterator = nullptr, typename ITERABLE::const_iterator last = nullptr);
171
172 template < typename ITERABLE, typename PRED >
173 typename ITERABLE::iterator predicate_find_first(ITERABLE & iterable, PRED pred, typename ITERABLE::iterator = nullptr, typename ITERABLE::iterator last = nullptr);
174
175 template < typename ITERABLE, typename ITYPE >
176 typename index case_insensitive_ifind_first(const ITERABLE & iterable, const ITYPE & pcsz, index first, ::collection::count count = -1);
177
178 template < typename ITERABLE, typename ITYPE >
179 typename index ifind_first_begins(const ITERABLE & iterable, const ITYPE & pcsz, ::collection::index find, ::collection::count count = -1);
180
181 template < typename ITERABLE, typename ITYPE >
182 typename index case_insensitive_ifind_first_begins(const ITERABLE & iterable, const ITYPE & pcsz, ::collection::index find = 0, ::collection::count count = -1);
183
184 template < typename ITERABLE, typename ITYPE >
185 typename ITERABLE::const_iterator case_insensitive_find_first(const ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::const_iterator find = nullptr, typename ITERABLE::const_iterator last = nullptr);
186
187 template < typename ITERABLE, typename ITYPE >
188 typename ITERABLE::const_iterator find_first(const ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::const_iterator find = nullptr, typename ITERABLE::const_iterator last = nullptr);
189
190 template < typename ITERABLE, typename ITYPE >
191 typename ITERABLE::const_iterator case_insensitive_find_last(const ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::const_iterator find = nullptr, typename ITERABLE::const_iterator last = nullptr);
192
193 template < typename ITERABLE, typename ITYPE >
194 typename ITERABLE::const_iterator find_last(const ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::const_iterator find = nullptr, typename ITERABLE::const_iterator last = nullptr);
195
196 template < typename ITERABLE, typename ITYPE >
197 typename ITERABLE::const_iterator case_insensitive_reverse_find(const ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::const_iterator find = -1, typename ITERABLE::const_iterator last = 0);
198
199 template < typename ITERABLE, typename ITYPE >
200 typename ITERABLE::const_iterator rear_find(const ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::const_iterator find = -1, typename ITERABLE::const_iterator last = 0);
201
202 template < typename ITERABLE, typename ITYPE >
203 typename ITERABLE::const_iterator any_suffixes(const ITERABLE & iterable, const ITYPE & lpcszIsSuffixed, typename ITERABLE::const_iterator find = nullptr, typename ITERABLE::const_iterator last = nullptr);
204
205 template < typename ITERABLE, typename ITYPE >
206 typename ITERABLE::const_iterator any_case_insensitive_suffixes(const ITERABLE & iterable, const ITYPE & lpcszIdSuffixed, typename ITERABLE::const_iterator find = nullptr, typename ITERABLE::const_iterator last = nullptr);
207
208 template < typename ITERABLE, typename ITYPE >
209 typename ITERABLE::const_iterator any_prefixes(const ITERABLE & iterable, const ITYPE & lpcszIsPrefixed, typename ITERABLE::const_iterator find = nullptr, typename ITERABLE::const_iterator last = nullptr);
210
211 template < typename ITERABLE, typename ITYPE >
212 typename ITERABLE::const_iterator case_insensitive_any_prefixes(const ITERABLE & iterable, const ITYPE & lpcszIsPrefixed, typename ITERABLE::const_iterator find = nullptr, typename ITERABLE::const_iterator last = nullptr);
213
214 template < typename ITERABLE, typename ITYPE >
215 typename ITERABLE::const_iterator find_first_ends(const ITERABLE & iterable, const ITYPE & lpcszSuffix, typename ITERABLE::const_iterator find = nullptr, typename ITERABLE::const_iterator last = nullptr);
216
217 template < typename ITERABLE, typename ITYPE >
218 typename ITERABLE::const_iterator case_insensitive_find_first_ends(const ITERABLE & iterable, const ITYPE & lpcszSuffix, typename ITERABLE::const_iterator find = nullptr, typename ITERABLE::const_iterator last = nullptr);
219
220 template < typename ITERABLE, typename ITYPE >
221 typename ITERABLE::const_iterator find_first_ends_eat(const ITERABLE & iterable, ITYPE & str, const ITYPE & pcsz, typename ITERABLE::const_iterator find = nullptr, typename ITERABLE::const_iterator last = nullptr);
222
223 template < typename ITERABLE, typename ITYPE >
224 typename ITERABLE::const_iterator case_insensitive_find_first_ends_eat(const ITERABLE & iterable, ITYPE & str, const ITYPE & pcsz, typename ITERABLE::const_iterator find = nullptr, typename ITERABLE::const_iterator last = nullptr);
225
226 template < typename ITERABLE, typename ITYPE >
227 typename ITERABLE::const_iterator find_first_begins(const ITERABLE & iterable, const ITYPE & lpcszPrefix, typename ITERABLE::const_iterator find = nullptr, typename ITERABLE::const_iterator last = nullptr);
228
229 template < typename ITERABLE, typename ITYPE >
230 typename ITERABLE::const_iterator case_insensitive_find_first_begins(const ITERABLE & iterable, const ITYPE & lpcszPrefix, typename ITERABLE::const_iterator find = 0, typename ITERABLE::const_iterator last = nullptr);
231
232 template < typename ITERABLE, typename ITYPE >
233 typename ITERABLE::const_iterator find_first_begins_eat(const ITERABLE & iterable, ITYPE & str, const ITYPE & pcsz, typename ITERABLE::const_iterator find = 0, typename ITERABLE::const_iterator last = nullptr);
234
235 template < typename ITERABLE, typename ITYPE >
236 typename ITERABLE::const_iterator case_insensitive_find_first_begins_eat(const ITERABLE & iterable, ITYPE & str, const ITYPE & pcsz, typename ITERABLE::const_iterator find = 0, typename ITERABLE::const_iterator last = nullptr);
237
238 template < typename ITERABLE, typename ITYPE >
239 typename ITERABLE::iterator case_insensitive_find_first(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr);
240
241 template < typename ITERABLE, typename ITYPE >
242 typename ITERABLE::iterator find_first(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr);
243
244 template < typename ITERABLE, typename ITYPE >
245 typename ITERABLE::iterator case_insensitive_find_last(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr);
246
247 template < typename ITERABLE, typename ITYPE >
248 typename ITERABLE::iterator find_last(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr);
249
250 template < typename ITERABLE, typename ITYPE >
251 typename ITERABLE::iterator case_insensitive_reverse_find(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator find = -1, typename ITERABLE::iterator last = 0);
252
253 template < typename ITERABLE, typename ITYPE >
254 typename ITERABLE::iterator rear_find(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator find = -1, typename ITERABLE::iterator last = 0);
255
256 template < typename ITERABLE, typename ITYPE >
257 typename ITERABLE::iterator any_suffixes(ITERABLE & iterable, const ITYPE & lpcszIsSuffixed, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr);
258
259 template < typename ITERABLE, typename ITYPE >
260 typename ITERABLE::iterator any_case_insensitive_suffixes(ITERABLE & iterable, const ITYPE & lpcszIdSuffixed, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr);
261
262 template < typename ITERABLE, typename ITYPE >
263 typename ITERABLE::iterator any_prefixes(ITERABLE & iterable, const ITYPE & lpcszIsPrefixed, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr);
264
265 template < typename ITERABLE, typename ITYPE >
266 typename ITERABLE::iterator case_insensitive_any_prefixes(ITERABLE & iterable, const ITYPE & lpcszIsPrefixed, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr);
267
268 template < typename ITERABLE, typename ITYPE >
269 typename ITERABLE::iterator find_first_ends(ITERABLE & iterable, const ITYPE & lpcszSuffix, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr);
270
271 template < typename ITERABLE, typename ITYPE >
272 typename ITERABLE::iterator case_insensitive_find_first_ends(ITERABLE & iterable, const ITYPE & lpcszSuffix, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr);
273
274 template < typename ITERABLE, typename ITYPE >
275 typename ITERABLE::iterator find_first_ends_eat(ITERABLE & iterable, ITYPE & str, const ITYPE & pcsz, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr);
276
277 template < typename ITERABLE, typename ITYPE >
278 typename ITERABLE::iterator case_insensitive_find_first_ends_eat(ITERABLE & iterable, ITYPE & str, const ITYPE & pcsz, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr);
279
280 template < typename ITERABLE, typename ITYPE >
281 typename ITERABLE::iterator find_first_begins(ITERABLE & iterable, const ITYPE & lpcszPrefix, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr);
282
283 template < typename ITERABLE, typename ITYPE >
284 typename ITERABLE::iterator case_insensitive_find_first_begins(ITERABLE & iterable, const ITYPE & lpcszPrefix, typename ITERABLE::iterator find = 0, typename ITERABLE::iterator last = nullptr);
285
286 template < typename ITERABLE, typename ITYPE >
287 typename ITERABLE::iterator find_first_begins_eat(ITERABLE & iterable, ITYPE & str, const ITYPE & pcsz, typename ITERABLE::iterator find = 0, typename ITERABLE::iterator last = nullptr);
288
289 template < typename ITERABLE, typename ITYPE >
290 typename ITERABLE::iterator case_insensitive_find_first_begins_eat(ITERABLE & iterable, ITYPE & str, const ITYPE & pcsz, typename ITERABLE::iterator find = 0, typename ITERABLE::iterator last = nullptr);
291
292 template < typename ITERABLE, typename ITYPE >
293 bool case_insensitive_contains(const ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator find, typename ITERABLE::iterator last = nullptr, ::collection::count countMin = 1, ::collection::count countMax = -1);
294
295 template < typename ITERABLE, typename ITYPE >
296 bool case_insensitive_icontains(const ITERABLE & iterable, const ITYPE & pcsz, index first, ::collection::count count = -1, ::collection::count countMin = 1, ::collection::count countMax = -1);
297
298 template < typename ITERABLE, typename STRITERABLE, typename ITYPE >
299 ::collection::count case_insensitive_get_begins(ITERABLE & iterable, STRITERABLE & stra, const ITYPE & pcsz, typename ITERABLE::iterator first = 0, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr);
300
301 template < typename ITERABLE, typename ITYPE >
302 ::collection::count case_insensitive_filter_begins(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator first = 0, typename ITERABLE::iterator last = nullptr);
303
304 template < typename ITERABLE, typename PRED >
305 ::collection::count filter(ITERABLE & iterable, PRED pred, typename ITERABLE::iterator first = 0, typename ITERABLE::iterator last = nullptr);
306
307 template < typename ITERABLE, typename PRED >
308 ::collection::count filter_out(ITERABLE & iterable, PRED pred, typename ITERABLE::iterator first = 0, typename ITERABLE::iterator last = nullptr);
309
310 template < typename ITERABLE, typename PRED, typename ArrayOut >
311 ::collection::count filter_out(ITERABLE & iterable, PRED pred, ArrayOut & a, typename ITERABLE::iterator first = 0, typename ITERABLE::iterator last = nullptr);
312
313 template < typename ITERABLE, typename ITYPE >
314 bool case_insensitive_erase_first(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr);
315
316 template < typename ITERABLE, typename ITYPE >
317 bool erase_first(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr);
318
319 template < typename ITERABLE >
320 void erase_first(ITERABLE & iterable);
321
322 template < typename ITERABLE, typename ITYPE >
323 bool case_insensitive_erase_last(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr);
324
325 template < typename ITERABLE, typename ITYPE >
326 bool erase_last(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr);
327
328 template < typename ITERABLE >
329 void erase_last(ITERABLE & iterable);
330
331 template < typename ITERABLE, typename ITYPE >
332 ::collection::count case_insensitive_erase(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator find, typename ITERABLE::iterator last, ::collection::count countMin, ::collection::count countMax = -1);
333
334 template < typename ITERABLE, typename ITYPE >
335 ::collection::count erase(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator find, typename ITERABLE::iterator last, ::collection::count countMin, ::collection::count countMax = -1);
336
337 template < typename ITERABLE, typename ITYPE >
338 ::collection::count case_insensitive_erase(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator find, typename ITERABLE::iterator last = nullptr);
339
340 template < typename ITERABLE, typename ITYPE >
341 ::collection::count erase(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator find, typename ITERABLE::iterator last = nullptr);
342
343 template < typename ITERABLE, typename ITYPE >
344 ::collection::count case_insensitive_erase(ITERABLE & iterable, const ITYPE & pcsz);
345
346 template < typename ITERABLE, typename ITYPE >
347 ::collection::count erase(ITERABLE & iterable, const ITYPE & pcsz);
348
349 template < typename ITERABLE, typename ITYPE >
350 ::collection::count case_insensitive_ierase(ITERABLE & iterable, const ITYPE & pcsz, index first = 0, ::collection::count count = -1);
351
352 template < typename ITERABLE, typename ITYPE >
353 ::collection::count ierase(ITERABLE & iterable, const ITYPE & pcsz, index first = 0, ::collection::count count = -1);
354
355 template < typename ITERABLE, typename ITYPE, typename ITYPE2 >
356 ITERABLE & explode(ITERABLE & iterable, const ITYPE & strSeparator, const ITYPE2 & str);
357
358 // csstidy: Same as explode, but not within a ITYPE
359 template < typename ITERABLE, typename ITYPE >
360 ITERABLE & csstidy_explode_ws(const ITERABLE & iterable, ::i8 sep, const ITYPE & psz);
361
362 template < typename ITERABLE, typename ITYPE >
363 void get_format_string(const ITERABLE & iterable, ITYPE & str, const ITYPE & lpcszSeparator);
364
365 template < typename ITERABLE, typename ITYPE, typename ITYPE2 >
366 ITERABLE & add_tokens(ITERABLE & iterable, const ITYPE & pcsz, const ITYPE2 & lpcszSeparator, bool bAddEmpty = true);
367
368 template < typename ITERABLE, typename ITYPE >
369 ITYPE encode_v16(const ITERABLE & iterable);
370
371 template < typename ITERABLE, typename ITYPE >
372 void decode_v16(ITERABLE & iterable, const ITYPE & psz);
373
374 template < typename ITERABLE, typename ITYPE >
375 ::collection::count get_count_except(const ITERABLE & iterable, const ITYPE & psz);
376
377 template < typename ITERABLE, typename ITYPE >
378 ::collection::count get_count_except(const ITERABLE & iterable, const ITYPE & str);
379
380 template < typename ITERABLE, typename ITERABLE2 >
381 ::collection::count get_count_except_iter(const ITERABLE & iterable, const ITERABLE & iterable2);
382
383 template < typename ITERABLE, typename ITYPE >
384 ::collection::count case_insensitive_get_count_except(const ITERABLE & iterable, const ITYPE & psz);
385
386 template < typename ITERABLE, typename ITYPE >
387 ::collection::count case_insensitive_get_count_except(const ITERABLE & iterable, const ITYPE & str);
388
389 template < typename ITERABLE, typename ITERABLE2 >
390 ::collection::count case_insensitive_get_count_except_iter(const ITERABLE & iterable, const ITERABLE & set);
391
392 template < typename ITERABLE, typename ITYPE >
393 ITYPE & get_network_payload(const ITERABLE & iterable, ITYPE & str, bool bNewLine = true);
394
395 template < typename ITERABLE, typename ITYPE >
396 void c_add(ITERABLE & iterable, char_pointer * ppsz, ::collection::count iCount);
397
398 template < typename ITERABLE, typename ITYPE >
399 void c_add(ITERABLE & iterable, char_pointer * ppsz);
400
401 template < typename ITERABLE, typename ITYPE >
402 void c_add(ITERABLE & iterable, wchar_t ** ppsz, ::collection::count iCount);
403
404 template < typename ITERABLE, typename ITYPE >
405 void c_add(ITERABLE & iterable, wchar_t ** ppsz);
406
407 template < typename ITERABLE, typename ITYPE >
408 bool contains(const ITERABLE & iterable, const ITYPE & value);
409
410 template < typename ITERABLE, typename ITYPE >
411 bool case_insensitive_contains(const ITERABLE & iterable, const ITYPE & value);
412
413
414
415
416 template < typename ITERABLE, typename ITYPE >
417 bool contains(const ITERABLE & iterable, const ITYPE & value)
418 {
419
420 for (auto & item : iterable)
421 {
422
423 if (item == value)
424 {
425
426 return true;
427
428 }
429
430 }
431
432 return false;
433
434 }
435
436
437 template < typename ITERABLE, typename ITYPE >
438 bool case_insensitive_contains(const ITERABLE & iterable, const ITYPE & value)
439 {
440
441 for (auto & item : iterable)
442 {
443
444 if (case_insensitive_ansi_compare(item, value) == 0)
445 {
446
447 return true;
448
449 }
450
451 }
452
453 return false;
454
455 }
456
457
458 template < typename ITERABLE, typename PAIR >
459 bool contains(ITERABLE & iterable, const set_node < PAIR > & assoc)
460 {
461
462 for (auto item : iterable1)
463 {
464
465 if (item == assoc.element1())
466 {
467
468 return true;
469
470 }
471
472 }
473
474 return false;
475
476 }
477
478
479 template < typename ITERABLE, typename ITERABLE2, typename PRED >
480 ITERABLE & intersect(ITERABLE & iterable, const ITERABLE2 & iterable2, PRED pred)
481 {
482
483 for (auto it = iterable.begin(); it != iterable.end();)
484 {
485
486 if (contains(iterable2, *it, pred))
487 {
488
489 iterable.erase_at(it);
490
491 }
492 else
493 {
494
495 it++;
496
497 }
498
499 }
500
501 return iterable;
502
503 }
504
505
506 template < typename ITERABLE1, typename ITERABLE2 >
507 ITERABLE1 & intersect(ITERABLE1 & iterable, const ITERABLE2 & iterable2)
508 {
509
510 for (auto it = iterable.begin(); it != iterable.end();)
511 {
512
513 if (contains(iterable2, *it))
514 {
515
516 iterable.erase(it);
517
518 }
519 else
520 {
521
522 it++;
523
524 }
525
526 }
527
528 return iterable;
529
530 }
531
532
533 template < typename ITERABLE, typename ITYPE >
534 typename ITYPE maximum(const ITERABLE & iterable, ITYPE maximum)
535 {
536
537 for (auto & item : iterable)
538 {
539
540 if (item > maximum)
541 {
542
543 maximum = item;
544
545 }
546
547 }
548
549 return maximum;
550
551 }
552
553
554 template < typename ITERABLE, typename ITYPE >
555 typename ITERABLE::iterator find_first_value(ITERABLE & iterable, const ITYPE & value)
556 {
557
558 auto it = iterable.begin();
559
560 for (; it != iterable.end(); it++)
561 {
562
563 if (it->element2() == value)
564 {
565
566 break;
567
568 }
569
570 }
571
572 return it;
573
574 }
575
576
577 template < typename ITERABLE, typename ITYPE >
578 typename ITERABLE::const_iterator find_first_value(const ITERABLE & iterable, const ITYPE & value)
579 {
580
581 auto it = iterable.begin();
582
583 for (; it != iterable.end(); it++)
584 {
585
586 if (it->element2() == value)
587 {
588
589 break;
590
591 }
592
593 }
594
595 return it;
596
597 }
598
599
600 template < typename ITERABLE >
601 typename ITERABLE::const_iterator find_first_value(const ITERABLE & iterable, const typename ITERABLE::PAYLOAD & value)
602 {
603
604 for (auto & item : iterable)
605 {
606
607 if (item.element2() == value)
608 {
609
610 return item;
611
612 }
613
614 }
615
616 return iterable.end();
617
618 }
619
620 template < typename ITERABLE, typename ITYPE >
621 bool contains_key(const ITERABLE & iterable, const ITYPE & value)
622 {
623
624 return iterable.find_first_key(value) != iterable.end();
625
626 }
627
628 template < typename ITERABLE, typename ITYPE >
629 bool contains_payload(const ITERABLE & iterable, const ITYPE & value)
630 {
631
632 return find_first_value(iterable, value) != iterable.end();
633
634 }
635
636
637 template < typename ITERABLE >
638 bool erase_first(ITERABLE & iterable, const typename ITERABLE::ITYPE & t)
639 {
640
641 auto find = find_first(iterable, t);
642
643 if (find != iterable.end())
644 {
645
646 iterable.erase(find);
647
648 return true;
649
650 }
651
652 return false;
653
654 }
655
656
657 template < typename ITERABLE >
658 bool erase_last(ITERABLE & iterable, const typename ITERABLE::ITYPE & t)
659 {
660
661 auto find = find_last(iterable, t);
662
663 if (find != iterable.end())
664 {
665
666 iterable.erase(find);
667
668 return true;
669
670 }
671
672 return false;
673 }
674
675
676 template < typename ITERABLE, typename ITYPE >
677 bool erase_first(ITERABLE & iterable, const ITYPE & t, typename ITERABLE::iterator first, typename ITERABLE::iterator last)
678 {
679
680 if ((first = find_first(iterable, t, first, last)) != iterable.end())
681 {
682
683 iterable.erase(first);
684
685 return true;
686
687 }
688
689 return false;
690
691 }
692
693
694 template < typename ITERABLE, typename ITYPE >
695 bool erase_last(ITERABLE & iterable, const ITYPE & t, typename ITERABLE::iterator first, typename ITERABLE::iterator last)
696 {
697
698 if ((first = find_last(iterable, t, first, last)) != iterable.end())
699 {
700
701 iterable.erase(first);
702
703 return true;
704
705 }
706
707 return false;
708
709 }
710
711
712 template < typename ITERABLE >
713 void erase_first(ITERABLE & iterable)
714 {
715
716 iterable.erase(iterable.begin());
717
718 }
719
720
721 template < typename ITERABLE >
722 void erase_last(ITERABLE & iterable)
723 {
724
725 iterable.erase(iterable.upper_bound());
726
727 }
728
729
730 template < typename ITERABLE, typename ITYPE >
731 bool case_insensitive_icontains(const ITERABLE & iterable, const ITYPE & t, index first, ::collection::count count, ::collection::count countMin, ::collection::count countMax)
732 {
733 ::collection::count c = 0;
734 while ((c < countMin || (countMax >= 0 && c <= countMax))
735 && (first = case_insensitive_ifind_first(iterable, t, first, count)) >= 0)
736 {
737 c++;
738 first++;
739 }
740 return c >= countMin && conditional(countMax >= 0, c <= countMax);
741 }
742
743
744 template < typename ITERABLE, typename ITYPE >
745 ::collection::index ifind_first(const ITERABLE & iterable, const ITYPE & t, index first, ::collection::count count)
746 {
747
748 iterable.iprepare_first_count(first, count);
749
750 for (; first < count; first++)
751 {
752
753 if (iterable.element_at(first) == t)
754 {
755
756 return first;
757
758 }
759
760 }
761
762 return -1;
763
764 }
765
766
767 template < typename ITERABLE, typename ITYPE >
768 bool icontains(const ITERABLE & iterable, const ITYPE & t, index first, ::collection::count count)
769 {
770
771 return ifind_first(iterable, t, first, count) >= 0;
772
773 }
774
775
776 template < typename ITERABLE, typename ITYPE >
777 bool contains(const ITERABLE & iterable, const ITYPE & t, typename ITERABLE::const_iterator find, typename ITERABLE::const_iterator last, ::collection::count countMin, ::collection::count countMax)
778 {
779 ::collection::count count = 0;
780 while ((count < countMin || (countMax >= 0 && count <= countMax))
781 && (find = find_first(iterable, t, find, last)) != iterable.end())
782 count++;
783 return count >= countMin && conditional(countMax >= 0, count <= countMax);
784 }
785
786
787
788 template < typename ITERABLE, typename ITYPE >
789 bool contains(ITERABLE & iterable, const ITYPE & t, typename ITERABLE::iterator find, typename ITERABLE::iterator last, ::collection::count countMin, ::collection::count countMax)
790 {
791 ::collection::count count = 0;
792 while ((count < countMin || (countMax >= 0 && count <= countMax))
793 && (find = find_first(iterable, t, find, last)) != iterable.end())
794 count++;
795 return count >= countMin && conditional(countMax >= 0, count <= countMax);
796 }
797
798
799 template < typename ITERABLE, typename ITYPE >
800 typename ITERABLE::const_iterator find_first(const ITERABLE & iterable, const ITYPE & t, typename ITERABLE::const_iterator find, typename ITERABLE::const_iterator last)
801 {
802
803 iterable.prepare_first_last(find, last);
804
805 for (; iterable.valid_iter(find, last); find++)
806 {
807
808 if (*find == t)
809 {
810
811 return find;
812
813 }
814
815 }
816
817 return iterable.end();
818
819 }
820
821
822 template < typename ITERABLE, typename ITYPE >
823 typename ITERABLE::iterator find_first(ITERABLE & iterable, const ITYPE & t, typename ITERABLE::iterator first, typename ITERABLE::iterator last)
824 {
825
826 iterable.prepare_first_last(first, last);
827
828 for (; iterable.valid_iter(first, last); find++)
829 {
830
831 if (*first == t)
832 {
833
834 return first;
835
836 }
837
838 }
839
840 return iterable.end();
841
842 }
843
844
845 template < typename ITERABLE, class ITYPE >
846 ::collection::count erase(ITERABLE & iterable, const ITYPE & t, typename ITERABLE::iterator first, typename ITERABLE::iterator last, ::collection::count countMin, ::collection::count countMax)
847 {
848 ::collection::count count = 0;
849 if (contains(iterable, t, first, last, countMin, countMax))
850 while (conditional(countMax >= 0, count < countMax) && erase_first(iterable, t, first, last))
851 count++;
852 return count;
853 }
854
855
856 template < typename ITERABLE, class ITYPE >
857 ::collection::count case_insensitive_erase(ITERABLE & iterable, const ITYPE & t, typename ITERABLE::iterator first, typename ITERABLE::iterator last, ::collection::count countMin, ::collection::count countMax)
858 {
859 ::collection::count count = 0;
860 if (case_insensitive_contains(iterable, t, first, last, countMin, countMax))
861 while (conditional(countMax >= 0, count < countMax) && case_insensitive_erase_first(iterable, t, first, last))
862 count++;
863 return count;
864 }
865
866
867 //template < typename ITERABLE, class ITYPE >
868 //::collection::count case_insensitive_erase(ITERABLE & iterable, const ITYPE & t, typename ITERABLE::iterator first, typename ITERABLE::iterator last)
869 //{
870
871 // ::collection::count c = 0;
872
873 // prepare_first_count(first, last);
874
875 // decltype(first) itRemove;
876
877 // for (; iterable.valid_iter(first, last);)
878 // {
879
880 // if (case_insensitive_ansi_compare(*first, t) == 0)
881 // {
882
883 // itRemove = first;
884
885 // first++;
886
887 // iterable.erase_at(itRemove);
888
889 // c++;
890
891 // }
892 // else
893 // {
894
895 // first++;
896
897 // }
898
899 // }
900
901 // return c;
902
903 //}
904
905
906 template < typename ITERABLE, class ITYPE >
907 ::collection::count erase(ITERABLE & iterable, const ITYPE & t, typename ITERABLE::iterator first, typename ITERABLE::iterator last)
908 {
909
910 ::collection::count c = 0;
911
912 prepare_first_count(first, last);
913
914 decltype(first) itRemove;
915
916 for (; iterable.valid_iter(first, last);)
917 {
918
919 if (*first == t)
920 {
921
922 itRemove = first;
923
924 first++;
925
926 iterable.erase_at(itRemove);
927
928 c++;
929
930 }
931 else
932 {
933
934 first++;
935
936 }
937
938 }
939
940 return c;
941
942 }
943
944
945 template < typename ITERABLE, class ITYPE >
946 ::collection::count case_insensitive_erase(ITERABLE & iterable, const ITYPE & t, typename ITERABLE::iterator first, typename ITERABLE::iterator last)
947 {
948
949 ::collection::count c = 0;
950
951 prepare_first_count(first, last);
952
953 decltype(first) itRemove;
954
955 for (; iterable.valid_iter(first, last);)
956 {
957
958 if (case_insensitive_ansi_compare(*first, t) == 0)
959 {
960
961 itRemove = first;
962
963 first++;
964
965 iterable.erase_at(itRemove);
966
967 c++;
968
969 }
970 else
971 {
972
973 first++;
974
975 }
976
977 }
978
979 return c;
980
981 }
982
983 template < typename ITERABLE, class ITYPE >
984 ::collection::count erase(ITERABLE & iterable, const ITYPE & t)
985 {
986
987 ::collection::count c = 0;
988
989 auto first = iterable.begin();
990
991 for (; iterable.valid_iter(first, iterable.end());)
992 {
993
994 if (*first == t)
995 {
996
997 iterable.erase(first);
998
999 c++;
1000
1001 }
1002 else
1003 {
1004
1005 first++;
1006
1007 }
1008
1009 }
1010
1011 return c;
1012
1013 }
1014
1015
1016 template < typename ITERABLE, class ITYPE >
1017 ::collection::count case_insensitive_erase(ITERABLE & iterable, const ITYPE & t)
1018 {
1019
1020 ::collection::count c = 0;
1021
1022 auto first = iterable.begin();
1023
1024 for (; iterable.valid_iter(first, iterable.end());)
1025 {
1026
1027 if (case_insensitive_ansi_compare(*first, t) == 0)
1028 {
1029
1030 itRemove = first;
1031
1032 first++;
1033
1034 iterable.erase_at(itRemove);
1035
1036 c++;
1037
1038 }
1039 else
1040 {
1041
1042 first++;
1043
1044 }
1045
1046 }
1047
1048 return c;
1049
1050 }
1051
1052
1053
1054 template < typename ITERABLE, class ITYPE >
1055 ::collection::count rerase(ITERABLE & iterable, const ITYPE & t, typename ITERABLE::iterator first, typename ITERABLE::iterator last, ::collection::count countMin, ::collection::count countMax)
1056 {
1057 ::collection::count count = 0;
1058 if (contains(iterable, t, first, last, countMin, countMax))
1059 while (conditional(countMax >= 0, count < countMax) && erase_last(iterable, t, first, last))
1060 count++;
1061 return count;
1062 }
1063
1064
1065 template < typename ITERABLE, typename ITERABLE2 >
1066 void copy(ITERABLE & iterable, const ITERABLE2 & iterable2)
1067 {
1068
1069 iterable.erase_all();
1070
1071 for (auto & item : iterable2)
1072 {
1073
1074 iterable.add(item);
1075
1076 }
1077
1078 }
1079
1080
1081 //template < typename ITERABLE, typename ITYPE >
1082 //bool contains_payload(const ITERABLE & map_base, const ITYPE & value)
1083 //{
1084
1085
1086 // auto it = map_base.begin();
1087
1088 // for (; it != map_base.end(); it++)
1089 // {
1090
1091 // if (it->element2() == value)
1092 // {
1093
1094 // return true;
1095
1096 // }
1097
1098 // }
1099
1100 // return false;
1101
1102 //}
1103
1104
1105
1106 //template < typename ITERABLE, typename ITYPE >
1107 //ITERABLE()
1108 //{
1109 //
1110 //
1111 //}
1112
1113 //template < typename ITERABLE, typename ITYPE >
1114 //ITERABLE(const ITERABLE & iterable)
1115 //{
1116 //
1117 // copy(iterable);
1118 //
1119 //}
1120
1121
1122 //template < typename ITERABLE, typename ITYPE >
1123 //template < typename ITERABLE >
1124 //ITERABLE(const ITERABLE & iterable)
1125 //{
1126 //
1127 // copy_iter(iterable);
1128 //
1129 //}
1130 //
1131
1132
1133 template < typename ITERABLE, typename ITYPE, typename ITYPE2 >
1134 void reverse_implode(const ITERABLE & iterable, ITYPE & str, const ITYPE2 & lpcszSeparator, typename ITERABLE::iterator first, ::collection::count last)
1135 {
1136
1137 str.empty();
1138
1139 string strSeparator(lpcszSeparator);
1140
1141 if (first == nullptr)
1142 {
1143
1144 first = begin();
1145
1146 }
1147
1148 if (last == nullptr)
1149 {
1150
1151 last = upper_bound();
1152
1153 }
1154
1155 if (last == )
1156
1157 for (auto i = last; i >= start; i--)
1158 {
1159
1160 if (i < last)
1161 {
1162 str += strSeparator;
1163 }
1164
1165 str += get_at(pos);
1166
1167 get_previous(pos);
1168
1169 }
1170
1171 }
1172
1173
1174
1175 template < typename ITERABLE, typename ITERABLE2 >
1176 ::collection::count case_insensitive_erase_iter(ITERABLE & iterable, const ITERABLE2 & iterable2)
1177 {
1178
1179 ::collection::count count = 0;
1180
1181 for (auto & item : iterable2)
1182 {
1183
1184 count += case_insensitive_erase(iterable, item);
1185
1186 }
1187
1188 return count;
1189
1190 }
1191
1192
1193 template < typename ITERABLE, typename ITERABLE2 >
1194 ::collection::count erase_iter(ITERABLE & iterable, const ITERABLE2 & iterable2)
1195 {
1196
1197 ::collection::count count = 0;
1198
1199 for (auto & item : iterable)
1200 {
1201
1202 count += erase(iterable, item);
1203
1204 }
1205
1206 return count;
1207
1208 }
1209
1210
1211
1212 template < typename ITERABLE, typename ITYPE, typename ITYPE2 >
1213 void implode(const ITERABLE & iterable, ITYPE & str, const ITYPE2 & lpcszSeparator, typename ITERABLE::const_iterator first, typename ITERABLE::const_iterator last)
1214 {
1215
1216 iterable.prepare_first_last(first, last);
1217
1218 str.empty();
1219
1220 ITYPE strSeparator(lpcszSeparator);
1221
1222 if (iterable.valid_iter(first, last))
1223 {
1224
1225 str = *first;
1226
1227 first++;
1228
1229 }
1230
1231 for (; iterable.valid_iter(first, last); first++)
1232 {
1233
1234 str += strSeparator;
1235
1236 str += *first;
1237
1238 }
1239
1240 }
1241
1242
1243
1244 //template < typename ITERABLE, typename ITYPE >
1245 //void reverse_implode(ITYPE & str, const ITYPE & lpcszSeparator, typename ITERABLE::iterator start, ::collection::count count)
1246 //{
1247 // str.empty();
1248 // ITYPE strSeparator(lpcszSeparator);
1249 // if (start < 0)
1250 // {
1251 // start += iterable.get_size();
1252 // }
1253 // typename ITERABLE::iterator last;
1254 // if (count < 0)
1255 // {
1256 // last = iterable.get_size() + count;
1257 // }
1258 // else
1259 // {
1260 // last = start + count - 1;
1261 // }
1262 // for (typename ITERABLE::iterator i = last; i >= start; i--)
1263 // {
1264 // if (i < last)
1265 // {
1266 // str += strSeparator;
1267 // }
1268 // str += iterable.element_at(i);
1269 // }
1270 //}
1271
1272
1273 //template < typename ITERABLE, typename ITYPE >
1274 //ITYPE reverse_implode(const ITYPE & lpcszSeparator, typename ITERABLE::iterator iStart, typename ITERABLE::iterator iEnd)
1275 //{
1276 // ITYPE str;
1277 // reverse_implode(str, lpcszSeparator, iStart, iEnd);
1278 // return str;
1279 //}
1280 //
1281
1282
1283
1284 //template < typename ITERABLE, typename ITERABLE >
1285 //bool is_equal (const ITERABLE & iterable, const ITERABLE2 & iterable2)
1286 //{
1287
1288 // if (iterable.get_count() != get_count())
1289 // {
1290
1291 // return false;
1292
1293 // }
1294
1295 // for (auto i = iterable.begin(), auto j = iterable.begin(); i < iterable.end(); i++, j++)
1296 // {
1297
1298 // if (*i != *j)
1299 // {
1300
1301 // return false;
1302
1303 // }
1304
1305 // }
1306
1307 // return true;
1308
1309 //}
1310
1311
1312 //template < typename ITERABLE, typename ITYPE >
1313 //template < typename ITERABLE >
1314 //bool operator != (const ITERABLE & iterable, const ITERABLE & iterable)
1315 //{
1316
1317 // return !operator == (iterable);
1318
1319 //}
1320
1321
1322
1323 template < typename ITERABLE, typename ITYPE >
1324 ::collection::count explode_command_line(ITERABLE & iterable, const ITYPE & str, char_pointer * argv)
1325 {
1326
1327 ITYPE strParse(str);
1328
1329 while (strParse.has_character())
1330 {
1331
1332 iterable.add((ITYPE)::str::consume_command_line_argument(strParse));
1333
1334 }
1335
1336 if (argv != nullptr)
1337 {
1338
1339 for (typename ITERABLE::iterator i = 0; i < get_count(); i++)
1340 {
1341
1342 char_pointer pch = (char_pointer )(const ITYPE &)element_at(i);
1343
1344 argv->add(pch);
1345
1346 }
1347
1348 argv->add(nullptr);
1349
1350 }
1351
1352 return get_count();
1353
1354
1355 }
1356
1357
1358
1359
1360 template < typename ITERABLE, typename ITYPE, typename ITERABLE2 >
1361 ITERABLE & add_shortest_tokens(ITERABLE & iterable, const ITYPE & pcsz, const ITERABLE2 & iterableSeparator, bool bAddEmpty, bool bWithSeparator)
1362 {
1363
1364 ::tokenizer strTokenizer(pcsz);
1365
1366 ITYPE strToken;
1367
1368 if (bAddEmpty)
1369 {
1370
1371 while (strTokenizer.next_shortest_token(strToken, iterableSeparator, bWithSeparator))
1372 {
1373
1374 iterable.add(strToken);
1375
1376 }
1377
1378 }
1379 else
1380 {
1381
1382 while (strTokenizer.next_shortest_token(strToken, iterableSeparator, bWithSeparator))
1383 {
1384
1385 if (!strToken.is_empty())
1386 {
1387
1388 iterable.add(strToken);
1389
1390 }
1391
1392 }
1393
1394 }
1395
1396 return iterable;
1397
1398 }
1399
1400
1401
1402 template < typename ITERABLE, typename ITYPE >
1403 ITERABLE & add_lines(ITERABLE & iterable, const ITYPE & strFindParam, bool bAddEmpty)
1404 {
1405
1406 typedef typename ITERABLE::BASE_TYPE STRING_TYPE;
1407
1408 STRING_TYPE str(strFindParam);
1409
1410 character_count iPos = 0;
1411
1412 character_count iFindA;
1413
1414 character_count iFindB;
1415
1416 character_count iFind1;
1417
1418 character_count iFind2;
1419
1420 do
1421 {
1422
1423 iFindA = str.find('\n', iPos);
1424
1425 if (iFindA < 0)
1426 goto r_only;
1427
1428 iFindB = str.find('\r', iPos);
1429
1430 if (iFindB < 0)
1431 goto n_only;
1432
1433 iFind1 = minimum(iFindA, iFindB);
1434
1435 iFind2 = maximum(iFindA, iFindB);
1436
1437 if (iFind1 > iPos)
1438 {
1439
1440 iterable.add((STRING_TYPE)STRING_TYPE(&str[iPos], iFind1 - iPos));
1441
1442 }
1443 else if (bAddEmpty)
1444 {
1445
1446 iterable.add(STRING_TYPE());
1447
1448 }
1449
1450 if (iFind2 - iFind1 == 1)
1451 {
1452
1453 iPos = iFind2 + 1;
1454
1455 }
1456 else
1457 {
1458
1459 iPos = iFind1 + 1;
1460
1461 }
1462
1463 }
1464 while (true);
1465
1466 goto end;
1467
1468n_only:
1469
1470 do
1471 {
1472
1473 iFindA = str.find('\n', iPos);
1474
1475 if (iFindA < 0)
1476 goto end;
1477
1478 if (iFindA > iPos)
1479 {
1480
1481 iterable.add((STRING_TYPE)STRING_TYPE(&str[iPos], iFindA - iPos));
1482
1483 }
1484 else if (bAddEmpty)
1485 {
1486
1487 iterable.add(STRING_TYPE());
1488
1489 }
1490
1491 iPos = iFindA + 1;
1492
1493
1494 }
1495 while (true);
1496 goto end;
1497r_only:
1498 do
1499 {
1500
1501 iFindB = str.find('\r', iPos);
1502
1503 if (iFindB < 0)
1504 goto end;
1505
1506 if (iFindB > iPos)
1507 {
1508
1509 iterable.add((STRING_TYPE)STRING_TYPE(&str[iPos], iFindB - iPos));
1510
1511 }
1512 else if (bAddEmpty)
1513 {
1514
1515 iterable.add(STRING_TYPE());
1516
1517 }
1518
1519 iPos = iFindB + 1;
1520
1521
1522 }
1523 while (true);
1524
1525end:
1526
1527 if (str.length() > iPos)
1528 {
1529
1530 iterable.add((STRING_TYPE)STRING_TYPE(&str[iPos], str.length() - iPos));
1531
1532 }
1533 else if (bAddEmpty)
1534 {
1535
1536 iterable.add(STRING_TYPE());
1537
1538 }
1539
1540 return iterable;
1541
1542 }
1543
1544
1545
1546
1547
1548 template < typename ITERABLE, typename ITYPE >
1549 void get_format_string(const ITERABLE & iterable, ITYPE & str, const ITYPE & lpcszSeparator)
1550 {
1551 str.empty();
1552 if (iterable.m_nSize > 0)
1553 {
1554 str = get_at(0);
1555 }
1556 for (::i32 i = 1; i < iterable.m_nSize; i++)
1557 {
1558 str += lpcszSeparator + get_at(i);
1559 }
1560 }
1561
1562
1563
1564
1565
1566
1567 /*void XFV001Expand()
1568 {
1569 ITERABLE strArray;
1570 u32_array dwa;
1571 for(::i32 i = 0; i < iterable.m_nSize; i++)
1572 {
1573 strArray.add_tokens(get_at(i), "/", false);
1574 if(strArray.get_size() > 1)
1575 {
1576 for(::i32 j = 0; j < strArray.get_size(); j++)
1577 {
1578 add_unique(strArray.get_at(j));
1579 }
1580 if(strArray.get_size() > 1)
1581 {
1582 dwa.add(i);
1583 }
1584 }
1585 strArray.erase_all();
1586 }
1587 for(i = dwa.get_size(); --i >= 0 ;)
1588 {
1589 erase_at(dwa.get_at(i));
1590 }
1591 Sort(Compare);
1592
1593 }*/
1594
1595
1596 template < typename ITERABLE, typename ITYPE >
1597 bool add_unique(ITERABLE & iterable, const ITYPE & str)
1598 {
1599
1600 if (::iter::contains(iterable, str))
1601 {
1602
1603 return false;
1604
1605 }
1606
1607 iterable.add((const ITYPE &)str);
1608
1609 return true;
1610
1611 }
1612
1613 template < typename ITERABLE, typename ITYPE >
1614 bool case_insensitive_add_unique(ITERABLE & iterable, const ITYPE & str)
1615 {
1616
1617 if (::iter::case_insensitive_contains(iterable, str))
1618 {
1619
1620 return false;
1621
1622 }
1623
1624 iterable.add((const ITYPE &)str);
1625
1626 return true;
1627
1628 }
1629
1630
1631
1632 template < typename ITERABLE, typename ITERABLE2 >
1633 ::collection::count add_unique_iter(ITERABLE & iterable, const typename ITERABLE2 & stra)
1634 {
1635
1636 ::collection::count count = 0;
1637
1638 for (auto & str : stra)
1639 {
1640
1641 if (iterable.add_unique(str))
1642 {
1643
1644 count++;
1645
1646 }
1647
1648 }
1649
1650 return count;
1651
1652 }
1653
1654
1655 template < typename ITERABLE, typename ITERABLE2 >
1656 ::collection::count case_insensitive_add_unique_iter(ITERABLE & iterable, const typename ITERABLE2 & iterable2)
1657 {
1658
1659 ::collection::count count = 0;
1660
1661 for (auto & str : iterable2)
1662 {
1663
1664 if (iterable.case_insensitive_add_unique(str) != iterable.end())
1665 {
1666
1667 count++;
1668
1669 }
1670
1671 }
1672
1673 return count;
1674
1675 }
1676
1677 template < typename ITERABLE, typename PRED>
1678 bool predicate_erase_first(ITERABLE & iterable, PRED pred)
1679 {
1680
1681 auto it = predicate_find_first(iterable, pred);
1682
1683 if (it == iterable.end())
1684 {
1685
1686 return false;
1687
1688 }
1689
1690 iterable.erase(it);
1691
1692 return true;
1693
1694 }
1695
1696 template < typename ITERABLE, typename PRED >
1697 typename ITERABLE::const_iterator predicate_find_first(const ITERABLE & iterable, PRED pred, typename ITERABLE::const_iterator first, typename ITERABLE::const_iterator last)
1698 {
1699
1700 iterable.prepare_first_last(first, last);
1701
1702 for (; iterable.valid_iter(first, last); first++)
1703 {
1704
1705 if (pred(*first))
1706 {
1707
1708 break;
1709
1710 }
1711
1712 }
1713
1714 return first;
1715
1716 }
1717
1718
1719 template < typename ITERABLE, typename PRED >
1720 typename ITERABLE::iterator predicate_find_first(ITERABLE & iterable, PRED pred, typename ITERABLE::iterator first, typename ITERABLE::iterator last)
1721 {
1722
1723 iterable.prepare_first_last(first, last);
1724
1725 for (; iterable.valid_iter(first, last); first++)
1726 {
1727
1728 if (pred(*first))
1729 {
1730
1731 break;
1732
1733 }
1734
1735 }
1736
1737 return first;
1738
1739 }
1740
1741
1742 //template<class ITYPE, class ARG_ITYPE>
1743 //void list_base<ITYPE, ARG_ITYPE>::erase(iterator & it)
1744 //{
1745 //
1746 // this->erase_at(it);
1747
1748 //}
1749
1750
1751 template < typename ITERABLE, typename ITYPE >
1752 typename index case_insensitive_ifind_first(const ITERABLE & iterable, const ITYPE & pcsz, index first, ::collection::count count)
1753 {
1754
1755 iterable.iprepare_first_count(first, count);
1756
1757 for (; first < count; first++)
1758 {
1759
1760 if (case_insensitive_ansi_compare(iterable.element_at(first), pcsz) == 0)
1761 {
1762
1763 return first;
1764
1765 }
1766
1767 }
1768
1769 return -1;
1770
1771 }
1772
1773
1774 template < typename ITERABLE, typename ITYPE >
1775 typename index ifind_first_begins(const ITERABLE & iterable, const ITYPE & pcsz, index first, ::collection::count count)
1776 {
1777
1778 iterable.iprepare_first_count(first, count);
1779
1780 for (; first < count; find++)
1781 {
1782
1783 if (string_begins(iterable.element_at(first), pcsz))
1784 {
1785
1786 return first;
1787
1788 }
1789
1790 }
1791
1792 return -1;
1793
1794 }
1795
1796 template < typename ITERABLE, typename ITYPE >
1797 typename index case_insensitive_ifind_first_begins(const ITERABLE & iterable, const ITYPE & pcsz, index first, ::collection::count count)
1798 {
1799
1800 iterable.iprepare_first_count(first, count);
1801
1802 for (; first < count; find++)
1803 {
1804
1805 if (case_insensitive_string_begins(iterable.element_at(first), pcsz))
1806 {
1807
1808 return first;
1809
1810 }
1811
1812 }
1813
1814 return -1;
1815
1816 }
1817
1818
1819
1820 //template < typename ITERABLE, typename ITYPE >
1821 //index case_insensitive_ifind_first(const ITERABLE & iterable, const ITYPE & pcsz, ::collection::index find, ::collection::count count)
1822 //{
1823 // if (find < 0)
1824 // find += iterable.get_count();
1825 // if (last < 0)
1826 // last += iterable.get_count();
1827 // for (; find <= last; find++)
1828 // {
1829 // if (iterable.element_at(find).CompareNoCase(pcsz) == 0)
1830 // return find;
1831 // }
1832 // return -1;
1833 //}
1834
1835
1836 //template < typename ITERABLE, typename ITYPE >
1837 //typename ITERABLE::const_iterator find_first(const ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::const_iterator find, typename ITERABLE::const_iterator last)
1838 //{
1839 // return ::iter::find_first(iterable, pcsz, find, last);
1840 //}
1841
1842 template < typename ITERABLE, typename ITYPE >
1843 typename ITERABLE::const_iterator case_insensitive_find_last(const ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::const_iterator first, typename ITERABLE::const_iterator last)
1844 {
1845
1846 return case_insensitive_reverse_find(pcsz, first, last);
1847
1848 }
1849
1850
1851 template < typename ITERABLE, typename ITYPE >
1852 typename ITERABLE::const_iterator find_last(const ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::const_iterator first, typename ITERABLE::const_iterator last)
1853 {
1854
1855 return rear_find(pcsz, first, last);
1856
1857 }
1858
1859
1860
1861 template < typename ITERABLE, typename ITYPE >
1862 typename ITERABLE::const_iterator case_insensitive_reverse_find(const ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::const_iterator first, typename ITERABLE::const_iterator last)
1863 {
1864
1865 iterable.rprepare_first_last(first, last);
1866
1867 for (; iterable.rvalid_iter(first, last); first--)
1868 {
1869
1870 if (case_insensitive_ansi_compare(*first, pcsz) == 0)
1871 {
1872
1873 return find;
1874
1875 }
1876
1877 }
1878
1879 return iterable.end();
1880
1881 }
1882
1883
1884 template < typename ITERABLE, typename ITYPE >
1885 typename ITERABLE::const_iterator rear_find(const ITERABLE & iterable, const ITYPE & value, typename ITERABLE::const_iterator first, typename ITERABLE::const_iterator last)
1886 {
1887
1888 iterable.rprepare_first_last(first, last);
1889
1890 for (; iterable.rvalid_iter(first, last); first--)
1891 {
1892
1893 if (*first == value)
1894 {
1895
1896 return first;
1897
1898 }
1899
1900 }
1901
1902 return iterable.end();
1903 }
1904
1905
1906
1907
1908 template < typename ITERABLE, typename ITYPE >
1909 typename ITERABLE::const_iterator find_first_ends(const ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::const_iterator first, typename ITERABLE::const_iterator last)
1910 {
1911
1912 iterable.prepare_first_last(first, last);
1913
1914 for (; iterable.valid_iter(first, last); first++)
1915 {
1916
1917 if (string_ends(*first, pcsz))
1918 {
1919
1920 return first;
1921
1922 }
1923
1924 }
1925
1926 return iterable.end();
1927
1928 }
1929
1930 template < typename ITERABLE, typename ITYPE >
1931 typename ITERABLE::const_iterator case_insensitive_find_first_ends(const ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::const_iterator find, typename ITERABLE::const_iterator last)
1932 {
1933
1934 iterable.prepare_first_last(first, last);
1935
1936 for (; iterable.valid_iter(first, last); first++)
1937 {
1938
1939 if (case_insensitive_string_ends(*first, pcsz))
1940 {
1941
1942 return first;
1943
1944 }
1945
1946 }
1947
1948 return iterable.end();
1949
1950 }
1951
1952
1953
1954 template < typename ITERABLE, typename ITYPE >
1955 typename ITERABLE::const_iterator find_first_ends_eat(ITERABLE & iterable, string & str, const ITYPE & pcsz, typename ITERABLE::const_iterator first, typename ITERABLE::const_iterator last)
1956 {
1957
1958 first = find_first_ends(pcsz, first, last);
1959
1960 if (first == iterable.end())
1961 return first;
1962
1963 str = first->Left(first->length() - ansi_length(pcsz));
1964
1965 return find;
1966
1967 }
1968
1969
1970
1971 template < typename ITERABLE, typename ITYPE >
1972 typename ITERABLE::const_iterator case_insensitive_find_first_ends_eat(ITERABLE & iterable, string & str, const ITYPE & pcsz, typename ITERABLE::const_iterator find, typename ITERABLE::const_iterator last)
1973 {
1974
1975 find = case_insensitive_find_first_ends(pcsz, find, last);
1976
1977 if (find < 0)
1978 return find;
1979
1980 str = element_at(find).left(element_at(find).length() - strlen(pcsz));
1981
1982 return find;
1983
1984 }
1985
1986
1987
1988 template < typename ITERABLE, typename ITYPE >
1989 typename ITERABLE::const_iterator find_first_begins(const ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::const_iterator find, typename ITERABLE::const_iterator last)
1990 {
1991 if (find < 0)
1992 find += iterable.get_count();
1993 if (last < 0)
1994 last += iterable.get_count();
1995 for (; find < iterable.get_count(); find++)
1996 {
1997 if (string_begins(iterable.element_at(find), pcsz))
1998 return find;
1999 }
2000 return -1;
2001 }
2002
2003
2004 template < typename ITERABLE, typename ITYPE >
2005 typename ITERABLE::const_iterator case_insensitive_find_first_begins(const ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::const_iterator first, typename ITERABLE::const_iterator last)
2006 {
2007
2008 iterable.prepare_first_last(first, last);
2009
2010 for(; iterable.valid_iter(first, last); first++)
2011 {
2012
2013 if (case_insensitive_string_begins(*first, pcsz))
2014 return first;
2015
2016 }
2017
2018 return iterable.end();
2019
2020 }
2021
2022
2023 template < typename ITERABLE, typename ITYPE >
2024 typename ITERABLE::const_iterator find_first_begins_eat(ITERABLE & iterable, string & str, const ITYPE & pcsz, typename ITERABLE::const_iterator find, typename ITERABLE::const_iterator last)
2025 {
2026
2027 find = find_first_begins(pcsz, find, last);
2028
2029 if (find < 0)
2030 return find;
2031
2032 str = element_at(find).substr(strlen(pcsz));
2033
2034 return find;
2035
2036 }
2037
2038
2039
2040 template < typename ITERABLE, typename ITYPE >
2041 typename ITERABLE::const_iterator case_insensitive_find_first_begins_eat(ITERABLE & iterable, string & str, const ITYPE & pcsz, typename ITERABLE::const_iterator find, typename ITERABLE::const_iterator last)
2042 {
2043
2044 find = case_insensitive_find_first_begins(pcsz, find, last);
2045
2046 if (find < 0)
2047 return find;
2048
2049 str = element_at(find).substr(strlen(pcsz));
2050
2051 return find;
2052
2053 }
2054
2055
2056 template < typename ITERABLE, typename ITYPE >
2057 typename ITERABLE::const_iterator any_suffixes(const ITERABLE & iterable, const ITYPE & lpcszIdSuffixed, typename ITERABLE::const_iterator find, typename ITERABLE::const_iterator last)
2058 {
2059
2060 if (find < 0)
2061 find += iterable.get_count();
2062 if (last < 0)
2063 last += iterable.get_count();
2064 for (; find < iterable.get_count(); find++)
2065 {
2066 if (string_ends(lpcszIdSuffixed, iterable.element_at(find)))
2067 return find;
2068 }
2069 return -1;
2070 }
2071
2072
2073 template < typename ITERABLE, typename ITYPE >
2074 typename ITERABLE::const_iterator any_case_insensitive_suffixes(const ITERABLE & iterable, const ITYPE & lpcszIdSuffixed, typename ITERABLE::const_iterator find, typename ITERABLE::const_iterator last)
2075 {
2076
2077 iterable.prepare_first_last(first, last);
2078
2079 for (; iterable.valid_iter(find, last); find++)
2080 {
2081
2082 if (case_insensitive_string_ends(lpcszIdSuffixed, *find))
2083 {
2084
2085 return find;
2086
2087 }
2088
2089 }
2090
2091 return find;
2092
2093 }
2094
2095
2096 template < typename ITERABLE, typename ITYPE >
2097 typename ITERABLE::const_iterator any_prefixes(const ITERABLE & iterable, const ITYPE & lpcszIdPrefixed, typename ITERABLE::const_iterator find, typename ITERABLE::const_iterator last)
2098 {
2099
2100 if (find < 0)
2101 find += iterable.get_count();
2102 if (last < 0)
2103 last += iterable.get_count();
2104 for (; find < iterable.get_count(); find++)
2105 {
2106 if (string_begins(lpcszIdPrefixed, iterable.element_at(find)))
2107 return find;
2108 }
2109 return -1;
2110 }
2111
2112
2113 template < typename ITERABLE, typename ITYPE >
2114 typename ITERABLE::const_iterator case_insensitive_any_prefixes(const ITERABLE & iterable, const ITYPE & lpcszIdPrefixed, typename ITERABLE::const_iterator find, typename ITERABLE::const_iterator last)
2115 {
2116
2117 if (find < 0)
2118 find += iterable.get_count();
2119 if (last < 0)
2120 last += iterable.get_count();
2121 for (; find < iterable.get_count(); find++)
2122 {
2123 if (case_insensitive_string_begins(lpcszIdPrefixed, iterable.element_at(find)))
2124 return find;
2125 }
2126 return -1;
2127 }
2128
2129
2130 template < typename ITERABLE, typename ITYPE >
2131 typename index find_first_begins(ITERABLE & iterable, const ITYPE & pcsz, ::collection::index find, ::collection::count count)
2132 {
2133
2134 iterable.iprepare_first_count(find, count);
2135
2136 for (; find < count; find++)
2137 {
2138
2139 if (string_begins(iterable.element_at(find), pcsz))
2140 {
2141
2142 return find;
2143
2144 }
2145
2146 }
2147
2148 return -1;
2149
2150 }
2151
2152 template < typename ITERABLE, typename ITYPE >
2153 typename index case_insensitive_find_first_begins(ITERABLE & iterable, const ITYPE & pcsz, ::collection::index find, ::collection::count count)
2154 {
2155
2156 iterable.iprepare_first_count(find, count);
2157
2158 for (; find < count; find++)
2159 {
2160
2161 if (case_insensitive_string_begins(iterable.element_at(find), pcsz))
2162 {
2163
2164 return find;
2165
2166 }
2167
2168 }
2169
2170 return -1;
2171
2172 }
2173
2174
2175
2176 template < typename ITERABLE, typename ITYPE >
2177 ::collection::index case_insensitive_find_first(ITERABLE & iterable, const ITYPE & pcsz, ::collection::index find, ::collection::count count)
2178 {
2179 if (find < 0)
2180 find += iterable.get_count();
2181 if (last < 0)
2182 last += iterable.get_count();
2183 for (; find <= last; find++)
2184 {
2185 if (iterable.element_at(find).CompareNoCase(pcsz) == 0)
2186 return find;
2187 }
2188 return -1;
2189 }
2190
2191
2192 //template < typename ITERABLE, typename ITYPE >
2193 //typename ITERABLE::iterator find_first(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator find, typename ITERABLE::iterator last)
2194 //{
2195 // return ::iter::find_first(iterable, pcsz, find, last);
2196 //}
2197
2198 template < typename ITERABLE, typename ITYPE >
2199 typename ITERABLE::iterator case_insensitive_find_last(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator find, typename ITERABLE::iterator last)
2200 {
2201 return case_insensitive_reverse_find(pcsz, find, last);
2202 }
2203
2204
2205 template < typename ITERABLE, typename ITYPE >
2206 typename ITERABLE::iterator find_last(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator find, typename ITERABLE::iterator last)
2207 {
2208 return rear_find(pcsz, find, last);
2209 }
2210
2211
2212
2213 template < typename ITERABLE, typename ITYPE >
2214 typename ITERABLE::iterator case_insensitive_reverse_find(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator find, typename ITERABLE::iterator last)
2215 {
2216 if (find < 0)
2217 find += iterable.get_count();
2218 if (last < 0)
2219 last += iterable.get_count();
2220 for (; find >= last; find--)
2221 {
2222 if (iterable.element_at(find).CompareNoCase(pcsz) == 0)
2223 return find;
2224 }
2225 return -1;
2226 }
2227
2228
2229 template < typename ITERABLE, typename ITYPE >
2230 typename ITERABLE::iterator rear_find(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator find, typename ITERABLE::iterator last)
2231 {
2232 if (find < 0)
2233 find += iterable.get_count();
2234 if (last < 0)
2235 last += iterable.get_count();
2236 for (; find >= last; find--)
2237 {
2238 if (iterable.element_at(find).Compare(pcsz) == 0)
2239 return find;
2240 }
2241 return -1;
2242 }
2243
2244
2245
2246
2247 template < typename ITERABLE, typename ITYPE >
2248 typename ITERABLE::iterator find_first_ends(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator find, typename ITERABLE::iterator last)
2249 {
2250 if (find < 0)
2251 find += iterable.get_count();
2252 if (last < 0)
2253 last += iterable.get_count();
2254 for (; find < iterable.get_count(); find++)
2255 {
2256 if (string_ends(iterable.element_at(find), pcsz))
2257 return find;
2258 }
2259 return -1;
2260 }
2261
2262 template < typename ITERABLE, typename ITYPE >
2263 typename ITERABLE::iterator case_insensitive_find_first_ends(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator find, typename ITERABLE::iterator last)
2264 {
2265 if (find < 0)
2266 find += iterable.get_count();
2267 if (last < 0)
2268 last += iterable.get_count();
2269 for (; find < iterable.get_count(); find++)
2270 {
2271 if (case_insensitive_string_ends(iterable.element_at(find), pcsz))
2272 return find;
2273 }
2274 return -1;
2275 }
2276
2277
2278
2279 template < typename ITERABLE, typename ITYPE >
2280 typename ITERABLE::iterator find_first_ends_eat(ITERABLE & iterable, string & str, const ITYPE & pcsz, typename ITERABLE::iterator find, typename ITERABLE::iterator last)
2281 {
2282
2283 find = find_first_ends(pcsz, find, last);
2284
2285 if (find < 0)
2286 return find;
2287
2288 str = element_at(find).left(element_at(find).length() - strlen(pcsz));
2289
2290 return find;
2291
2292 }
2293
2294
2295
2296 template < typename ITERABLE, typename ITYPE >
2297 typename ITERABLE::iterator case_insensitive_find_first_ends_eat(ITERABLE & iterable, string & str, const ITYPE & pcsz, typename ITERABLE::iterator find, typename ITERABLE::iterator last)
2298 {
2299
2300 find = case_insensitive_find_first_ends(pcsz, find, last);
2301
2302 if (find < 0)
2303 return find;
2304
2305 str = element_at(find).left(element_at(find).length() - strlen(pcsz));
2306
2307 return find;
2308
2309 }
2310
2311
2312
2313 template < typename ITERABLE, typename ITYPE >
2314 typename ITERABLE::iterator find_first_begins(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator find, typename ITERABLE::iterator last)
2315 {
2316 if (find < 0)
2317 find += iterable.get_count();
2318 if (last < 0)
2319 last += iterable.get_count();
2320 for (; find < iterable.get_count(); find++)
2321 {
2322 if (string_begins(iterable.element_at(find), pcsz))
2323 return find;
2324 }
2325 return -1;
2326 }
2327
2328
2329 template < typename ITERABLE, typename ITYPE >
2330 typename ITERABLE::iterator case_insensitive_find_first_begins(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator first, typename ITERABLE::iterator last)
2331 {
2332
2333 iterable.prepare_first_last(first, last);
2334
2335 for (; iterable.valid_iter(first, last); first++)
2336 {
2337
2338 if (case_insensitive_string_begins(*first, pcsz))
2339 return first;
2340
2341 }
2342
2343 return iterable.end();
2344
2345 }
2346
2347
2348 template < typename ITERABLE, typename ITYPE >
2349 typename ITERABLE::iterator find_first_begins_eat(ITERABLE & iterable, string & str, const ITYPE & pcsz, typename ITERABLE::iterator find, typename ITERABLE::iterator last)
2350 {
2351
2352 find = find_first_begins(pcsz, find, last);
2353
2354 if (find < 0)
2355 return find;
2356
2357 str = element_at(find).substr(strlen(pcsz));
2358
2359 return find;
2360
2361 }
2362
2363
2364
2365 template < typename ITERABLE, typename ITYPE >
2366 typename ITERABLE::iterator case_insensitive_find_first_begins_eat(ITERABLE & iterable, string & str, const ITYPE & pcsz, typename ITERABLE::iterator find, typename ITERABLE::iterator last)
2367 {
2368
2369 find = case_insensitive_find_first_begins(pcsz, find, last);
2370
2371 if (find < 0)
2372 return find;
2373
2374 str = element_at(find).substr(strlen(pcsz));
2375
2376 return find;
2377
2378 }
2379
2380
2381 template < typename ITERABLE, typename ITYPE >
2382 typename ITERABLE::iterator any_suffixes(ITERABLE & iterable, const ITYPE & lpcszIsSuffixed, typename ITERABLE::iterator find, typename ITERABLE::iterator last)
2383 {
2384
2385 iterable.prepare_first_last(first, last);
2386
2387 for (; iterable.valid_iter(first, last); first++)
2388 {
2389
2390 if (string_ends(lpcszIsSuffixed, *first))
2391 {
2392
2393 return first;
2394
2395 }
2396
2397 }
2398
2399 return iterable.end();
2400
2401 }
2402
2403
2404 template < typename ITERABLE, typename ITYPE >
2405 typename ITERABLE::iterator any_case_insensitive_suffixes(ITERABLE & iterable, const ITYPE & lpcszIsSuffixed, typename ITERABLE::iterator first, typename ITERABLE::iterator last)
2406 {
2407
2408 iterable.prepare_first_last(first, last);
2409
2410 for (; iterable.valid_iter(first, last); first++)
2411 {
2412
2413 if (case_insensitive_string_ends(lpcszIsSuffixed, *first))
2414 {
2415
2416 return first;
2417
2418 }
2419
2420 }
2421
2422 return iterable.end();
2423
2424 }
2425
2426
2427 template < typename ITERABLE, typename ITYPE >
2428 typename ITERABLE::iterator any_prefixes(ITERABLE & iterable, const ITYPE & lpcszIsPrefixed, typename ITERABLE::iterator find, typename ITERABLE::iterator last)
2429 {
2430
2431 iterable.prepare_first_last(first, last);
2432
2433 for (; iterable.valid_iter(first, last); first++)
2434 {
2435
2436 if (string_begins(lpcszIsPrefixed, *first))
2437 {
2438
2439 return first;
2440
2441 }
2442
2443 }
2444
2445 return iterable.end();
2446
2447 }
2448
2449
2450 template < typename ITERABLE, typename ITYPE >
2451 typename ITERABLE::iterator case_insensitive_any_prefixes(ITERABLE & iterable, const ITYPE & lpcszIsPrefixed, typename ITERABLE::iterator find, typename ITERABLE::iterator last)
2452 {
2453
2454 iterable.prepare_first_last(first, last);
2455
2456 for (; iterable.valid_iter(first, last); first++)
2457 {
2458
2459 if (case_insensitive_string_begins(lpcszIsPrefixed, *first))
2460 {
2461
2462 return first;
2463
2464 }
2465
2466 }
2467
2468 return iterable.end();
2469
2470 }
2471
2472
2473
2474 template < typename ITERABLE, typename ITYPE >
2475 typename ITERABLE::iterator case_insensitive_erase_first(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator first, typename ITERABLE::iterator last)
2476 {
2477
2478 if ((first = case_insensitive_find_first(pcsz, first, last)) == iterable.end())
2479 {
2480
2481 return false;
2482
2483 }
2484
2485 iterable.erase(first);
2486
2487 return true;
2488
2489 }
2490
2491
2492 template < typename ITERABLE, typename ITYPE >
2493 typename ITERABLE::iterator case_insensitive_erase_last(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator first, typename ITERABLE::iterator last)
2494 {
2495
2496 if ((first = case_insensitive_find_last(pcsz, first, last)) == iterable.end())
2497 {
2498
2499 return false;
2500
2501 }
2502
2503 iterable.erase(first);
2504
2505 return true;
2506
2507 }
2508
2509
2510 template < typename ITERABLE, typename ITYPE >
2511 typename ITERABLE::iterator erase_last(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator find, typename ITERABLE::iterator last)
2512 {
2513
2514 if ((find = find_last(pcsz, find, last)) == iterable.end())
2515 {
2516
2517 return false;
2518
2519 }
2520
2521 iterable.erase_at(find);
2522
2523 return true;
2524
2525 }
2526
2527
2528 template < typename ITERABLE, typename ITYPE >
2529 ITERABLE & trim_left(ITERABLE & iterable, const ITYPE & pszChars)
2530 {
2531
2532 for (auto & item : iterable)
2533 {
2534
2535 item.trim_left(scopedstrChars);
2536
2537 }
2538
2539 return iterable;
2540
2541 }
2542
2543
2544 template < typename ITERABLE, typename ITYPE >
2545 ITERABLE & trim_right(ITERABLE & iterable, const ITYPE & pszChars)
2546 {
2547
2548 for (auto & item : iterable)
2549 {
2550
2551 item.trim_right(scopedstrChars);
2552
2553 }
2554
2555 return iterable;
2556
2557 }
2558
2559
2560 template < typename ITERABLE, typename ITYPE >
2561 ITERABLE & trim(ITERABLE & iterable, const ITYPE & pszChars)
2562 {
2563
2564 for (auto & item : iterable)
2565 {
2566
2567 item.trim(scopedstrChars);
2568
2569 }
2570
2571 return iterable;
2572
2573 }
2574
2575
2576
2577 template < typename ITERABLE >
2578 ITERABLE & trim_left(ITERABLE & iterable)
2579 {
2580
2581 for (auto & item : iterable)
2582 {
2583
2584 item.trim_left();
2585
2586 }
2587
2588 return iterable;
2589
2590 }
2591
2592
2593 template < typename ITERABLE >
2594 ITERABLE & trim_right(ITERABLE & iterable)
2595 {
2596
2597 for (auto & item : iterable)
2598 {
2599
2600 item.trim_right();
2601
2602 }
2603
2604 return iterable;
2605
2606 }
2607
2608
2609 template < typename ITERABLE >
2610 ITERABLE & trim(ITERABLE & iterable)
2611 {
2612
2613 for (auto & item : iterable)
2614 {
2615
2616 item.trim();
2617
2618 }
2619
2620 return iterable;
2621
2622 }
2623
2624
2625 //template < typename ITERABLE, typename ITYPE >
2626 //typename ITERABLE::iterator add_normal(const ITYPE & pcsz)
2627 //{
2628
2629 // return ITERABLE::add(pcsz);
2630
2631 //}
2632
2633
2634 template < typename ITERABLE >
2635 ::collection::count erase_empty(ITERABLE & iterable)
2636 {
2637
2638 ::collection::count count = 0;
2639
2640 for (auto it = iterable.begin(); iterable.valid_iter(it, iterable.end());)
2641 {
2642
2643 if (it->is_empty())
2644 {
2645
2646 iterable.erase(it);
2647
2648 count++;
2649 }
2650 else
2651 {
2652
2653 it++;
2654
2655 }
2656
2657 }
2658
2659 return count;
2660
2661 }
2662
2663
2664
2665
2666
2667
2668
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679
2680 template < typename ITERABLE, typename ITYPESEP, typename ITYPE2 >
2681 ITERABLE & explode(ITERABLE & iterable, const ITYPESEP & strSeparator, const ITYPE2 & str)
2682 {
2683
2684 iterable.erase_all();
2685
2686 return add_tokens(iterable, str, strSeparator, true);
2687
2688 }
2689
2690 template < typename ITERABLE, typename ITYPE, typename ITYPESEP >
2691 ITERABLE & add_tokens(ITERABLE & iterable, const ITYPE & pcsz, const ITYPESEP & lpcszSeparator, bool bAddEmpty)
2692 {
2693
2694 ::tokenizer strTokenizer(pcsz);
2695
2696 string strToken;
2697
2698 if (bAddEmpty)
2699 {
2700
2701 while (strTokenizer.next_token(strToken, lpcszSeparator, false))
2702 {
2703
2704 iterable.add(strToken);
2705
2706 }
2707
2708 }
2709 else
2710 {
2711
2712 while (strTokenizer.next_token(strToken, lpcszSeparator, false))
2713 {
2714
2715 if (!strToken.is_empty())
2716 {
2717
2718 iterable.add(strToken);
2719
2720 }
2721
2722 }
2723
2724 }
2725
2726 return iterable;
2727
2728 }
2729
2730
2731
2732 template < typename ITERABLE, typename ITYPE >
2733 ITERABLE & csstidy_explode_ws(ITERABLE & iterable, ::i8 sep, const ITYPE & psz)
2734 {
2735
2736 ITYPE istring(scopedstr);
2737
2738 // 1 = st // 2 = str
2739 ::i32 status = 1;
2740 ::i8 to = '\0';
2741
2742 add("");
2743 character_count num = 0;
2744 character_count len = istring.length();
2745 for (character_count i = 0; i < len; i++)
2746 {
2747
2748 switch (status)
2749 {
2750 case 1:
2751 if (istring[i] == sep && !::str::simple_escaped(istring, i))
2752 {
2753 ++num;
2754 add("");
2755 }
2756 else if ((istring[i] == '"' || istring[i] == '\'' || istring[i] == '(') && !::str::simple_escaped(istring, i))
2757 {
2758 status = 2;
2759 to = (istring[i] == '(') ? ')' : istring[i];
2760 element_at(num) += (ITYPE)ITYPE(istring[i]);
2761 }
2762 else
2763 {
2764 element_at(num) += (ITYPE)ITYPE(istring[i]);
2765 }
2766 break;
2767
2768 case 2:
2769 if (istring[i] == to && !::str::simple_escaped(istring, i))
2770 {
2771 status = 1;
2772 }
2773 element_at(num) += (ITYPE)ITYPE(istring[i]);
2774 break;
2775 }
2776
2777 }
2778
2779 return iterable;
2780
2781 }
2782
2783
2784
2785
2786 template < typename ITERABLE, typename ITYPE >
2787 void replace(ITERABLE & iterable, const ITYPE & lpszSearch, const ITYPE & lpszReplace)
2788 {
2789
2790 for (::i32 i = 0; i < iterable.get_size(); i++)
2791 {
2792
2793 iterable.element_at(i).replace(lpszSearch, lpszReplace);
2794
2795 }
2796
2797 }
2798
2799 template < typename ITERABLE, typename ITERABLE2, typename ITYPE >
2800 void prefix(ITERABLE & iterable, const ITERABLE2 & iterable2, const ITYPE & pszPrefix, typename ITERABLE2::const_iterator first, typename ITERABLE2::const_iterator last)
2801 {
2802
2803 typedef ITERABLE::BASE_TYPE STRING_TYPE;
2804
2805 STRING_TYPE strPrefix(scopedstrPrefix);
2806
2807 iterable2.prepare_first_last(first, last);
2808
2809 for (; iterable2.valid_iter(first, last); first++)
2810 {
2811
2812 iterable.add(strPrefix + *first);
2813
2814 }
2815
2816 }
2817
2818 template < typename ITERABLE, typename ITERABLE2, typename ITYPE >
2819 void suffix(ITERABLE & iterable, const ITERABLE2 & iterable2, const ITYPE & pszSuffix, typename ITERABLE2::const_iterator first, typename ITERABLE2::const_iterator last)
2820 {
2821
2822 typedef ITERABLE::BASE_TYPE STRING_TYPE;
2823
2824 STRING_TYPE strSuffix(scopedstrSuffix);
2825
2826 iterable2.prepare_first_last(first, last);
2827
2828 for (; iterable2.valid_iter(first, last); first++)
2829 {
2830
2831 iterable.add(*first + strSuffix);
2832
2833 }
2834
2835 }
2836
2837 template < typename ITERABLE, typename ITERABLE2, typename ITYPE, typename ITYPE2 >
2838 void surround(ITERABLE & iterable, const ITERABLE2 & iterable2, const ITYPE & pszPrefix, const ITYPE2 & pszSuffix, typename ITERABLE2::const_iterator first, typename ITERABLE2::const_iterator last)
2839 {
2840
2841 typedef ITERABLE::BASE_TYPE STRING_TYPE;
2842
2843 STRING_TYPE strPrefix(scopedstrPrefix);
2844
2845 STRING_TYPE strSuffix(scopedstrSuffix);
2846
2847 iterable2.prepare_first_last(first, last);
2848
2849 for (; iterable2.valid_iter(first, last); first++)
2850 {
2851
2852 iterable.add(strPrefix + *first + strSuffix);
2853
2854 }
2855
2856 }
2857
2858
2859 template < typename ITERABLE, typename ITYPE >
2860 void prefix(ITERABLE & iterable, const ITYPE & pszPrefix, typename ITERABLE::iterator first, typename ITERABLE::iterator last)
2861 {
2862
2863 typedef ITERABLE::BASE_TYPE STRING_TYPE;
2864
2865 STRING_TYPE strPrefix(scopedstrPrefix);
2866
2867 iterable.prepare_first_last(first, last);
2868
2869 for (; iterable.valid_iter(first, last); first++)
2870 {
2871
2872 *first = strPrefix + *first;
2873
2874 }
2875
2876 }
2877
2878 template < typename ITERABLE, typename ITYPE >
2879 void suffix(ITERABLE & iterable, const ITYPE & pszSuffix, typename ITERABLE::iterator first, typename ITERABLE::iterator last)
2880 {
2881
2882 typedef ITERABLE::BASE_TYPE STRING_TYPE;
2883
2884 STRING_TYPE strSuffix(scopedstrSuffix);
2885
2886 iterable.prepare_first_last(first, last);
2887
2888 for (; iterable.valid_iter(first, last); first++)
2889 {
2890
2891 *first = *first + strSuffix;
2892
2893 }
2894
2895 }
2896
2897
2898 template < typename ITERABLE, typename ITYPE, typename ITYPE2 >
2899 void surround(ITERABLE & iterable, const ITYPE & pszPrefix, const ITYPE2 & pszSuffix, typename ITERABLE::iterator first, typename ITERABLE::iterator last)
2900 {
2901
2902 typedef ITERABLE::BASE_TYPE STRING_TYPE;
2903
2904 STRING_TYPE strPrefix(scopedstrPrefix);
2905
2906 STRING_TYPE strSuffix(scopedstrSuffix);
2907
2908 iterable.prepare_first_last(first, last);
2909
2910 for (; iterable.valid_iter(first, last); first++)
2911 {
2912
2913 *first = strPrefix + *first + strSuffix;
2914
2915 }
2916
2917 }
2918
2919
2920 template < typename ITERABLE, typename ITYPE, typename ITYPE2, typename ITYPE3, typename ITYPE4 >
2921 void surround_and_implode(const ITERABLE & iterable, ITYPE & str, const ITYPE2 & lpcszSeparator, const ITYPE3 & pszPrefix, const ITYPE4 & pszSuffix, typename ITERABLE::iterator first, typename ITERABLE::iterator last)
2922 {
2923
2924 str.empty();
2925
2926 typedef ITERABLE::BASE_TYPE STRING_TYPE;
2927
2928 STRING_TYPE strPrefix(scopedstrPrefix);
2929
2930 STRING_TYPE strSuffix(scopedstrSuffix);
2931
2932 iterable.prepare_first_last(first, last);
2933
2934 if (iterable.valid_iter(first, last))
2935 {
2936
2937 str = strPrefix + *first + strSuffix;
2938
2939 first++;
2940
2941 }
2942
2943 for (; iterable.valid_iter(first, last); first++)
2944 {
2945
2946 str += lpcszSeparator;
2947
2948 str += strPrefix + *first + strSuffix;
2949
2950 }
2951
2952 }
2953
2954
2955
2956
2957
2958
2959 template < typename ITERABLE, typename ITYPE >
2960 void prefix(const ITERABLE & stra, const ITYPE & pszPrefix, typename ITERABLE::iterator iStart, ::collection::count iCount)
2961 {
2962
2963 ITYPE strPrefix(scopedstrPrefix);
2964
2965 character_count iEnd;
2966
2967 if (iStart < 0)
2968 iStart = stra.get_size() + iStart;
2969
2970 if (iCount < 0)
2971 iEnd = stra.get_size() + iCount;
2972 else
2973 iEnd = iStart + iCount - 1;
2974
2975 for (auto & str : stra)
2976 {
2977
2978 add(strPrefix + str);
2979
2980 }
2981
2982 }
2983
2984
2985 template < typename ITERABLE, typename ITYPE >
2986 void suffix(const ITERABLE & stra, const ITYPE & pszSuffix, typename ITERABLE::iterator iStart, ::collection::count iCount)
2987 {
2988
2989 ITYPE strSuffix(scopedstrSuffix);
2990
2991 character_count iEnd;
2992
2993 if (iStart < 0)
2994 iStart = stra.get_size() + iStart;
2995
2996 if (iCount < 0)
2997 iEnd = stra.get_size() + iCount;
2998 else
2999 iEnd = iStart + iCount - 1;
3000
3001 for (typename ITERABLE::iterator i = iStart; i <= iEnd; i++)
3002 {
3003
3004 add(stra.element_at(i) + strSuffix);
3005
3006 }
3007
3008 }
3009
3010
3011 template < typename ITERABLE, typename ITYPE >
3012 void surround(const ITERABLE & stra, const ITYPE & pszPrefix, const ITYPE & pszSuffix, typename ITERABLE::iterator iStart, ::collection::count iCount)
3013 {
3014
3015 ITYPE strPrefix(scopedstrPrefix);
3016
3017 ITYPE strSuffix(scopedstrSuffix);
3018
3019 character_count iEnd;
3020
3021 if (iStart < 0)
3022 iStart = stra.get_size() + iStart;
3023
3024 if (iCount < 0)
3025 iEnd = stra.get_size() + iCount;
3026 else
3027 iEnd = iStart + iCount - 1;
3028
3029 for (typename ITERABLE::iterator i = iStart; i <= iEnd; i++)
3030 {
3031
3032 add(strPrefix + stra.element_at(i) + strSuffix);
3033
3034 }
3035
3036 }
3037
3038
3039 template < typename ITERABLE, typename ITYPE >
3040 void surround(ITERABLE & iterable, const ITYPE & pszPrefix, const ITYPE & pszSuffix, typename ITERABLE::iterator iStart, ::collection::count iCount)
3041 {
3042
3043 ITYPE strPrefix(scopedstrPrefix);
3044
3045 ITYPE strSuffix(scopedstrSuffix);
3046
3047 character_count iEnd;
3048
3049 if (iStart < 0)
3050 iStart = iterable.get_size() + iStart;
3051
3052 if (iCount < 0)
3053 iEnd = iterable.get_size() + iCount;
3054 else
3055 iEnd = iStart + iCount - 1;
3056
3057 for (typename ITERABLE::iterator i = iStart; i <= iEnd; i++)
3058 {
3059
3060 iterable.element_at(i) = strPrefix + iterable.element_at(i);
3061
3062 }
3063
3064 }
3065
3066
3067 template < typename ITERABLE, typename ITYPE >
3068 void suffix(ITERABLE & iterable, const ITYPE & pszSuffix, typename ITERABLE::iterator iStart, ::collection::count iCount)
3069 {
3070
3071 ITYPE strSuffix(scopedstrSuffix);
3072
3073 character_count iEnd;
3074
3075 if (iStart < 0)
3076 iStart = iterable.get_size() + iStart;
3077
3078 if (iCount < 0)
3079 iEnd = iterable.get_size() + iCount;
3080 else
3081 iEnd = iStart + iCount - 1;
3082
3083 for (typename ITERABLE::iterator i = iStart; i <= iEnd; i++)
3084 {
3085
3086 iterable.element_at(i) = iterable.element_at(i) + strSuffix;
3087
3088 }
3089
3090 }
3091
3092
3093
3094
3095
3096 template < typename ITERABLE, typename ITYPE, typename ITYPE2, typename ITYPE3 >
3097 void surround_and_implode(const ITERABLE & iterable, ITYPE & str, const ITYPE2 & pszSeparator, const ITYPE3 & pszPrefix, const ITYPE & pszSuffix, typename ITERABLE::iterator iStart, ::collection::count iCount)
3098 {
3099 ITYPE str;
3100 ITYPE strSeparator(scopedstrSeparator);
3101 ITYPE strPrefix(scopedstrPrefix);
3102 ITYPE strSuffix(scopedstrSuffix);
3103
3104 typename ITERABLE::iterator iEnd;
3105
3106 if (iStart < 0)
3107 iStart = iterable.get_size() + iStart;
3108
3109 if (iCount < 0)
3110 iEnd = iterable.get_size() + iCount;
3111 else
3112 iEnd = iStart + iCount - 1;
3113
3114 if (iStart <= iEnd)
3115 {
3116
3117 str = strPrefix + iterable.element_at(iStart) + strSuffix;
3118
3119 iStart++;
3120
3121 for (typename ITERABLE::iterator i = iStart; i <= iEnd; i++)
3122 {
3123
3124 str += strSeparator + strPrefix + iterable.element_at(i) + strSuffix;
3125
3126 }
3127
3128 }
3129
3130 return str;
3131
3132 }
3133
3134 template < typename ITERABLE, typename ITERABLE2 >
3135 ITERABLE & add_iter(ITERABLE & iterable, const ITERABLE2 & iterable2)
3136 {
3137
3138 for (auto & item : iterable2)
3139 {
3140
3141 iterable.add(item);
3142
3143 }
3144
3145 return iterable;
3146
3147 }
3148
3149
3150 template < typename ITERABLE, typename ITERABLE2 >
3151 ITERABLE diff(const ITERABLE & iterable, const ITERABLE2 & iterable2)
3152 {
3153
3154 ITERABLE contanerSubtracted(iterable);
3155
3156 contanerSubtracted.erase_iter(iterable2);
3157
3158 return contanerSubtracted;
3159
3160 }
3161
3162
3163 template < typename ITERABLE, typename ITERABLE2 >
3164 ITERABLE sum(const ITERABLE & iterable, const ITERABLE2 & iterable2)
3165 {
3166
3167 ITERABLE contanerAdded(iterable);
3168
3169 contanerAdded += iterable2;
3170
3171 return contanerAdded;
3172
3173 }
3174
3175
3176 template < typename ITERABLE, typename ITYPE >
3177 bool case_insensitive_move(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator iIndex)
3178 {
3179 typename ITERABLE::iterator i = case_insensitive_find_first(pcsz);
3180 if (i < 0)
3181 return false;
3182 iterable.erase_at(i);
3183 insert_at(iIndex, pcsz);
3184 return true;
3185 }
3186
3187
3188 template < typename ITERABLE, typename ITYPE >
3189 bool preferred(ITERABLE & iterable, const ITYPE & pcsz)
3190 {
3191
3192 return case_insensitive_move(pcsz, 0);
3193
3194 }
3195
3196
3197 template < typename ITERABLE, typename ITERABLE2 >
3198 ::collection::count preferred_iter(ITERABLE & iterable, const ITERABLE2 & iterable2)
3199 {
3200
3201 ::collection::count count = 0;
3202
3203 for (auto i = upper_bound(); i >= begin(); i--)
3204 {
3205
3206 if (preferred(*i))
3207 count++;
3208
3209 }
3210
3211 return count;
3212
3213 }
3214
3215
3216
3217
3218 //template < typename ITERABLE, typename ITYPE >
3219 //template < typename ITERABLE >
3220 //void slice(ITERABLE & stra, const_iterator iOffset, ::collection::count count)
3221 //{
3222 //
3223 // typename ITERABLE::iterator iEnd;
3224 //
3225 // if (count < 0)
3226 // iEnd = get_upper_bound(count);
3227 // else
3228 // iEnd = iOffset + count - 1;
3229 //
3230 // for (typename ITERABLE::iterator i = iOffset; i <= iEnd; i++)
3231 // {
3232 // stra.add(iterable.element_at(i));
3233 // }
3234 //
3235 //}
3236 //
3237
3238 template < typename ITERABLE, typename ITYPE >
3239 void erase(ITERABLE & iterable, typename ITERABLE::iterator first, typename ITERABLE::iterator last)
3240 {
3241
3242 while(iterable.valid_iter(first, last))
3243 {
3244
3245 iterable.erase_at(first);
3246
3247 }
3248
3249 }
3250
3251
3252
3253
3254
3255 //template < typename ITERABLE, typename ITYPE >
3256 //bool is_empty(::collection::count countMinimum)
3257 //{
3258 // return iterable.get_size() < countMinimum;
3259 //}
3260
3261
3262 //template < typename ITERABLE, typename ITYPE >
3263 //bool has_elements(::collection::count countMinimum)
3264 //{
3265 // return iterable.get_count() >= countMinimum;
3266 //}
3267
3268
3269
3270 template < typename ITERABLE, typename STRITERABLE, typename ITYPE >
3271 ::collection::count case_insensitive_get_begins(const ITERABLE & iterable, STRITERABLE & stra, const ITYPE & pcsz, typename ITERABLE::iterator first, typename ITERABLE::iterator last)
3272 {
3273 if (last < 0)
3274 last = iterable.get_size() + last;
3275 if (last >= iterable.get_size())
3276 last = get_upper_bound();
3277 if (first < 0)
3278 first = 0;
3279 typename ITERABLE::iterator i = first;
3280 typename ITERABLE::iterator iFind;
3281 ::collection::count count = 0;
3282 while (true)
3283 {
3284 iFind = case_insensitive_find_first_begins(pcsz, i, last);
3285 if (::is_null(pFind))
3286 return count;
3287 stra.add(iterable.element_at(iFind));
3288 i = iFind + 1;
3289 count++;
3290 }
3291 }
3292
3293
3294 template < typename ITERABLE, typename ITYPE >
3295 ::collection::count case_insensitive_filter_begins(ITERABLE & iterable, const ITYPE & pcsz, typename ITERABLE::iterator first, typename ITERABLE::iterator last)
3296 {
3297
3298 iterable.prepare_first_last(first, last);
3299
3300 typename ITERABLE::iterator it = first;
3301
3302 typename ITERABLE::iterator itFind;
3303
3304 ::collection::count count = 0;
3305
3306 while (true)
3307 {
3308
3309 itFind = case_insensitive_find_first_begins(iterable, pcsz, it, last);
3310
3311 if (itFind < 0)
3312 {
3313
3314 iterable.erase(it, last);
3315
3316 return count;
3317
3318 }
3319
3320 iterable.erase_count(it, itFind - it);
3321
3322 count++;
3323
3324 it++;
3325
3326 }
3327
3328 }
3329
3330 template < typename ITERABLE, typename ITYPE, typename PRED >
3331 ::collection::count filter(ITERABLE & iterable, PRED pred, typename ITERABLE::iterator first, typename ITERABLE::iterator last)
3332 {
3333 if (last < 0)
3334 last = iterable.get_size() + last;
3335 if (last >= iterable.get_size())
3336 last = get_upper_bound();
3337 if (first < 0)
3338 first = 0;
3339 // typename ITERABLE::iterator i = first;
3340 ::collection::count count = 0;
3341 for (typename ITERABLE::iterator i = first; i <= last;)
3342 {
3343 if (pred(element_at(i)))
3344 {
3345 i++;
3346 }
3347 else
3348 {
3349 iterable.erase_at(i);
3350 count++;
3351 last--;
3352 }
3353
3354 }
3355 return count;
3356 }
3357
3358
3359 template < typename ITERABLE, typename ITYPE, typename PRED >
3360 ::collection::count filter_out(ITERABLE & iterable, PRED pred, typename ITERABLE::iterator first, typename ITERABLE::iterator last)
3361 {
3362 if (last < 0)
3363 last = iterable.get_size() + last;
3364 if (last >= iterable.get_size())
3365 last = get_upper_bound();
3366 if (first < 0)
3367 first = 0;
3368 // typename ITERABLE::iterator i = first;
3369 ::collection::count count = 0;
3370 for (typename ITERABLE::iterator i = first; i <= last;)
3371 {
3372 if (!pred(element_at(i)))
3373 {
3374 i++;
3375 }
3376 else
3377 {
3378 iterable.erase_at(i);
3379 count++;
3380 last--;
3381 }
3382
3383 }
3384 return count;
3385 }
3386
3387 template < typename ITERABLE, typename ITYPE, typename PRED, typename ArrayOut >
3388 ::collection::count filter_out(ITERABLE & iterable, PRED pred, ArrayOut & a, typename ITERABLE::iterator first, typename ITERABLE::iterator last)
3389 {
3390 if (last < 0)
3391 last = iterable.get_size() + last;
3392 if (last >= iterable.get_size())
3393 last = get_upper_bound();
3394 if (first < 0)
3395 first = 0;
3396 // typename ITERABLE::iterator i = first;
3397 ::collection::count count = 0;
3398 for (typename ITERABLE::iterator i = first; i <= last;)
3399 {
3400 if (!pred(element_at(i)))
3401 {
3402 i++;
3403 }
3404 else
3405 {
3406 a.add(iterable.element_at(i));
3407 iterable.erase_at(i);
3408 count++;
3409 last--;
3410 }
3411
3412 }
3413 return count;
3414 }
3415
3416
3417
3418
3419
3420
3421 template < typename ITERABLE >
3422 void make_lower(ITERABLE & iterable)
3423 {
3424 for (typename ITERABLE::iterator i = 0; i < iterable.get_count(); i++)
3425 {
3426 iterable.element_at(i).make_lower();
3427 }
3428 }
3429
3430
3431 template < typename ITERABLE >
3432 void make_upper(ITERABLE & iterable)
3433 {
3434 for (typename ITERABLE::iterator i = 0; i < iterable.get_count(); i++)
3435 {
3436 iterable.element_at(i).make_upper();
3437 }
3438 }
3439
3440
3441
3442 //template < typename ITERABLE, typename ITERABLE2 >
3443 //void get_comparable_ida(const ITERABLE & iterable, ITERABLE2 & iterable2)
3444 //{
3445
3446 // array < atom > ida;
3447
3448 // for (::i32 i = 0; i < get_count(); i++)
3449 // {
3450 // iterable2.add(element_at(i));
3451 // }
3452
3453 // return ida;
3454
3455 //}
3456
3457
3458
3459
3460 template < typename ITERABLE, typename ITYPE >
3461 ITYPE encode_v16(const ITERABLE & iterable)
3462 {
3463 ITYPE strEncode;
3464 for (::i32 u = 0; u < iterable.get_count(); u++)
3465 {
3466 ITYPE & str = iterable.element_at(u);
3467 strEncode += hex::lower_from((const_char_pointer )str);
3468 strEncode += "00";
3469 /* for(::i32 uj = 0; uj < str.length(); uj++)
3470 {
3471 ::i8 sz[32];
3472 ansi_from_i64(sz, str[uj], 16);
3473 if(ansi_length(sz) == 0)
3474 {
3475 strEncode += "00";
3476 }
3477 else if(ansi_length(sz) == 1)
3478 {
3479 strEncode += "0";
3480 strEncode += sz;
3481 }
3482 else if(ansi_length(sz) == 2)
3483 {
3484 strEncode += sz;
3485 }
3486 }*/
3487
3488 }
3489 return strEncode;
3490 }
3491
3492
3493
3494
3495 template < typename ITERABLE, typename ITYPE >
3496 void decode_v16(const ITERABLE & iterable, const ITYPE & psz)
3497 {
3498 ::i32 iSize = 1024;
3499 char_pointer str = nullptr;
3500 if (scopedstr == nullptr)
3501 return;
3502 while (*psz != '\0')
3503 {
3504 psz++;
3505 if (*psz == '\0')
3506 break;
3507 ::i8 sz[3];
3508 sz[0] = psz[-1];
3509 sz[1] = psz[0];
3510 sz[2] = '\0';
3511 const ITYPE & pszEnd;
3512 ::i32 iConversion = ::ansi_to_int(sz, &pszEnd, 16);
3513 ::i8 ch = static_cast <::i8> (iConversion);
3514 if (ch == '\0')
3515 {
3516 add(str);
3517 str = nullptr;
3518 iSize = 1024;
3519 }
3520 else
3521 {
3522 if (str == nullptr)
3523 {
3524 str = (char_pointer )::system()->m_pheapmanagement->memory(::heap::e_memory_main)->allocate(iSize);
3525 }
3526 else if (iSize < (ansi_length(str) + 1))
3527 {
3528 char_pointer strOld = str;
3529 iSize += 1024;
3530 char_pointer strNew = (char_pointer )::system()->m_pheapmanagement->memory(::heap::e_memory_main)->allocate(iSize);
3531 ansi_copy(strNew, strOld);
3532 str = strNew;
3533 }
3534 sz[0] = ch;
3535 sz[1] = '\0';
3536 ansi_copy(str, sz);
3537 }
3538 psz++;
3539 }
3540
3541 }
3542
3543
3544
3545 template < typename ITERABLE, typename ITYPE >
3546 ::collection::count get_count_except(const ITERABLE & iterable, const ITYPE & str)
3547 {
3548
3549 ::collection::count c = get_count();
3550
3551 for (typename ITERABLE::iterator i = 0; i < get_count(); i++)
3552 {
3553
3554 if (element_at(i) == str)
3555 c--;
3556
3557 }
3558
3559 return c;
3560
3561 }
3562
3563
3564 template < typename ITERABLE, typename ITERABLE2 >
3565 ::collection::count get_count_except_iter(const ITERABLE & iterable, const ITERABLE2 & iterable2)
3566 {
3567
3568 ::collection::count c = get_count();
3569
3570 for (auto & item : iterable)
3571 {
3572
3573 if (stra.contains(item))
3574 c--;
3575
3576 }
3577
3578 return c;
3579
3580 }
3581
3582
3583
3584 template < typename ITERABLE, typename ITYPE >
3585 ::collection::count case_insensitive_get_count_except(const ITERABLE & iterable, const ITYPE & str)
3586 {
3587
3588 ::collection::count c = get_count();
3589
3590 for (typename ITERABLE::iterator i = 0; i < get_count(); i++)
3591 {
3592
3593 if (element_at(i).CompareNoCase(str) == 0)
3594 c--;
3595
3596 }
3597
3598 return c;
3599
3600 }
3601
3602
3603 template < typename ITERABLE, typename ITERABLE2 >
3604 ::collection::count case_insensitive_get_count_except_iter(const ITERABLE & iterable, const ITERABLE2 & iterable2)
3605 {
3606
3607 ::collection::count c = get_count();
3608
3609 for (auto & item : iterable)
3610 {
3611
3612 if (stra.case_insensitive_contains(item))
3613 c--;
3614
3615 }
3616
3617 return c;
3618
3619 }
3620
3621
3622
3623 template < typename ITERABLE, typename ITYPE >
3624 ITYPE & get_network_payload(const ITERABLE & iterable, ITYPE & str, bool bNewLine)
3625 {
3626
3627 str += "[";
3628
3629 auto it = iterable.begin();
3630
3631 if (iterable.get_count() > 0)
3632 {
3633
3634 str += "\"";
3635
3636 str += *it;
3637
3638 str += "\"";
3639
3640 it++;
3641
3642 }
3643
3644 for (; iterable.valid_iter(it, iterable.end()); it++)
3645 {
3646
3647 if (bNewLine)
3648 {
3649
3650 str += ", \r\n";
3651
3652 }
3653 else
3654 {
3655
3656 str += ", ";
3657
3658 }
3659
3660 str += "\"";
3661
3662 str += *it;
3663
3664 str += "\"";
3665
3666 }
3667
3668 if (bNewLine)
3669 {
3670
3671 str += "\r\n";
3672
3673 }
3674
3675 str += "]";
3676
3677 return str;
3678
3679 }
3680
3681
3682
3683
3684
3685 template < typename ITERABLE, typename ITYPE, typename ITYPE2, typename ITYPE3 >
3686 void implode_ex(const ITERABLE & iterable, ITYPE & str, const ITYPE2 & lpcszSeparator, const ITYPE3 & lpcszLastSeparator, typename ITERABLE::const_iterator start, typename ITERABLE::const_iterator end)
3687 {
3688
3689 str.empty();
3690
3691 ITYPE strSeparator(lpcszSeparator);
3692
3693 if (start == nullptr)
3694 {
3695
3696 start = iterable.upper_bound();
3697
3698 }
3699
3700 typename ITERABLE::iterator last;
3701
3702 if (end == nullptr)
3703 {
3704
3705 start = iterable.upper_bound();
3706
3707 }
3708
3709 auto i = start;
3710
3711 if (i != last)
3712 {
3713
3714 str = *i;
3715
3716 i++;
3717
3718 if (i != iterable.end())
3719 {
3720
3721 for (; i != last; i++)
3722 {
3723
3724 str += strSeparator;
3725
3726 str += *i;
3727
3728 }
3729
3730 str += lpcszLastSeparator;
3731
3732 str += *i;
3733
3734 }
3735
3736 }
3737
3738 }
3739
3740
3741
3742
3743 template < typename ITERABLE, typename ITYPE >
3744 void if_prefix_implode_ex(const ITERABLE & iterable, ITYPE & str, const ITYPE & lpcszIfHasElementPrefix, const ITYPE & lpcszSeparator, const ITYPE & lpcszLastSeparator, bool bUseLast, typename ITERABLE::iterator start, ::collection::count count)
3745 {
3746
3747 str.empty();
3748
3749 ITYPE strSeparator(lpcszSeparator);
3750
3751 if (start < 0)
3752 {
3753 start += iterable.get_size();
3754 }
3755 typename ITERABLE::iterator last;
3756 if (count < 0)
3757 {
3758 last = iterable.get_size() + count;
3759 }
3760 else
3761 {
3762 last = start + count - 1;
3763 }
3764 if (last >= start)
3765 {
3766 str += lpcszIfHasElementPrefix;
3767 }
3768 for (typename ITERABLE::iterator i = start; i <= last; i++)
3769 {
3770 if (i > start)
3771 {
3772 if (i == last && bUseLast)
3773 {
3774 str += lpcszLastSeparator;
3775 }
3776 else
3777 {
3778 str += strSeparator;
3779 }
3780 }
3781 str += iterable.element_at(i);
3782 }
3783 }
3784
3785
3786 template < typename ITERABLE, typename ITYPE >
3787 typename ITERABLE::ITYPE if_prefix_implode_ex(const ITERABLE & iterable, const ITYPE & lpcszIfHasElementPrefix, const ITYPE & lpcszSeparator, const ITYPE & lpcszLastSeparator, bool bUseLast, typename ITERABLE::iterator iStart, typename ITERABLE::iterator iEnd)
3788 {
3789 ITYPE str;
3790 if_prefix_implode_ex(str, lpcszIfHasElementPrefix, lpcszSeparator, lpcszLastSeparator, bUseLast, iStart, iEnd);
3791 return str;
3792 }
3793
3794
3796 template < typename ITERABLE >
3797 void c_add(ITERABLE & iterable, char_pointer * ppsz, ::collection::count c)
3798 {
3799
3800 for (typename ITERABLE::iterator i = 0; i < c; i++)
3801 {
3802
3803 iterable.add(ppsz[i]);
3804
3805 free((void *)ppsz[i]);
3806
3807 }
3808
3809 free((void *)ppsz);
3810
3811 }
3812
3814 template < typename ITERABLE >
3815 void c_add(ITERABLE & iterable, char_pointer * ppszParam)
3816 {
3817
3818 char_pointer * ppsz = ppszParam;
3819
3820 while (ppsz != nullptr)
3821 {
3822
3823 char_pointer psz = *ppsz;
3824
3825 iterable.add(scopedstr);
3826
3827 free((void *)psz);
3828
3829 ppsz++;
3830
3831 }
3832
3833 free((void *)ppsz);
3834
3835 }
3836
3838 template < typename ITERABLE >
3839 void c_add(ITERABLE & iterable, wchar_t ** ppsz, ::collection::count c)
3840 {
3841
3842 for (typename ITERABLE::iterator i = 0; i < c; i++)
3843 {
3844
3845 iterable.add(ppsz[i]);
3846
3847 free((void *)ppsz[i]);
3848
3849 }
3850
3851 free((void *)ppsz);
3852
3853 }
3854
3856 template < typename ITERABLE >
3857 void c_add(ITERABLE & iterable, wchar_t ** ppszParam)
3858 {
3859
3860 wchar_t ** ppsz = ppszParam;
3861
3862 while (ppsz != nullptr)
3863 {
3864
3865 wchar_t * psz = *ppsz;
3866
3867 iterable.add(scopedstr);
3868
3869 free((void *)psz);
3870
3871 ppsz++;
3872
3873 }
3874
3875 free((void *)ppsz);
3876
3877 }
3878
3879
3880 template < typename ITERABLE, typename ITERABLE2 >
3881 ITERABLE & copy_iter(ITERABLE & iterable, const ITERABLE2 & iterable2)
3882 {
3883
3884 for (auto & item : iterable2)
3885 {
3886
3887 iterable.add(item);
3888
3889 }
3890
3891 return iterable;
3892
3893 }
3894
3895
3896
3897 template < typename ITERABLE, typename ITERABLE2 >
3898 ITERABLE & copy_from(ITERABLE & iterable, const ITERABLE2 & iterable2)
3899 {
3900
3901 return copy_iter(iterable, iterable2.begin(), iterable2.end());
3902
3903 }
3904
3905
3906 template < typename ITERABLE, typename ITERATOR >
3907 ITERABLE & copy_from(ITERABLE & iterable, ITERATOR & iterator, ITERATOR & limit)
3908 {
3909
3910 ASSERT_OK(this);
3911
3912 iterable.provision(iterator, limit);
3913
3914 for (; iterator != limit; iterator++)
3915 {
3916
3917 iterable.add(as_string(*iterator));
3918
3919 }
3920
3921 return *iterable;
3922
3923 }
3924
3925
3926 template < typename ITERABLE >
3927 ITERABLE & copy(ITERABLE & iterable, ::payload varSrc)
3928 {
3929
3930 iterable.erase_all();
3931
3932 if (varSrc.get_type() == ::e_type_string_array)
3933 {
3934
3935 varSrc.get_array(iterable);
3936
3937 }
3938 else
3939 {
3940 if (varSrc.get_count() == 1)
3941 {
3942
3943 add((ITYPE)varSrc.get_string());
3944
3945 }
3946 else if (varSrc.get_count() > 1)
3947 {
3948
3949 varSrc.get_array(iterable);
3950
3951 }
3952
3953 }
3954
3955 return iterable;
3956
3957 }
3958
3959
3960 template < typename ITERABLE, typename ITERABLE2 >
3961 ITERABLE2 & slice(ITERABLE & iterable, ITERABLE2 & iterable2, typename ITERABLE::iterator first, typename ITERABLE::iterator last)
3962 {
3963
3964 iterable.prepare_first_last(first, last);
3965
3966 for (; iterable.valid_iter(first, last); first++)
3967 {
3968
3969 iterable2.add(*first);
3970
3971 }
3972
3973 iterable.erase(first, last);
3974
3975 return iterable2;
3976
3977 }
3978
3979
3980 template < typename ITERABLE, typename ITERABLE2 >
3981 ITERABLE2 & islice(ITERABLE & iterable, ITERABLE2 & iterable2, index first, ::collection::count count)
3982 {
3983
3984 iterable.iprepare_first_count(first, count);
3985
3986 for (; first < count; first++)
3987 {
3988
3989 iterable2.add(iterable.element_at(first));
3990
3991 }
3992
3993 iterable.erase_at(first, count-first);
3994
3995 return iterable2;
3996
3997 }
3998
3999 template < typename ITERABLE, typename ITYPE >
4000 ITERABLE & add_data(ITERABLE & iterable, const ITYPE * pdata, ::collection::count count)
4001 {
4002
4003 for (::collection::index i = 0; i < count; i++)
4004 {
4005
4006 iterable.add(pdata[i]);
4007
4008 }
4009
4010 return iterable;
4011
4012 }
4013
4014
4015 template < typename ITERABLE, typename ITYPE >
4016 ITERABLE & add_item(ITERABLE & iterable, const ITYPE & t, ::collection::count n)
4017 {
4018
4019 while (n > 0)
4020 {
4021
4022 iterable.add(t);
4023
4024 n--;
4025
4026 }
4027
4028 return iterable;
4029
4030 }
4031
4032
4033} // namespace iter
4034
4035
4036
4037template < typename ITERABLE >
4038class iterable :
4039 public ITERABLE
4040{
4041public:
4042
4043 typedef typename ITERABLE::iterator iterator;
4044 typedef typename ITERABLE::const_iterator const_iterator;
4045 typedef typename ITERABLE Iterable;
4046 typedef typename Iterable::BASE_TYPE Type;
4047 typedef iterable Container;
4048
4049
4050 template < typename ITYPE >
4051 bool add_unique(const ITYPE & str)
4052 {
4053
4054 return ::iter::add_unique(*this, str);
4055
4056 }
4057
4058
4059 template < typename ITYPE >
4060 bool case_insensitive_add_unique(const ITYPE & str)
4061 {
4062
4063 return ::iter::case_insensitive_add_unique(*this, str);
4064
4065 }
4066
4067
4068 template < typename ITYPE >
4069 bool case_insensitive_contains_iter(const ITYPE & str, typename ITERABLE::iterator find = 0, typename ITERABLE::iterator last = nullptr, ::collection::count countMin = 1, ::collection::count countMax = -1) const
4070 {
4071
4072 return ::iter::case_insensitive_contains(*this, str, find, last, countMin, countMax);
4073
4074 }
4075
4076
4077 template < typename ITYPE >
4078 bool contains_iter(const ITYPE & str, typename ITERABLE::iterator find = 0, typename ITERABLE::iterator last = nullptr, ::collection::count countMin = 1, ::collection::count countMax = -1) const
4079 {
4080
4081 return ::iter::contains(*this, str, find, last, countMin, countMax);
4082
4083 }
4084
4085
4086 template < typename ITYPE >
4087 bool case_insensitive_icontains(const ITYPE & str, ::collection::index find, ::collection::count count, ::collection::count countMin /*= 1*/, ::collection::count countMax = -1) const
4088 {
4089
4090 return ::iter::case_insensitive_icontains(*this, str, find, last, countMin, countMax);
4091
4092 }
4093
4094
4095 template < typename ITYPE >
4096 bool icontains(const ITYPE & str, ::collection::index find, ::collection::count count, ::collection::count countMin /*= 1*/, ::collection::count countMax = -1) const
4097 {
4098
4099 return ::iter::icontains(*this, str, find, last, countMin, countMax);
4100
4101 }
4102
4103 template < typename ITYPE >
4104 Type implode(const ITYPE & lpcszSeparator = "", typename ITERABLE::const_iterator iStart = 0, typename ITERABLE::const_iterator iEnd = nullptr) const
4105 {
4106
4107 Type value;
4108
4109 ::iter::implode(*this, value, lpcszSeparator, iStart, iEnd);
4110
4111 return value;
4112
4113 }
4114
4115 template < typename ITYPE, typename ITYPE2 >
4116 Type implode_ex(const ITYPE & lpcszSeparator = "", const ITYPE2 & lpcszLastSeparator = "", typename ITERABLE::const_iterator iStart = 0, typename ITERABLE::const_iterator iEnd = nullptr) const
4117 {
4118
4119 Type value;
4120
4121 ::iter::implode_ex(*this, value, lpcszSeparator, lpcszLastSeparator, iStart, iEnd);
4122
4123 return value;
4124
4125 }
4126
4127
4128 template < typename ITERABLE2, typename ITYPE >
4129 void prefix(const ITERABLE2 & iterable2, const ITYPE & pszPrefix, typename ITERABLE2::const_iterator first = nullptr, typename ITERABLE2::const_iterator last = nullptr)
4130 {
4131
4132 ::iter::prefix(*this, iterable2, pszPrefix, first, last);
4133
4134 }
4135
4136 template < typename ITERABLE2, typename ITYPE >
4137 void suffix(const ITERABLE2 & iterable2, const ITYPE & pszSuffix, typename ITERABLE2::const_iterator first = nullptr, typename ITERABLE2::const_iterator last = nullptr)
4138 {
4139
4140 ::iter::suffix(*this, iterable2, pszSuffix, first, last);
4141
4142 }
4143
4144 template < typename ITERABLE2, typename ITYPE, typename ITYPE2 >
4145 void surround(const ITERABLE2 & iterable2, const ITYPE & pszPrefix = "", const ITYPE2 & pszSuffix = "", typename ITERABLE2::iterator first = nullptr, typename ITERABLE2::const_iterator last = nullptr)
4146 {
4147
4148 ::iter::surround(*this, iterable2, pszPrefix, pszSuffix, first, last);
4149
4150 }
4151
4152 template < typename ITYPE >
4153 void prefix(const ITYPE & pszPrefix, typename ITERABLE::iterator first = nullptr, typename ITERABLE::iterator last = nullptr)
4154 {
4155
4156 ::iter::surround(*this, pszPrefix, first, last);
4157
4158 }
4159
4160 template < typename ITYPE >
4161 void suffix(const ITYPE & pszSuffix, typename ITERABLE::iterator first = nullptr, typename ITERABLE::iterator last = nullptr)
4162 {
4163
4164 ::iter::surround(*this, pszSuffix, first, last);
4165
4166 }
4167
4168
4169 template < typename ITYPE, typename ITYPE2 >
4170 void surround(const ITYPE & pszPrefix = "", const ITYPE & pszSuffix = "", typename ITERABLE::iterator first = 0, typename ITERABLE::iterator last = nullptr)
4171 {
4172
4173 ::iter::surround(*this, pszPrefix, pszSuffix, first, last);
4174
4175 }
4176
4177
4178 template < typename ITYPE, typename ITYPE2, typename ITYPE3 >
4179 void surround_and_implode(const ITYPE & str, const ITYPE2 & lpcszSeparator = "", const ITYPE3 & pszPrefix = "", const ITYPE2 & pszSuffix = nullptr, typename ITERABLE::iterator first = nullptr, typename ITERABLE::iterator last = nullptr)
4180 {
4181
4182 ::iter::surround(*this, lpcszSeparator, pszPrefix, lpszSuffix, first, last);
4183
4184 }
4185
4186
4187
4188
4189 template < typename ITYPE, typename ITYPESEP >
4190 Container & add_tokens(const ITYPE & pcsz, const ITYPESEP & lpcszSeparator, bool bAddEmpty = true)
4191 {
4192
4193 return ::iter::add_tokens(*this, pcsz, lpcszSeparator, bAddEmpty);
4194
4195 }
4196
4197 template < typename ITYPE >
4198 Container & add_lines(const ITYPE & str, bool bAddEmpty = true)
4199 {
4200
4201 return ::iter::add_lines(*this, str, bAddEmpty);
4202
4203 }
4204
4205 template < typename ITYPE, typename ITERABLE2 >
4206 Container & add_shortest_tokens(const ITYPE & pcsz, const ITERABLE2 & iterableSeparator, bool bAddEmpty = true, bool bWithSeparator = false)
4207 {
4208
4209 return ::iter::add_shortest_tokens(*this, pcsz, iterableSeparator, bAddEmpty, bWithSeparator);
4210
4211 }
4212
4213 template < typename ITYPE >
4214 Container & trim_right(const ITYPE & pszChars)
4215 {
4216
4217 return ::iter::trim_right(*this, pszChars);
4218
4219 }
4220
4221 template < typename ITYPE >
4222 Container & trim_left(const ITYPE & pszChars)
4223 {
4224
4225 return ::iter::trim_left(*this, pszChars);
4226
4227 }
4228
4229 template < typename ITYPE >
4230 Container & trim(const ITYPE & pszChars)
4231 {
4232
4233 return ::iter::trim(*this, pszChars);
4234
4235 }
4236
4237
4238
4239
4240 // transfer preferred in order
4241 template < typename ITYPE >
4242 Container & preferred(const ITYPE & pcsz)
4243 {
4244
4245 return ::iter::preferred(*this, pcsz);
4246
4247 }
4248
4249
4250 template < typename ITERABLE2 >
4251 Container & preferred_iter(const ITERABLE2 & iterable2)
4252 {
4253
4254 return ::iter::preferred_iter(*this, iterable2);
4255
4256 }
4257
4258 template < typename ITERABLE2 >
4259 ::collection::count erase_iter(const ITERABLE2 & iterable2)
4260 {
4261
4262 return ::iter::erase_iter(*this, iterable2);
4263
4264 }
4265
4266
4267 template < typename ITERABLE2 >
4268 Container & add_iter(const ITERABLE2 & iterable2)
4269 {
4270
4271 return ::iter::add_iter(*this, iterable2);
4272
4273 }
4274
4275
4276 template < typename ITERABLE2 >
4277 Container diff(const ITERABLE2 & iterable2) const
4278 {
4279
4280 return ::iter::diff(*this, iterable2);
4281
4282 }
4283
4284
4285 template < typename ITERABLE2 >
4286 Container sum(const ITERABLE2 & iterable2) const
4287 {
4288
4289 return ::iter::sum(*this, iterable2);
4290
4291 }
4292
4293 template < typename ITYPE >
4294 ::collection::count case_insensitive_erase_element_iter(const ITYPE & pcsz, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr, ::collection::count countMin = 0, ::collection::count countMax = -1)
4295 {
4296
4297 return ::iter::case_insensitive_erase(pcsz, find, last, countMin, countMax);
4298
4299 }
4300
4301 template < typename ITYPE >
4302 ::collection::count erase_element_iter(const ITYPE & pcsz, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr, ::collection::count countMin = 0, ::collection::count countMax = -1)
4303 {
4304
4305 return ::iter::case_insensitive_erase(pcsz, find, last, countMin, countMax);
4306
4307 }
4308
4309
4310 template < typename ITYPE >
4311 typename ITERABLE::iterator case_insensitive_reverse_find(const ITYPE & pcsz, typename ITERABLE::iterator find = -1, typename ITERABLE::iterator last = 0)
4312 {
4313
4314 return ::iter::case_insensitive_reverse_find(*this, pcsz, find, last);
4315
4316 }
4317
4318 template < typename ITYPE >
4319 typename ITERABLE::iterator rear_find(const ITYPE & pcsz, typename ITERABLE::iterator find = -1, typename ITERABLE::iterator last = 0)
4320 {
4321
4322 return ::iter::rear_find(*this, pcsz, find, last);
4323
4324 }
4325
4326 template < typename ITYPE >
4327 typename ITERABLE::iterator any_suffixes(const ITYPE & lpcszIsSuffixed, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr)
4328 {
4329
4330 return ::iter::any_suffixes(*this, lpcszIsSuffixed, find, last);
4331
4332 }
4333
4334 template < typename ITYPE >
4335 bool any_case_insensitive_suffixes(const ITYPE & lpcszIsSuffixed, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr)
4336 {
4337
4338 return ::iter::any_case_insensitive_suffixes(*this, lpcszIsSuffixed, find, last) != end();
4339
4340 }
4341
4342 template < typename ITYPE >
4343 typename ITERABLE::iterator any_prefixes(const ITYPE & lpcszIsPrefixed, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr)
4344 {
4345
4346 return ::iter::any_prefixes(*this, lpcszIsPrefixed, find, last);
4347
4348 }
4349
4350 template < typename ITYPE >
4351 typename ITERABLE::iterator case_insensitive_any_prefixes(const ITYPE & lpcszIsPrefixed, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr)
4352 {
4353
4354 return ::iter::case_insensitive_any_prefixes(*this, lpcszIsPrefixed, find, last);
4355
4356 }
4357
4358 template < typename ITYPE >
4359 typename ITERABLE::iterator find_first_ends(const ITYPE & lpcszSuffix, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr)
4360 {
4361
4362 return ::iter::find_first_ends(*this, lpcszSuffix, find, last);
4363
4364 }
4365
4366 template < typename ITYPE >
4367 typename ITERABLE::iterator case_insensitive_find_first_ends(const ITYPE & lpcszSuffix, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr)
4368 {
4369
4370 return ::iter::case_insensitive_find_first_ends(*this, lpcszSuffix, find, last);
4371
4372 }
4373
4374 template < typename ITYPE >
4375 typename ITERABLE::iterator find_first_ends_eat(ITYPE & str, const ITYPE & pcsz, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr)
4376 {
4377
4378 return ::iter::find_first_ends_eat(*this, str, pcsz, find, last);
4379
4380 }
4381
4382 template < typename ITYPE >
4383 typename ITERABLE::iterator case_insensitive_find_first_ends_eat(ITYPE & str, const ITYPE & pcsz, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr)
4384 {
4385
4386 return ::iter::case_insensitive_find_first_ends_eat(*this, str, pcsz, find, last);
4387
4388 }
4389
4390 template < typename ITYPE >
4391 typename ITERABLE::iterator find_first_begins(const ITYPE & lpcszPrefix, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr)
4392 {
4393
4394 return ::iter::find_first_begins(*this, lpclpcszPrefixsz, find, last);
4395
4396 }
4397
4398 template < typename ITYPE >
4399 typename ITERABLE::iterator case_insensitive_find_first_begins(const ITYPE & lpcszPrefix, typename ITERABLE::iterator find = 0, typename ITERABLE::iterator last = nullptr)
4400 {
4401
4402 return ::iter::case_insensitive_find_first_begins(*this, lpcszPrefix, find, last);
4403
4404 }
4405
4406 template < typename ITYPE >
4407 typename ITERABLE::iterator find_first_begins_eat(ITYPE & str, const ITYPE & pcsz, typename ITERABLE::iterator find = 0, typename ITERABLE::iterator last = nullptr)
4408 {
4409
4410 return ::iter::find_first_begins_eat(*this, str, pcsz, find, last);
4411
4412 }
4413
4414 template < typename ITYPE >
4415 typename ITERABLE::iterator case_insensitive_find_first_begins_eat(ITYPE & str, const ITYPE & pcsz, typename ITERABLE::iterator find = 0, typename ITERABLE::iterator last = nullptr)
4416 {
4417
4418 return ::iter::case_insensitive_find_first_begins_eat(*this, str, pcsz, find, last);
4419
4420 }
4421
4422 template < typename STRITERABLE, typename ITYPE >
4423 ::collection::count case_insensitive_get_begins(STRITERABLE & stra, const ITYPE & pcsz, typename ITERABLE::iterator first = 0, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr)
4424 {
4425
4426 return ::iter::case_insensitive_get_begins(*this, stra, pcsz, first, last);
4427
4428 }
4429
4430
4431 template < typename ITYPE >
4432 ::collection::count case_insensitive_filter_begins(const ITYPE & pcsz, typename ITERABLE::iterator first = 0, typename ITERABLE::iterator last = nullptr)
4433 {
4434
4435 return ::iter::case_insensitive_filter_begins(*this, pcsz, first, last);
4436
4437 }
4438
4439
4440 template < typename PRED >
4441 ::collection::count filter(PRED pred, typename ITERABLE::iterator first = 0, typename ITERABLE::iterator last = nullptr)
4442 {
4443
4444 return ::iter::filter(*this, pred, first, last);
4445
4446 }
4447
4448 template < typename PRED >
4449 ::collection::count filter_out(PRED pred, typename ITERABLE::iterator first = 0, typename ITERABLE::iterator last = nullptr)
4450 {
4451
4452 return ::iter::filter_out(*this, pred, first, last);
4453
4454 }
4455
4456 template < typename PRED, typename ArrayOut >
4457 ::collection::count filter_out(PRED pred, ArrayOut & a, typename ITERABLE::iterator first = 0, typename ITERABLE::iterator last = nullptr)
4458 {
4459
4460 return ::iter::filter_out(*this, pred, a, first, last);
4461
4462 }
4463
4464 template < typename ITYPE >
4465 ::collection::count case_insensitive_erase_first(const ITYPE & pcsz, typename ITERABLE::iterator find = nullptr, typename ITERABLE::iterator last = nullptr)
4466 {
4467
4468 return ::iter::case_insensitive_erase_first(*this, pcsz, first, last);
4469
4470 }
4471
4472 using ITERABLE::erase_first;
4473 template < typename ITYPE >
4474 ::collection::count erase_first(const ITYPE & pcsz, typename ITERABLE::iterator first = nullptr, typename ITERABLE::iterator last = nullptr)
4475 {
4476
4477 return ::iter::erase_first(*this, pcsz, first, last);
4478
4479 }
4480
4481 template < typename ITYPE >
4482 ::collection::count case_insensitive_erase_last(const ITYPE & pcsz, typename ITERABLE::iterator first = nullptr, typename ITERABLE::iterator last = nullptr)
4483 {
4484
4485 return ::iter::case_insensitive_erase_last(*this, pcsz, first, last);
4486
4487 }
4488
4489
4490 using ITERABLE::erase_last;
4491 template < typename ITYPE >
4492 ::collection::count erase_last(const ITYPE & pcsz, typename ITERABLE::iterator first = nullptr, typename ITERABLE::iterator last = nullptr)
4493 {
4494
4495 return ::iter::erase_last(*this, pcsz, first, last);
4496
4497 }
4498
4499
4500
4501
4502
4503 template < typename ITYPESEP, typename ITYPE2 >
4504 Container & explode(const ITYPESEP & strSeparator, const ITYPE2 & str)
4505 {
4506
4507 return ::iter::explode(*this, strSeparator, str);
4508
4509 }
4510
4511 // csstidy: Same as explode, but not within a ITYPE
4512 template < typename ITYPE >
4513 Container & csstidy_explode_ws(const ::i8 sep, const ITYPE & psz)
4514 {
4515
4516 return ::iter::csstidy_explode_ws(*this, sep, psz);
4517
4518 }
4519
4520 template < typename ITYPE >
4521 void get_format_string(const ITYPE & str, const ITYPE & lpcszSeparator) const
4522 {
4523
4524 return ::iter::get_format_string(*this, str, lpcszSeparator);
4525
4526 }
4527
4528 template < typename ITYPE >
4529 ITYPE & get_network_payload(ITYPE & str, bool bNewLine = true) const
4530 {
4531
4532 return ::iter::get_network_payload(*this, str, bNewLine);
4533
4534 }
4535
4536 template < typename ITYPE >
4537 void c_add(char_pointer * ppsz, ::collection::count iCount)
4538 {
4539
4540 return ::iter::c_add(*this, ppsz, iCount);
4541
4542 }
4543
4544 template < typename ITYPE >
4545 void c_add(char_pointer * ppsz)
4546 {
4547
4548 return ::iter::c_add(*this, ppsz);
4549
4550 }
4551
4552 template < typename ITYPE >
4553 void c_add(wchar_t ** ppsz, ::collection::count iCount)
4554 {
4555
4556 return ::iter::c_add(*this, ppsz, iCount);
4557
4558 }
4559
4560 template < typename ITYPE >
4561 void c_add(wchar_t ** ppsz)
4562 {
4563
4564 return ::iter::c_add(ppsz);
4565
4566 }
4567
4568
4569 template < typename ITYPE >
4570 bool contains_key(const ITYPE & key) const
4571 {
4572
4573 return ::iter::contains_key(*this, key);
4574
4575 }
4576
4577
4578 template < typename ITYPE >
4579 bool contains_payload(const ITYPE & value) const
4580 {
4581
4582 return ::iter::contains_payload(*this, value);
4583
4584 }
4585
4586
4587 template < typename ITYPE >
4588 bool contains(const ITYPE & value) const
4589 {
4590
4591 return ::iter::contains(*this, value);
4592
4593 }
4594
4595
4596 template < typename ITYPE >
4597 bool contains(const ITYPE & value, const_iterator first, const_iterator last = nullptr) const
4598 {
4599
4600 return ::iter::contains(*this, value, first, last);
4601
4602 }
4603
4604 template < typename ITYPE >
4605 bool case_insensitive_icontains(const ITYPE & value, index first = 0, ::collection::count count = -1) const
4606 {
4607
4608 return ::iter::case_insensitive_icontains(*this, value, first, count);
4609
4610 }
4611
4612
4613 template < typename ITYPE >
4614 bool icontains(const ITYPE & value, index first = 0, ::collection::count count = -1) const
4615 {
4616
4617 return ::iter::icontains(*this, value, first, count);
4618
4619 }
4620
4621 template < typename ITYPE >
4622 ::collection::count erase(const ITYPE & value)
4623 {
4624
4625 return ::iter::erase(*this, value);
4626
4627 }
4628
4629
4630 template < typename ITERABLE2 >
4631 ITERABLE & intersect(const ITERABLE2 & iterable2)
4632 {
4633
4634 return ::iter::intersect(*this, iterable2);
4635
4636 }
4637
4638 template < typename ITERABLE2 >
4639 typename ::collection::count add_unique_iter(const ITERABLE2 & stra)
4640 {
4641
4642 return ::iter::add_unique_iter(*this, stra);
4643
4644 }
4645
4646 template < typename ITERABLE2 >
4647 typename ::collection::count case_insensitive_add_unique_iter(const ITERABLE2 & stra)
4648 {
4649
4650 return ::iter::case_insensitive_add_unique_iter(*this, stra);
4651
4652 }
4653
4654 template < typename PRED >
4655 bool predicate_erase_first(PRED pred)
4656 {
4657
4658 return ::iter::predicate_erase_first(*this, pred);
4659
4660 }
4661
4662 template < typename PRED >
4663 typename ITERABLE::const_iterator predicate_find_first(PRED pred, typename ITERABLE::const_iterator first = nullptr, typename ITERABLE::const_iterator last = nullptr) const
4664 {
4665
4666 return ::iter::predicate_find_first(*this, pred, first, last);
4667
4668 }
4669
4670 template < typename PRED >
4671 typename ITERABLE::iterator predicate_find_first(PRED pred, typename ITERABLE::iterator first = nullptr, typename ITERABLE::iterator last = nullptr)
4672 {
4673
4674 return ::iter::predicate_find_first(*this, pred, first, last);
4675
4676 }
4677
4678 template < typename ITERATOR >
4679 Container slice(ITERATOR first, ITERATOR last = nullptr)
4680 {
4681
4682 Container iterableSlice;
4683
4684 ::iter::slice(*this, iterableSlice, first, last);
4685
4686 return iterableSlice;
4687
4688
4689 }
4690
4691 template < typename ::i32, typename INT2 >
4692 Container islice(::i32 first, INT2 count = -1)
4693 {
4694
4695 Container iterableSlice;
4696
4697 ::iter::islice(*this, iterableSlice, first, count);
4698
4699 return iterableSlice;
4700
4701
4702 }
4703
4704
4705 template < typename ITYPE >
4706 typename index ifind_first_begins(const ITYPE & lpcszPrefix, typename ITERABLE::const_iterator find = nullptr, typename ITERABLE::const_iterator last = nullptr) const
4707 {
4708
4709 return ::iter::ifind_first_begins(*this, lpcszPrefix, find, last);
4710
4711 }
4712
4713
4714 template < typename ITYPE >
4715 typename index ifind_first_begins(const ITYPE & lpcszPrefix, index first = 0, ::collection::count count = -1)
4716 {
4717
4718 return ::iter::ifind_first_begins(*this, lpcszPrefix, first, count);
4719
4720 }
4721
4722
4723 template < typename ITYPE >
4724 typename index ifind_first(const ITYPE & lpcszPrefix, ::collection::index find = 0, ::collection::count count = -1) const
4725 {
4726
4727 return ::iter::ifind_first(*this, lpcszPrefix, find, count);
4728
4729 }
4730
4731
4732 template < typename ITYPE >
4733 typename index ifind_first(const ITYPE & lpcszPrefix, ::collection::index find = 0, ::collection::count count = -1)
4734 {
4735
4736 return ::iter::ifind_first(*this, lpcszPrefix, find, count);
4737
4738 }
4739
4740
4741 template < typename ITYPE >
4742 typename index case_insensitive_ifind_first(const ITYPE & lpcszPrefix, ::collection::index find = 0, ::collection::count count = -1) const
4743 {
4744
4745 return ::iter::case_insensitive_ifind_first(*this, lpcszPrefix, find, count);
4746
4747 }
4748
4749 template < typename ITYPE >
4750 typename index case_insensitive_ifind_first(const ITYPE & lpcszPrefix, ::collection::index find = 0, ::collection::count count = -1)
4751 {
4752
4753 return ::iter::case_insensitive_ifind_first(*this, lpcszPrefix, find, count);
4754
4755 }
4756
4757
4758
4759
4760
4761
4762 template < typename SWAP >
4763 void swap_quick_sort(SWAP __swap, bool bAscending)
4764 {
4765
4766 ::sort::swap_quick_sort(*this, __swap, bAscending);
4767
4768 }
4769
4770 template < typename SWAP >
4771 void swap_quick_sort(SWAP __swap)
4772 {
4773
4774 ::sort::swap_quick_sort(*this, __swap);
4775
4776 }
4777
4778 template < typename SWAP >
4779 void swap_quick_sort_descending(SWAP __swap)
4780 {
4781
4782 ::sort::swap_quick_sort_desceding(*this, __swap);
4783
4784 }
4785
4786 template < typename SWAP >
4787 void case_insensitive_swap_quick_sort(SWAP __swap, bool bAscending)
4788 {
4789
4790 ::sort::swap_quick_sort(*this, __swap, bAscending);
4791
4792 }
4793
4794 template < typename SWAP >
4795 void case_insensitive_swap_quick_sort(SWAP __swap)
4796 {
4797
4798 ::sort::swap_quick_sort(*this, __swap);
4799
4800 }
4801
4802 template < typename SWAP >
4803 void swap_quick_sort_ci_descending(SWAP __swap)
4804 {
4805
4806 ::sort::swap_quick_sort_desceding(*this, __swap);
4807
4808 }
4809
4810
4811
4812
4813
4814
4815
4816 template < typename PRED >
4817 void predicate_quick_sort(PRED pred, bool bAscending)
4818 {
4819
4820 ::sort::predicate_quick_sort(*this, pred, bAscending);
4821
4822 }
4823
4824
4825 template < typename PRED >
4826 void predicate_quick_sort(PRED pred)
4827 {
4828
4829 ::sort::predicate_quick_sort(*this, pred);
4830
4831 }
4832
4833
4834 template < typename PRED >
4835 void predicate_quick_sort_descending(PRED pred)
4836 {
4837
4838 ::sort::predicate_quick_sort_descending(*this, pred);
4839
4840 }
4841
4842
4843
4844
4845
4846
4847 template < typename PRED, typename SWAP >
4848 void predicate_swap_quick_sort(PRED pred, SWAP __swap, bool bAscending)
4849 {
4850
4851 ::sort::predicate_swap_quick_sort(*this, pred, bAscending);
4852
4853 }
4854
4855
4856 template < typename PRED, typename SWAP >
4857 void predicate_swap_quick_sort(PRED pred, SWAP __swap)
4858 {
4859
4860 ::sort::predicate_swap_quick_sort(*this, pred);
4861
4862 }
4863
4864 template < typename PRED, typename SWAP >
4865 void predicate_swap_quick_sort_descending(PRED pred, SWAP __swap)
4866 {
4867
4868 ::sort::predicate_swap_quick_sort_descending(*this, pred, bAscending);
4869
4870 }
4871
4872
4873
4874
4875
4876
4877 template < typename INDEX_ARRAY >
4878 void get_quick_sort(const INDEX_ARRAY & ia)
4879 {
4880
4881 ::sort::get_quick_sort(*this, ia);
4882
4883 }
4884
4885 template < typename INDEX_ARRAY >
4886 void case_insensitive_get_quick_sort(const INDEX_ARRAY & ia)
4887 {
4888
4889 ::sort::case_insensitive_get_quick_sort(*this, ia);
4890
4891 }
4892
4893
4894 template < typename ITERABLE2 >
4895 bool is_equal(const ITERABLE2 & iterable2) const
4896 {
4897
4898 if (iterable2.get_count() != get_count())
4899 {
4900
4901 return false;
4902
4903 }
4904
4905 auto a = begin();
4906
4907 auto b = iterable2.begin();
4908
4909 for (; valid_iter(a, end()) && iterable2.valid_iter(b, iterable2.end()); a++, b++)
4910 {
4911
4912 if (!(*a == *b))
4913 {
4914
4915 return false;
4916
4917 }
4918
4919 }
4920
4921 return a == end() && b == iterable2.end();
4922
4923 }
4924
4925
4926};
4927
4928
4929
4930
iterable
Definition iterable.h:4040