Boost  v1.57.0
doxygen for www.boost.org
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
Public Types | Public Member Functions | List of all members
boost::basic_regex< charT, traits > Singleton Reference

#include <regex_fwd.hpp>

Inheritance diagram for boost::basic_regex< charT, traits >:
Inheritance graph
[legend]
Collaboration diagram for boost::basic_regex< charT, traits >:
Collaboration graph
[legend]

Public Types

typedef std::size_t traits_size_type
 
typedef traits::string_type traits_string_type
 
typedef charT char_type
 
typedef traits traits_type
 
typedef charT value_type
 
typedef charT & reference
 
typedef const charT & const_reference
 
typedef const charT * const_iterator
 
typedef const_iterator iterator
 
typedef std::ptrdiff_t difference_type
 
typedef std::size_t size_type
 
typedef
regex_constants::syntax_option_type 		flag_type
 
typedef traits::locale_type locale_type
 
enum  flag_type_ {
  perl_syntax_group = 0,
  basic_syntax_group = 1,
  literal = 2,
  main_option_type = literal | basic_syntax_group | perl_syntax_group,
  no_bk_refs = 1 << 8,
  no_perl_ex = 1 << 9,
  no_mod_m = 1 << 10,
  mod_x = 1 << 11,
  mod_s = 1 << 12,
  no_mod_s = 1 << 13,
  no_char_classes = 1 << 8,
  no_intervals = 1 << 9,
  bk_plus_qm = 1 << 10,
  bk_vbar = 1 << 11,
  emacs_ex = 1 << 12,
  no_escape_in_lists = 1 << 16,
  newline_alt = 1 << 17,
  no_except = 1 << 18,
  failbit = 1 << 19,
  icase = 1 << 20,
  nocollate = 0,
  collate = 1 << 21,
  nosubs = 1 << 22,
  save_subexpression_location = 1 << 23,
  no_empty_expressions = 1 << 24,
  optimize = 0,
  basic = basic_syntax_group | collate | no_escape_in_lists,
  extended = no_bk_refs | collate | no_perl_ex | no_escape_in_lists,
  normal = 0,
  emacs = basic_syntax_group | collate | emacs_ex | bk_vbar,
  awk = no_bk_refs | collate | no_perl_ex,
  grep = basic | newline_alt,
  egrep = extended | newline_alt,
  sed = basic,
  perl = normal,
  ECMAScript = normal,
  JavaScript = normal,
  JScript = normal
}
 
enum  restart_info {
  restart_any = 0,
  restart_word = 1,
  restart_line = 2,
  restart_buf = 3,
  restart_continue = 4,
  restart_lit = 5,
  restart_fixed_lit = 6,
  restart_count = 7
}
 

Public Member Functions

 basic_regex ()
 
 basic_regex (const charT *p, flag_type f=regex_constants::normal)
 
 basic_regex (const charT *p1, const charT *p2, flag_type f=regex_constants::normal)
 
 basic_regex (const charT *p, size_type len, flag_type f)
 
 basic_regex (const basic_regex &that)
 
 ~basic_regex ()
 
basic_regex &BOOST_REGEX_CALL operator= (const basic_regex &that)
 
basic_regex &BOOST_REGEX_CALL operator= (const charT *ptr)
 
basic_regex & assign (const basic_regex &that)
 
basic_regex & assign (const charT *p, flag_type f=regex_constants::normal)
 
basic_regex & assign (const charT *p, size_type len, flag_type f)
 
basic_regex & assign (const charT *p1, const charT *p2, flag_type f=regex_constants::normal)
 
template<class ST , class SA >
unsigned int BOOST_REGEX_CALL set_expression (const std::basic_string< charT, ST, SA > &p, flag_type f=regex_constants::normal)
 
template<class ST , class SA >
 basic_regex (const std::basic_string< charT, ST, SA > &p, flag_type f=regex_constants::normal)
 
