6 * Use, modification and distribution are subject to the
\r
7 * Boost Software License, Version 1.0. (See accompanying file
\r
8 * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
\r
13 * LOCATION: see http://www.boost.org for most recent version.
\r
15 * VERSION see <boost/version.hpp>
\r
16 * DESCRIPTION: Declares regular expression concepts.
\r
19 #ifndef BOOST_REGEX_CONCEPTS_HPP_INCLUDED
\r
20 #define BOOST_REGEX_CONCEPTS_HPP_INCLUDED
\r
22 #include <boost/concept_archetype.hpp>
\r
23 #include <boost/concept_check.hpp>
\r
24 #include <boost/type_traits/is_enum.hpp>
\r
25 #include <boost/type_traits/is_base_and_derived.hpp>
\r
26 #include <boost/static_assert.hpp>
\r
27 #ifndef BOOST_TEST_TR1_REGEX
\r
28 #include <boost/regex.hpp>
\r
37 // bitmask_archetype:
\r
38 // this can be either an integer type, an enum, or a std::bitset,
\r
39 // we use the latter as the architype as it offers the "strictest"
\r
40 // of the possible interfaces:
\r
42 typedef std::bitset<512> bitmask_archetype;
\r
45 // A strict model for the character type interface.
\r
47 struct char_architype
\r
49 // default constructable:
\r
51 // copy constructable / assignable:
\r
52 char_architype(const char_architype&);
\r
53 char_architype& operator=(const char_architype&);
\r
54 // constructable from an integral value:
\r
55 char_architype(unsigned long val);
\r
57 bool operator==(const char_architype&)const;
\r
58 bool operator!=(const char_architype&)const;
\r
59 bool operator<(const char_architype&)const;
\r
60 bool operator<=(const char_architype&)const;
\r
61 bool operator>=(const char_architype&)const;
\r
62 bool operator>(const char_architype&)const;
\r
63 // conversion to integral type:
\r
64 operator long()const;
\r
67 // char_architype can not be used with basic_string:
\r
69 } // namespace boost
\r
71 template<> struct char_traits<boost::char_architype>
\r
73 // The intent is that this template is not instantiated,
\r
74 // but this typedef gives us a chance of compilation in
\r
76 typedef boost::char_architype char_type;
\r
81 // regex_traits_architype:
\r
82 // A strict interpretation of the regular expression traits class requirements.
\r
84 template <class charT>
\r
85 struct regex_traits_architype
\r
88 regex_traits_architype();
\r
89 typedef charT char_type;
\r
90 // typedef std::size_t size_type;
\r
91 typedef std::vector<char_type> string_type;
\r
92 typedef copy_constructible_archetype<assignable_archetype<> > locale_type;
\r
93 typedef bitmask_archetype char_class_type;
\r
95 static std::size_t length(const char_type* ) { return 0; }
\r
97 charT translate(charT ) const { return charT(); }
\r
98 charT translate_nocase(charT ) const { return static_object<charT>::get(); }
\r
100 template <class ForwardIterator>
\r
101 string_type transform(ForwardIterator , ForwardIterator ) const
\r
102 { return static_object<string_type>::get(); }
\r
103 template <class ForwardIterator>
\r
104 string_type transform_primary(ForwardIterator , ForwardIterator ) const
\r
105 { return static_object<string_type>::get(); }
\r
107 template <class ForwardIterator>
\r
108 char_class_type lookup_classname(ForwardIterator , ForwardIterator ) const
\r
109 { return static_object<char_class_type>::get(); }
\r
110 template <class ForwardIterator>
\r
111 string_type lookup_collatename(ForwardIterator , ForwardIterator ) const
\r
112 { return static_object<string_type>::get(); }
\r
114 bool isctype(charT, char_class_type) const
\r
116 int value(charT, int) const
\r
119 locale_type imbue(locale_type l)
\r
121 locale_type getloc()const
\r
122 { return static_object<locale_type>::get(); }
\r
125 // this type is not copyable:
\r
126 regex_traits_architype(const regex_traits_architype&);
\r
127 regex_traits_architype& operator=(const regex_traits_architype&);
\r
131 // alter this to std::tr1, to test a std implementation:
\r
133 #ifndef BOOST_TEST_TR1_REGEX
\r
134 namespace global_regex_namespace = ::boost;
\r
136 namespace global_regex_namespace = ::std::tr1;
\r
139 template <class Bitmask>
\r
140 struct BitmaskConcept
\r
142 void constraints()
\r
144 function_requires<CopyConstructibleConcept<Bitmask> >();
\r
145 function_requires<AssignableConcept<Bitmask> >();
\r
147 m_mask1 = m_mask2 | m_mask3;
\r
148 m_mask1 = m_mask2 & m_mask3;
\r
149 m_mask1 = m_mask2 ^ m_mask3;
\r
151 m_mask1 = ~m_mask2;
\r
153 m_mask1 |= m_mask2;
\r
154 m_mask1 &= m_mask2;
\r
155 m_mask1 ^= m_mask2;
\r
157 Bitmask m_mask1, m_mask2, m_mask3;
\r
160 template <class traits>
\r
161 struct RegexTraitsConcept
\r
163 RegexTraitsConcept();
\r
164 // required typedefs:
\r
165 typedef typename traits::char_type char_type;
\r
166 // typedef typename traits::size_type size_type;
\r
167 typedef typename traits::string_type string_type;
\r
168 typedef typename traits::locale_type locale_type;
\r
169 typedef typename traits::char_class_type char_class_type;
\r
171 void constraints()
\r
173 //function_requires<UnsignedIntegerConcept<size_type> >();
\r
174 function_requires<RandomAccessContainerConcept<string_type> >();
\r
175 function_requires<DefaultConstructibleConcept<locale_type> >();
\r
176 function_requires<CopyConstructibleConcept<locale_type> >();
\r
177 function_requires<AssignableConcept<locale_type> >();
\r
178 function_requires<BitmaskConcept<char_class_type> >();
\r
180 std::size_t n = traits::length(m_pointer);
\r
181 ignore_unused_variable_warning(n);
\r
183 char_type c = m_ctraits.translate(m_char);
\r
184 ignore_unused_variable_warning(c);
\r
185 c = m_ctraits.translate_nocase(m_char);
\r
187 //string_type::foobar bar;
\r
188 string_type s1 = m_ctraits.transform(m_pointer, m_pointer);
\r
189 ignore_unused_variable_warning(s1);
\r
191 string_type s2 = m_ctraits.transform_primary(m_pointer, m_pointer);
\r
192 ignore_unused_variable_warning(s2);
\r
194 char_class_type cc = m_ctraits.lookup_classname(m_pointer, m_pointer);
\r
195 ignore_unused_variable_warning(cc);
\r
197 string_type s3 = m_ctraits.lookup_collatename(m_pointer, m_pointer);
\r
198 ignore_unused_variable_warning(s3);
\r
200 bool b = m_ctraits.isctype(m_char, cc);
\r
201 ignore_unused_variable_warning(b);
\r
203 int v = m_ctraits.value(m_char, 16);
\r
204 ignore_unused_variable_warning(v);
\r
206 locale_type l(m_ctraits.getloc());
\r
208 ignore_unused_variable_warning(l);
\r
211 const traits m_ctraits;
\r
212 const char_type* m_pointer;
\r
215 RegexTraitsConcept& operator=(RegexTraitsConcept&);
\r
219 // helper class to compute what traits class a regular expression type is using:
\r
221 template <class Regex>
\r
222 struct regex_traits_computer;
\r
224 template <class charT, class traits>
\r
225 struct regex_traits_computer< global_regex_namespace::basic_regex<charT, traits> >
\r
227 typedef traits type;
\r
231 // BaseRegexConcept does not test anything dependent on basic_string,
\r
232 // in case our charT does not have an associated char_traits:
\r
234 template <class Regex>
\r
235 struct BaseRegexConcept
\r
237 typedef typename Regex::value_type value_type;
\r
238 //typedef typename Regex::size_type size_type;
\r
239 typedef typename Regex::flag_type flag_type;
\r
240 typedef typename Regex::locale_type locale_type;
\r
241 typedef input_iterator_archetype<value_type> input_iterator_type;
\r
243 // derived test types:
\r
244 typedef const value_type* pointer_type;
\r
245 typedef bidirectional_iterator_archetype<value_type> BidiIterator;
\r
246 typedef global_regex_namespace::sub_match<BidiIterator> sub_match_type;
\r
247 typedef global_regex_namespace::match_results<BidiIterator> match_results_type;
\r
248 typedef output_iterator_archetype<value_type> OutIterator;
\r
249 typedef typename regex_traits_computer<Regex>::type traits_type;
\r
250 typedef global_regex_namespace::regex_iterator<BidiIterator, value_type, traits_type> regex_iterator_type;
\r
251 typedef global_regex_namespace::regex_token_iterator<BidiIterator, value_type, traits_type> regex_token_iterator_type;
\r
253 void global_constraints()
\r
256 // test non-template components:
\r
258 function_requires<BitmaskConcept<global_regex_namespace::regex_constants::syntax_option_type> >();
\r
259 global_regex_namespace::regex_constants::syntax_option_type opts
\r
260 = global_regex_namespace::regex_constants::icase
\r
261 | global_regex_namespace::regex_constants::nosubs
\r
262 | global_regex_namespace::regex_constants::optimize
\r
263 | global_regex_namespace::regex_constants::collate
\r
264 | global_regex_namespace::regex_constants::ECMAScript
\r
265 | global_regex_namespace::regex_constants::basic
\r
266 | global_regex_namespace::regex_constants::extended
\r
267 | global_regex_namespace::regex_constants::awk
\r
268 | global_regex_namespace::regex_constants::grep
\r
269 | global_regex_namespace::regex_constants::egrep;
\r
270 ignore_unused_variable_warning(opts);
\r
272 function_requires<BitmaskConcept<global_regex_namespace::regex_constants::match_flag_type> >();
\r
273 global_regex_namespace::regex_constants::match_flag_type mopts
\r
274 = global_regex_namespace::regex_constants::match_default
\r
275 | global_regex_namespace::regex_constants::match_not_bol
\r
276 | global_regex_namespace::regex_constants::match_not_eol
\r
277 | global_regex_namespace::regex_constants::match_not_bow
\r
278 | global_regex_namespace::regex_constants::match_not_eow
\r
279 | global_regex_namespace::regex_constants::match_any
\r
280 | global_regex_namespace::regex_constants::match_not_null
\r
281 | global_regex_namespace::regex_constants::match_continuous
\r
282 | global_regex_namespace::regex_constants::match_prev_avail
\r
283 | global_regex_namespace::regex_constants::format_default
\r
284 | global_regex_namespace::regex_constants::format_sed
\r
285 | global_regex_namespace::regex_constants::format_no_copy
\r
286 | global_regex_namespace::regex_constants::format_first_only;
\r
287 ignore_unused_variable_warning(mopts);
\r
289 BOOST_STATIC_ASSERT((::boost::is_enum<global_regex_namespace::regex_constants::error_type>::value));
\r
290 global_regex_namespace::regex_constants::error_type e1 = global_regex_namespace::regex_constants::error_collate;
\r
291 ignore_unused_variable_warning(e1);
\r
292 e1 = global_regex_namespace::regex_constants::error_ctype;
\r
293 ignore_unused_variable_warning(e1);
\r
294 e1 = global_regex_namespace::regex_constants::error_escape;
\r
295 ignore_unused_variable_warning(e1);
\r
296 e1 = global_regex_namespace::regex_constants::error_backref;
\r
297 ignore_unused_variable_warning(e1);
\r
298 e1 = global_regex_namespace::regex_constants::error_brack;
\r
299 ignore_unused_variable_warning(e1);
\r
300 e1 = global_regex_namespace::regex_constants::error_paren;
\r
301 ignore_unused_variable_warning(e1);
\r
302 e1 = global_regex_namespace::regex_constants::error_brace;
\r
303 ignore_unused_variable_warning(e1);
\r
304 e1 = global_regex_namespace::regex_constants::error_badbrace;
\r
305 ignore_unused_variable_warning(e1);
\r
306 e1 = global_regex_namespace::regex_constants::error_range;
\r
307 ignore_unused_variable_warning(e1);
\r
308 e1 = global_regex_namespace::regex_constants::error_space;
\r
309 ignore_unused_variable_warning(e1);
\r
310 e1 = global_regex_namespace::regex_constants::error_badrepeat;
\r
311 ignore_unused_variable_warning(e1);
\r
312 e1 = global_regex_namespace::regex_constants::error_complexity;
\r
313 ignore_unused_variable_warning(e1);
\r
314 e1 = global_regex_namespace::regex_constants::error_stack;
\r
315 ignore_unused_variable_warning(e1);
\r
317 BOOST_STATIC_ASSERT((::boost::is_base_and_derived<std::runtime_error, global_regex_namespace::regex_error>::value ));
\r
318 const global_regex_namespace::regex_error except(e1);
\r
319 e1 = except.code();
\r
321 typedef typename Regex::value_type value_type;
\r
322 function_requires< RegexTraitsConcept<global_regex_namespace::regex_traits<char> > >();
\r
323 function_requires< BaseRegexConcept<global_regex_namespace::basic_regex<char> > >();
\r
325 void constraints()
\r
327 global_constraints();
\r
329 BOOST_STATIC_ASSERT((::boost::is_same< flag_type, global_regex_namespace::regex_constants::syntax_option_type>::value));
\r
335 | Regex::ECMAScript
\r
341 ignore_unused_variable_warning(opts);
\r
343 function_requires<DefaultConstructibleConcept<Regex> >();
\r
344 function_requires<CopyConstructibleConcept<Regex> >();
\r
346 // Regex constructors:
\r
347 Regex e1(m_pointer);
\r
348 ignore_unused_variable_warning(e1);
\r
349 Regex e2(m_pointer, m_flags);
\r
350 ignore_unused_variable_warning(e2);
\r
351 Regex e3(m_pointer, m_size, m_flags);
\r
352 ignore_unused_variable_warning(e3);
\r
353 Regex e4(in1, in2);
\r
354 ignore_unused_variable_warning(e4);
\r
355 Regex e5(in1, in2, m_flags);
\r
356 ignore_unused_variable_warning(e5);
\r
363 e.assign(m_pointer);
\r
364 e.assign(m_pointer, m_flags);
\r
365 e.assign(m_pointer, m_size, m_flags);
\r
366 e.assign(in1, in2);
\r
367 e.assign(in1, in2, m_flags);
\r
371 unsigned i = ce.mark_count();
\r
372 ignore_unused_variable_warning(i);
\r
373 m_flags = ce.flags();
\r
374 e.imbue(ce.getloc());
\r
377 global_regex_namespace::swap(e, e1);
\r
380 BOOST_STATIC_ASSERT((::boost::is_base_and_derived<std::pair<BidiIterator, BidiIterator>, sub_match_type>::value));
\r
381 typedef typename sub_match_type::value_type sub_value_type;
\r
382 typedef typename sub_match_type::difference_type sub_diff_type;
\r
383 typedef typename sub_match_type::iterator sub_iter_type;
\r
384 BOOST_STATIC_ASSERT((::boost::is_same<sub_value_type, value_type>::value));
\r
385 BOOST_STATIC_ASSERT((::boost::is_same<sub_iter_type, BidiIterator>::value));
\r
386 bool b = m_sub.matched;
\r
387 ignore_unused_variable_warning(b);
\r
388 BidiIterator bi = m_sub.first;
\r
389 ignore_unused_variable_warning(bi);
\r
391 ignore_unused_variable_warning(bi);
\r
392 sub_diff_type diff = m_sub.length();
\r
393 ignore_unused_variable_warning(diff);
\r
394 // match_results tests:
\r
395 typedef typename match_results_type::value_type mr_value_type;
\r
396 typedef typename match_results_type::const_reference mr_const_reference;
\r
397 typedef typename match_results_type::reference mr_reference;
\r
398 typedef typename match_results_type::const_iterator mr_const_iterator;
\r
399 typedef typename match_results_type::iterator mr_iterator;
\r
400 typedef typename match_results_type::difference_type mr_difference_type;
\r
401 typedef typename match_results_type::size_type mr_size_type;
\r
402 typedef typename match_results_type::allocator_type mr_allocator_type;
\r
403 typedef typename match_results_type::char_type mr_char_type;
\r
404 typedef typename match_results_type::string_type mr_string_type;
\r
406 match_results_type m1;
\r
407 mr_allocator_type at;
\r
408 match_results_type m2(at);
\r
409 match_results_type m3(m1);
\r
414 mr_size_type mrs = m_cresults.size();
\r
415 ignore_unused_variable_warning(mrs);
\r
416 mrs = m_cresults.max_size();
\r
417 ignore_unused_variable_warning(mrs);
\r
418 b = m_cresults.empty();
\r
419 ignore_unused_variable_warning(b);
\r
420 mr_difference_type mrd = m_cresults.length();
\r
421 ignore_unused_variable_warning(mrd);
\r
422 mrd = m_cresults.length(ival);
\r
423 ignore_unused_variable_warning(mrd);
\r
424 mrd = m_cresults.position();
\r
425 ignore_unused_variable_warning(mrd);
\r
426 mrd = m_cresults.position(mrs);
\r
427 ignore_unused_variable_warning(mrd);
\r
429 mr_const_reference mrcr = m_cresults[ival];
\r
430 ignore_unused_variable_warning(mrcr);
\r
431 mr_const_reference mrcr2 = m_cresults.prefix();
\r
432 ignore_unused_variable_warning(mrcr2);
\r
433 mr_const_reference mrcr3 = m_cresults.suffix();
\r
434 ignore_unused_variable_warning(mrcr3);
\r
435 mr_const_iterator mrci = m_cresults.begin();
\r
436 ignore_unused_variable_warning(mrci);
\r
437 mrci = m_cresults.end();
\r
438 ignore_unused_variable_warning(mrci);
\r
440 mr_allocator_type at2 = m_cresults.get_allocator();
\r
441 m_results.swap(m_results);
\r
442 global_regex_namespace::swap(m_results, m_results);
\r
445 b = global_regex_namespace::regex_match(m_in, m_in, m_results, e);
\r
446 ignore_unused_variable_warning(b);
\r
447 b = global_regex_namespace::regex_match(m_in, m_in, m_results, e, m_mft);
\r
448 ignore_unused_variable_warning(b);
\r
449 b = global_regex_namespace::regex_match(m_in, m_in, e);
\r
450 ignore_unused_variable_warning(b);
\r
451 b = global_regex_namespace::regex_match(m_in, m_in, e, m_mft);
\r
452 ignore_unused_variable_warning(b);
\r
453 b = global_regex_namespace::regex_match(m_pointer, m_pmatch, e);
\r
454 ignore_unused_variable_warning(b);
\r
455 b = global_regex_namespace::regex_match(m_pointer, m_pmatch, e, m_mft);
\r
456 ignore_unused_variable_warning(b);
\r
457 b = global_regex_namespace::regex_match(m_pointer, e);
\r
458 ignore_unused_variable_warning(b);
\r
459 b = global_regex_namespace::regex_match(m_pointer, e, m_mft);
\r
460 ignore_unused_variable_warning(b);
\r
462 b = global_regex_namespace::regex_search(m_in, m_in, m_results, e);
\r
463 ignore_unused_variable_warning(b);
\r
464 b = global_regex_namespace::regex_search(m_in, m_in, m_results, e, m_mft);
\r
465 ignore_unused_variable_warning(b);
\r
466 b = global_regex_namespace::regex_search(m_in, m_in, e);
\r
467 ignore_unused_variable_warning(b);
\r
468 b = global_regex_namespace::regex_search(m_in, m_in, e, m_mft);
\r
469 ignore_unused_variable_warning(b);
\r
470 b = global_regex_namespace::regex_search(m_pointer, m_pmatch, e);
\r
471 ignore_unused_variable_warning(b);
\r
472 b = global_regex_namespace::regex_search(m_pointer, m_pmatch, e, m_mft);
\r
473 ignore_unused_variable_warning(b);
\r
474 b = global_regex_namespace::regex_search(m_pointer, e);
\r
475 ignore_unused_variable_warning(b);
\r
476 b = global_regex_namespace::regex_search(m_pointer, e, m_mft);
\r
477 ignore_unused_variable_warning(b);
\r
480 typedef typename regex_iterator_type::regex_type rit_regex_type;
\r
481 typedef typename regex_iterator_type::value_type rit_value_type;
\r
482 typedef typename regex_iterator_type::difference_type rit_difference_type;
\r
483 typedef typename regex_iterator_type::pointer rit_pointer;
\r
484 typedef typename regex_iterator_type::reference rit_reference;
\r
485 typedef typename regex_iterator_type::iterator_category rit_iterator_category;
\r
486 BOOST_STATIC_ASSERT((::boost::is_same<rit_regex_type, Regex>::value));
\r
487 BOOST_STATIC_ASSERT((::boost::is_same<rit_value_type, match_results_type>::value));
\r
488 BOOST_STATIC_ASSERT((::boost::is_same<rit_difference_type, std::ptrdiff_t>::value));
\r
489 BOOST_STATIC_ASSERT((::boost::is_same<rit_pointer, const match_results_type*>::value));
\r
490 BOOST_STATIC_ASSERT((::boost::is_same<rit_reference, const match_results_type&>::value));
\r
491 BOOST_STATIC_ASSERT((::boost::is_convertible<rit_iterator_category*, std::forward_iterator_tag*>::value));
\r
492 // this takes care of most of the checks needed:
\r
493 function_requires<ForwardIteratorConcept<regex_iterator_type> >();
\r
494 regex_iterator_type iter1(m_in, m_in, e);
\r
495 ignore_unused_variable_warning(iter1);
\r
496 regex_iterator_type iter2(m_in, m_in, e, m_mft);
\r
497 ignore_unused_variable_warning(iter2);
\r
499 // regex_token_iterator:
\r
500 typedef typename regex_token_iterator_type::regex_type rtit_regex_type;
\r
501 typedef typename regex_token_iterator_type::value_type rtit_value_type;
\r
502 typedef typename regex_token_iterator_type::difference_type rtit_difference_type;
\r
503 typedef typename regex_token_iterator_type::pointer rtit_pointer;
\r
504 typedef typename regex_token_iterator_type::reference rtit_reference;
\r
505 typedef typename regex_token_iterator_type::iterator_category rtit_iterator_category;
\r
506 BOOST_STATIC_ASSERT((::boost::is_same<rtit_regex_type, Regex>::value));
\r
507 BOOST_STATIC_ASSERT((::boost::is_same<rtit_value_type, sub_match_type>::value));
\r
508 BOOST_STATIC_ASSERT((::boost::is_same<rtit_difference_type, std::ptrdiff_t>::value));
\r
509 BOOST_STATIC_ASSERT((::boost::is_same<rtit_pointer, const sub_match_type*>::value));
\r
510 BOOST_STATIC_ASSERT((::boost::is_same<rtit_reference, const sub_match_type&>::value));
\r
511 BOOST_STATIC_ASSERT((::boost::is_convertible<rtit_iterator_category*, std::forward_iterator_tag*>::value));
\r
512 // this takes care of most of the checks needed:
\r
513 function_requires<ForwardIteratorConcept<regex_token_iterator_type> >();
\r
514 regex_token_iterator_type ti1(m_in, m_in, e);
\r
515 ignore_unused_variable_warning(ti1);
\r
516 regex_token_iterator_type ti2(m_in, m_in, e, 0);
\r
517 ignore_unused_variable_warning(ti2);
\r
518 regex_token_iterator_type ti3(m_in, m_in, e, 0, m_mft);
\r
519 ignore_unused_variable_warning(ti3);
\r
520 std::vector<int> subs;
\r
521 regex_token_iterator_type ti4(m_in, m_in, e, subs);
\r
522 ignore_unused_variable_warning(ti4);
\r
523 regex_token_iterator_type ti5(m_in, m_in, e, subs, m_mft);
\r
524 ignore_unused_variable_warning(ti5);
\r
525 static const int i_array[3] = { 1, 2, 3, };
\r
526 regex_token_iterator_type ti6(m_in, m_in, e, i_array);
\r
527 ignore_unused_variable_warning(ti6);
\r
528 regex_token_iterator_type ti7(m_in, m_in, e, i_array, m_mft);
\r
529 ignore_unused_variable_warning(ti7);
\r
532 pointer_type m_pointer;
\r
534 std::size_t m_size;
\r
535 input_iterator_type in1, in2;
\r
536 const sub_match_type m_sub;
\r
537 const value_type m_char;
\r
538 match_results_type m_results;
\r
539 const match_results_type m_cresults;
\r
542 global_regex_namespace::regex_constants::match_flag_type m_mft;
\r
543 global_regex_namespace::match_results<pointer_type> m_pmatch;
\r
545 BaseRegexConcept();
\r
546 BaseRegexConcept(const BaseRegexConcept&);
\r
547 BaseRegexConcept& operator=(const BaseRegexConcept&);
\r
552 // Test every interface in the std:
\r
554 template <class Regex>
\r
555 struct RegexConcept
\r
557 typedef typename Regex::value_type value_type;
\r
558 //typedef typename Regex::size_type size_type;
\r
559 typedef typename Regex::flag_type flag_type;
\r
560 typedef typename Regex::locale_type locale_type;
\r
562 // derived test types:
\r
563 typedef const value_type* pointer_type;
\r
564 typedef std::basic_string<value_type> string_type;
\r
565 typedef boost::bidirectional_iterator_archetype<value_type> BidiIterator;
\r
566 typedef global_regex_namespace::sub_match<BidiIterator> sub_match_type;
\r
567 typedef global_regex_namespace::match_results<BidiIterator> match_results_type;
\r
568 typedef output_iterator_archetype<value_type> OutIterator;
\r
571 void constraints()
\r
573 function_requires<BaseRegexConcept<Regex> >();
\r
574 // string based construct:
\r
575 Regex e1(m_string);
\r
576 ignore_unused_variable_warning(e1);
\r
577 Regex e2(m_string, m_flags);
\r
578 ignore_unused_variable_warning(e2);
\r
583 e.assign(m_string);
\r
584 e.assign(m_string, m_flags);
\r
587 string_type s(m_sub);
\r
588 ignore_unused_variable_warning(s);
\r
590 ignore_unused_variable_warning(s);
\r
591 int i = m_sub.compare(m_string);
\r
592 ignore_unused_variable_warning(i);
\r
594 int i2 = m_sub.compare(m_sub);
\r
595 ignore_unused_variable_warning(i2);
\r
596 i2 = m_sub.compare(m_pointer);
\r
597 ignore_unused_variable_warning(i2);
\r
599 bool b = m_sub == m_sub;
\r
600 ignore_unused_variable_warning(b);
\r
601 b = m_sub != m_sub;
\r
602 ignore_unused_variable_warning(b);
\r
603 b = m_sub <= m_sub;
\r
604 ignore_unused_variable_warning(b);
\r
605 b = m_sub <= m_sub;
\r
606 ignore_unused_variable_warning(b);
\r
608 ignore_unused_variable_warning(b);
\r
609 b = m_sub >= m_sub;
\r
610 ignore_unused_variable_warning(b);
\r
612 b = m_sub == m_pointer;
\r
613 ignore_unused_variable_warning(b);
\r
614 b = m_sub != m_pointer;
\r
615 ignore_unused_variable_warning(b);
\r
616 b = m_sub <= m_pointer;
\r
617 ignore_unused_variable_warning(b);
\r
618 b = m_sub <= m_pointer;
\r
619 ignore_unused_variable_warning(b);
\r
620 b = m_sub > m_pointer;
\r
621 ignore_unused_variable_warning(b);
\r
622 b = m_sub >= m_pointer;
\r
623 ignore_unused_variable_warning(b);
\r
625 b = m_pointer == m_sub;
\r
626 ignore_unused_variable_warning(b);
\r
627 b = m_pointer != m_sub;
\r
628 ignore_unused_variable_warning(b);
\r
629 b = m_pointer <= m_sub;
\r
630 ignore_unused_variable_warning(b);
\r
631 b = m_pointer <= m_sub;
\r
632 ignore_unused_variable_warning(b);
\r
633 b = m_pointer > m_sub;
\r
634 ignore_unused_variable_warning(b);
\r
635 b = m_pointer >= m_sub;
\r
636 ignore_unused_variable_warning(b);
\r
638 b = m_sub == m_char;
\r
639 ignore_unused_variable_warning(b);
\r
640 b = m_sub != m_char;
\r
641 ignore_unused_variable_warning(b);
\r
642 b = m_sub <= m_char;
\r
643 ignore_unused_variable_warning(b);
\r
644 b = m_sub <= m_char;
\r
645 ignore_unused_variable_warning(b);
\r
646 b = m_sub > m_char;
\r
647 ignore_unused_variable_warning(b);
\r
648 b = m_sub >= m_char;
\r
649 ignore_unused_variable_warning(b);
\r
651 b = m_char == m_sub;
\r
652 ignore_unused_variable_warning(b);
\r
653 b = m_char != m_sub;
\r
654 ignore_unused_variable_warning(b);
\r
655 b = m_char <= m_sub;
\r
656 ignore_unused_variable_warning(b);
\r
657 b = m_char <= m_sub;
\r
658 ignore_unused_variable_warning(b);
\r
659 b = m_char > m_sub;
\r
660 ignore_unused_variable_warning(b);
\r
661 b = m_char >= m_sub;
\r
662 ignore_unused_variable_warning(b);
\r
664 b = m_sub == m_string;
\r
665 ignore_unused_variable_warning(b);
\r
666 b = m_sub != m_string;
\r
667 ignore_unused_variable_warning(b);
\r
668 b = m_sub <= m_string;
\r
669 ignore_unused_variable_warning(b);
\r
670 b = m_sub <= m_string;
\r
671 ignore_unused_variable_warning(b);
\r
672 b = m_sub > m_string;
\r
673 ignore_unused_variable_warning(b);
\r
674 b = m_sub >= m_string;
\r
675 ignore_unused_variable_warning(b);
\r
677 b = m_string == m_sub;
\r
678 ignore_unused_variable_warning(b);
\r
679 b = m_string != m_sub;
\r
680 ignore_unused_variable_warning(b);
\r
681 b = m_string <= m_sub;
\r
682 ignore_unused_variable_warning(b);
\r
683 b = m_string <= m_sub;
\r
684 ignore_unused_variable_warning(b);
\r
685 b = m_string > m_sub;
\r
686 ignore_unused_variable_warning(b);
\r
687 b = m_string >= m_sub;
\r
688 ignore_unused_variable_warning(b);
\r
691 m_string = m_results.str();
\r
692 ignore_unused_variable_warning(m_string);
\r
693 m_string = m_results.str(0);
\r
694 ignore_unused_variable_warning(m_string);
\r
695 m_out = m_cresults.format(m_out, m_string);
\r
696 m_out = m_cresults.format(m_out, m_string, m_mft);
\r
697 m_string = m_cresults.format(m_string);
\r
698 ignore_unused_variable_warning(m_string);
\r
699 m_string = m_cresults.format(m_string, m_mft);
\r
700 ignore_unused_variable_warning(m_string);
\r
703 b = global_regex_namespace::regex_match(m_string, m_smatch, e);
\r
704 ignore_unused_variable_warning(b);
\r
705 b = global_regex_namespace::regex_match(m_string, m_smatch, e, m_mft);
\r
706 ignore_unused_variable_warning(b);
\r
707 b = global_regex_namespace::regex_match(m_string, e);
\r
708 ignore_unused_variable_warning(b);
\r
709 b = global_regex_namespace::regex_match(m_string, e, m_mft);
\r
710 ignore_unused_variable_warning(b);
\r
713 b = global_regex_namespace::regex_search(m_string, m_smatch, e);
\r
714 ignore_unused_variable_warning(b);
\r
715 b = global_regex_namespace::regex_search(m_string, m_smatch, e, m_mft);
\r
716 ignore_unused_variable_warning(b);
\r
717 b = global_regex_namespace::regex_search(m_string, e);
\r
718 ignore_unused_variable_warning(b);
\r
719 b = global_regex_namespace::regex_search(m_string, e, m_mft);
\r
720 ignore_unused_variable_warning(b);
\r
723 m_out = global_regex_namespace::regex_replace(m_out, m_in, m_in, e, m_string, m_mft);
\r
724 m_out = global_regex_namespace::regex_replace(m_out, m_in, m_in, e, m_string);
\r
725 m_string = global_regex_namespace::regex_replace(m_string, e, m_string, m_mft);
\r
726 ignore_unused_variable_warning(m_string);
\r
727 m_string = global_regex_namespace::regex_replace(m_string, e, m_string);
\r
728 ignore_unused_variable_warning(m_string);
\r
733 string_type m_string;
\r
734 const sub_match_type m_sub;
\r
735 match_results_type m_results;
\r
736 pointer_type m_pointer;
\r
738 const match_results_type m_cresults;
\r
741 global_regex_namespace::regex_constants::match_flag_type m_mft;
\r
742 global_regex_namespace::match_results<typename string_type::const_iterator> m_smatch;
\r
745 RegexConcept(const RegexConcept&);
\r
746 RegexConcept& operator=(const RegexConcept&);
\r
749 #ifndef BOOST_REGEX_TEST_STD
\r
751 // BoostRegexConcept:
\r
752 // Test every interface in the Boost implementation:
\r
754 template <class Regex>
\r
755 struct BoostRegexConcept
\r
757 typedef typename Regex::value_type value_type;
\r
758 typedef typename Regex::size_type size_type;
\r
759 typedef typename Regex::flag_type flag_type;
\r
760 typedef typename Regex::locale_type locale_type;
\r
762 // derived test types:
\r
763 typedef const value_type* pointer_type;
\r
764 typedef std::basic_string<value_type> string_type;
\r
765 typedef typename Regex::const_iterator const_iterator;
\r
766 typedef bidirectional_iterator_archetype<value_type> BidiIterator;
\r
767 typedef global_regex_namespace::sub_match<BidiIterator> sub_match_type;
\r
768 typedef global_regex_namespace::match_results<BidiIterator> match_results_type;
\r
770 void constraints()
\r
772 global_regex_namespace::regex_constants::match_flag_type mopts
\r
773 = global_regex_namespace::regex_constants::match_default
\r
774 | global_regex_namespace::regex_constants::match_not_bol
\r
775 | global_regex_namespace::regex_constants::match_not_eol
\r
776 | global_regex_namespace::regex_constants::match_not_bow
\r
777 | global_regex_namespace::regex_constants::match_not_eow
\r
778 | global_regex_namespace::regex_constants::match_any
\r
779 | global_regex_namespace::regex_constants::match_not_null
\r
780 | global_regex_namespace::regex_constants::match_continuous
\r
781 | global_regex_namespace::regex_constants::match_partial
\r
782 | global_regex_namespace::regex_constants::match_prev_avail
\r
783 | global_regex_namespace::regex_constants::format_default
\r
784 | global_regex_namespace::regex_constants::format_sed
\r
785 | global_regex_namespace::regex_constants::format_perl
\r
786 | global_regex_namespace::regex_constants::format_no_copy
\r
787 | global_regex_namespace::regex_constants::format_first_only;
\r
791 function_requires<RegexConcept<Regex> >();
\r
792 const global_regex_namespace::regex_error except(global_regex_namespace::regex_constants::error_collate);
\r
793 std::ptrdiff_t pt = except.position();
\r
794 ignore_unused_variable_warning(pt);
\r
795 const Regex ce, ce2;
\r
796 #ifndef BOOST_NO_STD_LOCALE
\r
799 unsigned i = ce.error_code();
\r
800 ignore_unused_variable_warning(i);
\r
801 pointer_type p = ce.expression();
\r
802 ignore_unused_variable_warning(p);
\r
803 int i2 = ce.compare(ce2);
\r
804 ignore_unused_variable_warning(i2);
\r
805 bool b = ce == ce2;
\r
806 ignore_unused_variable_warning(b);
\r
808 ignore_unused_variable_warning(b);
\r
810 ignore_unused_variable_warning(b);
\r
812 ignore_unused_variable_warning(b);
\r
814 ignore_unused_variable_warning(b);
\r
816 ignore_unused_variable_warning(b);
\r
818 ignore_unused_variable_warning(b);
\r
820 ignore_unused_variable_warning(i);
\r
821 size_type s = ce.max_size();
\r
822 ignore_unused_variable_warning(s);
\r
824 ignore_unused_variable_warning(s);
\r
825 const_iterator pi = ce.begin();
\r
826 ignore_unused_variable_warning(pi);
\r
828 ignore_unused_variable_warning(pi);
\r
829 string_type s2 = ce.str();
\r
830 ignore_unused_variable_warning(s2);
\r
832 m_string = m_sub + m_sub;
\r
833 ignore_unused_variable_warning(m_string);
\r
834 m_string = m_sub + m_pointer;
\r
835 ignore_unused_variable_warning(m_string);
\r
836 m_string = m_pointer + m_sub;
\r
837 ignore_unused_variable_warning(m_string);
\r
838 m_string = m_sub + m_string;
\r
839 ignore_unused_variable_warning(m_string);
\r
840 m_string = m_string + m_sub;
\r
841 ignore_unused_variable_warning(m_string);
\r
842 m_string = m_sub + m_char;
\r
843 ignore_unused_variable_warning(m_string);
\r
844 m_string = m_char + m_sub;
\r
845 ignore_unused_variable_warning(m_string);
\r
847 // Named sub-expressions:
\r
848 m_sub = m_cresults[&m_char];
\r
849 ignore_unused_variable_warning(m_sub);
\r
850 m_sub = m_cresults[m_string];
\r
851 ignore_unused_variable_warning(m_sub);
\r
852 m_sub = m_cresults[""];
\r
853 ignore_unused_variable_warning(m_sub);
\r
854 m_sub = m_cresults[std::string("")];
\r
855 ignore_unused_variable_warning(m_sub);
\r
856 m_string = m_cresults.str(&m_char);
\r
857 ignore_unused_variable_warning(m_string);
\r
858 m_string = m_cresults.str(m_string);
\r
859 ignore_unused_variable_warning(m_string);
\r
860 m_string = m_cresults.str("");
\r
861 ignore_unused_variable_warning(m_string);
\r
862 m_string = m_cresults.str(std::string(""));
\r
863 ignore_unused_variable_warning(m_string);
\r
865 typename match_results_type::difference_type diff;
\r
866 diff = m_cresults.length(&m_char);
\r
867 ignore_unused_variable_warning(diff);
\r
868 diff = m_cresults.length(m_string);
\r
869 ignore_unused_variable_warning(diff);
\r
870 diff = m_cresults.length("");
\r
871 ignore_unused_variable_warning(diff);
\r
872 diff = m_cresults.length(std::string(""));
\r
873 ignore_unused_variable_warning(diff);
\r
874 diff = m_cresults.position(&m_char);
\r
875 ignore_unused_variable_warning(diff);
\r
876 diff = m_cresults.position(m_string);
\r
877 ignore_unused_variable_warning(diff);
\r
878 diff = m_cresults.position("");
\r
879 ignore_unused_variable_warning(diff);
\r
880 diff = m_cresults.position(std::string(""));
\r
881 ignore_unused_variable_warning(diff);
\r
883 #ifndef BOOST_NO_STD_LOCALE
\r
885 m_stream << m_cresults;
\r
889 std::basic_ostream<value_type> m_stream;
\r
890 sub_match_type m_sub;
\r
891 pointer_type m_pointer;
\r
892 string_type m_string;
\r
893 const value_type m_char;
\r
894 match_results_type m_results;
\r
895 const match_results_type m_cresults;
\r
897 BoostRegexConcept();
\r
898 BoostRegexConcept(const BoostRegexConcept&);
\r
899 BoostRegexConcept& operator=(const BoostRegexConcept&);
\r
902 #endif // BOOST_REGEX_TEST_STD
\r