1[/
2  Copyright 2006-2007 John Maddock.
3  Distributed under the Boost Software License, Version 1.0.
4  (See accompanying file LICENSE_1_0.txt or copy at
5  http://www.boost.org/LICENSE_1_0.txt).
6]
7
8[section:basic_regex basic_regex]
9
10[h4 Synopsis]
11
12   #include <boost/regex.hpp>
13
14The template class `basic_regex` encapsulates regular expression
15parsing and compilation. The class takes two template parameters:
16
17* `charT`: determines the character type, i.e. either `char` or `wchar_t`;
18see [link boost_regex.ref.concepts.charT_concept charT concept].
19* `traits`: determines the behavior of the character type, for example which
20character class names are recognized. A default traits class is provided:
21`regex_traits<charT>`.  See also
22[link boost_regex.ref.concepts.traits_concept traits concept].
23
24For ease of use there are two typedefs that define the two standard
25`basic_regex` instances, unless you want to use custom traits classes or
26non-standard character types (for example see
27[link boost_regex.ref.non_std_strings.icu unicode support]),
28you won't need to use anything other than these:
29
30   namespace boost{
31
32   template <class charT, class traits = regex_traits<charT>  >
33   class basic_regex;
34
35   typedef basic_regex<char>      regex;
36   typedef basic_regex<wchar_t>   wregex;
37
38   }
39
40The definition of `basic_regex` follows: it is based very closely on class
41`basic_string`, and fulfils the requirements for a constant-container of `charT`.
42
43   namespace boost{
44
45   template <class  charT, class traits = regex_traits<charT> >
46   class basic_regex {
47      public:
48      // types:
49      typedef          charT                                value_type;
50      typedef          implementation-specific              const_iterator;
51      typedef          const_iterator                       iterator;
52      typedef          charT&                               reference;
53      typedef          const charT&                         const_reference;
54      typedef          std::ptrdiff_t                       difference_type;
55      typedef          std::size_t                          size_type;
56      typedef          regex_constants::``[syntax_option_type]``  flag_type;
57      typedef typename traits::locale_type                  locale_type;
58
59      // constants:
60      // main option selection:
61      static const regex_constants::``[syntax_option_type]`` normal
62                                                   = regex_constants::normal;
63      static const regex_constants::``[syntax_option_type]`` ECMAScript
64                                                   = normal;
65      static const regex_constants::``[syntax_option_type]`` JavaScript
66                                                   = normal;
67      static const regex_constants::``[syntax_option_type]`` JScript
68                                                   = normal;
69      static const regex_constants::``[syntax_option_type]`` basic
70                                                   = regex_constants::basic;
71      static const regex_constants::``[syntax_option_type]`` extended
72                                                   = regex_constants::extended;
73      static const regex_constants::``[syntax_option_type]`` awk
74                                                   = regex_constants::awk;
75      static const regex_constants::``[syntax_option_type]`` grep
76                                                   = regex_constants::grep;
77      static const regex_constants::``[syntax_option_type]`` egrep
78                                                   = regex_constants::egrep;
79      static const regex_constants::``[syntax_option_type]`` sed
80                                                   = basic = regex_constants::sed;
81      static const regex_constants::``[syntax_option_type]`` perl
82                                                   = regex_constants::perl;
83      static const regex_constants::``[syntax_option_type]`` literal
84                                                   = regex_constants::literal;
85
86      // modifiers specific to perl expressions:
87      static const regex_constants::``[syntax_option_type]`` no_mod_m
88                                                   = regex_constants::no_mod_m;
89      static const regex_constants::``[syntax_option_type]`` no_mod_s
90                                                   = regex_constants::no_mod_s;
91      static const regex_constants::``[syntax_option_type]`` mod_s
92                                                   = regex_constants::mod_s;
93      static const regex_constants::``[syntax_option_type]`` mod_x
94                                                   = regex_constants::mod_x;
95
96      // modifiers specific to POSIX basic expressions:
97      static const regex_constants::``[syntax_option_type]`` bk_plus_qm
98                                                   = regex_constants::bk_plus_qm;
99      static const regex_constants::``[syntax_option_type]`` bk_vbar
100                                                   = regex_constants::bk_vbar
101      static const regex_constants::``[syntax_option_type]`` no_char_classes
102                                                   = regex_constants::no_char_classes
103      static const regex_constants::``[syntax_option_type]`` no_intervals
104                                                   = regex_constants::no_intervals
105
106      // common modifiers:
107      static const regex_constants::``[syntax_option_type]`` nosubs
108                                                   = regex_constants::nosubs;
109      static const regex_constants::``[syntax_option_type]`` optimize
110                                                   = regex_constants::optimize;
111      static const regex_constants::``[syntax_option_type]`` collate
112                                                   = regex_constants::collate;
113      static const regex_constants::``[syntax_option_type]`` newline_alt
114                                                   = regex_constants::newline_alt;
115      static const regex_constants::``[syntax_option_type]`` no_except
116                                                   = regex_constants::newline_alt;
117
118      // construct/copy/destroy:
119      explicit ``[link boost_regex.basic_regex.construct1 basic_regex]`` ();
120      explicit ``[link boost_regex.basic_regex.construct2 basic_regex]``(const  charT* p, flag_type f = regex_constants::normal);
121      ``[link boost_regex.basic_regex.construct3 basic_regex]``(const charT* p1, const  charT* p2,
122                  flag_type f = regex_constants::normal);
123      ``[link boost_regex.basic_regex.construct4 basic_regex]``(const charT* p, size_type len, flag_type  f);
124      ``[link boost_regex.basic_regex.construct5 basic_regex]``(const basic_regex&);
125
126      template <class ST, class SA>
127      explicit ``[link boost_regex.basic_regex.construct6 basic_regex]``(const basic_string<charT, ST,  SA>& p,
128                           flag_type f = regex_constants::normal);
129
130      template <class InputIterator>
131      ``[link boost_regex.basic_regex.construct7 basic_regex]``(InputIterator first,  InputIterator last,
132                  flag_type f = regex_constants::normal);
133
134      ~basic_regex();
135      ``[link boost_regex.basic_regex.opeq1 basic_regex& operator=]``(const basic_regex&);
136      ``[link boost_regex.basic_regex.opeq2 basic_regex& operator=]`` (const charT* ptr);
137
138      template <class ST, class SA>
139      ``[link boost_regex.basic_regex.opeq3 basic_regex& operator=]`` (const basic_string<charT, ST, SA>& p);
140      // iterators:
141      ``[link boost_regex.basic_regex.subexpression std::pair<const_iterator, const_iterator> subexpression]``(size_type n) const;
142      ``[link boost_regex.basic_regex.begin const_iterator begin]``() const;
143      ``[link boost_regex.basic_regex.end const_iterator end]``() const;
144      // capacity:
145      ``[link boost_regex.basic_regex.size size_type size]``() const;
146      ``[link boost_regex.basic_regex.max_size size_type max_size]``() const;
147      ``[link boost_regex.basic_regex.empty bool empty]``() const;
148      ``[link boost_regex.basic_regex.mark_count size_type mark_count]``()const;
149      //
150      // modifiers:
151      ``[link boost_regex.basic_regex.assign1 basic_regex& assign]``(const basic_regex& that);
152      ``[link boost_regex.basic_regex.assign2 basic_regex& assign]``(const charT* ptr,
153                          flag_type f = regex_constants::normal);
154      ``[link boost_regex.basic_regex.assign3 basic_regex& assign]``(const charT* ptr, unsigned int len, flag_type f);
155
156      template <class string_traits, class A>
157      ``[link boost_regex.basic_regex.assign4 basic_regex& assign]``(const basic_string<charT, string_traits, A>& s,
158                          flag_type f = regex_constants::normal);
159
160      template <class InputIterator>
161      ``[link boost_regex.basic_regex.assign5 basic_regex& assign]``(InputIterator first, InputIterator last,
162                          flag_type f = regex_constants::normal);
163
164      // const operations:
165      ``[link boost_regex.basic_regex.flags flag_type flags]``() const;
166      ``[link boost_regex.basic_regex.status int status]``()const;
167      ``[link boost_regex.basic_regex.str basic_string<charT> str]``() const;
168      ``[link boost_regex.basic_regex.compare int compare]``(basic_regex&) const;
169      // locale:
170      ``[link boost_regex.basic_regex.imbue locale_type imbue]``(locale_type loc);
171      ``[link boost_regex.basic_regex.getloc locale_type getloc]``() const;
172      // swap
173      ``[link boost_regex.basic_regex.swap void swap]``(basic_regex&) throw();
174   };
175
176   template <class charT, class traits>
177   ``[link boost_regex.basic_regex.op_eq bool operator ==]`` (const basic_regex<charT, traits>& lhs,
178                     const basic_regex<charT, traits>& rhs);
179
180   template <class charT, class traits>
181   ``[link boost_regex.basic_regex.op_ne bool operator !=]`` (const basic_regex<charT, traits>& lhs,
182                     const basic_regex<charT, traits>& rhs);
183
184   template <class charT, class traits>
185   ``[link boost_regex.basic_regex.op_lt bool operator <]`` (const basic_regex<charT, traits>& lhs,
186                  const basic_regex<charT, traits>& rhs);
187
188   template <class charT, class traits>
189   ``[link boost_regex.basic_regex.op_le bool operator <=]`` (const basic_regex<charT, traits>& lhs,
190                     const basic_regex<charT, traits>& rhs);
191
192   template <class charT, class traits>
193   ``[link boost_regex.basic_regex.op_ge bool operator >=]`` (const basic_regex<charT, traits>& lhs,
194                     const basic_regex<charT, traits>& rhs);
195
196   template <class charT, class traits>
197   ``[link boost_regex.basic_regex.op_gt bool operator >]`` (const basic_regex<charT, traits>& lhs,
198                  const basic_regex<charT, traits>& rhs);
199
200   template <class charT, class io_traits, class re_traits>
201   basic_ostream<charT, io_traits>&
202      ``[link boost_regex.basic_regex.op_stream operator <<]`` (basic_ostream<charT, io_traits>& os,
203                  const basic_regex<charT, re_traits>& e);
204
205   template <class charT, class traits>
206   ``[link boost_regex.basic_regex.op_swap void swap]``(basic_regex<charT, traits>& e1,
207            basic_regex<charT, traits>& e2);
208
209   typedef basic_regex<char> regex;
210   typedef basic_regex<wchar_t> wregex;
211
212   } // namespace boost
213
214[h4 Description]
215
216Class `basic_regex` has the following public members:
217
218   // main option selection:
219   static const regex_constants::``[syntax_option_type]`` normal
220                                             = regex_constants::normal;
221   static const regex_constants::``[syntax_option_type]`` ECMAScript
222                                             = normal;
223   static const regex_constants::``[syntax_option_type]`` JavaScript
224                                             = normal;
225   static const regex_constants::``[syntax_option_type]`` JScript
226                                             = normal;
227   static const regex_constants::``[syntax_option_type]`` basic
228                                             = regex_constants::basic;
229   static const regex_constants::``[syntax_option_type]`` extended
230                                             = regex_constants::extended;
231   static const regex_constants::``[syntax_option_type]`` awk
232                                             = regex_constants::awk;
233   static const regex_constants::``[syntax_option_type]`` grep
234                                             = regex_constants::grep;
235   static const regex_constants::``[syntax_option_type]`` egrep
236                                             = regex_constants::egrep;
237   static const regex_constants::``[syntax_option_type]`` sed
238                                             = regex_constants::sed;
239   static const regex_constants::``[syntax_option_type]`` perl
240                                             = regex_constants::perl;
241   static const regex_constants::``[syntax_option_type]`` literal
242                                             = regex_constants::literal;
243
244   // modifiers specific to perl expressions:
245   static const regex_constants::``[syntax_option_type]`` no_mod_m
246                                             = regex_constants::no_mod_m;
247   static const regex_constants::``[syntax_option_type]`` no_mod_s
248                                             = regex_constants::no_mod_s;
249   static const regex_constants::``[syntax_option_type]`` mod_s
250                                             = regex_constants::mod_s;
251   static const regex_constants::``[syntax_option_type]`` mod_x
252                                             = regex_constants::mod_x;
253
254   // modifiers specific to POSIX basic expressions:
255   static const regex_constants::``[syntax_option_type]`` bk_plus_qm
256                                             = regex_constants::bk_plus_qm;
257   static const regex_constants::``[syntax_option_type]`` bk_vbar
258                                             = regex_constants::bk_vbar
259   static const regex_constants::``[syntax_option_type]`` no_char_classes
260                                             = regex_constants::no_char_classes
261   static const regex_constants::``[syntax_option_type]`` no_intervals
262                                             = regex_constants::no_intervals
263
264   // common modifiers:
265   static const regex_constants::``[syntax_option_type]`` nosubs
266                                             = regex_constants::nosubs;
267   static const regex_constants::``[syntax_option_type]`` optimize
268                                             = regex_constants::optimize;
269   static const regex_constants::``[syntax_option_type]`` collate
270                                             = regex_constants::collate;
271   static const regex_constants::``[syntax_option_type]`` newline_alt
272                                             = regex_constants::newline_alt;
273
274The meaning of these options is documented in the [syntax_option_type]
275section.
276
277The static constant members are provided as synonyms for the constants declared
278in namespace `boost::regex_constants`; for each constant of type [syntax_option_type]
279declared in namespace `boost::regex_constants` then a constant with the same name,
280type and value is declared within the scope of basic_regex.
281
282[#boost_regex.basic_regex.construct1]
283
284   basic_regex();
285
286[*Effects]: Constructs an object of class `basic_regex`.
287
288[table basic_regex default construction postconditions
289[[Element][Value]]
290[[`empty()`][`true`]]
291[[`size()`][`0`]]
292[[`str()`][`basic_string<charT>()`]]
293]
294
295[#boost_regex.basic_regex.construct2]
296
297   basic_regex(const charT* p, flag_type f = regex_constants::normal);
298
299[*Requires]: /p/ shall not be a null pointer.
300
301[*Throws]: [bad_expression] if /p/ is not a valid regular expression,
302unless the flag `no_except` is set in /f/.
303
304[*Effects]: Constructs an object of class [basic_regex]; the object's internal
305finite state machine is constructed from the regular expression contained
306in the null-terminated string /p/, and interpreted according to the
307[link boost_regex.ref.syntax_option_type option
308flags] specified in /f/.
309
310[table Postconditions for basic_regex construction
311[[Element][Value]]
312[[`empty()`][`false`]]
313[[`size()`][`char_traits<charT>::length(p)`]]
314[[`str()`][`basic_string<charT>(p)`]]
315[[`flags()`][['f]]]
316[[`mark_count()`][The number of marked sub-expressions within the expression.]]
317]
318
319[#boost_regex.basic_regex.construct3]
320
321   basic_regex(const charT* p1, const charT* p2,
322               flag_type f = regex_constants::normal);
323
324[*Requires]: /p1/ and /p2/ are not null pointers, `p1 < p2`.
325
326[*Throws]: bad_expression if \[p1,p2) is not a valid regular expression, unless
327the flag `no_except` is set in /f/.
328
329[*Effects]: Constructs an object of class [basic_regex]; the object's
330internal finite state machine is constructed from the regular expression
331contained in the sequence of characters \[p1,p2), and interpreted according the
332[link boost_regex.ref.syntax_option_type option flags] specified in /f/.
333
334[table Postconditions for basic_regex construction
335[[Element][Value]]
336[[`empty()`][`false`]]
337[[`size()`][`std::distance(p1,p2)`]]
338[[`str()`][`basic_string<charT>(p1,p2)`]]
339[[`flags()`][['f]]]
340[[`mark_count()`][The number of marked sub-expressions within the expression.]]
341]
342
343[#boost_regex.basic_regex.construct4]
344
345   basic_regex(const charT* p, size_type len, flag_type f);
346
347[*Requires]: /p/ shall not be a null pointer, `len < max_size()`.
348
349[*Throws]: [bad_expression] if /p/ is not a valid regular expression, unless
350the flag `no_except` is set in /f/.
351
352[*Effects]: Constructs an object of class [basic_regex]; the object's
353internal finite state machine is constructed from the regular expression
354contained in the sequence of characters \[p, p+len), and interpreted
355according the option flags specified in /f/.
356
357[table Postconditions for basic_regex construction
358[[Element][Value]]
359[[`empty()`][`false`]]
360[[`size()`][['len]]]
361[[`str()`][`basic_string<charT>(p, len)`]]
362[[`flags()`][['f]]]
363[[`mark_count()`][The number of marked sub-expressions within the expression.]]
364]
365
366[#boost_regex.basic_regex.construct5]
367
368   basic_regex(const basic_regex& e);
369
370[*Effects]: Constructs an object of class [basic_regex] as a copy of the object
371/e/.
372
373[#boost_regex.basic_regex.construct6]
374
375   template <class ST, class SA>
376   basic_regex(const basic_string<charT, ST, SA>& s,
377               flag_type f = regex_constants::normal);
378
379[*Throws]: [bad_expression] if /s/ is not a valid regular expression,
380unless the flag `no_except` is set in /f/.
381
382[*Effects]: Constructs an object of class [basic_regex]; the object's
383internal finite state machine is constructed from the regular expression
384contained in the string /s/, and interpreted according to the [link boost_regex.ref.syntax_option_type option
385flags] specified in /f/.
386
387[table Postconditions for basic_regex construction
388[[Element][Value]]
389[[`empty()`][`false`]]
390[[`size()`][`s.size()`]]
391[[`str()`][['s]]]
392[[`flags()`][['f]]]
393[[`mark_count()`][The number of marked sub-expressions within the expression.]]
394]
395
396[#boost_regex.basic_regex.construct7]
397
398   template <class ForwardIterator>
399   basic_regex(ForwardIterator first, ForwardIterator last,
400               flag_type f = regex_constants::normal);
401
402[*Throws]: [bad_expression] if the sequence \[first, last) is not a valid
403regular expression, unless the flag `no_except` is set in /f/.
404
405[*Effects]: Constructs an object of class [basic_regex]; the object's
406internal finite state machine is constructed from the regular expression
407contained in the sequence of characters \[first, last), and interpreted
408according to the [link boost_regex.ref.syntax_option_type option flags] specified in /f/.
409
410[table Postconditions for basic_regex construction
411[[Element][Value]]
412[[`empty()`][`false`]]
413[[`size()`][`distance(first,last)`]]
414[[`str()`][`basic_string<charT>(first,last)`]]
415[[`flags()`][['f]]]
416[[`mark_count()`][The number of marked sub-expressions within the expression.]]
417]
418
419[#boost_regex.basic_regex.opeq1]
420
421   basic_regex& operator=(const basic_regex& e);
422
423[*Effects]: Returns the result of `assign(e.str(), e.flags())`.
424
425[#boost_regex.basic_regex.opeq2]
426
427   basic_regex& operator=(const charT* ptr);
428
429[*Requires]: /p/ shall not be a null pointer.
430
431[*Effects]: Returns the result of `assign(ptr)`.
432
433[#boost_regex.basic_regex.opeq3]
434
435   template <class ST, class SA>
436   basic_regex& operator=(const basic_string<charT, ST, SA>& p);
437
438[*Effects]: Returns the result of `assign(p)`.
439
440[#boost_regex.basic_regex.subexpression]
441
442   std::pair<const_iterator, const_iterator> subexpression(size_type n) const;
443
444[*Effects]: Returns a pair of iterators denoting the location of
445marked subexpression /n/ within the original regular expression string.
446The returned iterators are relative to `begin()` and `end()`.
447
448[*Requires]: The expression must have been compiled with the
449[syntax_option_type] save_subexpression_location set.  Argument
450/n/ must be in within the range `0 <= n < mark_count()`.
451
452[#boost_regex.basic_regex.begin]
453
454   const_iterator begin() const;
455
456[*Effects]: Returns a starting iterator to a sequence of characters representing
457the regular expression.
458
459[#boost_regex.basic_regex.end]
460
461   const_iterator end() const;
462
463[*Effects]: Returns termination iterator to a sequence of characters representing
464the regular expression.
465
466[#boost_regex.basic_regex.size]
467
468   size_type size() const;
469
470[*Effects]: Returns the length of the sequence of characters representing the regular expression.
471
472[#boost_regex.basic_regex.max_size]
473
474   size_type max_size() const;
475
476[*Effects]: Returns the maximum length of the sequence of characters representing
477the regular expression.
478
479[#boost_regex.basic_regex.empty]
480
481   bool empty() const;
482
483[*Effects]: Returns true if the object does not contain a valid regular expression,
484otherwise false.
485
486[#boost_regex.basic_regex.mark_count]
487
488   size_type mark_count() const;
489
490[*Effects]: Returns the number of marked sub-expressions within the regular expression.
491
492[#boost_regex.basic_regex.assign1]
493
494   basic_regex& assign(const basic_regex& that);
495
496[*Effects]: Returns [link boost_regex.basic_regex.assign4 `assign(that.str(), that.flags())`].
497
498[#boost_regex.basic_regex.assign2]
499
500   basic_regex& assign(const charT* ptr, flag_type f = regex_constants::normal);
501
502[*Effects]: Returns [link boost_regex.basic_regex.assign4 `assign(string_type(ptr), f)`].
503
504[#boost_regex.basic_regex.assign3]
505
506   basic_regex& assign(const charT* ptr, unsigned int len, flag_type f);
507
508[*Effects]: Returns [link boost_regex.basic_regex.assign4 `assign(string_type(ptr, len), f)`].
509
510[#boost_regex.basic_regex.assign4]
511
512   template <class string_traits, class A>
513   basic_regex& assign(const basic_string<charT, string_traits, A>& s,
514                     flag_type f = regex_constants::normal);
515
516[*Throws]: [bad_expression] if /s/ is not a valid regular expression,
517unless the flag `no_except` is set in /f/.
518
519[*Returns]: *this.
520
521[*Effects]: Assigns the regular expression contained in the string /s/,
522interpreted according the [link boost_regex.ref.syntax_option_type option flags]
523specified in /f/.
524
525[table Postconditions for basic_regex::assign
526[[Element][Value]]
527[[`empty()`][`false`]]
528[[`size()`][`s.size()`]]
529[[`str()`][['s]]]
530[[`flags()`][['f]]]
531[[`mark_count()`][The number of marked sub-expressions within the expression.]]
532]
533
534[#boost_regex.basic_regex.assign5]
535
536   template <class InputIterator>
537   basic_regex& assign(InputIterator first, InputIterator last,
538                       flag_type f = regex_constants::normal);
539
540[*Requires]: The type `InputIterator` corresponds to the
541[@http://input_iterator Input Iterator requirements
542(24.1.1)].
543
544[*Effects]: Returns [link boost_regex.basic_regex.assign4 `assign(string_type(first, last), f)`].
545
546[#boost_regex.basic_regex.flags]
547
548   flag_type flags() const;
549
550[*Effects]: Returns a copy of the [link boost_regex.ref.syntax_option_type
551regular expression syntax flags] that were passed to the object's constructor,
552or the last call to `assign`.
553
554[#boost_regex.basic_regex.status]
555
556   int status() const;
557
558[*Effects]: Returns zero if the expression contains a valid regular expression,
559otherwise an error code.  This member function is retained for use in
560environments that cannot use exception handling.
561
562[#boost_regex.basic_regex.str]
563
564   basic_string<charT> str() const;
565
566[*Effects]: Returns a copy of the character sequence passed to the object's constructor,
567or the last call to assign.
568
569[#boost_regex.basic_regex.compare]
570
571   int compare(basic_regex& e)const;
572
573[*Effects]: If `flags() == e.flags()` then returns `str().compare(e.str())`,
574otherwise returns `flags() - e.flags()`.
575
576[#boost_regex.basic_regex.imbue]
577
578   locale_type imbue(locale_type l);
579
580[*Effects]: Returns the result of `traits_inst.imbue(l)` where `traits_inst` is
581a (default initialized) instance of the template parameter `traits` stored
582within the object. Calls to `imbue` invalidate any currently contained
583regular expression.
584
585[*Postcondition]: `empty() == true`.
586
587[#boost_regex.basic_regex.getloc]
588
589   locale_type getloc() const;
590
591[*Effects]: Returns the result of `traits_inst.getloc()` where `traits_inst` is
592a (default initialized) instance of the template parameter traits stored
593within the object.
594
595[#boost_regex.basic_regex.swap]
596
597   void swap(basic_regex& e) throw();
598
599[*Effects]: Swaps the contents of the two regular expressions.
600
601[*Postcondition]: `*this` contains the regular expression that was in /e/, /e/ contains
602the regular expression that was in `*this`.
603
604[*Complexity]: constant time.
605
606[note Comparisons between [basic_regex] objects are provided on an
607experimental basis: please note that these are not present in the [tr1],
608so use with care if you are writing code that may need to be ported
609to other implementations of [basic_regex].]
610
611[#boost_regex.basic_regex.op_eq]
612
613   template <class charT, class traits>
614   bool operator == (const basic_regex<charT, traits>& lhs,
615                     const basic_regex<charT, traits>& rhs);
616
617[*Effects]: Returns `lhs.compare(rhs) == 0`.
618
619[#boost_regex.basic_regex.op_ne]
620
621   template <class charT, class traits>
622   bool operator != (const basic_regex<charT, traits>& lhs,
623                     const basic_regex<charT, traits>& rhs);
624
625[*Effects]: Returns `lhs.compare(rhs) != 0`.
626
627[#boost_regex.basic_regex.op_lt]
628
629   template <class charT, class traits>
630   bool operator < (const basic_regex<charT, traits>& lhs,
631                  const basic_regex<charT, traits>& rhs);
632
633[*Effects]: Returns `lhs.compare(rhs) < 0`.
634
635[#boost_regex.basic_regex.op_le]
636
637   template <class charT, class traits>
638   bool operator <= (const basic_regex<charT, traits>& lhs,
639                     const basic_regex<charT, traits>& rhs);
640
641[*Effects]: Returns `lhs.compare(rhs) <= 0`.
642
643[#boost_regex.basic_regex.op_ge]
644
645   template <class charT, class traits>
646   bool operator >= (const basic_regex<charT, traits>& lhs,
647                     const basic_regex<charT, traits>& rhs);
648
649[*Effects]: Returns `lhs.compare(rhs) >= 0`.
650
651[#boost_regex.basic_regex.op_gt]
652
653   template <class charT, class traits>
654   bool operator > (const basic_regex<charT, traits>& lhs,
655                  const basic_regex<charT, traits>& rhs);
656
657[*Effects]: Returns `lhs.compare(rhs) > 0`.
658
659[note The basic_regex stream inserter is provided on an experimental basis,
660and outputs the textual representation of the expression to the stream.]
661
662[#boost_regex.basic_regex.op_stream]
663
664   template <class charT, class io_traits, class re_traits>
665   basic_ostream<charT, io_traits>&
666      operator << (basic_ostream<charT, io_traits>& os
667                  const basic_regex<charT, re_traits>& e);
668
669[*Effects]: Returns `(os << e.str())`.
670
671[#boost_regex.basic_regex.op_swap]
672
673   template <class charT, class traits>
674   void swap(basic_regex<charT, traits>& lhs,
675            basic_regex<charT, traits>& rhs);
676
677[*Effects]: calls `lhs.swap(rhs)`.
678
679[endsect]
680
681