template<class InputIterator >
 basic_regex (InputIterator arg_first, InputIterator arg_last, flag_type f=regex_constants::normal)
 
template<class ST , class SA >
basic_regex &BOOST_REGEX_CALL operator= (const std::basic_string< charT, ST, SA > &p)
 
template<class string_traits , class A >
basic_regex &BOOST_REGEX_CALL assign (const std::basic_string< charT, string_traits, A > &s, flag_type f=regex_constants::normal)
 
template<class InputIterator >
basic_regex &BOOST_REGEX_CALL assign (InputIterator arg_first, InputIterator arg_last, flag_type f=regex_constants::normal)
 
locale_type BOOST_REGEX_CALL imbue (locale_type l)
 
locale_type BOOST_REGEX_CALL getloc () const
 
flag_type BOOST_REGEX_CALL getflags () const
 
flag_type BOOST_REGEX_CALL flags () const
 
std::basic_string< charT >
BOOST_REGEX_CALL 		str () const
 
std::pair< const_iterator,
const_iterator >
BOOST_REGEX_CALL 		subexpression (std::size_t n) const
 
const_iterator BOOST_REGEX_CALL begin () const
 
const_iterator BOOST_REGEX_CALL end () const
 
void BOOST_REGEX_CALL swap (basic_regex &that) throw ()
 
size_type BOOST_REGEX_CALL size () const
 
size_type BOOST_REGEX_CALL max_size () const
 
bool BOOST_REGEX_CALL empty () const
 
size_type BOOST_REGEX_CALL mark_count () const
 
int status () const
 
int BOOST_REGEX_CALL compare (const basic_regex &that) const
 
bool BOOST_REGEX_CALL operator== (const basic_regex &e) const
 
bool BOOST_REGEX_CALL operator!= (const basic_regex &e) const
 
bool BOOST_REGEX_CALL operator< (const basic_regex &e) const
 
bool BOOST_REGEX_CALL operator> (const basic_regex &e) const
 
bool BOOST_REGEX_CALL operator<= (const basic_regex &e) const
 
bool BOOST_REGEX_CALL operator>= (const basic_regex &e) const
 
const charT *BOOST_REGEX_CALL expression () const
 
unsigned int BOOST_REGEX_CALL set_expression (const charT *p1, const charT *p2, flag_type f=regex_constants::normal)
 
unsigned int BOOST_REGEX_CALL set_expression (const charT *p, flag_type f=regex_constants::normal)
 
unsigned int BOOST_REGEX_CALL error_code () const
 
const re_detail::re_syntax_base * get_first_state () const
 
unsigned get_restart_type () const
 
const unsigned char * get_map () const
 
const
::boost::regex_traits_wrapper
< traits > & 		get_traits () const
 
bool can_be_null () const
 
const re_detail::regex_data
< charT, traits > & 		get_data () const
 
boost::shared_ptr
< re_detail::named_subexpressions > 		get_named_subs () const
 

Member Typedef Documentation

template<class charT, class traits>
typedef charT boost::basic_regex< charT, traits >::char_type
template<class charT, class traits>
typedef const charT* boost::basic_regex< charT, traits >::const_iterator
template<class charT, class traits>
typedef const charT& boost::basic_regex< charT, traits >::const_reference
template<class charT, class traits>
typedef std::ptrdiff_t boost::basic_regex< charT, traits >::difference_type
template<class charT, class traits>
typedef regex_constants::syntax_option_type boost::basic_regex< charT, traits >::flag_type
template<class charT, class traits>
typedef const_iterator boost::basic_regex< charT, traits >::iterator
template<class charT, class traits>
typedef traits::locale_type boost::basic_regex< charT, traits >::locale_type
template<class charT, class traits>
typedef charT& boost::basic_regex< charT, traits >::reference
template<class charT, class traits>
typedef std::size_t boost::basic_regex< charT, traits >::size_type
template<class charT, class traits>
typedef std::size_t boost::basic_regex< charT, traits >::traits_size_type
template<class charT, class traits>
typedef traits::string_type boost::basic_regex< charT, traits >::traits_string_type
template<class charT, class traits>
typedef traits boost::basic_regex< charT, traits >::traits_type
template<class charT, class traits>
typedef charT boost::basic_regex< charT, traits >::value_type

