basic_regex.qbk

来自「Boost provides free peer-reviewed portab」· QBK 代码 · 共 668 行 · 第 1/2 页

[[`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.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]

   unsigned mark_count() const;

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

[#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]