1 /*
2  *
3  * Copyright (c) 2004
4  * John Maddock
5  *
6  * Use, modification and distribution are subject to the
7  * Boost Software License, Version 1.0. (See accompanying file
8  * LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
9  *
10  */
11 
12  /*
13   *   LOCATION:    see http://www.boost.org for most recent version.
14   *   FILE         concepts.hpp
15   *   VERSION      see <boost/version.hpp>
16   *   DESCRIPTION: Declares regular expression concepts.
17   */
18 
19 #ifndef BOOST_REGEX_CONCEPTS_HPP_INCLUDED
20 #define BOOST_REGEX_CONCEPTS_HPP_INCLUDED
21 
22 #include <boost/concept_archetype.hpp>
23 #include <boost/concept_check.hpp>
24 #include <boost/type_traits/is_enum.hpp>
25 #include <boost/type_traits/is_base_and_derived.hpp>
26 #include <boost/static_assert.hpp>
27 #ifndef BOOST_TEST_TR1_REGEX
28 #include <boost/regex.hpp>
29 #endif
30 #include <bitset>
31 #include <vector>
32 #include <iostream>
33 
34 #ifdef BOOST_REGEX_CXX03
35 #define RW_NS boost
36 #else
37 #define RW_NS std
38 #endif
39 
40 namespace boost{
41 
42 //
43 // bitmask_archetype:
44 // this can be either an integer type, an enum, or a std::bitset,
45 // we use the latter as the architype as it offers the "strictest"
46 // of the possible interfaces:
47 //
48 typedef std::bitset<512> bitmask_archetype;
49 //
50 // char_architype:
51 // A strict model for the character type interface.
52 //
53 struct char_architype
54 {
55    // default constructable:
56    char_architype();
57    // copy constructable / assignable:
58    char_architype(const char_architype&);
59    char_architype& operator=(const char_architype&);
60    // constructable from an integral value:
61    char_architype(unsigned long val);
62    // comparable:
63    bool operator==(const char_architype&)const;
64    bool operator!=(const char_architype&)const;
65    bool operator<(const char_architype&)const;
66    bool operator<=(const char_architype&)const;
67    bool operator>=(const char_architype&)const;
68    bool operator>(const char_architype&)const;
69    // conversion to integral type:
70    operator long()const;
71 };
hash_value(char_architype val)72 inline long hash_value(char_architype val)
73 {  return val;  }
74 //
75 // char_architype can not be used with basic_string:
76 //
77 } // namespace boost
78 namespace std{
79    template<> struct char_traits<boost::char_architype>
80    {
81       // The intent is that this template is not instantiated,
82       // but this typedef gives us a chance of compilation in
83       // case it is:
84       typedef boost::char_architype char_type;
85    };
86 }
87 //
88 // Allocator architype:
89 //
90 template <class T>
91 class allocator_architype
92 {
93 public:
94    typedef T* pointer;
95    typedef const T* const_pointer;
96    typedef T& reference;
97    typedef const T& const_reference;
98    typedef T value_type;
99    typedef unsigned size_type;
100    typedef int difference_type;
101 
102    template <class U>
103    struct rebind
104    {
105       typedef allocator_architype<U> other;
106    };
107 
address(reference r)108    pointer address(reference r){ return &r; }
address(const_reference r)109    const_pointer address(const_reference r) { return &r; }
allocate(size_type n)110    pointer allocate(size_type n) { return static_cast<pointer>(std::malloc(n)); }
allocate(size_type n,pointer)111    pointer allocate(size_type n, pointer) { return static_cast<pointer>(std::malloc(n)); }
deallocate(pointer p,size_type)112    void deallocate(pointer p, size_type) { std::free(p); }
max_size() const113    size_type max_size()const { return UINT_MAX; }
114 
allocator_architype()115    allocator_architype(){}
allocator_architype(const allocator_architype &)116    allocator_architype(const allocator_architype&){}
117 
118    template <class Other>
allocator_architype(const allocator_architype<Other> &)119    allocator_architype(const allocator_architype<Other>&){}
120 
construct(pointer p,const_reference r)121    void construct(pointer p, const_reference r) { new (p)T(r); }
destroy(pointer p)122    void destroy(pointer p) { p->~T(); }
123 };
124 
125 template <class T>
operator ==(const allocator_architype<T> &,const allocator_architype<T> &)126 bool operator == (const allocator_architype<T>&, const allocator_architype<T>&) {return true; }
127 template <class T>
operator !=(const allocator_architype<T> &,const allocator_architype<T> &)128 bool operator != (const allocator_architype<T>&, const allocator_architype<T>&) { return false; }
129 
130 namespace boost{
131 //
132 // regex_traits_architype:
133 // A strict interpretation of the regular expression traits class requirements.
134 //
135 template <class charT>
136 struct regex_traits_architype
137 {
138 public:
regex_traits_architypeboost::regex_traits_architype139    regex_traits_architype(){}
140    typedef charT char_type;
141    // typedef std::size_t size_type;
142    typedef std::vector<char_type> string_type;
143    typedef copy_constructible_archetype<assignable_archetype<> > locale_type;
144    typedef bitmask_archetype char_class_type;
145 
lengthboost::regex_traits_architype146    static std::size_t length(const char_type* ) { return 0; }
147 
translateboost::regex_traits_architype148    charT translate(charT ) const { return charT(); }
translate_nocaseboost::regex_traits_architype149    charT translate_nocase(charT ) const { return static_object<charT>::get(); }
150 
151    template <class ForwardIterator>
transformboost::regex_traits_architype152    string_type transform(ForwardIterator , ForwardIterator ) const
153    { return static_object<string_type>::get(); }
154    template <class ForwardIterator>
transform_primaryboost::regex_traits_architype155    string_type transform_primary(ForwardIterator , ForwardIterator ) const
156    { return static_object<string_type>::get(); }
157 
158    template <class ForwardIterator>
lookup_classnameboost::regex_traits_architype159    char_class_type lookup_classname(ForwardIterator , ForwardIterator ) const
160    { return static_object<char_class_type>::get(); }
161    template <class ForwardIterator>
lookup_collatenameboost::regex_traits_architype162    string_type lookup_collatename(ForwardIterator , ForwardIterator ) const
163    { return static_object<string_type>::get(); }
164 
isctypeboost::regex_traits_architype165    bool isctype(charT, char_class_type) const
166    { return false; }
valueboost::regex_traits_architype167    int value(charT, int) const
168    { return 0; }
169 
imbueboost::regex_traits_architype170    locale_type imbue(locale_type l)
171    { return l; }
getlocboost::regex_traits_architype172    locale_type getloc()const
173    { return static_object<locale_type>::get(); }
174 
175 private:
176    // this type is not copyable:
regex_traits_architypeboost::regex_traits_architype177    regex_traits_architype(const regex_traits_architype&){}
operator =boost::regex_traits_architype178    regex_traits_architype& operator=(const regex_traits_architype&){ return *this; }
179 };
180 
181 //
182 // alter this to std::tr1, to test a std implementation:
183 //
184 #ifndef BOOST_TEST_TR1_REGEX
185 namespace global_regex_namespace = ::boost;
186 #else
187 namespace global_regex_namespace = ::std::tr1;
188 #endif
189 
190 template <class Bitmask>
191 struct BitmaskConcept
192 {
constraintsboost::BitmaskConcept193    void constraints()
194    {
195       function_requires<CopyConstructibleConcept<Bitmask> >();
196       function_requires<AssignableConcept<Bitmask> >();
197 
198       m_mask1 = m_mask2 | m_mask3;
199       m_mask1 = m_mask2 & m_mask3;
200       m_mask1 = m_mask2 ^ m_mask3;
201 
202       m_mask1 = ~m_mask2;
203 
204       m_mask1 |= m_mask2;
205       m_mask1 &= m_mask2;
206       m_mask1 ^= m_mask2;
207    }
208    Bitmask m_mask1, m_mask2, m_mask3;
209 };
210 
211 template <class traits>
212 struct RegexTraitsConcept
213 {
214    RegexTraitsConcept();
215    // required typedefs:
216    typedef typename traits::char_type char_type;
217    // typedef typename traits::size_type size_type;
218    typedef typename traits::string_type string_type;
219    typedef typename traits::locale_type locale_type;
220    typedef typename traits::char_class_type char_class_type;
221 
constraintsboost::RegexTraitsConcept222    void constraints()
223    {
224       //function_requires<UnsignedIntegerConcept<size_type> >();
225       function_requires<RandomAccessContainerConcept<string_type> >();
226       function_requires<DefaultConstructibleConcept<locale_type> >();
227       function_requires<CopyConstructibleConcept<locale_type> >();
228       function_requires<AssignableConcept<locale_type> >();
229       function_requires<BitmaskConcept<char_class_type> >();
230 
231       std::size_t n = traits::length(m_pointer);
232       ignore_unused_variable_warning(n);
233 
234       char_type c = m_ctraits.translate(m_char);
235       ignore_unused_variable_warning(c);
236       c = m_ctraits.translate_nocase(m_char);
237 
238       //string_type::foobar bar;
239       string_type s1 = m_ctraits.transform(m_pointer, m_pointer);
240       ignore_unused_variable_warning(s1);
241 
242       string_type s2 = m_ctraits.transform_primary(m_pointer, m_pointer);
243       ignore_unused_variable_warning(s2);
244 
245       char_class_type cc = m_ctraits.lookup_classname(m_pointer, m_pointer);
246       ignore_unused_variable_warning(cc);
247 
248       string_type s3 = m_ctraits.lookup_collatename(m_pointer, m_pointer);
249       ignore_unused_variable_warning(s3);
250 
251       bool b = m_ctraits.isctype(m_char, cc);
252       ignore_unused_variable_warning(b);
253 
254       int v = m_ctraits.value(m_char, 16);
255       ignore_unused_variable_warning(v);
256 
257       locale_type l(m_ctraits.getloc());
258       m_traits.imbue(l);
259       ignore_unused_variable_warning(l);
260    }
261    traits m_traits;
262    const traits m_ctraits;
263    const char_type* m_pointer;
264    char_type m_char;
265 private:
266    RegexTraitsConcept& operator=(RegexTraitsConcept&);
267 };
268 
269 //
270 // helper class to compute what traits class a regular expression type is using:
271 //
272 template <class Regex>
273 struct regex_traits_computer;
274 
275 template <class charT, class traits>
276 struct regex_traits_computer< global_regex_namespace::basic_regex<charT, traits> >
277 {
278    typedef traits type;
279 };
280 
281 //
282 // BaseRegexConcept does not test anything dependent on basic_string,
283 // in case our charT does not have an associated char_traits:
284 //
285 template <class Regex>
286 struct BaseRegexConcept
287 {
288    typedef typename Regex::value_type value_type;
289    //typedef typename Regex::size_type size_type;
290    typedef typename Regex::flag_type flag_type;
291    typedef typename Regex::locale_type locale_type;
292    typedef input_iterator_archetype<value_type> input_iterator_type;
293 
294    // derived test types:
295    typedef const value_type* pointer_type;
296    typedef bidirectional_iterator_archetype<value_type> BidiIterator;
297    typedef global_regex_namespace::sub_match<BidiIterator> sub_match_type;
298    typedef global_regex_namespace::match_results<BidiIterator, allocator_architype<sub_match_type> > match_results_type;
299    typedef global_regex_namespace::match_results<BidiIterator> match_results_default_type;
300    typedef output_iterator_archetype<value_type> OutIterator;
301    typedef typename regex_traits_computer<Regex>::type traits_type;
302    typedef global_regex_namespace::regex_iterator<BidiIterator, value_type, traits_type> regex_iterator_type;
303    typedef global_regex_namespace::regex_token_iterator<BidiIterator, value_type, traits_type> regex_token_iterator_type;
304 
global_constraintsboost::BaseRegexConcept305    void global_constraints()
306    {
307       //
308       // test non-template components:
309       //
310       function_requires<BitmaskConcept<global_regex_namespace::regex_constants::syntax_option_type> >();
311       global_regex_namespace::regex_constants::syntax_option_type opts
312          = global_regex_namespace::regex_constants::icase
313          | global_regex_namespace::regex_constants::nosubs
314          | global_regex_namespace::regex_constants::optimize
315          | global_regex_namespace::regex_constants::collate
316          | global_regex_namespace::regex_constants::ECMAScript
317          | global_regex_namespace::regex_constants::basic
318          | global_regex_namespace::regex_constants::extended
319          | global_regex_namespace::regex_constants::awk
320          | global_regex_namespace::regex_constants::grep
321          | global_regex_namespace::regex_constants::egrep;
322       ignore_unused_variable_warning(opts);
323 
324       function_requires<BitmaskConcept<global_regex_namespace::regex_constants::match_flag_type> >();
325       global_regex_namespace::regex_constants::match_flag_type mopts
326          = global_regex_namespace::regex_constants::match_default
327          | global_regex_namespace::regex_constants::match_not_bol
328          | global_regex_namespace::regex_constants::match_not_eol
329          | global_regex_namespace::regex_constants::match_not_bow
330          | global_regex_namespace::regex_constants::match_not_eow
331          | global_regex_namespace::regex_constants::match_any
332          | global_regex_namespace::regex_constants::match_not_null
333          | global_regex_namespace::regex_constants::match_continuous
334          | global_regex_namespace::regex_constants::match_prev_avail
335          | global_regex_namespace::regex_constants::format_default
336          | global_regex_namespace::regex_constants::format_sed
337          | global_regex_namespace::regex_constants::format_no_copy
338          | global_regex_namespace::regex_constants::format_first_only;
339       ignore_unused_variable_warning(mopts);
340 
341       BOOST_STATIC_ASSERT((::boost::is_enum<global_regex_namespace::regex_constants::error_type>::value));
342       global_regex_namespace::regex_constants::error_type e1 = global_regex_namespace::regex_constants::error_collate;
343       ignore_unused_variable_warning(e1);
344       e1 = global_regex_namespace::regex_constants::error_ctype;
345       ignore_unused_variable_warning(e1);
346       e1 = global_regex_namespace::regex_constants::error_escape;
347       ignore_unused_variable_warning(e1);
348       e1 = global_regex_namespace::regex_constants::error_backref;
349       ignore_unused_variable_warning(e1);
350       e1 = global_regex_namespace::regex_constants::error_brack;
351       ignore_unused_variable_warning(e1);
352       e1 = global_regex_namespace::regex_constants::error_paren;
353       ignore_unused_variable_warning(e1);
354       e1 = global_regex_namespace::regex_constants::error_brace;
355       ignore_unused_variable_warning(e1);
356       e1 = global_regex_namespace::regex_constants::error_badbrace;
357       ignore_unused_variable_warning(e1);
358       e1 = global_regex_namespace::regex_constants::error_range;
359       ignore_unused_variable_warning(e1);
360       e1 = global_regex_namespace::regex_constants::error_space;
361       ignore_unused_variable_warning(e1);
362       e1 = global_regex_namespace::regex_constants::error_badrepeat;
363       ignore_unused_variable_warning(e1);
364       e1 = global_regex_namespace::regex_constants::error_complexity;
365       ignore_unused_variable_warning(e1);
366       e1 = global_regex_namespace::regex_constants::error_stack;
367       ignore_unused_variable_warning(e1);
368 
369       BOOST_STATIC_ASSERT((::boost::is_base_and_derived<std::runtime_error, global_regex_namespace::regex_error>::value  ));
370       const global_regex_namespace::regex_error except(e1);
371       e1 = except.code();
372 
373       typedef typename Regex::value_type regex_value_type;
374       function_requires< RegexTraitsConcept<global_regex_namespace::regex_traits<char> > >();
375       function_requires< BaseRegexConcept<global_regex_namespace::basic_regex<char> > >();
376    }
constraintsboost::BaseRegexConcept377    void constraints()
378    {
379       global_constraints();
380 
381       BOOST_STATIC_ASSERT((::boost::is_same< flag_type, global_regex_namespace::regex_constants::syntax_option_type>::value));
382       flag_type opts
383          = Regex::icase
384          | Regex::nosubs
385          | Regex::optimize
386          | Regex::collate
387          | Regex::ECMAScript
388          | Regex::basic
389          | Regex::extended
390          | Regex::awk
391          | Regex::grep
392          | Regex::egrep;
393       ignore_unused_variable_warning(opts);
394 
395       function_requires<DefaultConstructibleConcept<Regex> >();
396       function_requires<CopyConstructibleConcept<Regex> >();
397 
398       // Regex constructors:
399       Regex e1(m_pointer);
400       ignore_unused_variable_warning(e1);
401       Regex e2(m_pointer, m_flags);
402       ignore_unused_variable_warning(e2);
403       Regex e3(m_pointer, m_size, m_flags);
404       ignore_unused_variable_warning(e3);
405       Regex e4(in1, in2);
406       ignore_unused_variable_warning(e4);
407       Regex e5(in1, in2, m_flags);
408       ignore_unused_variable_warning(e5);
409 
410       // assign etc:
411       Regex e;
412       e = m_pointer;
413       e = e1;
414       e.assign(e1);
415       e.assign(m_pointer);
416       e.assign(m_pointer, m_flags);
417       e.assign(m_pointer, m_size, m_flags);
418       e.assign(in1, in2);
419       e.assign(in1, in2, m_flags);
420 
421       // access:
422       const Regex ce;
423       typename Regex::size_type i = ce.mark_count();
424       ignore_unused_variable_warning(i);
425       m_flags = ce.flags();
426       e.imbue(ce.getloc());
427       e.swap(e1);
428 
429       global_regex_namespace::swap(e, e1);
430 
431       // sub_match:
432       BOOST_STATIC_ASSERT((::boost::is_base_and_derived<std::pair<BidiIterator, BidiIterator>, sub_match_type>::value));
433       typedef typename sub_match_type::value_type sub_value_type;
434       typedef typename sub_match_type::difference_type sub_diff_type;
435       typedef typename sub_match_type::iterator sub_iter_type;
436       BOOST_STATIC_ASSERT((::boost::is_same<sub_value_type, value_type>::value));
437       BOOST_STATIC_ASSERT((::boost::is_same<sub_iter_type, BidiIterator>::value));
438       bool b = m_sub.matched;
439       ignore_unused_variable_warning(b);
440       BidiIterator bi = m_sub.first;
441       ignore_unused_variable_warning(bi);
442       bi = m_sub.second;
443       ignore_unused_variable_warning(bi);
444       sub_diff_type diff = m_sub.length();
445       ignore_unused_variable_warning(diff);
446       // match_results tests - some typedefs are not used, however these
447       // guarante that they exist (some compilers may warn on non-usage)
448       typedef typename match_results_type::value_type mr_value_type;
449       typedef typename match_results_type::const_reference mr_const_reference;
450       typedef typename match_results_type::reference mr_reference;
451       typedef typename match_results_type::const_iterator mr_const_iterator;
452       typedef typename match_results_type::iterator mr_iterator;
453       typedef typename match_results_type::difference_type mr_difference_type;
454       typedef typename match_results_type::size_type mr_size_type;
455       typedef typename match_results_type::allocator_type mr_allocator_type;
456       typedef typename match_results_type::char_type mr_char_type;
457       typedef typename match_results_type::string_type mr_string_type;
458 
459       match_results_type m1;
460       mr_allocator_type at;
461       match_results_type m2(at);
462       match_results_type m3(m1);
463       m1 = m2;
464 
465       int ival = 0;
466 
467       mr_size_type mrs = m_cresults.size();
468       ignore_unused_variable_warning(mrs);
469       mrs = m_cresults.max_size();
470       ignore_unused_variable_warning(mrs);
471       b = m_cresults.empty();
472       ignore_unused_variable_warning(b);
473       mr_difference_type mrd = m_cresults.length();
474       ignore_unused_variable_warning(mrd);
475       mrd = m_cresults.length(ival);
476       ignore_unused_variable_warning(mrd);
477       mrd = m_cresults.position();
478       ignore_unused_variable_warning(mrd);
479       mrd = m_cresults.position(mrs);
480       ignore_unused_variable_warning(mrd);
481 
482       mr_const_reference mrcr = m_cresults[ival];
483       ignore_unused_variable_warning(mrcr);
484       mr_const_reference mrcr2 = m_cresults.prefix();
485       ignore_unused_variable_warning(mrcr2);
486       mr_const_reference mrcr3 = m_cresults.suffix();
487       ignore_unused_variable_warning(mrcr3);
488       mr_const_iterator mrci = m_cresults.begin();
489       ignore_unused_variable_warning(mrci);
490       mrci = m_cresults.end();
491       ignore_unused_variable_warning(mrci);
492 
493       (void) m_cresults.get_allocator();
494       m_results.swap(m_results);
495       global_regex_namespace::swap(m_results, m_results);
496 
497       // regex_match:
498       b = global_regex_namespace::regex_match(m_in, m_in, m_results, e);
499       ignore_unused_variable_warning(b);
500       b = global_regex_namespace::regex_match(m_in, m_in, m_results, e, m_mft);
501       ignore_unused_variable_warning(b);
502       b = global_regex_namespace::regex_match(m_in, m_in, e);
503       ignore_unused_variable_warning(b);
504       b = global_regex_namespace::regex_match(m_in, m_in, e, m_mft);
505       ignore_unused_variable_warning(b);
506       b = global_regex_namespace::regex_match(m_pointer, m_pmatch, e);
507       ignore_unused_variable_warning(b);
508       b = global_regex_namespace::regex_match(m_pointer, m_pmatch, e, m_mft);
509       ignore_unused_variable_warning(b);
510       b = global_regex_namespace::regex_match(m_pointer, e);
511       ignore_unused_variable_warning(b);
512       b = global_regex_namespace::regex_match(m_pointer, e, m_mft);
513       ignore_unused_variable_warning(b);
514       // regex_search:
515       b = global_regex_namespace::regex_search(m_in, m_in, m_results, e);
516       ignore_unused_variable_warning(b);
517       b = global_regex_namespace::regex_search(m_in, m_in, m_results, e, m_mft);
518       ignore_unused_variable_warning(b);
519       b = global_regex_namespace::regex_search(m_in, m_in, e);
520       ignore_unused_variable_warning(b);
521       b = global_regex_namespace::regex_search(m_in, m_in, e, m_mft);
522       ignore_unused_variable_warning(b);
523       b = global_regex_namespace::regex_search(m_pointer, m_pmatch, e);
524       ignore_unused_variable_warning(b);
525       b = global_regex_namespace::regex_search(m_pointer, m_pmatch, e, m_mft);
526       ignore_unused_variable_warning(b);
527       b = global_regex_namespace::regex_search(m_pointer, e);
528       ignore_unused_variable_warning(b);
529       b = global_regex_namespace::regex_search(m_pointer, e, m_mft);
530       ignore_unused_variable_warning(b);
531 
532       // regex_iterator:
533       typedef typename regex_iterator_type::regex_type rit_regex_type;
534       typedef typename regex_iterator_type::value_type rit_value_type;
535       typedef typename regex_iterator_type::difference_type rit_difference_type;
536       typedef typename regex_iterator_type::pointer rit_pointer;
537       typedef typename regex_iterator_type::reference rit_reference;
538       typedef typename regex_iterator_type::iterator_category rit_iterator_category;
539       BOOST_STATIC_ASSERT((::boost::is_same<rit_regex_type, Regex>::value));
540       BOOST_STATIC_ASSERT((::boost::is_same<rit_value_type, match_results_default_type>::value));
541       BOOST_STATIC_ASSERT((::boost::is_same<rit_difference_type, std::ptrdiff_t>::value));
542       BOOST_STATIC_ASSERT((::boost::is_same<rit_pointer, const match_results_default_type*>::value));
543       BOOST_STATIC_ASSERT((::boost::is_same<rit_reference, const match_results_default_type&>::value));
544       BOOST_STATIC_ASSERT((::boost::is_convertible<rit_iterator_category*, std::forward_iterator_tag*>::value));
545       // this takes care of most of the checks needed:
546       function_requires<ForwardIteratorConcept<regex_iterator_type> >();
547       regex_iterator_type iter1(m_in, m_in, e);
548       ignore_unused_variable_warning(iter1);
549       regex_iterator_type iter2(m_in, m_in, e, m_mft);
550       ignore_unused_variable_warning(iter2);
551 
552       // regex_token_iterator:
553       typedef typename regex_token_iterator_type::regex_type rtit_regex_type;
554       typedef typename regex_token_iterator_type::value_type rtit_value_type;
555       typedef typename regex_token_iterator_type::difference_type rtit_difference_type;
556       typedef typename regex_token_iterator_type::pointer rtit_pointer;
557       typedef typename regex_token_iterator_type::reference rtit_reference;
558       typedef typename regex_token_iterator_type::iterator_category rtit_iterator_category;
559       BOOST_STATIC_ASSERT((::boost::is_same<rtit_regex_type, Regex>::value));
560       BOOST_STATIC_ASSERT((::boost::is_same<rtit_value_type, sub_match_type>::value));
561       BOOST_STATIC_ASSERT((::boost::is_same<rtit_difference_type, std::ptrdiff_t>::value));
562       BOOST_STATIC_ASSERT((::boost::is_same<rtit_pointer, const sub_match_type*>::value));
563       BOOST_STATIC_ASSERT((::boost::is_same<rtit_reference, const sub_match_type&>::value));
564       BOOST_STATIC_ASSERT((::boost::is_convertible<rtit_iterator_category*, std::forward_iterator_tag*>::value));
565       // this takes care of most of the checks needed:
566       function_requires<ForwardIteratorConcept<regex_token_iterator_type> >();
567       regex_token_iterator_type ti1(m_in, m_in, e);
568       ignore_unused_variable_warning(ti1);
569       regex_token_iterator_type ti2(m_in, m_in, e, 0);
570       ignore_unused_variable_warning(ti2);
571       regex_token_iterator_type ti3(m_in, m_in, e, 0, m_mft);
572       ignore_unused_variable_warning(ti3);
573       std::vector<int> subs;
574       regex_token_iterator_type ti4(m_in, m_in, e, subs);
575       ignore_unused_variable_warning(ti4);
576       regex_token_iterator_type ti5(m_in, m_in, e, subs, m_mft);
577       ignore_unused_variable_warning(ti5);
578       static const int i_array[3] = { 1, 2, 3, };
579       regex_token_iterator_type ti6(m_in, m_in, e, i_array);
580       ignore_unused_variable_warning(ti6);
581       regex_token_iterator_type ti7(m_in, m_in, e, i_array, m_mft);
582       ignore_unused_variable_warning(ti7);
583    }
584 
585    pointer_type m_pointer;
586    flag_type m_flags;
587    std::size_t m_size;
588    input_iterator_type in1, in2;
589    const sub_match_type m_sub;
590    const value_type m_char;
591    match_results_type m_results;
592    const match_results_type m_cresults;
593    OutIterator m_out;
594    BidiIterator m_in;
595    global_regex_namespace::regex_constants::match_flag_type m_mft;
596    global_regex_namespace::match_results<
597       pointer_type,
598       allocator_architype<global_regex_namespace::sub_match<pointer_type> > >
599       m_pmatch;
600 
601    BaseRegexConcept();
602    BaseRegexConcept(const BaseRegexConcept&);
603    BaseRegexConcept& operator=(const BaseRegexConcept&);
604 };
605 
606 //
607 // RegexConcept:
608 // Test every interface in the std:
609 //
610 template <class Regex>
611 struct RegexConcept
612 {
613    typedef typename Regex::value_type value_type;
614    //typedef typename Regex::size_type size_type;
615    typedef typename Regex::flag_type flag_type;
616    typedef typename Regex::locale_type locale_type;
617 
618    // derived test types:
619    typedef const value_type* pointer_type;
620    typedef std::basic_string<value_type> string_type;
621    typedef boost::bidirectional_iterator_archetype<value_type> BidiIterator;
622    typedef global_regex_namespace::sub_match<BidiIterator> sub_match_type;
623    typedef global_regex_namespace::match_results<BidiIterator, allocator_architype<sub_match_type> > match_results_type;
624    typedef output_iterator_archetype<value_type> OutIterator;
625 
626 
constraintsboost::RegexConcept627    void constraints()
628    {
629       function_requires<BaseRegexConcept<Regex> >();
630       // string based construct:
631       Regex e1(m_string);
632       ignore_unused_variable_warning(e1);
633       Regex e2(m_string, m_flags);
634       ignore_unused_variable_warning(e2);
635 
636       // assign etc:
637       Regex e;
638       e = m_string;
639       e.assign(m_string);
640       e.assign(m_string, m_flags);
641 
642       // sub_match:
643       string_type s(m_sub);
644       ignore_unused_variable_warning(s);
645       s = m_sub.str();
646       ignore_unused_variable_warning(s);
647       int i = m_sub.compare(m_string);
648       ignore_unused_variable_warning(i);
649 
650       int i2 = m_sub.compare(m_sub);
651       ignore_unused_variable_warning(i2);
652       i2 = m_sub.compare(m_pointer);
653       ignore_unused_variable_warning(i2);
654 
655       bool b = m_sub == m_sub;
656       ignore_unused_variable_warning(b);
657       b = m_sub != m_sub;
658       ignore_unused_variable_warning(b);
659       b = m_sub <= m_sub;
660       ignore_unused_variable_warning(b);
661       b = m_sub <= m_sub;
662       ignore_unused_variable_warning(b);
663       b = m_sub > m_sub;
664       ignore_unused_variable_warning(b);
665       b = m_sub >= m_sub;
666       ignore_unused_variable_warning(b);
667 
668       b = m_sub == m_pointer;
669       ignore_unused_variable_warning(b);
670       b = m_sub != m_pointer;
671       ignore_unused_variable_warning(b);
672       b = m_sub <= m_pointer;
673       ignore_unused_variable_warning(b);
674       b = m_sub <= m_pointer;
675       ignore_unused_variable_warning(b);
676       b = m_sub > m_pointer;
677       ignore_unused_variable_warning(b);
678       b = m_sub >= m_pointer;
679       ignore_unused_variable_warning(b);
680 
681       b = m_pointer == m_sub;
682       ignore_unused_variable_warning(b);
683       b = m_pointer != m_sub;
684       ignore_unused_variable_warning(b);
685       b = m_pointer <= m_sub;
686       ignore_unused_variable_warning(b);
687       b = m_pointer <= m_sub;
688       ignore_unused_variable_warning(b);
689       b = m_pointer > m_sub;
690       ignore_unused_variable_warning(b);
691       b = m_pointer >= m_sub;
692       ignore_unused_variable_warning(b);
693 
694       b = m_sub == m_char;
695       ignore_unused_variable_warning(b);
696       b = m_sub != m_char;
697       ignore_unused_variable_warning(b);
698       b = m_sub <= m_char;
699       ignore_unused_variable_warning(b);
700       b = m_sub <= m_char;
701       ignore_unused_variable_warning(b);
702       b = m_sub > m_char;
703       ignore_unused_variable_warning(b);
704       b = m_sub >= m_char;
705       ignore_unused_variable_warning(b);
706 
707       b = m_char == m_sub;
708       ignore_unused_variable_warning(b);
709       b = m_char != m_sub;
710       ignore_unused_variable_warning(b);
711       b = m_char <= m_sub;
712       ignore_unused_variable_warning(b);
713       b = m_char <= m_sub;
714       ignore_unused_variable_warning(b);
715       b = m_char > m_sub;
716       ignore_unused_variable_warning(b);
717       b = m_char >= m_sub;
718       ignore_unused_variable_warning(b);
719 
720       b = m_sub == m_string;
721       ignore_unused_variable_warning(b);
722       b = m_sub != m_string;
723       ignore_unused_variable_warning(b);
724       b = m_sub <= m_string;
725       ignore_unused_variable_warning(b);
726       b = m_sub <= m_string;
727       ignore_unused_variable_warning(b);
728       b = m_sub > m_string;
729       ignore_unused_variable_warning(b);
730       b = m_sub >= m_string;
731       ignore_unused_variable_warning(b);
732 
733       b = m_string == m_sub;
734       ignore_unused_variable_warning(b);
735       b = m_string != m_sub;
736       ignore_unused_variable_warning(b);
737       b = m_string <= m_sub;
738       ignore_unused_variable_warning(b);
739       b = m_string <= m_sub;
740       ignore_unused_variable_warning(b);
741       b = m_string > m_sub;
742       ignore_unused_variable_warning(b);
743       b = m_string >= m_sub;
744       ignore_unused_variable_warning(b);
745 
746       // match results:
747       m_string = m_results.str();
748       ignore_unused_variable_warning(m_string);
749       m_string = m_results.str(0);
750       ignore_unused_variable_warning(m_string);
751       m_out = m_cresults.format(m_out, m_string);
752       m_out = m_cresults.format(m_out, m_string, m_mft);
753       m_string = m_cresults.format(m_string);
754       ignore_unused_variable_warning(m_string);
755       m_string = m_cresults.format(m_string, m_mft);
756       ignore_unused_variable_warning(m_string);
757 
758       // regex_match:
759       b = global_regex_namespace::regex_match(m_string, m_smatch, e);
760       ignore_unused_variable_warning(b);
761       b = global_regex_namespace::regex_match(m_string, m_smatch, e, m_mft);
762       ignore_unused_variable_warning(b);
763       b = global_regex_namespace::regex_match(m_string, e);
764       ignore_unused_variable_warning(b);
765       b = global_regex_namespace::regex_match(m_string, e, m_mft);
766       ignore_unused_variable_warning(b);
767 
768       // regex_search:
769       b = global_regex_namespace::regex_search(m_string, m_smatch, e);
770       ignore_unused_variable_warning(b);
771       b = global_regex_namespace::regex_search(m_string, m_smatch, e, m_mft);
772       ignore_unused_variable_warning(b);
773       b = global_regex_namespace::regex_search(m_string, e);
774       ignore_unused_variable_warning(b);
775       b = global_regex_namespace::regex_search(m_string, e, m_mft);
776       ignore_unused_variable_warning(b);
777 
778       // regex_replace:
779       m_out = global_regex_namespace::regex_replace(m_out, m_in, m_in, e, m_string, m_mft);
780       m_out = global_regex_namespace::regex_replace(m_out, m_in, m_in, e, m_string);
781       m_string = global_regex_namespace::regex_replace(m_string, e, m_string, m_mft);
782       ignore_unused_variable_warning(m_string);
783       m_string = global_regex_namespace::regex_replace(m_string, e, m_string);
784       ignore_unused_variable_warning(m_string);
785 
786    }
787 
788    flag_type m_flags;
789    string_type m_string;
790    const sub_match_type m_sub;
791    match_results_type m_results;
792    pointer_type m_pointer;
793    value_type m_char;
794    const match_results_type m_cresults;
795    OutIterator m_out;
796    BidiIterator m_in;
797    global_regex_namespace::regex_constants::match_flag_type m_mft;
798    global_regex_namespace::match_results<typename string_type::const_iterator, allocator_architype<global_regex_namespace::sub_match<typename string_type::const_iterator> > > m_smatch;
799 
800    RegexConcept();
801    RegexConcept(const RegexConcept&);
802    RegexConcept& operator=(const RegexConcept&);
803 };
804 
805 #ifndef BOOST_REGEX_TEST_STD
806 
807 template <class M>
808 struct functor1
809 {
810    typedef typename M::char_type char_type;
operator ()boost::functor1811    const char_type* operator()(const M&)const
812    {
813       static const char_type c = static_cast<char_type>(0);
814       return &c;
815    }
816 };
817 template <class M>
818 struct functor1b
819 {
820    typedef typename M::char_type char_type;
operator ()boost::functor1b821    std::vector<char_type> operator()(const M&)const
822    {
823       static const std::vector<char_type> c;
824       return c;
825    }
826 };
827 template <class M>
828 struct functor2
829 {
830    template <class O>
operator ()boost::functor2831    O operator()(const M& /*m*/, O i)const
832    {
833       return i;
834    }
835 };
836 template <class M>
837 struct functor3
838 {
839    template <class O>
operator ()boost::functor3840    O operator()(const M& /*m*/, O i, regex_constants::match_flag_type)const
841    {
842       return i;
843    }
844 };
845 
846 //
847 // BoostRegexConcept:
848 // Test every interface in the Boost implementation:
849 //
850 template <class Regex>
851 struct BoostRegexConcept
852 {
853    typedef typename Regex::value_type value_type;
854    typedef typename Regex::size_type size_type;
855    typedef typename Regex::flag_type flag_type;
856    typedef typename Regex::locale_type locale_type;
857 
858    // derived test types:
859    typedef const value_type* pointer_type;
860    typedef std::basic_string<value_type> string_type;
861    typedef typename Regex::const_iterator const_iterator;
862    typedef bidirectional_iterator_archetype<value_type> BidiIterator;
863    typedef output_iterator_archetype<value_type> OutputIterator;
864    typedef global_regex_namespace::sub_match<BidiIterator> sub_match_type;
865    typedef global_regex_namespace::match_results<BidiIterator, allocator_architype<sub_match_type> > match_results_type;
866    typedef global_regex_namespace::match_results<BidiIterator> match_results_default_type;
867 
constraintsboost::BoostRegexConcept868    void constraints()
869    {
870       global_regex_namespace::regex_constants::match_flag_type mopts
871          = global_regex_namespace::regex_constants::match_default
872          | global_regex_namespace::regex_constants::match_not_bol
873          | global_regex_namespace::regex_constants::match_not_eol
874          | global_regex_namespace::regex_constants::match_not_bow
875          | global_regex_namespace::regex_constants::match_not_eow
876          | global_regex_namespace::regex_constants::match_any
877          | global_regex_namespace::regex_constants::match_not_null
878          | global_regex_namespace::regex_constants::match_continuous
879          | global_regex_namespace::regex_constants::match_partial
880          | global_regex_namespace::regex_constants::match_prev_avail
881          | global_regex_namespace::regex_constants::format_default
882          | global_regex_namespace::regex_constants::format_sed
883          | global_regex_namespace::regex_constants::format_perl
884          | global_regex_namespace::regex_constants::format_no_copy
885          | global_regex_namespace::regex_constants::format_first_only;
886 
887       (void)mopts;
888 
889       function_requires<RegexConcept<Regex> >();
890       const global_regex_namespace::regex_error except(global_regex_namespace::regex_constants::error_collate);
891       std::ptrdiff_t pt = except.position();
892       ignore_unused_variable_warning(pt);
893       const Regex ce, ce2;
894 #ifndef BOOST_NO_STD_LOCALE
895       m_stream << ce;
896 #endif
897       unsigned i = ce.error_code();
898       ignore_unused_variable_warning(i);
899       pointer_type p = ce.expression();
900       ignore_unused_variable_warning(p);
901       int i2 = ce.compare(ce2);
902       ignore_unused_variable_warning(i2);
903       bool b = ce == ce2;
904       ignore_unused_variable_warning(b);
905       b = ce.empty();
906       ignore_unused_variable_warning(b);
907       b = ce != ce2;
908       ignore_unused_variable_warning(b);
909       b = ce < ce2;
910       ignore_unused_variable_warning(b);
911       b = ce > ce2;
912       ignore_unused_variable_warning(b);
913       b = ce <= ce2;
914       ignore_unused_variable_warning(b);
915       b = ce >= ce2;
916       ignore_unused_variable_warning(b);
917       i = ce.status();
918       ignore_unused_variable_warning(i);
919       size_type s = ce.max_size();
920       ignore_unused_variable_warning(s);
921       s = ce.size();
922       ignore_unused_variable_warning(s);
923       const_iterator pi = ce.begin();
924       ignore_unused_variable_warning(pi);
925       pi = ce.end();
926       ignore_unused_variable_warning(pi);
927       string_type s2 = ce.str();
928       ignore_unused_variable_warning(s2);
929 
930       m_string = m_sub + m_sub;
931       ignore_unused_variable_warning(m_string);
932       m_string = m_sub + m_pointer;
933       ignore_unused_variable_warning(m_string);
934       m_string = m_pointer + m_sub;
935       ignore_unused_variable_warning(m_string);
936       m_string = m_sub + m_string;
937       ignore_unused_variable_warning(m_string);
938       m_string = m_string + m_sub;
939       ignore_unused_variable_warning(m_string);
940       m_string = m_sub + m_char;
941       ignore_unused_variable_warning(m_string);
942       m_string = m_char + m_sub;
943       ignore_unused_variable_warning(m_string);
944 
945       // Named sub-expressions:
946       m_sub = m_cresults[&m_char];
947       ignore_unused_variable_warning(m_sub);
948       m_sub = m_cresults[m_string];
949       ignore_unused_variable_warning(m_sub);
950       m_sub = m_cresults[""];
951       ignore_unused_variable_warning(m_sub);
952       m_sub = m_cresults[std::string("")];
953       ignore_unused_variable_warning(m_sub);
954       m_string = m_cresults.str(&m_char);
955       ignore_unused_variable_warning(m_string);
956       m_string = m_cresults.str(m_string);
957       ignore_unused_variable_warning(m_string);
958       m_string = m_cresults.str("");
959       ignore_unused_variable_warning(m_string);
960       m_string = m_cresults.str(std::string(""));
961       ignore_unused_variable_warning(m_string);
962 
963       typename match_results_type::difference_type diff;
964       diff = m_cresults.length(&m_char);
965       ignore_unused_variable_warning(diff);
966       diff = m_cresults.length(m_string);
967       ignore_unused_variable_warning(diff);
968       diff = m_cresults.length("");
969       ignore_unused_variable_warning(diff);
970       diff = m_cresults.length(std::string(""));
971       ignore_unused_variable_warning(diff);
972       diff = m_cresults.position(&m_char);
973       ignore_unused_variable_warning(diff);
974       diff = m_cresults.position(m_string);
975       ignore_unused_variable_warning(diff);
976       diff = m_cresults.position("");
977       ignore_unused_variable_warning(diff);
978       diff = m_cresults.position(std::string(""));
979       ignore_unused_variable_warning(diff);
980 
981 #ifndef BOOST_NO_STD_LOCALE
982       m_stream << m_sub;
983       m_stream << m_cresults;
984 #endif
985       //
986       // Extended formatting with a functor:
987       //
988       regex_constants::match_flag_type f = regex_constants::match_default;
989       OutputIterator out = static_object<OutputIterator>::get();
990 
991       functor3<match_results_default_type> func3;
992       functor2<match_results_default_type> func2;
993       functor1<match_results_default_type> func1;
994 
995       functor3<match_results_type> func3b;
996       functor2<match_results_type> func2b;
997       functor1<match_results_type> func1b;
998 
999       out = regex_format(out, m_cresults, func3b, f);
1000       out = regex_format(out, m_cresults, func3b);
1001       out = regex_format(out, m_cresults, func2b, f);
1002       out = regex_format(out, m_cresults, func2b);
1003       out = regex_format(out, m_cresults, func1b, f);
1004       out = regex_format(out, m_cresults, func1b);
1005       out = regex_format(out, m_cresults, RW_NS::ref(func3b), f);
1006       out = regex_format(out, m_cresults, RW_NS::ref(func3b));
1007       out = regex_format(out, m_cresults, RW_NS::ref(func2b), f);
1008       out = regex_format(out, m_cresults, RW_NS::ref(func2b));
1009       out = regex_format(out, m_cresults, RW_NS::ref(func1b), f);
1010       out = regex_format(out, m_cresults, RW_NS::ref(func1b));
1011       out = regex_format(out, m_cresults, RW_NS::cref(func3b), f);
1012       out = regex_format(out, m_cresults, RW_NS::cref(func3b));
1013       out = regex_format(out, m_cresults, RW_NS::cref(func2b), f);
1014       out = regex_format(out, m_cresults, RW_NS::cref(func2b));
1015       out = regex_format(out, m_cresults, RW_NS::cref(func1b), f);
1016       out = regex_format(out, m_cresults, RW_NS::cref(func1b));
1017       m_string += regex_format(m_cresults, func3b, f);
1018       m_string += regex_format(m_cresults, func3b);
1019       m_string += regex_format(m_cresults, func2b, f);
1020       m_string += regex_format(m_cresults, func2b);
1021       m_string += regex_format(m_cresults, func1b, f);
1022       m_string += regex_format(m_cresults, func1b);
1023       m_string += regex_format(m_cresults, RW_NS::ref(func3b), f);
1024       m_string += regex_format(m_cresults, RW_NS::ref(func3b));
1025       m_string += regex_format(m_cresults, RW_NS::ref(func2b), f);
1026       m_string += regex_format(m_cresults, RW_NS::ref(func2b));
1027       m_string += regex_format(m_cresults, RW_NS::ref(func1b), f);
1028       m_string += regex_format(m_cresults, RW_NS::ref(func1b));
1029       m_string += regex_format(m_cresults, RW_NS::cref(func3b), f);
1030       m_string += regex_format(m_cresults, RW_NS::cref(func3b));
1031       m_string += regex_format(m_cresults, RW_NS::cref(func2b), f);
1032       m_string += regex_format(m_cresults, RW_NS::cref(func2b));
1033       m_string += regex_format(m_cresults, RW_NS::cref(func1b), f);
1034       m_string += regex_format(m_cresults, RW_NS::cref(func1b));
1035 
1036       out = m_cresults.format(out, func3b, f);
1037       out = m_cresults.format(out, func3b);
1038       out = m_cresults.format(out, func2b, f);
1039       out = m_cresults.format(out, func2b);
1040       out = m_cresults.format(out, func1b, f);
1041       out = m_cresults.format(out, func1b);
1042       out = m_cresults.format(out, RW_NS::ref(func3b), f);
1043       out = m_cresults.format(out, RW_NS::ref(func3b));
1044       out = m_cresults.format(out, RW_NS::ref(func2b), f);
1045       out = m_cresults.format(out, RW_NS::ref(func2b));
1046       out = m_cresults.format(out, RW_NS::ref(func1b), f);
1047       out = m_cresults.format(out, RW_NS::ref(func1b));
1048       out = m_cresults.format(out, RW_NS::cref(func3b), f);
1049       out = m_cresults.format(out, RW_NS::cref(func3b));
1050       out = m_cresults.format(out, RW_NS::cref(func2b), f);
1051       out = m_cresults.format(out, RW_NS::cref(func2b));
1052       out = m_cresults.format(out, RW_NS::cref(func1b), f);
1053       out = m_cresults.format(out, RW_NS::cref(func1b));
1054 
1055       m_string += m_cresults.format(func3b, f);
1056       m_string += m_cresults.format(func3b);
1057       m_string += m_cresults.format(func2b, f);
1058       m_string += m_cresults.format(func2b);
1059       m_string += m_cresults.format(func1b, f);
1060       m_string += m_cresults.format(func1b);
1061       m_string += m_cresults.format(RW_NS::ref(func3b), f);
1062       m_string += m_cresults.format(RW_NS::ref(func3b));
1063       m_string += m_cresults.format(RW_NS::ref(func2b), f);
1064       m_string += m_cresults.format(RW_NS::ref(func2b));
1065       m_string += m_cresults.format(RW_NS::ref(func1b), f);
1066       m_string += m_cresults.format(RW_NS::ref(func1b));
1067       m_string += m_cresults.format(RW_NS::cref(func3b), f);
1068       m_string += m_cresults.format(RW_NS::cref(func3b));
1069       m_string += m_cresults.format(RW_NS::cref(func2b), f);
1070       m_string += m_cresults.format(RW_NS::cref(func2b));
1071       m_string += m_cresults.format(RW_NS::cref(func1b), f);
1072       m_string += m_cresults.format(RW_NS::cref(func1b));
1073 
1074       out = regex_replace(out, m_in, m_in, ce, func3, f);
1075       out = regex_replace(out, m_in, m_in, ce, func3);
1076       out = regex_replace(out, m_in, m_in, ce, func2, f);
1077       out = regex_replace(out, m_in, m_in, ce, func2);
1078       out = regex_replace(out, m_in, m_in, ce, func1, f);
1079       out = regex_replace(out, m_in, m_in, ce, func1);
1080       out = regex_replace(out, m_in, m_in, ce, RW_NS::ref(func3), f);
1081       out = regex_replace(out, m_in, m_in, ce, RW_NS::ref(func3));
1082       out = regex_replace(out, m_in, m_in, ce, RW_NS::ref(func2), f);
1083       out = regex_replace(out, m_in, m_in, ce, RW_NS::ref(func2));
1084       out = regex_replace(out, m_in, m_in, ce, RW_NS::ref(func1), f);
1085       out = regex_replace(out, m_in, m_in, ce, RW_NS::ref(func1));
1086       out = regex_replace(out, m_in, m_in, ce, RW_NS::cref(func3), f);
1087       out = regex_replace(out, m_in, m_in, ce, RW_NS::cref(func3));
1088       out = regex_replace(out, m_in, m_in, ce, RW_NS::cref(func2), f);
1089       out = regex_replace(out, m_in, m_in, ce, RW_NS::cref(func2));
1090       out = regex_replace(out, m_in, m_in, ce, RW_NS::cref(func1), f);
1091       out = regex_replace(out, m_in, m_in, ce, RW_NS::cref(func1));
1092 
1093       functor3<match_results<typename string_type::const_iterator> > func3s;
1094       functor2<match_results<typename string_type::const_iterator> > func2s;
1095       functor1<match_results<typename string_type::const_iterator> > func1s;
1096       m_string += regex_replace(m_string, ce, func3s, f);
1097       m_string += regex_replace(m_string, ce, func3s);
1098       m_string += regex_replace(m_string, ce, func2s, f);
1099       m_string += regex_replace(m_string, ce, func2s);
1100       m_string += regex_replace(m_string, ce, func1s, f);
1101       m_string += regex_replace(m_string, ce, func1s);
1102       m_string += regex_replace(m_string, ce, RW_NS::ref(func3s), f);
1103       m_string += regex_replace(m_string, ce, RW_NS::ref(func3s));
1104       m_string += regex_replace(m_string, ce, RW_NS::ref(func2s), f);
1105       m_string += regex_replace(m_string, ce, RW_NS::ref(func2s));
1106       m_string += regex_replace(m_string, ce, RW_NS::ref(func1s), f);
1107       m_string += regex_replace(m_string, ce, RW_NS::ref(func1s));
1108       m_string += regex_replace(m_string, ce, RW_NS::cref(func3s), f);
1109       m_string += regex_replace(m_string, ce, RW_NS::cref(func3s));
1110       m_string += regex_replace(m_string, ce, RW_NS::cref(func2s), f);
1111       m_string += regex_replace(m_string, ce, RW_NS::cref(func2s));
1112       m_string += regex_replace(m_string, ce, RW_NS::cref(func1s), f);
1113       m_string += regex_replace(m_string, ce, RW_NS::cref(func1s));
1114    }
1115 
1116    std::basic_ostream<value_type> m_stream;
1117    sub_match_type m_sub;
1118    pointer_type m_pointer;
1119    string_type m_string;
1120    const value_type m_char;
1121    match_results_type m_results;
1122    const match_results_type m_cresults;
1123    BidiIterator m_in;
1124 
1125    BoostRegexConcept();
1126    BoostRegexConcept(const BoostRegexConcept&);
1127    BoostRegexConcept& operator=(const BoostRegexConcept&);
1128 };
1129 
1130 #endif // BOOST_REGEX_TEST_STD
1131 
1132 }
1133 
1134 #endif
1135