Member Enumeration Documentation

enum boost::regbase::flag_type_
inherited
Enumerator
perl_syntax_group 
basic_syntax_group 
literal 
main_option_type 
no_bk_refs 
no_perl_ex 
no_mod_m 
mod_x 
mod_s 
no_mod_s 
no_char_classes 
no_intervals 
bk_plus_qm 
bk_vbar 
emacs_ex 
no_escape_in_lists 
newline_alt 
no_except 
failbit 
icase 
nocollate 
collate 
nosubs 
save_subexpression_location 
no_empty_expressions 
optimize 
basic 
extended 
normal 
emacs 
awk 
grep 
egrep 
sed 
perl 
ECMAScript 
JavaScript 
JScript 
enum boost::regbase::restart_info
inherited
Enumerator
restart_any 
restart_word 
restart_line 
restart_buf 
restart_continue 
restart_lit 
restart_fixed_lit 
restart_count 

Constructor & Destructor Documentation

template<class charT, class traits>
boost::basic_regex< charT, traits >::basic_regex ( )
inlineexplicit
template<class charT, class traits>
boost::basic_regex< charT, traits >::basic_regex ( const charT *  p,
flag_type  f = regex_constants::normal 
)
inlineexplicit
template<class charT, class traits>
boost::basic_regex< charT, traits >::basic_regex ( const charT *  p1,
const charT *  p2,
flag_type  f = regex_constants::normal 
)
inline
template<class charT, class traits>
boost::basic_regex< charT, traits >::basic_regex ( const charT *  p,
size_type  len,
flag_type  f 
)
inline
template<class charT, class traits>
boost::basic_regex< charT, traits >::basic_regex ( const basic_regex< charT, traits > &  that)
inline
template<class charT, class traits>
boost::basic_regex< charT, traits >::~basic_regex ( )
inline
template<class charT, class traits>
template<class ST , class SA >
boost::basic_regex< charT, traits >::basic_regex ( const std::basic_string< charT, ST, SA > &  p,
flag_type  f = regex_constants::normal 
)
inlineexplicit
template<class charT, class traits>
template<class InputIterator >
boost::basic_regex< charT, traits >::basic_regex ( InputIterator  arg_first,
InputIterator  arg_last,
flag_type  f = regex_constants::normal 
)
inline

Member Function Documentation

template<class charT, class traits>
basic_regex& boost::basic_regex< charT, traits >::assign ( const basic_regex< charT, traits > &  that)
inline

Referenced by boost::basic_regex< Ch, Tr >::assign(), boost::basic_regex< Ch, Tr >::basic_regex(), boost::basic_regex< Ch, Tr >::operator=(), boost::reg_expression< charT, traits >::operator=(), and boost::basic_regex< Ch, Tr >::set_expression().

template<class charT, class traits>
basic_regex& boost::basic_regex< charT, traits >::assign ( const charT *  p,
flag_type  f = regex_constants::normal 
)
inline
template<class charT, class traits>
basic_regex& boost::basic_regex< charT, traits >::assign ( const charT *  p,
size_type  len,
flag_type  f 
)
inline
template<class charT, class traits>
basic_regex& boost::basic_regex< charT, traits >::assign ( const charT *  p1,
const charT *  p2,
flag_type  f = regex_constants::normal 
)
inline
template<class charT, class traits>
template<class string_traits , class A >
basic_regex& BOOST_REGEX_CALL boost::basic_regex< charT, traits >::assign ( const std::basic_string< charT, string_traits, A > &  s,
flag_type  f = regex_constants::normal 
)
inline
template<class charT, class traits>
template<class InputIterator >
basic_regex& BOOST_REGEX_CALL boost::basic_regex< charT, traits >::assign ( InputIterator  arg_first,
InputIterator  arg_last,
flag_type  f = regex_constants::normal 
)
inline
template<class charT, class traits>
const_iterator BOOST_REGEX_CALL boost::basic_regex< charT, traits >::begin ( void  ) const
inline

