[/ 
  Copyright 2006-2007 John Maddock.
  Distributed under the Boost Software License, Version 1.0.
  (See accompanying file LICENSE_1_0.txt or copy at
  http://www.boost.org/LICENSE_1_0.txt).
]

[section:basic_regex basic_regex]

[h4 Synopsis]

   #include <boost/regex.hpp>

The template class `basic_regex` encapsulates regular expression 
parsing and compilation. The class takes two template parameters:

* `charT`: determines the character type, i.e. either `char` or `wchar_t`; 
see [link boost_regex.ref.concepts.charT_concept charT concept].
* `traits`: determines the behavior of the character type, for example which 
character class names are recognized. A default traits class is provided: 
`regex_traits<charT>`.  See also 
[link boost_regex.ref.concepts.traits_concept traits concept].

For ease of use there are two typedefs that define the two standard 
`basic_regex` instances, unless you want to use custom traits classes or 
non-standard character types (for example see 
[link boost_regex.ref.non_std_strings.icu unicode support]), 
you won't need to use anything other than these:

   namespace boost{

   template <class charT, class traits = regex_traits<charT>  >
   class basic_regex;
   
   typedef basic_regex<char>      regex;
   typedef basic_regex<wchar_t>   wregex;

   }

The definition of `basic_regex` follows: it is based very closely on class 
`basic_string`, and fulfils the requirements for a constant-container of `charT`.

   namespace boost{

   template <class  charT, class traits = regex_traits<charT> >
   class basic_regex {
      public:          
      // types:
      typedef          charT                                value_type;
      typedef          implementation-specific              const_iterator;
      typedef          const_iterator                       iterator;                 
      typedef          charT&                               reference;           
      typedef          const charT&                         const_reference;           
      typedef          std::ptrdiff_t                       difference_type;                 
      typedef          std::size_t                          size_type;
      typedef          regex_constants::``[syntax_option_type]``  flag_type;
      typedef typename traits::locale_type                  locale_type;

      // constants:
      // main option selection:
      static const regex_constants::``[syntax_option_type]`` normal          
                                                   = regex_constants::normal;
      static const regex_constants::``[syntax_option_type]`` ECMAScript      
                                                   = normal;
      static const regex_constants::``[syntax_option_type]`` JavaScript      
                                                   = normal;
      static const regex_constants::``[syntax_option_type]`` JScript         
                                                   = normal;
      static const regex_constants::``[syntax_option_type]`` basic           
                                                   = regex_constants::basic;
      static const regex_constants::``[syntax_option_type]`` extended        
                                                   = regex_constants::extended;
      static const regex_constants::``[syntax_option_type]`` awk             
                                                   = regex_constants::awk;
      static const regex_constants::``[syntax_option_type]`` grep            
                                                   = regex_constants::grep;
      static const regex_constants::``[syntax_option_type]`` egrep           
                                                   = regex_constants::egrep;
      static const regex_constants::``[syntax_option_type]`` sed             
                                                   = basic = regex_constants::sed;
      static const regex_constants::``[syntax_option_type]`` perl            
                                                   = regex_constants::perl;
      static const regex_constants::``[syntax_option_type]`` literal         
                                                   = regex_constants::literal;

      // modifiers specific to perl expressions:
      static const regex_constants::``[syntax_option_type]`` no_mod_m        
                                                   = regex_constants::no_mod_m;
      static const regex_constants::``[syntax_option_type]`` no_mod_s        
                                                   = regex_constants::no_mod_s;
      static const regex_constants::``[syntax_option_type]`` mod_s           
                                                   = regex_constants::mod_s;
      static const regex_constants::``[syntax_option_type]`` mod_x           
                                                   = regex_constants::mod_x;

      // modifiers specific to POSIX basic expressions:
      static const regex_constants::``[syntax_option_type]`` bk_plus_qm      
                                                   = regex_constants::bk_plus_qm;
      static const regex_constants::``[syntax_option_type]`` bk_vbar         
                                                   = regex_constants::bk_vbar
      static const regex_constants::``[syntax_option_type]`` no_char_classes 
                                                   = regex_constants::no_char_classes
      static const regex_constants::``[syntax_option_type]`` no_intervals    
                                                   = regex_constants::no_intervals

      // common modifiers:
      static const regex_constants::``[syntax_option_type]`` nosubs          
                                                   = regex_constants::nosubs;
      static const regex_constants::``[syntax_option_type]`` optimize        
                                                   = regex_constants::optimize;
      static const regex_constants::``[syntax_option_type]`` collate         
                                                   = regex_constants::collate;
      static const regex_constants::``[syntax_option_type]`` newline_alt     
                                                   = regex_constants::newline_alt;
      static const regex_constants::``[syntax_option_type]`` no_except       
                                                   = regex_constants::newline_alt;

      // construct/copy/destroy:
      explicit ``[link boost_regex.basic_regex.construct1 basic_regex]`` ();
      explicit ``[link boost_regex.basic_regex.construct2 basic_regex]``(const  charT* p, flag_type f = regex_constants::normal);
      ``[link boost_regex.basic_regex.construct3 basic_regex]``(const charT* p1, const  charT* p2, 
                  flag_type f = regex_constants::normal);
      ``[link boost_regex.basic_regex.construct4 basic_regex]``(const charT* p, size_type len, flag_type  f);
      ``[link boost_regex.basic_regex.construct5 basic_regex]``(const basic_regex&);

      template <class ST, class SA>
      explicit ``[link boost_regex.basic_regex.construct6 basic_regex]``(const basic_string<charT, ST,  SA>& p, 
                           flag_type f = regex_constants::normal);

      template <class InputIterator>
      ``[link boost_regex.basic_regex.construct7 basic_regex]``(InputIterator first,  InputIterator last, 
                  flag_type f = regex_constants::normal);

      ~basic_regex();
      ``[link boost_regex.basic_regex.opeq1 basic_regex& operator=]``(const basic_regex&);
      ``[link boost_regex.basic_regex.opeq2 basic_regex& operator=]`` (const charT* ptr); 

      template <class ST, class SA> 
      ``[link boost_regex.basic_regex.opeq3 basic_regex& operator=]`` (const basic_string<charT, ST, SA>& p);
      // iterators: 
      ``[link boost_regex.basic_regex.subexpression std::pair<const_iterator, const_iterator> subexpression]``(size_type n) const; 
      ``[link boost_regex.basic_regex.begin const_iterator begin]``() const; 
      ``[link boost_regex.basic_regex.end const_iterator end]``() const;
      // capacity: 
      ``[link boost_regex.basic_regex.size size_type size]``() const; 
      ``[link boost_regex.basic_regex.max_size size_type max_size]``() const; 
      ``[link boost_regex.basic_regex.empty bool empty]``() const; 
      ``[link boost_regex.basic_regex.mark_count size_type mark_count]``()const; 
      //
      // modifiers: 
      ``[link boost_regex.basic_regex.assign1 basic_regex& assign]``(const basic_regex& that); 
      ``[link boost_regex.basic_regex.assign2 basic_regex& assign]``(const charT* ptr, 
                          flag_type f = regex_constants::normal);
      ``[link boost_regex.basic_regex.assign3 basic_regex& assign]``(const charT* ptr, unsigned int len, flag_type f);

      template <class string_traits, class A>
      ``[link boost_regex.basic_regex.assign4 basic_regex& assign]``(const basic_string<charT, string_traits, A>& s,
                          flag_type f = regex_constants::normal);

      template <class InputIterator>
      ``[link boost_regex.basic_regex.assign5 basic_regex& assign]``(InputIterator first, InputIterator last,
                          flag_type f = regex_constants::normal);

      // const operations:
      ``[link boost_regex.basic_regex.flags flag_type flags]``() const;
      ``[link boost_regex.basic_regex.status int status]``()const;
      ``[link boost_regex.basic_regex.str basic_string<charT> str]``() const;
      ``[link boost_regex.basic_regex.compare int compare]``(basic_regex&) const;
      // locale:
      ``[link boost_regex.basic_regex.imbue locale_type imbue]``(locale_type loc);
      ``[link boost_regex.basic_regex.getloc locale_type getloc]``() const;
      // swap
      ``[link boost_regex.basic_regex.swap void swap]``(basic_regex&) throw();
   };

   template <class charT, class traits>
   ``[link boost_regex.basic_regex.op_eq bool operator ==]`` (const basic_regex<charT, traits>& lhs,
                     const basic_regex<charT, traits>& rhs);

   template <class charT, class traits>
   ``[link boost_regex.basic_regex.op_ne bool operator !=]`` (const basic_regex<charT, traits>& lhs,
                     const basic_regex<charT, traits>& rhs);

   template <class charT, class traits>
   ``[link boost_regex.basic_regex.op_lt bool operator <]`` (const basic_regex<charT, traits>& lhs,
                  const basic_regex<charT, traits>& rhs);

   template <class charT, class traits>
   ``[link boost_regex.basic_regex.op_le bool operator <=]`` (const basic_regex<charT, traits>& lhs,
                     const basic_regex<charT, traits>& rhs);

   template <class charT, class traits>
   ``[link boost_regex.basic_regex.op_ge bool operator >=]`` (const basic_regex<charT, traits>& lhs,
                     const basic_regex<charT, traits>& rhs);

   template <class charT, class traits>
   ``[link boost_regex.basic_regex.op_gt bool operator >]`` (const basic_regex<charT, traits>& lhs,
                  const basic_regex<charT, traits>& rhs);

   template <class charT, class io_traits, class re_traits>
   basic_ostream<charT, io_traits>&
      ``[link boost_regex.basic_regex.op_stream operator <<]`` (basic_ostream<charT, io_traits>& os,
                  const basic_regex<charT, re_traits>& e);

   template <class charT, class traits>
   ``[link boost_regex.basic_regex.op_swap void swap]``(basic_regex<charT, traits>& e1,
            basic_regex<charT, traits>& e2);

   typedef basic_regex<char> regex;
   typedef basic_regex<wchar_t> wregex;

   } // namespace boost

[h4 Description]

Class `basic_regex` has the following public members:

   // main option selection:
   static const regex_constants::``[syntax_option_type]`` normal           
                                             = regex_constants::normal;
   static const regex_constants::``[syntax_option_type]`` ECMAScript       
                                             = normal;
   static const regex_constants::``[syntax_option_type]`` JavaScript       
                                             = normal;
   static const regex_constants::``[syntax_option_type]`` JScript          
                                             = normal;
   static const regex_constants::``[syntax_option_type]`` basic            
                                             = regex_constants::basic;
   static const regex_constants::``[syntax_option_type]`` extended         
                                             = regex_constants::extended;
   static const regex_constants::``[syntax_option_type]`` awk              
                                             = regex_constants::awk;
   static const regex_constants::``[syntax_option_type]`` grep             
                                             = regex_constants::grep;
   static const regex_constants::``[syntax_option_type]`` egrep            
                                             = regex_constants::egrep;
   static const regex_constants::``[syntax_option_type]`` sed              
                                             = regex_constants::sed;
   static const regex_constants::``[syntax_option_type]`` perl             
                                             = regex_constants::perl;
   static const regex_constants::``[syntax_option_type]`` literal          
                                             = regex_constants::literal;

   // modifiers specific to perl expressions:
   static const regex_constants::``[syntax_option_type]`` no_mod_m         
                                             = regex_constants::no_mod_m;
   static const regex_constants::``[syntax_option_type]`` no_mod_s         
                                             = regex_constants::no_mod_s;
   static const regex_constants::``[syntax_option_type]`` mod_s            
                                             = regex_constants::mod_s;
   static const regex_constants::``[syntax_option_type]`` mod_x            
                                             = regex_constants::mod_x;

   // modifiers specific to POSIX basic expressions:
   static const regex_constants::``[syntax_option_type]`` bk_plus_qm       
                                             = regex_constants::bk_plus_qm;
   static const regex_constants::``[syntax_option_type]`` bk_vbar          
                                             = regex_constants::bk_vbar
   static const regex_constants::``[syntax_option_type]`` no_char_classes  
                                             = regex_constants::no_char_classes
   static const regex_constants::``[syntax_option_type]`` no_intervals     
                                             = regex_constants::no_intervals

   // common modifiers:
   static const regex_constants::``[syntax_option_type]`` nosubs           
                                             = regex_constants::nosubs;
   static const regex_constants::``[syntax_option_type]`` optimize         
                                             = regex_constants::optimize;
   static const regex_constants::``[syntax_option_type]`` collate          
                                             = regex_constants::collate;
   static const regex_constants::``[syntax_option_type]`` newline_alt      
                                             = regex_constants::newline_alt;

The meaning of these options is documented in the [syntax_option_type]
section.

The static constant members are provided as synonyms for the constants declared 
in namespace `boost::regex_constants`; for each constant of type [syntax_option_type] 
declared in namespace `boost::regex_constants` then a constant with the same name, 
type and value is declared within the scope of basic_regex.

[#boost_regex.basic_regex.construct1]

   basic_regex();

[*Effects]: Constructs an object of class `basic_regex`. 

[table basic_regex default construction postconditions
[[Element][Value]]
[[`empty()`][`true`]]
[[`size()`][`0`]]
[[`str()`][`basic_string<charT>()`]]
]

[#boost_regex.basic_regex.construct2]

   basic_regex(const charT* p, flag_type f = regex_constants::normal);

[*Requires]: /p/ shall not be a null pointer.

[*Throws]: [bad_expression] if /p/ is not a valid regular expression, 
unless the flag `no_except` is set in /f/.

[*Effects]: Constructs an object of class [basic_regex]; the object's internal 
finite state machine is constructed from the regular expression contained 
in the null-terminated string /p/, and interpreted according to the 
[link boost_regex.ref.syntax_option_type option 
flags] specified in /f/. 

[table Postconditions for basic_regex construction
[[Element][Value]]
[[`empty()`][`false`]]
[[`size()`][`char_traits<charT>::length(p)`]]
[[`str()`][`basic_string<charT>(p)`]]
[[`flags()`][['f]]]
[[`mark_count()`][The number of marked sub-expressions within the expression.]]
]

[#boost_regex.basic_regex.construct3]

   basic_regex(const charT* p1, const charT* p2, 
               flag_type f = regex_constants::normal);

[*Requires]: /p1/ and /p2/ are not null pointers, `p1 < p2`.

[*Throws]: bad_expression if \[p1,p2) is not a valid regular expression, unless 
the flag `no_except` is set in /f/.

[*Effects]: Constructs an object of class [basic_regex]; the object's 
internal finite state machine is constructed from the regular expression 
contained in the sequence of characters \[p1,p2), and interpreted according the 
[link boost_regex.ref.syntax_option_type option flags] specified in /f/. 

[table Postconditions for basic_regex construction
[[Element][Value]]
[[`empty()`][`false`]]
[[`size()`][`std::distance(p1,p2)`]]
[[`str()`][`basic_string<charT>(p1,p2)`]]
[[`flags()`][['f]]]
[[`mark_count()`][The number of marked sub-expressions within the expression.]]
]

[#boost_regex.basic_regex.construct4]

   basic_regex(const charT* p, size_type len, flag_type f);

[*Requires]: /p/ shall not be a null pointer, `len < max_size()`.

[*Throws]: [bad_expression] if /p/ is not a valid regular expression, unless 
the flag `no_except` is set in /f/.

[*Effects]: Constructs an object of class [basic_regex]; the object's 
internal finite state machine is constructed from the regular expression 
contained in the sequence of characters \[p, p+len), and interpreted 
according the option flags specified in /f/. 

[table Postconditions for basic_regex construction
[[Element][Value]]
[[`empty()`][`false`]]
[[`size()`][['len]]]
[[`str()`][`basic_string<charT>(p, len)`]]
[[`flags()`][['f]]]
[[`mark_count()`][The number of marked sub-expressions within the expression.]]
]

[#boost_regex.basic_regex.construct5]

   basic_regex(const basic_regex& e);

[*Effects]: Constructs an object of class [basic_regex] as a copy of the object 
/e/. 

[#boost_regex.basic_regex.construct6]

   template <class ST, class SA>
   basic_regex(const basic_string<charT, ST, SA>& s, 
               flag_type f = regex_constants::normal);

[*Throws]: [bad_expression] if /s/ is not a valid regular expression, 
unless the flag `no_except` is set in /f/.

[*Effects]: Constructs an object of class [basic_regex]; the object's 
internal finite state machine is constructed from the regular expression 
contained in the string /s/, and interpreted according to the [link boost_regex.ref.syntax_option_type option 
flags] specified in /f/. 

[table Postconditions for basic_regex construction
[[Element][Value]]
[[`empty()`][`false`]]
[[`size()`][`s.size()`]]
[[`str()`][['s]]]
[[`flags()`][['f]]]
[[`mark_count()`][The number of marked sub-expressions within the expression.]]
]

[#boost_regex.basic_regex.construct7]

   template <class ForwardIterator>
   basic_regex(ForwardIterator first, ForwardIterator last, 
               flag_type f = regex_constants::normal);

[*Throws]: [bad_expression] if the sequence \[first, last) is not a valid 
regular expression, unless the flag `no_except` is set in /f/.

[*Effects]: Constructs an object of class [basic_regex]; the object's 
internal finite state machine is constructed from the regular expression 
contained in the sequence of characters \[first, last), and interpreted 
according to the [link boost_regex.ref.syntax_option_type option flags] specified in /f/. 

[table Postconditions for basic_regex construction
[[Element][Value]]
[[`empty()`][`false`]]
[[`size()`][`distance(first,last)`]]
[[`str()`][`basic_string<charT>(first,last)`]]
[[`flags()`][['f]]]
[[`mark_count()`][The number of marked sub-expressions within the expression.]]
]

[#boost_regex.basic_regex.opeq1]

   basic_regex& operator=(const basic_regex& e);

[*Effects]: Returns the result of `assign(e.str(), e.flags())`.

[#boost_regex.basic_regex.opeq2]

   basic_regex& operator=(const charT* ptr);

[*Requires]: /p/ shall not be a null pointer.

[*Effects]: Returns the result of `assign(ptr)`.

[#boost_regex.basic_regex.opeq3]

   template <class ST, class SA>
   basic_regex& operator=(const basic_string<charT, ST, SA>& p);

[*Effects]: Returns the result of `assign(p)`.

[#boost_regex.basic_regex.subexpression]

   std::pair<const_iterator, const_iterator> subexpression(size_type n) const;

[*Effects]: Returns a pair of iterators denoting the location of 
marked subexpression /n/ within the original regular expression string.
The returned iterators are relative to `begin()` and `end()`.

[*Requires]: The expression must have been compiled with the
[syntax_option_type] save_subexpression_location set.  Argument
/n/ must be in within the range `0 <= n < mark_count()`.

[#boost_regex.basic_regex.begin]

   const_iterator begin() const;

[*Effects]: Returns a starting iterator to a sequence of characters representing 
the regular expression.

[#boost_regex.basic_regex.end]

   const_iterator end() const;

[*Effects]: Returns termination iterator to a sequence of characters representing 
the regular expression.

[#boost_regex.basic_regex.size]

   size_type size() const;

[*Effects]: Returns the length of the sequence of characters representing the regular expression.

[#boost_regex.basic_regex.max_size]

   size_type max_size() const;

[*Effects]: Returns the maximum length of the sequence of characters representing 
the regular expression.

[#boost_regex.basic_regex.empty]

   bool empty() const;

[*Effects]: Returns true if the object does not contain a valid regular expression, 
otherwise false.

[#boost_regex.basic_regex.mark_count]

   size_type mark_count() const;

[*Effects]: Returns the number of marked sub-expressions within the regular expression.

[#boost_regex.basic_regex.assign1]

   basic_regex& assign(const basic_regex& that);

[*Effects]: Returns [link boost_regex.basic_regex.assign4 `assign(that.str(), that.flags())`].

[#boost_regex.basic_regex.assign2]

   basic_regex& assign(const charT* ptr, flag_type f = regex_constants::normal);

[*Effects]: Returns [link boost_regex.basic_regex.assign4 `assign(string_type(ptr), f)`].

[#boost_regex.basic_regex.assign3]

   basic_regex& assign(const charT* ptr, unsigned int len, flag_type f);

[*Effects]: Returns [link boost_regex.basic_regex.assign4 `assign(string_type(ptr, len), f)`].

[#boost_regex.basic_regex.assign4]

   template <class string_traits, class A>
   basic_regex& assign(const basic_string<charT, string_traits, A>& s,
                     flag_type f = regex_constants::normal);

[*Throws]: [bad_expression] if /s/ is not a valid regular expression, 
unless the flag `no_except` is set in /f/.

[*Returns]: *this.

[*Effects]: Assigns the regular expression contained in the string /s/, 
interpreted according the [link boost_regex.ref.syntax_option_type option flags] 
specified in /f/. 

[table Postconditions for basic_regex::assign
[[Element][Value]]
[[`empty()`][`false`]]
[[`size()`][`s.size()`]]
[[`str()`][['s]]]
[[`flags()`][['f]]]
[[`mark_count()`][The number of marked sub-expressions within the expression.]]
]

[#boost_regex.basic_regex.assign5]

   template <class InputIterator>
   basic_regex& assign(InputIterator first, InputIterator last,
                       flag_type f = regex_constants::normal);

[*Requires]: The type `InputIterator` corresponds to the 
[@http://input_iterator Input Iterator requirements 
(24.1.1)].

[*Effects]: Returns [link boost_regex.basic_regex.assign4 `assign(string_type(first, last), f)`].

[#boost_regex.basic_regex.flags]

   flag_type flags() const;

[*Effects]: Returns a copy of the [link boost_regex.ref.syntax_option_type 
regular expression syntax flags] that were passed to the object's constructor, 
or the last call to `assign`.

[#boost_regex.basic_regex.status]

   int status() const;

[*Effects]: Returns zero if the expression contains a valid regular expression, 
otherwise an error code.  This member function is retained for use in 
environments that cannot use exception handling.

[#boost_regex.basic_regex.str]

   basic_string<charT> str() const;

[*Effects]: Returns a copy of the character sequence passed to the object's constructor, 
or the last call to assign.

[#boost_regex.basic_regex.compare]

   int compare(basic_regex& e)const;

[*Effects]: If `flags() == e.flags()` then returns `str().compare(e.str())`, 
otherwise returns `flags() - e.flags()`.

[#boost_regex.basic_regex.imbue]

   locale_type imbue(locale_type l);

[*Effects]: Returns the result of `traits_inst.imbue(l)` where `traits_inst` is 
a (default initialized) instance of the template parameter `traits` stored 
within the object. Calls to `imbue` invalidate any currently contained 
regular expression.

[*Postcondition]: `empty() == true`.

[#boost_regex.basic_regex.getloc]

   locale_type getloc() const;

[*Effects]: Returns the result of `traits_inst.getloc()` where `traits_inst` is 
a (default initialized) instance of the template parameter traits stored 
within the object.

[#boost_regex.basic_regex.swap]

   void swap(basic_regex& e) throw();

[*Effects]: Swaps the contents of the two regular expressions.

[*Postcondition]: `*this` contains the regular expression that was in /e/, /e/ contains 
the regular expression that was in `*this`.

[*Complexity]: constant time.

[note Comparisons between [basic_regex] objects are provided on an 
experimental basis: please note that these are not present in the [tr1], 
so use with care if you are writing code that may need to be ported
to other implementations of [basic_regex].]

[#boost_regex.basic_regex.op_eq]

   template <class charT, class traits>
   bool operator == (const basic_regex<charT, traits>& lhs,
                     const basic_regex<charT, traits>& rhs);

[*Effects]: Returns `lhs.compare(rhs) == 0`.

[#boost_regex.basic_regex.op_ne]

   template <class charT, class traits>
   bool operator != (const basic_regex<charT, traits>& lhs,
                     const basic_regex<charT, traits>& rhs);

[*Effects]: Returns `lhs.compare(rhs) != 0`.

[#boost_regex.basic_regex.op_lt]

   template <class charT, class traits>
   bool operator < (const basic_regex<charT, traits>& lhs,
                  const basic_regex<charT, traits>& rhs);

[*Effects]: Returns `lhs.compare(rhs) < 0`.

[#boost_regex.basic_regex.op_le]

   template <class charT, class traits>
   bool operator <= (const basic_regex<charT, traits>& lhs,
                     const basic_regex<charT, traits>& rhs);

[*Effects]: Returns `lhs.compare(rhs) <= 0`.

[#boost_regex.basic_regex.op_ge]

   template <class charT, class traits>
   bool operator >= (const basic_regex<charT, traits>& lhs,
                     const basic_regex<charT, traits>& rhs);

[*Effects]: Returns `lhs.compare(rhs) >= 0`.

[#boost_regex.basic_regex.op_gt]

   template <class charT, class traits>
   bool operator > (const basic_regex<charT, traits>& lhs,
                  const basic_regex<charT, traits>& rhs);

[*Effects]: Returns `lhs.compare(rhs) > 0`.

[note The basic_regex stream inserter is provided on an experimental basis, 
and outputs the textual representation of the expression to the stream.]

[#boost_regex.basic_regex.op_stream]

   template <class charT, class io_traits, class re_traits>
   basic_ostream<charT, io_traits>&
      operator << (basic_ostream<charT, io_traits>& os
                  const basic_regex<charT, re_traits>& e);

[*Effects]: Returns `(os << e.str())`.

[#boost_regex.basic_regex.op_swap]

   template <class charT, class traits>
   void swap(basic_regex<charT, traits>& lhs,
            basic_regex<charT, traits>& rhs);

[*Effects]: calls `lhs.swap(rhs)`.

[endsect]