Referenced by boost::u32regex_search().

template<class charT, class traits>
bool boost::basic_regex< charT, traits >::can_be_null ( ) const
inline
template<class charT, class traits>
int BOOST_REGEX_CALL boost::basic_regex< charT, traits >::compare ( const basic_regex< charT, traits > &  that) const
inline

Referenced by boost::basic_regex< Ch, Tr >::operator!=(), boost::basic_regex< Ch, Tr >::operator<(), boost::basic_regex< Ch, Tr >::operator<=(), boost::basic_regex< Ch, Tr >::operator==(), boost::basic_regex< Ch, Tr >::operator>(), and boost::basic_regex< Ch, Tr >::operator>=().

template<class charT, class traits>
bool BOOST_REGEX_CALL boost::basic_regex< charT, traits >::empty ( void  ) const
inline
template<class charT, class traits>
const_iterator BOOST_REGEX_CALL boost::basic_regex< charT, traits >::end ( void  ) const
inline
template<class charT, class traits>
unsigned int BOOST_REGEX_CALL boost::basic_regex< charT, traits >::error_code ( ) const
inline
template<class charT, class traits>
const charT* BOOST_REGEX_CALL boost::basic_regex< charT, traits >::expression ( ) const
inline
template<class charT, class traits>
flag_type BOOST_REGEX_CALL boost::basic_regex< charT, traits >::flags ( ) const
inline

Referenced by boost::basic_regex< Ch, Tr >::compare(), boost::basic_regex< Ch, Tr >::getflags(), boost::regex_grep(), and boost::regex_search().

template<class charT, class traits>
const re_detail::regex_data<charT, traits>& boost::basic_regex< charT, traits >::get_data ( ) const
inline

Referenced by boost::u32regex_iterator_implementation< BidirectionalIterator >::compare(), boost::regex_iterator_implementation< BidirectionalIterator, charT, traits >::compare(), boost::u32regex_token_iterator_implementation< BidirectionalIterator >::compare(), and boost::regex_token_iterator_implementation< BidirectionalIterator, charT, traits >::compare().

template<class charT, class traits>
const re_detail::re_syntax_base* boost::basic_regex< charT, traits >::get_first_state ( ) const
inline
template<class charT, class traits>
const unsigned char* boost::basic_regex< charT, traits >::get_map ( ) const
inline
template<class charT, class traits>
boost::shared_ptr<re_detail::named_subexpressions > boost::basic_regex< charT, traits >::get_named_subs ( ) const
inline
template<class charT, class traits>
unsigned boost::basic_regex< charT, traits >::get_restart_type ( ) const
inline
template<class charT, class traits>
const ::boost::regex_traits_wrapper<traits>& boost::basic_regex< charT, traits >::get_traits ( ) const
inline

Referenced by boost::re_detail::do_regex_replace().

template<class charT, class traits>
flag_type BOOST_REGEX_CALL boost::basic_regex< charT, traits >::getflags ( ) const
inline
template<class charT, class traits>
locale_type BOOST_REGEX_CALL boost::basic_regex< charT, traits >::getloc ( ) const
inline
template<class charT , class traits >
template BOOST_REGEX_DECL basic_regex< BOOST_REGEX_CHAR_T, boost::regex_traits< BOOST_REGEX_CHAR_T > >::locale_type BOOST_REGEX_CALL boost::basic_regex< charT, traits >::imbue ( locale_type  l)

References boost::shared_ptr< T >::swap().

template<class charT, class traits>
size_type BOOST_REGEX_CALL boost::basic_regex< charT, traits >::mark_count ( ) const
inline

Referenced by boost::regex_split().

template<class charT, class traits>
size_type BOOST_REGEX_CALL boost::basic_regex< charT, traits >::max_size ( void  ) const
inline
template<class charT, class traits>
bool BOOST_REGEX_CALL boost::basic_regex< charT, traits >::operator!= ( const basic_regex< charT, traits > &  e) const
inline
template<class charT, class traits>
bool BOOST_REGEX_CALL boost::basic_regex< charT, traits >::operator< ( const basic_regex< charT, traits > &  e) const
inline
template<class charT, class traits>
bool BOOST_REGEX_CALL boost::basic_regex< charT, traits >::operator<= ( const basic_regex< charT, traits > &  e) const
inline
template<class charT, class traits>
basic_regex& BOOST_REGEX_CALL boost::basic_regex< charT, traits >::operator= ( const basic_regex< charT, traits > &  that)
inline
template<class charT, class traits>
basic_regex& BOOST_REGEX_CALL boost::basic_regex< charT, traits >::operator= ( const charT *  ptr)
inline
template<class charT, class traits>
template<class ST , class SA >
basic_regex& BOOST_REGEX_CALL boost::basic_regex< charT, traits >::operator= ( const std::basic_string< charT, ST, SA > &  p)
inline
template<class charT, class traits>
bool BOOST_REGEX_CALL boost::basic_regex< charT, traits >::operator== ( const basic_regex< charT, traits > &  e) const
inline
template<class charT, class traits>
bool BOOST_REGEX_CALL boost::basic_regex< charT, traits >::operator> ( const basic_regex< charT, traits > &  e) const
inline
template<class charT, class traits>
bool BOOST_REGEX_CALL boost::basic_regex< charT, traits >::operator>= ( const basic_regex< charT, traits > &  e) const
inline
template<class charT, class traits>
template<class ST , class SA >
unsigned int BOOST_REGEX_CALL boost::basic_regex< charT, traits >::set_expression ( const std::basic_string< charT, ST, SA > &  p,
flag_type  f = regex_constants::normal 
)
inline

Referenced by boost::basic_regex< Ch, Tr >::set_expression().

template<class charT, class traits>
unsigned int BOOST_REGEX_CALL boost::basic_regex< charT, traits >::set_expression ( const charT *  p1,
const charT *  p2,
flag_type  f = regex_constants::normal 
)
inline
template<class charT, class traits>
unsigned int BOOST_REGEX_CALL boost::basic_regex< charT, traits >::set_expression ( const charT *  p,
flag_type  f = regex_constants::normal 
)
inline
template<class charT, class traits>
size_type BOOST_REGEX_CALL boost::basic_regex< charT, traits >::size ( void  ) const
inline
template<class charT, class traits>
int boost::basic_regex< charT, traits >::status ( ) const
inline

Referenced by boost::basic_regex< Ch, Tr >::compare(), boost::basic_regex< Ch, Tr >::error_code(), and boost::basic_regex< Ch, Tr >::set_expression().

template<class charT, class traits>
std::basic_string<charT> BOOST_REGEX_CALL boost::basic_regex< charT, traits >::str ( ) const
inline

Referenced by boost::basic_regex< Ch, Tr >::compare().

template<class charT, class traits>
std::pair<const_iterator, const_iterator> BOOST_REGEX_CALL boost::basic_regex< charT, traits >::subexpression ( std::size_t  n) const
inline
template<class charT, class traits>
void BOOST_REGEX_CALL boost::basic_regex< charT, traits >::swap ( basic_regex< charT, traits > &  that)
throw (
)
inline

Referenced by boost::swap().

The documentation for this singleton was generated from the following files: