Namespaces
	detail

	op

	regex_constants

Classes
struct	basic_regex
	Class template basic_regex<> is a class for holding a compiled regular expression. More...

struct	c_regex_traits
	Encapsaulates the standard C locale functions for use by the `basic_regex<>` class template. More...

struct	compiler_traits

struct	cpp_regex_traits
	Encapsaulates a `std::locale` for use by the `basic_regex<>` class template. More...

struct	function
	A unary metafunction that turns an ordinary function object type into the type of a deferred function object for use in xpressive semantic actions. More...

struct	has_fold_case
	Trait used to denote that a traits class has the fold_case member function. More...

struct	has_fold_case< c_regex_traits< char > >

struct	has_fold_case< cpp_regex_traits< char > >

struct	local
	`local<>` is a lazy wrapper for a reference to a value that is stored within the local itself. More...

struct	mark_tag
	Sub-match placeholder type, used to create named captures in static regexes. More...

struct	match_results
	Class template match_results<> holds the results of a regex_match() or a regex_search() as a collection of sub_match objects. More...

struct	null_regex_traits
	stub regex_traits for non-char data More...

struct	placeholder
	For defining a placeholder to stand in for a variable a semantic action. More...

struct	reference
	`reference<>` is a lazy wrapper for a reference that can be used in xpressive semantic actions. More...

struct	regex_compiler
	Class template regex_compiler is a factory for building basic_regex objects from a string. More...

struct	regex_error
	The class regex_error defines the type of objects thrown as exceptions to report errors during the conversion from a string representing a regular expression to a finite state machine. More...

struct	regex_id_filter_predicate

struct	regex_iterator

struct	regex_token_iterator

struct	regex_traits
	Thin wrapper around the default regex_traits implementation, either cpp_regex_traits or c_regex_traits. More...

struct	regex_traits_version_1_case_fold_tag
	INTERNAL ONLY. More...

struct	regex_traits_version_1_tag
	Tag used to denote that a traits class conforms to the version 1 traits interface. More...

struct	regex_traits_version_2_tag
	Tag used to denote that a traits class conforms to the version 2 traits interface. More...

struct	sub_match
	Class template `sub_match` denotes the sequence of characters matched by a particular marked sub-expression. More...

struct	value
	`value<>` is a lazy wrapper for a value that can be used in xpressive semantic actions. More...

Typedefs
typedef void const *	regex_id_type

typedef basic_regex < std::string::const_iterator >	sregex

typedef basic_regex< char const * >	cregex

typedef basic_regex < std::wstring::const_iterator >	wsregex

typedef basic_regex< wchar_t const * >	wcregex

typedef sub_match < std::string::const_iterator >	ssub_match

typedef sub_match< char const * >	csub_match

typedef sub_match < std::wstring::const_iterator >	wssub_match

typedef sub_match< wchar_t const * >	wcsub_match

typedef regex_compiler < std::string::const_iterator >	sregex_compiler

typedef regex_compiler< char const * >	cregex_compiler

typedef regex_compiler < std::wstring::const_iterator >	wsregex_compiler

typedef regex_compiler < wchar_t const * >	wcregex_compiler

typedef regex_iterator < std::string::const_iterator >	sregex_iterator

typedef regex_iterator< char const * >	cregex_iterator

typedef regex_iterator < std::wstring::const_iterator >	wsregex_iterator

typedef regex_iterator < wchar_t const * >	wcregex_iterator

typedef regex_token_iterator < std::string::const_iterator >	sregex_token_iterator

typedef regex_token_iterator < char const * >	cregex_token_iterator

typedef regex_token_iterator < std::wstring::const_iterator >	wsregex_token_iterator

typedef regex_token_iterator < wchar_t const * >	wcregex_token_iterator

typedef match_results < std::string::const_iterator >	smatch

typedef match_results< char const * >	cmatch

typedef match_results < std::wstring::const_iterator >	wsmatch

typedef match_results< wchar_t const * >	wcmatch

typedef regex_id_filter_predicate < std::string::const_iterator >	sregex_id_filter_predicate

typedef regex_id_filter_predicate < char const * >	cregex_id_filter_predicate

typedef regex_id_filter_predicate < std::wstring::const_iterator >	wsregex_id_filter_predicate

typedef regex_id_filter_predicate < wchar_t const * >	wcregex_id_filter_predicate

Functions
template<typename BidiIter >
void	swap (basic_regex< BidiIter > &left, basic_regex< BidiIter > &right)
	Swaps the contents of two basic_regex objects. More...

template<typename T , typename A >
detail::make_function::impl < op::as< T > const, A const & > ::result_type const	as (A const &a)
	`as()` is a lazy funtion for lexically casting a parameter to a different type. More...

template<typename T , typename A >
detail::make_function::impl < op::static_cast_< T > const, A const & >::result_type const	static_cast_ (A const &a)
	`static_cast_` is a lazy funtion for statically casting a parameter to a different type. More...

template<typename T , typename A >
detail::make_function::impl < op::dynamic_cast_< T > const, A const & >::result_type const	dynamic_cast_ (A const &a)
	`dynamic_cast_` is a lazy funtion for dynamically casting a parameter to a different type. More...

template<typename T , typename A >
detail::make_function::impl < op::const_cast_< T > const, A const & >::result_type const	const_cast_ (A const &a)
	`dynamic_cast_` is a lazy funtion for const-casting a parameter to a different type. More...

template<typename T >
value< T > const	val (T const &t)
	Helper for constructing `value<>` objects. More...

template<typename T >
reference< T > const	ref (T &t)
	Helper for constructing `reference<>` objects. More...

template<typename T >
reference< T const > const	cref (T const &t)
	Helper for constructing `reference<>` objects that store a reference to const. More...

template<typename BidiIter >
bool	regex_match (typename mpl::identity< BidiIter >::type begin, typename mpl::identity< BidiIter >::type end, match_results< BidiIter > &what, basic_regex< BidiIter > const &re, regex_constants::match_flag_type flags=regex_constants::match_default)
	See if a regex matches a sequence from beginning to end. More...

template<typename BidiIter >
bool	regex_match (typename mpl::identity< BidiIter >::type begin, typename mpl::identity< BidiIter >::type end, basic_regex< BidiIter > const &re, regex_constants::match_flag_type flags=regex_constants::match_default)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename Char >
bool	regex_match (typename mpl::identity< Char >::type begin, match_results< Char > &what, basic_regex< Char * > const &re, regex_constants::match_flag_type flags=regex_constants::match_default)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename BidiRange , typename BidiIter >
bool	regex_match (BidiRange &rng, match_results< BidiIter > &what, basic_regex< BidiIter > const &re, regex_constants::match_flag_type flags=regex_constants::match_default, typename disable_if< detail::is_char_ptr< BidiRange > >::type *=0)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename BidiRange , typename BidiIter >
bool	regex_match (BidiRange const &rng, match_results< BidiIter > &what, basic_regex< BidiIter > const &re, regex_constants::match_flag_type flags=regex_constants::match_default, typename disable_if< detail::is_char_ptr< BidiRange > >::type *=0)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename Char >
bool	regex_match (typename mpl::identity< Char >::type begin, basic_regex< Char > const &re, regex_constants::match_flag_type flags=regex_constants::match_default)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename BidiRange , typename BidiIter >
bool	regex_match (BidiRange &rng, basic_regex< BidiIter > const &re, regex_constants::match_flag_type flags=regex_constants::match_default, typename disable_if< detail::is_char_ptr< BidiRange > >::type *=0)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename BidiRange , typename BidiIter >
bool	regex_match (BidiRange const &rng, basic_regex< BidiIter > const &re, regex_constants::match_flag_type flags=regex_constants::match_default, typename disable_if< detail::is_char_ptr< BidiRange > >::type *=0)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename BidiIter >
bool	regex_search (typename mpl::identity< BidiIter >::type begin, typename mpl::identity< BidiIter >::type end, match_results< BidiIter > &what, basic_regex< BidiIter > const &re, regex_constants::match_flag_type flags=regex_constants::match_default)
	Determines whether there is some sub-sequence within `[begin,end)` that matches the regular expression `re`. More...

template<typename BidiIter >
bool	regex_search (typename mpl::identity< BidiIter >::type begin, typename mpl::identity< BidiIter >::type end, basic_regex< BidiIter > const &re, regex_constants::match_flag_type flags=regex_constants::match_default)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename Char >
bool	regex_search (typename mpl::identity< Char >::type begin, match_results< Char > &what, basic_regex< Char * > const &re, regex_constants::match_flag_type flags=regex_constants::match_default)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename BidiRange , typename BidiIter >
bool	regex_search (BidiRange &rng, match_results< BidiIter > &what, basic_regex< BidiIter > const &re, regex_constants::match_flag_type flags=regex_constants::match_default, typename disable_if< detail::is_char_ptr< BidiRange > >::type *=0)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename BidiRange , typename BidiIter >
bool	regex_search (BidiRange const &rng, match_results< BidiIter > &what, basic_regex< BidiIter > const &re, regex_constants::match_flag_type flags=regex_constants::match_default, typename disable_if< detail::is_char_ptr< BidiRange > >::type *=0)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename Char >
bool	regex_search (typename mpl::identity< Char >::type begin, basic_regex< Char > const &re, regex_constants::match_flag_type flags=regex_constants::match_default)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename BidiRange , typename BidiIter >
bool	regex_search (BidiRange &rng, basic_regex< BidiIter > const &re, regex_constants::match_flag_type flags=regex_constants::match_default, typename disable_if< detail::is_char_ptr< BidiRange > >::type *=0)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename BidiRange , typename BidiIter >
bool	regex_search (BidiRange const &rng, basic_regex< BidiIter > const &re, regex_constants::match_flag_type flags=regex_constants::match_default, typename disable_if< detail::is_char_ptr< BidiRange > >::type *=0)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename OutIter , typename BidiIter , typename Formatter >
OutIter	regex_replace (OutIter out, typename mpl::identity< BidiIter >::type begin, typename mpl::identity< BidiIter >::type end, basic_regex< BidiIter > const &re, Formatter const &format, regex_constants::match_flag_type flags=regex_constants::match_default, typename disable_if< detail::is_char_ptr< Formatter > >::type *=0)
	Build an output sequence given an input sequence, a regex, and a format string or a formatter object, function, or expression. More...

template<typename OutIter , typename BidiIter >
OutIter	regex_replace (OutIter out, typename mpl::identity< BidiIter >::type begin, typename mpl::identity< BidiIter >::type end, basic_regex< BidiIter > const &re, typename iterator_value< BidiIter >::type const *format, regex_constants::match_flag_type flags=regex_constants::match_default)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename BidiContainer , typename BidiIter , typename Formatter >
BidiContainer	regex_replace (BidiContainer &str, basic_regex< BidiIter > const &re, Formatter const &format, regex_constants::match_flag_type flags=regex_constants::match_default, typename disable_if< mpl::or_< detail::is_char_ptr< BidiContainer >, detail::is_char_ptr< Formatter > > >::type *=0)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename BidiContainer , typename BidiIter , typename Formatter >
BidiContainer	regex_replace (BidiContainer const &str, basic_regex< BidiIter > const &re, Formatter const &format, regex_constants::match_flag_type flags=regex_constants::match_default, typename disable_if< mpl::or_< detail::is_char_ptr< BidiContainer >, detail::is_char_ptr< Formatter > > >::type *=0)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename Char , typename Formatter >
std::basic_string< typename remove_const< Char >::type >	regex_replace (typename mpl::identity< Char >::type str, basic_regex< Char > const &re, Formatter const &format, regex_constants::match_flag_type flags=regex_constants::match_default, typename disable_if< detail::is_char_ptr< Formatter > >::type *=0)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename BidiContainer , typename BidiIter >
BidiContainer	regex_replace (BidiContainer &str, basic_regex< BidiIter > const &re, typename iterator_value< BidiIter >::type const format, regex_constants::match_flag_type flags=regex_constants::match_default, typename disable_if< detail::is_char_ptr< BidiContainer > >::type =0)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename BidiContainer , typename BidiIter >
BidiContainer	regex_replace (BidiContainer const &str, basic_regex< BidiIter > const &re, typename iterator_value< BidiIter >::type const format, regex_constants::match_flag_type flags=regex_constants::match_default, typename disable_if< detail::is_char_ptr< BidiContainer > >::type =0)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename Char >
std::basic_string< typename remove_const< Char >::type >	regex_replace (typename mpl::identity< Char >::type str, basic_regex< Char > const &re, typename add_const< Char >::type *format, regex_constants::match_flag_type flags=regex_constants::match_default)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename BidiIter >
proto::terminal < reference_wrapper < basic_regex< BidiIter > const > >::type const	by_ref (basic_regex< BidiIter > const &rex)
	Embed a regex object by reference. More...

template<typename Char >
proto::terminal < detail::range_placeholder < Char > >::type const	range (Char ch_min, Char ch_max)
	Match a range of characters. More...

template<typename Expr >
proto::result_of::make_expr < proto::tag::logical_not, proto::default_domain, Expr const & >::type const	optional (Expr const &expr)
	Make a sub-expression optional. More...

template<unsigned int Min, unsigned int Max, typename Expr >
proto::result_of::make_expr < detail::generic_quant_tag < Min, Max > , proto::default_domain, Expr const & >::type const	repeat (Expr const &expr)
	Repeat a sub-expression multiple times. More...

template<unsigned int Count, typename Expr2 >
proto::result_of::make_expr < detail::generic_quant_tag < Count, Count > , proto::default_domain, Expr2 const & >::type const	repeat (Expr2 const &expr2)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename Expr >
proto::result_of::make_expr < detail::keeper_tag, proto::default_domain, Expr const & >::type const	keep (Expr const &expr)
	Create an independent sub-expression. More...

template<typename Expr >
proto::result_of::make_expr < detail::lookahead_tag, proto::default_domain, Expr const & >::type const	before (Expr const &expr)
	Look-ahead assertion. More...

template<typename Expr >
proto::result_of::make_expr < detail::lookbehind_tag, proto::default_domain, Expr const & >::type const	after (Expr const &expr)
	Look-behind assertion. More...

template<typename Locale >
detail::modifier_op < detail::locale_modifier < Locale > > const	imbue (Locale const &loc)
	Specify a regex traits or a std::locale. More...

template<typename Skip >
detail::skip_directive< Skip >	skip (Skip const &skip)
	Specify which characters to skip when matching a regex. More...

template<typename Traits , std::size_t N>
Traits::char_class_type	lookup_classname (Traits const &traits, char const (&cname)[N], bool icase)
	INTERNAL ONLY. More...

template<typename BidiIter >
BidiIter	range_begin (sub_match< BidiIter > &sub)
	`range_begin()` to make `sub_match<>` a valid range More...

template<typename BidiIter >
BidiIter	range_begin (sub_match< BidiIter > const &sub)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename BidiIter >
BidiIter	range_end (sub_match< BidiIter > &sub)
	`range_end()` to make `sub_match<>` a valid range More...

template<typename BidiIter >
BidiIter	range_end (sub_match< BidiIter > const &sub)
	This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts. More...

template<typename BidiIter , typename Char , typename Traits >
std::basic_ostream< Char, Traits > &	operator<< (std::basic_ostream< Char, Traits > &sout, sub_match< BidiIter > const &sub)
	insertion operator for sending sub-matches to ostreams More...

template<typename BidiIter >
bool	operator== (sub_match< BidiIter > const &lhs, sub_match< BidiIter > const &rhs)

template<typename BidiIter >
bool	operator!= (sub_match< BidiIter > const &lhs, sub_match< BidiIter > const &rhs)

template<typename BidiIter >
bool	operator< (sub_match< BidiIter > const &lhs, sub_match< BidiIter > const &rhs)

template<typename BidiIter >
bool	operator<= (sub_match< BidiIter > const &lhs, sub_match< BidiIter > const &rhs)

template<typename BidiIter >
bool	operator>= (sub_match< BidiIter > const &lhs, sub_match< BidiIter > const &rhs)

template<typename BidiIter >
bool	operator> (sub_match< BidiIter > const &lhs, sub_match< BidiIter > const &rhs)

template<typename BidiIter >
bool	operator== (typename iterator_value< BidiIter >::type const *lhs, sub_match< BidiIter > const &rhs)

template<typename BidiIter >
bool	operator!= (typename iterator_value< BidiIter >::type const *lhs, sub_match< BidiIter > const &rhs)

template<typename BidiIter >
bool	operator< (typename iterator_value< BidiIter >::type const *lhs, sub_match< BidiIter > const &rhs)

template<typename BidiIter >
bool	operator> (typename iterator_value< BidiIter >::type const *lhs, sub_match< BidiIter > const &rhs)

template<typename BidiIter >
bool	operator>= (typename iterator_value< BidiIter >::type const *lhs, sub_match< BidiIter > const &rhs)

template<typename BidiIter >
bool	operator<= (typename iterator_value< BidiIter >::type const *lhs, sub_match< BidiIter > const &rhs)

template<typename BidiIter >
bool	operator== (sub_match< BidiIter > const &lhs, typename iterator_value< BidiIter >::type const *rhs)

template<typename BidiIter >
bool	operator!= (sub_match< BidiIter > const &lhs, typename iterator_value< BidiIter >::type const *rhs)

template<typename BidiIter >
bool	operator< (sub_match< BidiIter > const &lhs, typename iterator_value< BidiIter >::type const *rhs)

template<typename BidiIter >
bool	operator> (sub_match< BidiIter > const &lhs, typename iterator_value< BidiIter >::type const *rhs)

template<typename BidiIter >
bool	operator>= (sub_match< BidiIter > const &lhs, typename iterator_value< BidiIter >::type const *rhs)

template<typename BidiIter >
bool	operator<= (sub_match< BidiIter > const &lhs, typename iterator_value< BidiIter >::type const *rhs)

template<typename BidiIter >
bool	operator== (typename iterator_value< BidiIter >::type const &lhs, sub_match< BidiIter > const &rhs)

template<typename BidiIter >
bool	operator!= (typename iterator_value< BidiIter >::type const &lhs, sub_match< BidiIter > const &rhs)

template<typename BidiIter >
bool	operator< (typename iterator_value< BidiIter >::type const &lhs, sub_match< BidiIter > const &rhs)

template<typename BidiIter >
bool	operator> (typename iterator_value< BidiIter >::type const &lhs, sub_match< BidiIter > const &rhs)

template<typename BidiIter >
bool	operator>= (typename iterator_value< BidiIter >::type const &lhs, sub_match< BidiIter > const &rhs)

template<typename BidiIter >
bool	operator<= (typename iterator_value< BidiIter >::type const &lhs, sub_match< BidiIter > const &rhs)

template<typename BidiIter >
bool	operator== (sub_match< BidiIter > const &lhs, typename iterator_value< BidiIter >::type const &rhs)

template<typename BidiIter >
bool	operator!= (sub_match< BidiIter > const &lhs, typename iterator_value< BidiIter >::type const &rhs)

template<typename BidiIter >
bool	operator< (sub_match< BidiIter > const &lhs, typename iterator_value< BidiIter >::type const &rhs)

template<typename BidiIter >
bool	operator> (sub_match< BidiIter > const &lhs, typename iterator_value< BidiIter >::type const &rhs)

template<typename BidiIter >
bool	operator>= (sub_match< BidiIter > const &lhs, typename iterator_value< BidiIter >::type const &rhs)

template<typename BidiIter >
bool	operator<= (sub_match< BidiIter > const &lhs, typename iterator_value< BidiIter >::type const &rhs)

template<typename BidiIter >
sub_match< BidiIter >::string_type	operator+ (sub_match< BidiIter > const &lhs, sub_match< BidiIter > const &rhs)

template<typename BidiIter >
sub_match< BidiIter >::string_type	operator+ (sub_match< BidiIter > const &lhs, typename iterator_value< BidiIter >::type const &rhs)

template<typename BidiIter >
sub_match< BidiIter >::string_type	operator+ (typename iterator_value< BidiIter >::type const &lhs, sub_match< BidiIter > const &rhs)

template<typename BidiIter >
sub_match< BidiIter >::string_type	operator+ (sub_match< BidiIter > const &lhs, typename iterator_value< BidiIter >::type const *rhs)

template<typename BidiIter >
sub_match< BidiIter >::string_type	operator+ (typename iterator_value< BidiIter >::type const *lhs, sub_match< BidiIter > const &rhs)

template<typename BidiIter >
sub_match< BidiIter >::string_type	operator+ (sub_match< BidiIter > const &lhs, typename sub_match< BidiIter >::string_type const &rhs)

template<typename BidiIter >
sub_match< BidiIter >::string_type	operator+ (typename sub_match< BidiIter >::string_type const &lhs, sub_match< BidiIter > const &rhs)

Variables
function< op::at >::type const	at = {{}}
	`at` is a lazy PolymorphicFunctionObject for indexing into a sequence in an xpressive semantic action. More...

function< op::push >::type const	push = {{}}
	`push` is a lazy PolymorphicFunctionObject for pushing a value into a container in an xpressive semantic action. More...

function< op::push_back > ::type const	push_back = {{}}
	`push_back` is a lazy PolymorphicFunctionObject for pushing a value into a container in an xpressive semantic action. More...

function< op::push_front > ::type const	push_front = {{}}
	`push_front` is a lazy PolymorphicFunctionObject for pushing a value into a container in an xpressive semantic action. More...

function< op::pop >::type const	pop = {{}}
	`pop` is a lazy PolymorphicFunctionObject for popping the top element from a sequence in an xpressive semantic action. More...

function< op::pop_back >::type const	pop_back = {{}}
	`pop_back` is a lazy PolymorphicFunctionObject for popping the back element from a sequence in an xpressive semantic action. More...

function< op::pop_front > ::type const	pop_front = {{}}
	`pop_front` is a lazy PolymorphicFunctionObject for popping the front element from a sequence in an xpressive semantic action. More...

function< op::top >::type const	top = {{}}
	`top` is a lazy PolymorphicFunctionObject for accessing the top element from a stack in an xpressive semantic action. More...

function< op::back >::type const	back = {{}}
	`back` is a lazy PolymorphicFunctionObject for fetching the back element of a sequence in an xpressive semantic action. More...

function< op::front >::type const	front = {{}}
	`front` is a lazy PolymorphicFunctionObject for fetching the front element of a sequence in an xpressive semantic action. More...

function< op::first >::type const	first = {{}}
	`first` is a lazy PolymorphicFunctionObject for accessing the first element of a `std::pair<>` in an xpressive semantic action. More...

function< op::second >::type const	second = {{}}
	`second` is a lazy PolymorphicFunctionObject for accessing the second element of a `std::pair<>` in an xpressive semantic action. More...

function< op::matched >::type const	matched = {{}}
	`matched` is a lazy PolymorphicFunctionObject for accessing the `matched` member of a `xpressive::sub_match<>` in an xpressive semantic action. More...

function< op::length >::type const	length = {{}}
	`length` is a lazy PolymorphicFunctionObject for computing the length of a `xpressive::sub_match<>` in an xpressive semantic action. More...

function< op::str >::type const	str = {{}}
	`str` is a lazy PolymorphicFunctionObject for converting a `xpressive::sub_match<>` to a `std::basic_string<>` in an xpressive semantic action. More...

function< op::insert >::type const	insert = {{}}
	`insert` is a lazy PolymorphicFunctionObject for inserting a value or a range of values into a sequence in an xpressive semantic action. More...

function< op::make_pair > ::type const	make_pair = {{}}
	`make_pair` is a lazy PolymorphicFunctionObject for making a `std::pair<>` in an xpressive semantic action. More...

function< op::unwrap_reference > ::type const	unwrap_reference = {{}}
	`unwrap_reference` is a lazy PolymorphicFunctionObject for unwrapping a `boost::reference_wrapper<>` in an xpressive semantic action. More...

proto::terminal < detail::check_tag >::type const	check = {{}}
	For adding user-defined assertions to your regular expressions. More...

detail::let_< proto::terminal < detail::let_tag >::type > const	let = {{{}}}
	For binding local variables to placeholders in semantic actions when constructing a `regex_iterator` or a `regex_token_iterator`. More...

unsigned int const	repeat_max = UINT_MAX-1
	INTERNAL ONLY (for backwards compatibility) More...

unsigned int const	inf = UINT_MAX-1
	For infinite repetition of a sub-expression. More...

proto::terminal < detail::epsilon_matcher > ::type const	epsilon = {{}}
	INTERNAL ONLY (for backwards compatibility) More...

proto::terminal < detail::epsilon_matcher > ::type const	nil = {{}}
	Successfully matches nothing. More...

proto::terminal < detail::posix_charset_placeholder > ::type const	alnum = {{"alnum", false}}
	Matches an alpha-numeric character. More...

proto::terminal < detail::posix_charset_placeholder > ::type const	alpha = {{"alpha", false}}
	Matches an alphabetic character. More...

proto::terminal < detail::posix_charset_placeholder > ::type const	blank = {{"blank", false}}
	Matches a blank (horizonal white-space) character. More...

proto::terminal < detail::posix_charset_placeholder > ::type const	cntrl = {{"cntrl", false}}
	Matches a control character. More...

proto::terminal < detail::posix_charset_placeholder > ::type const	digit = {{"digit", false}}
	Matches a digit character. More...

proto::terminal < detail::posix_charset_placeholder > ::type const	graph = {{"graph", false}}
	Matches a graph character. More...

proto::terminal < detail::posix_charset_placeholder > ::type const	lower = {{"lower", false}}
	Matches a lower-case character. More...

proto::terminal < detail::posix_charset_placeholder > ::type const	print = {{"print", false}}
	Matches a printable character. More...

proto::terminal < detail::posix_charset_placeholder > ::type const	punct = {{"punct", false}}
	Matches a punctuation character. More...

proto::terminal < detail::posix_charset_placeholder > ::type const	space = {{"space", false}}
	Matches a space character. More...

proto::terminal < detail::posix_charset_placeholder > ::type const	upper = {{"upper", false}}
	Matches an upper-case character. More...

proto::terminal < detail::posix_charset_placeholder > ::type const	xdigit = {{"xdigit", false}}
	Matches a hexadecimal digit character. More...

proto::terminal < detail::assert_bos_matcher > ::type const	bos = {{}}
	Beginning of sequence assertion. More...

proto::terminal < detail::assert_eos_matcher > ::type const	eos = {{}}
	End of sequence assertion. More...

proto::terminal < detail::assert_bol_placeholder > ::type const	bol = {{}}
	Beginning of line assertion. More...

proto::terminal < detail::assert_eol_placeholder > ::type const	eol = {{}}
	End of line assertion. More...

proto::terminal < detail::assert_word_begin > ::type const	bow = {{}}
	Beginning of word assertion. More...

proto::terminal < detail::assert_word_end > ::type const	eow = {{}}
	End of word assertion. More...

proto::terminal < detail::assert_word_boundary > ::type const	_b = {{}}
	Word boundary assertion. More...

proto::terminal < detail::posix_charset_placeholder > ::type const	_w = {{"w", false}}
	Matches a word character. More...

proto::terminal < detail::posix_charset_placeholder > ::type const	_d = {{"d", false}}
	Matches a digit character. More...

proto::terminal < detail::posix_charset_placeholder > ::type const	_s = {{"s", false}}
	Matches a space character. More...

proto::terminal< char >::type const	_n = {'\n'}
	Matches a literal newline character, '\n'. More...

detail::logical_newline_xpression const	_ln = {{}}
	Matches a logical newline sequence. More...

proto::terminal < detail::any_matcher >::type const	_ = {{}}
	Matches any one character. More...

proto::terminal < detail::self_placeholder > ::type const	self = {{}}
	Reference to the current regex object. More...

detail::set_initializer_type const	set = {{}}
	Used to create character sets. More...

boost::xpressive::mark_tag::proto_base_expr const	s0 = {{ 0 }}
	Sub-match placeholder, like $& in Perl. More...

boost::xpressive::mark_tag::proto_base_expr const	s1 = {{ 1 }}
	Sub-match placeholder, like $1 in perl. More...

boost::xpressive::mark_tag::proto_base_expr const	s2 = {{ 2 }}

boost::xpressive::mark_tag::proto_base_expr const	s3 = {{ 3 }}

boost::xpressive::mark_tag::proto_base_expr const	s4 = {{ 4 }}

boost::xpressive::mark_tag::proto_base_expr const	s5 = {{ 5 }}

boost::xpressive::mark_tag::proto_base_expr const	s6 = {{ 6 }}

boost::xpressive::mark_tag::proto_base_expr const	s7 = {{ 7 }}

boost::xpressive::mark_tag::proto_base_expr const	s8 = {{ 8 }}

boost::xpressive::mark_tag::proto_base_expr const	s9 = {{ 9 }}

proto::functional::as_expr const	as_xpr = {}
	Makes a literal into a regular expression. More...

proto::terminal < detail::attribute_placeholder < mpl::int_< 1 > > >::type const	a1 = {{}}

proto::terminal < detail::attribute_placeholder < mpl::int_< 2 > > >::type const	a2 = {{}}

proto::terminal < detail::attribute_placeholder < mpl::int_< 3 > > >::type const	a3 = {{}}

proto::terminal < detail::attribute_placeholder < mpl::int_< 4 > > >::type const	a4 = {{}}

proto::terminal < detail::attribute_placeholder < mpl::int_< 5 > > >::type const	a5 = {{}}

proto::terminal < detail::attribute_placeholder < mpl::int_< 6 > > >::type const	a6 = {{}}

proto::terminal < detail::attribute_placeholder < mpl::int_< 7 > > >::type const	a7 = {{}}

proto::terminal < detail::attribute_placeholder < mpl::int_< 8 > > >::type const	a8 = {{}}

proto::terminal < detail::attribute_placeholder < mpl::int_< 9 > > >::type const	a9 = {{}}

Typedef Documentation

typedef match_results<char const *> boost::xpressive::cmatch

typedef basic_regex<char const *> boost::xpressive::cregex

typedef regex_compiler<char const *> boost::xpressive::cregex_compiler

typedef regex_id_filter_predicate<char const *> boost::xpressive::cregex_id_filter_predicate

typedef regex_iterator<char const *> boost::xpressive::cregex_iterator

typedef regex_token_iterator<char const *> boost::xpressive::cregex_token_iterator

typedef sub_match<char const *> boost::xpressive::csub_match

typedef void const* boost::xpressive::regex_id_type

typedef match_results<std::string::const_iterator> boost::xpressive::smatch

typedef basic_regex<std::string::const_iterator> boost::xpressive::sregex

typedef regex_compiler<std::string::const_iterator> boost::xpressive::sregex_compiler

typedef regex_id_filter_predicate<std::string::const_iterator> boost::xpressive::sregex_id_filter_predicate

typedef regex_iterator<std::string::const_iterator> boost::xpressive::sregex_iterator

typedef regex_token_iterator<std::string::const_iterator> boost::xpressive::sregex_token_iterator

typedef sub_match<std::string::const_iterator> boost::xpressive::ssub_match

typedef match_results<wchar_t const *> boost::xpressive::wcmatch

typedef basic_regex<wchar_t const *> boost::xpressive::wcregex

typedef regex_compiler<wchar_t const *> boost::xpressive::wcregex_compiler

typedef regex_id_filter_predicate<wchar_t const *> boost::xpressive::wcregex_id_filter_predicate

typedef regex_iterator<wchar_t const *> boost::xpressive::wcregex_iterator

typedef regex_token_iterator<wchar_t const *> boost::xpressive::wcregex_token_iterator

typedef sub_match<wchar_t const *> boost::xpressive::wcsub_match

typedef match_results<std::wstring::const_iterator> boost::xpressive::wsmatch

typedef basic_regex<std::wstring::const_iterator> boost::xpressive::wsregex

typedef regex_compiler<std::wstring::const_iterator> boost::xpressive::wsregex_compiler

typedef regex_id_filter_predicate<std::wstring::const_iterator> boost::xpressive::wsregex_id_filter_predicate

typedef regex_iterator<std::wstring::const_iterator> boost::xpressive::wsregex_iterator

typedef regex_token_iterator<std::wstring::const_iterator> boost::xpressive::wsregex_token_iterator

typedef sub_match<std::wstring::const_iterator> boost::xpressive::wssub_match

Function Documentation

template<typename Expr >

proto::result_of::make_expr< detail::lookbehind_tag , proto::default_domain , Expr const &>::type const boost::xpressive::after ( Expr const & expr )

Look-behind assertion.

after(expr) succeeds if the expr sub-expression would match at the current position minus N in the sequence, where N is the width of expr. expr is not included in the match. For instance, after("foo") succeeds if we are after a "foo". Look-behind assertions can be negated with the bit-complement operator.

Attention: after(expr) is equivalent to the perl (?<=...) extension. ~after(expr) is a negative look-behind assertion, equivalent to the perl (?<!...) extension.

Parameters

expr	The sub-expression to put in the look-ahead assertion.

Precondition: expr cannot match a variable number of characters.

References boost::proto::make_expr(), and boost::ref().

Referenced by boost::geometry::detail::coordinate_cast< rational< T > >::apply(), boost::multi_index::detail::hashed_index< KeyFromValue, Hash, Pred, SuperMeta, TagList, Category >::copy_(), boost::multi_index::detail::hashed_index< KeyFromValue, Hash, Pred, SuperMeta, TagList, Category >::count(), boost::multi_index::detail::hashed_index< KeyFromValue, Hash, Pred, SuperMeta, TagList, Category >::erase(), boost::iostreams::detail::bzip2_compressor_impl< Alloc >::filter(), boost::iostreams::detail::bzip2_decompressor_impl< Alloc >::filter(), boost::iostreams::detail::zlib_compressor_impl< Alloc >::filter(), boost::iostreams::detail::zlib_decompressor_impl< Alloc >::filter(), boost::is_straight_line_drawing(), and boost::intrusive::list_impl< ValueTraits, SizeType, ConstantTimeSize, HeaderHolder >::unique_and_dispose().

template<typename T , typename A >

detail::make_function::impl<op::as<T> const, A const &>::result_type const boost::xpressive::as ( A const & a )

as() is a lazy funtion for lexically casting a parameter to a different type.

Template Parameters

T	The type to which to lexically cast the parameter.

Parameters

a	The lazy value to lexically cast.

Returns: A lazy object that, when evaluated, lexically casts its argument to the desired type.

References boost::a.

template<typename Expr >

proto::result_of::make_expr< detail::lookahead_tag , proto::default_domain , Expr const &>::type const boost::xpressive::before ( Expr const & expr )

Look-ahead assertion.

before(expr) succeeds if the expr sub-expression would match at the current position in the sequence, but expr is not included in the match. For instance, before("foo") succeeds if we are before a "foo". Look-ahead assertions can be negated with the bit-compliment operator.

Attention: before(expr) is equivalent to the perl (?=...) extension. ~before(expr) is a negative look-ahead assertion, equivalent to the perl (?!...) extension.

Parameters

expr	The sub-expression to put in the look-ahead assertion.

References boost::proto::make_expr(), and boost::ref().

Referenced by boost::geometry::detail::coordinate_cast< rational< T > >::apply(), boost::iostreams::detail::bzip2_compressor_impl< Alloc >::filter(), boost::iostreams::detail::bzip2_decompressor_impl< Alloc >::filter(), boost::iostreams::detail::zlib_compressor_impl< Alloc >::filter(), boost::iostreams::detail::zlib_decompressor_impl< Alloc >::filter(), boost::container::basic_string< CharT, Traits, Allocator >::insert(), boost::is_straight_line_drawing(), boost::ptr_container::ptr_inserter(), and boost::ptr_circular_buffer< T, CloneAllocator, Allocator >::transfer().

template<typename BidiIter >

proto::terminal<reference_wrapper<basic_regex<BidiIter> const> >::type const boost::xpressive::by_ref ( basic_regex< BidiIter > const & rex )

inline

Embed a regex object by reference.

Parameters

rex	The basic_regex object to embed by reference.

References boost::geometry::make(), and ref().

template<typename T , typename A >

detail::make_function::impl<op::const_cast_<T> const, A const &>::result_type const boost::xpressive::const_cast_ ( A const & a )

dynamic_cast_ is a lazy funtion for const-casting a parameter to a different type.

Template Parameters

T	The type to which to const-cast the parameter.

Parameters

a	The lazy value to const-cast.

Returns: A lazy object that, when evaluated, const-casts its argument to the desired type.

References boost::a.

template<typename T >

reference<T const> const boost::xpressive::cref ( T const & t )

Helper for constructing reference<> objects that store a reference to const.

Returns: reference<T const>(t)

References boost::flyweights::t.

template<typename T , typename A >

detail::make_function::impl<op::dynamic_cast_<T> const, A const &>::result_type const boost::xpressive::dynamic_cast_ ( A const & a )

dynamic_cast_ is a lazy funtion for dynamically casting a parameter to a different type.

Template Parameters

T	The type to which to dynamically cast the parameter.

Parameters

a	The lazy value to dynamically cast.

Returns: A lazy object that, when evaluated, dynamically casts its argument to the desired type.

References boost::a.

template<typename Locale >

detail::modifier_op<detail::locale_modifier<Locale> > const boost::xpressive::imbue ( Locale const & loc )

inline

Specify a regex traits or a std::locale.

imbue() instructs the regex engine to use the specified traits or locale when matching the regex. The entire expression must use the same traits/locale. For instance, the following specifies a locale for use with a regex: std::locale loc; sregex rx = imbue(loc)(+digit);

Parameters

loc	The std::locale or regex traits object.

References boost::xpressive::regex_constants::ECMAScript.

Referenced by boost::xpressive::c_regex_traits< Char >::c_regex_traits().

template<typename Expr >

proto::result_of::make_expr< detail::keeper_tag , proto::default_domain , Expr const &>::type const boost::xpressive::keep ( Expr const & expr )

Create an independent sub-expression.

Turn off back-tracking for a sub-expression. Any branches or repeats within the sub-expression will match only one way, and no other alternatives are tried.

Attention: keep(expr) is equivalent to the perl (?>...) extension.

Parameters

expr	The sub-expression to modify.

References boost::proto::make_expr(), and boost::ref().

template<typename Traits , std::size_t N>

Traits::char_class_type boost::xpressive::lookup_classname	(	Traits const &	traits,
		char const (&)	cname[N],
		bool	icase
	)

inline

INTERNAL ONLY.

References N, and boost::iostreams::gzip::flags::name.

Referenced by boost::xpressive::regex_compiler< BidiIter, RegexTraits, CompilerTraits >::imbue(), boost::xpressive::c_regex_traits< Char >::lookup_classname(), and boost::xpressive::regex_compiler< BidiIter, RegexTraits, CompilerTraits >::regex_compiler().

template<typename BidiIter >

bool boost::xpressive::operator!=	(	sub_match< BidiIter > const &	lhs,
		sub_match< BidiIter > const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::compare().

template<typename BidiIter >

bool boost::xpressive::operator!=	(	typename iterator_value< BidiIter >::type const *	lhs,
		sub_match< BidiIter > const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

bool boost::xpressive::operator!=	(	sub_match< BidiIter > const &	lhs,
		typename iterator_value< BidiIter >::type const *	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

bool boost::xpressive::operator!=	(	typename iterator_value< BidiIter >::type const &	lhs,
		sub_match< BidiIter > const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

bool boost::xpressive::operator!=	(	sub_match< BidiIter > const &	lhs,
		typename iterator_value< BidiIter >::type const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

sub_match<BidiIter>::string_type boost::xpressive::operator+	(	sub_match< BidiIter > const &	lhs,
		sub_match< BidiIter > const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

sub_match<BidiIter>::string_type boost::xpressive::operator+	(	sub_match< BidiIter > const &	lhs,
		typename iterator_value< BidiIter >::type const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

sub_match<BidiIter>::string_type boost::xpressive::operator+	(	typename iterator_value< BidiIter >::type const &	lhs,
		sub_match< BidiIter > const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

sub_match<BidiIter>::string_type boost::xpressive::operator+	(	sub_match< BidiIter > const &	lhs,
		typename iterator_value< BidiIter >::type const *	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

sub_match<BidiIter>::string_type boost::xpressive::operator+	(	typename iterator_value< BidiIter >::type const *	lhs,
		sub_match< BidiIter > const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

sub_match<BidiIter>::string_type boost::xpressive::operator+	(	sub_match< BidiIter > const &	lhs,
		typename sub_match< BidiIter >::string_type const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

sub_match<BidiIter>::string_type boost::xpressive::operator+	(	typename sub_match< BidiIter >::string_type const &	lhs,
		sub_match< BidiIter > const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

bool boost::xpressive::operator<	(	sub_match< BidiIter > const &	lhs,
		sub_match< BidiIter > const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::compare().

template<typename BidiIter >

bool boost::xpressive::operator<	(	typename iterator_value< BidiIter >::type const *	lhs,
		sub_match< BidiIter > const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

bool boost::xpressive::operator<	(	sub_match< BidiIter > const &	lhs,
		typename iterator_value< BidiIter >::type const *	rhs
	)

template<typename BidiIter >

bool boost::xpressive::operator<	(	typename iterator_value< BidiIter >::type const &	lhs,
		sub_match< BidiIter > const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

bool boost::xpressive::operator<	(	sub_match< BidiIter > const &	lhs,
		typename iterator_value< BidiIter >::type const &	rhs
	)

template<typename BidiIter , typename Char , typename Traits >

std::basic_ostream<Char, Traits>& boost::xpressive::operator<<	(	std::basic_ostream< Char, Traits > &	sout,
		sub_match< BidiIter > const &	sub
	)

inline

insertion operator for sending sub-matches to ostreams

Parameters

sout	output stream.
sub	sub_match object to be written to the stream.

Returns: sout << sub.str()

References BOOST_MPL_ASSERT_MSG, boost::filesystem::detail::copy(), boost::numeric::interval_lib::sub(), boost::detail::type, and boost::program_options::value().

template<typename BidiIter >

bool boost::xpressive::operator<=	(	sub_match< BidiIter > const &	lhs,
		sub_match< BidiIter > const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::compare().

template<typename BidiIter >

bool boost::xpressive::operator<=	(	typename iterator_value< BidiIter >::type const *	lhs,
		sub_match< BidiIter > const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

bool boost::xpressive::operator<=	(	sub_match< BidiIter > const &	lhs,
		typename iterator_value< BidiIter >::type const *	rhs
	)

template<typename BidiIter >

bool boost::xpressive::operator<=	(	typename iterator_value< BidiIter >::type const &	lhs,
		sub_match< BidiIter > const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

bool boost::xpressive::operator<=	(	sub_match< BidiIter > const &	lhs,
		typename iterator_value< BidiIter >::type const &	rhs
	)

template<typename BidiIter >

bool boost::xpressive::operator==	(	sub_match< BidiIter > const &	lhs,
		sub_match< BidiIter > const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::compare().

template<typename BidiIter >

bool boost::xpressive::operator==	(	typename iterator_value< BidiIter >::type const *	lhs,
		sub_match< BidiIter > const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

bool boost::xpressive::operator==	(	sub_match< BidiIter > const &	lhs,
		typename iterator_value< BidiIter >::type const *	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

bool boost::xpressive::operator==	(	typename iterator_value< BidiIter >::type const &	lhs,
		sub_match< BidiIter > const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

bool boost::xpressive::operator==	(	sub_match< BidiIter > const &	lhs,
		typename iterator_value< BidiIter >::type const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

bool boost::xpressive::operator>	(	sub_match< BidiIter > const &	lhs,
		sub_match< BidiIter > const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::compare().

template<typename BidiIter >

bool boost::xpressive::operator>	(	typename iterator_value< BidiIter >::type const *	lhs,
		sub_match< BidiIter > const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

bool boost::xpressive::operator>	(	sub_match< BidiIter > const &	lhs,
		typename iterator_value< BidiIter >::type const *	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

bool boost::xpressive::operator>	(	typename iterator_value< BidiIter >::type const &	lhs,
		sub_match< BidiIter > const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

bool boost::xpressive::operator>	(	sub_match< BidiIter > const &	lhs,
		typename iterator_value< BidiIter >::type const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

bool boost::xpressive::operator>=	(	sub_match< BidiIter > const &	lhs,
		sub_match< BidiIter > const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::compare().

template<typename BidiIter >

bool boost::xpressive::operator>=	(	typename iterator_value< BidiIter >::type const *	lhs,
		sub_match< BidiIter > const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

bool boost::xpressive::operator>=	(	sub_match< BidiIter > const &	lhs,
		typename iterator_value< BidiIter >::type const *	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

bool boost::xpressive::operator>=	(	typename iterator_value< BidiIter >::type const &	lhs,
		sub_match< BidiIter > const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename BidiIter >

bool boost::xpressive::operator>=	(	sub_match< BidiIter > const &	lhs,
		typename iterator_value< BidiIter >::type const &	rhs
	)

References boost::xpressive::sub_match< BidiIter >::str().

template<typename Expr >

proto::result_of::make_expr< proto::tag::logical_not , proto::default_domain , Expr const &>::type const boost::xpressive::optional ( Expr const & expr )

Make a sub-expression optional.

Equivalent to !as_xpr(expr).

Parameters

expr	The sub-expression to make optional.

References boost::proto::make_expr(), and boost::ref().

template<typename Char >

proto::terminal<detail::range_placeholder<Char> >::type const boost::xpressive::range	(	Char	ch_min,
		Char	ch_max
	)

inline

Match a range of characters.

Match any character in the range [ch_min, ch_max].

Parameters

ch_min	The lower end of the range to match.
ch_max	The upper end of the range to match.

References boost::geometry::make().

template<typename BidiIter >

BidiIter boost::xpressive::range_begin ( sub_match< BidiIter > & sub )

inline

range_begin() to make sub_match<> a valid range

Parameters

sub	the `sub_match<>` object denoting the range

Returns: sub.first

Precondition: sub.first is not singular

template<typename BidiIter >

BidiIter boost::xpressive::range_begin ( sub_match< BidiIter > const & sub )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename BidiIter >

BidiIter boost::xpressive::range_end ( sub_match< BidiIter > & sub )

inline

range_end() to make sub_match<> a valid range

Parameters

sub	the `sub_match<>` object denoting the range

Returns: sub.second

Precondition: sub.second is not singular

template<typename BidiIter >

BidiIter boost::xpressive::range_end ( sub_match< BidiIter > const & sub )

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

template<typename T >

reference<T> const boost::xpressive::ref ( T & t )

Helper for constructing reference<> objects.

Returns: reference<T>(t)

References boost::flyweights::t.

Referenced by by_ref().

template<typename BidiIter >

bool boost::xpressive::regex_match	(	typename mpl::identity< BidiIter >::type	begin,
		typename mpl::identity< BidiIter >::type	end,
		match_results< BidiIter > &	what,
		basic_regex< BidiIter > const &	re,
		regex_constants::match_flag_type	flags = `regex_constants::match_default`
	)

inline

See if a regex matches a sequence from beginning to end.

Determines whether there is an exact match between the regular expression re, and all of the sequence [begin, end).

Precondition: Type BidiIter meets the requirements of a Bidirectional Iterator (24.1.4).; [begin,end) denotes a valid iterator range.

Parameters

begin	The beginning of the sequence.
end	The end of the sequence.
what	The `match_results` struct into which the sub_matches will be written
re	The regular expression object to use
flags	Optional match flags, used to control how the expression is matched against the sequence. (See `match_flag_type`.)

Returns: true if a match is found, false otherwise

Exceptions

regex_error on stack exhaustion

References boost::xpressive::basic_regex< BidiIter >::regex_id(), and boost::xpressive::detail::regex_match_impl().

Referenced by boost::escape_dot_string(), and boost::aux::match_traits< ExpressionT, boost_xpressive_expression_tag >::matches().

template<typename BidiIter >

bool boost::xpressive::regex_match	(	typename mpl::identity< BidiIter >::type	begin,
		typename mpl::identity< BidiIter >::type	end,
		basic_regex< BidiIter > const &	re,
		regex_constants::match_flag_type	flags = `regex_constants::match_default`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::xpressive::basic_regex< BidiIter >::regex_id(), boost::xpressive::detail::regex_match_impl(), and boost::archive::what().

template<typename Char >

bool boost::xpressive::regex_match	(	typename mpl::identity< Char >::type *	begin,
		match_results< Char * > &	what,
		basic_regex< Char * > const &	re,
		regex_constants::match_flag_type	flags = `regex_constants::match_default`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::xpressive::basic_regex< BidiIter >::regex_id(), boost::xpressive::detail::regex_match_impl(), and boost::detail::type.

template<typename BidiRange , typename BidiIter >

bool boost::xpressive::regex_match	(	BidiRange &	rng,
		match_results< BidiIter > &	what,
		basic_regex< BidiIter > const &	re,
		regex_constants::match_flag_type	flags = `regex_constants::match_default`,
		typename disable_if< detail::is_char_ptr< BidiRange > >::type *	= `0`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::asio::begin, boost::end, boost::xpressive::basic_regex< BidiIter >::regex_id(), and boost::xpressive::detail::regex_match_impl().

template<typename BidiRange , typename BidiIter >

bool boost::xpressive::regex_match	(	BidiRange const &	rng,
		match_results< BidiIter > &	what,
		basic_regex< BidiIter > const &	re,
		regex_constants::match_flag_type	flags = `regex_constants::match_default`,
		typename disable_if< detail::is_char_ptr< BidiRange > >::type *	= `0`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::asio::begin, boost::end, boost::xpressive::basic_regex< BidiIter >::regex_id(), and boost::xpressive::detail::regex_match_impl().

template<typename Char >

bool boost::xpressive::regex_match	(	typename mpl::identity< Char >::type *	begin,
		basic_regex< Char * > const &	re,
		regex_constants::match_flag_type	flags = `regex_constants::match_default`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::xpressive::basic_regex< BidiIter >::regex_id(), boost::xpressive::detail::regex_match_impl(), boost::detail::type, and boost::archive::what().

template<typename BidiRange , typename BidiIter >

bool boost::xpressive::regex_match	(	BidiRange &	rng,
		basic_regex< BidiIter > const &	re,
		regex_constants::match_flag_type	flags = `regex_constants::match_default`,
		typename disable_if< detail::is_char_ptr< BidiRange > >::type *	= `0`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::asio::begin, boost::end, boost::xpressive::basic_regex< BidiIter >::regex_id(), boost::xpressive::detail::regex_match_impl(), and boost::archive::what().

template<typename BidiRange , typename BidiIter >

bool boost::xpressive::regex_match	(	BidiRange const &	rng,
		basic_regex< BidiIter > const &	re,
		regex_constants::match_flag_type	flags = `regex_constants::match_default`,
		typename disable_if< detail::is_char_ptr< BidiRange > >::type *	= `0`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::asio::begin, boost::end, boost::xpressive::basic_regex< BidiIter >::regex_id(), boost::xpressive::detail::regex_match_impl(), and boost::archive::what().

template<typename OutIter , typename BidiIter , typename Formatter >

OutIter boost::xpressive::regex_replace	(	OutIter	out,
		typename mpl::identity< BidiIter >::type	begin,
		typename mpl::identity< BidiIter >::type	end,
		basic_regex< BidiIter > const &	re,
		Formatter const &	format,
		regex_constants::match_flag_type	flags = `regex_constants::match_default`,
		typename disable_if< detail::is_char_ptr< Formatter > >::type *	= `0`
	)

inline

Build an output sequence given an input sequence, a regex, and a format string or a formatter object, function, or expression.

Constructs a regex_iterator object: regex_iterator< BidiIter > i(begin, end, re, flags), and uses i to enumerate through all of the matches m of type match_results< BidiIter > that occur within the sequence [begin, end). If no such matches are found and !(flags & format_no_copy) then calls std::copy(begin, end, out). Otherwise, for each match found, if !(flags & format_no_copy) calls std::copy(m.prefix().first, m.prefix().second, out), and then calls m.format(out, format, flags). Finally if !(flags & format_no_copy) calls std::copy(last_m.suffix().first, last_m.suffix().second, out) where last_m is a copy of the last match found.

If flags & format_first_only is non-zero then only the first match found is replaced.

Precondition: Type BidiIter meets the requirements of a Bidirectional Iterator (24.1.4).; Type OutIter meets the requirements of an Output Iterator (24.1.2).; Type Formatter models ForwardRange, Callable<match_results<BidiIter> >, Callable<match_results<BidiIter>, OutIter>, or Callable<match_results<BidiIter>, OutIter, regex_constants::match_flag_type>; or else it is a null-terminated format string, or an expression template representing a formatter lambda expression.; [begin,end) denotes a valid iterator range.

Parameters

out	An output iterator into which the output sequence is written.
begin	The beginning of the input sequence.
end	The end of the input sequence.
re	The regular expression object to use.
format	The format string used to format the replacement sequence, or a formatter function, function object, or expression.
flags	Optional match flags, used to control how the expression is matched against the sequence. (See `match_flag_type`.)

Returns: The value of the output iterator after the output sequence has been written to it.

Exceptions

regex_error on stack exhaustion or invalid format string.

References boost::filesystem::detail::copy(), boost::xpressive::regex_constants::format_no_copy, boost::out, boost::xpressive::basic_regex< BidiIter >::regex_id(), and boost::xpressive::detail::regex_replace_impl().

template<typename OutIter , typename BidiIter >

OutIter boost::xpressive::regex_replace	(	OutIter	out,
		typename mpl::identity< BidiIter >::type	begin,
		typename mpl::identity< BidiIter >::type	end,
		basic_regex< BidiIter > const &	re,
		typename iterator_value< BidiIter >::type const *	format,
		regex_constants::match_flag_type	flags = `regex_constants::match_default`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::filesystem::detail::copy(), boost::xpressive::regex_constants::format_no_copy, boost::out, boost::xpressive::basic_regex< BidiIter >::regex_id(), and boost::xpressive::detail::regex_replace_impl().

template<typename BidiContainer , typename BidiIter , typename Formatter >

BidiContainer boost::xpressive::regex_replace	(	BidiContainer &	str,
		basic_regex< BidiIter > const &	re,
		Formatter const &	format,
		regex_constants::match_flag_type	flags = `regex_constants::match_default`,
		typename disable_if< mpl::or_< detail::is_char_ptr< BidiContainer >, detail::is_char_ptr< Formatter > > >::type *	= `0`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::asio::begin, boost::filesystem::detail::copy(), boost::end, boost::xpressive::regex_constants::format_no_copy, boost::xpressive::basic_regex< BidiIter >::regex_id(), and boost::xpressive::detail::regex_replace_impl().

template<typename BidiContainer , typename BidiIter , typename Formatter >

BidiContainer boost::xpressive::regex_replace	(	BidiContainer const &	str,
		basic_regex< BidiIter > const &	re,
		Formatter const &	format,
		regex_constants::match_flag_type	flags = `regex_constants::match_default`,
		typename disable_if< mpl::or_< detail::is_char_ptr< BidiContainer >, detail::is_char_ptr< Formatter > > >::type *	= `0`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::asio::begin, boost::filesystem::detail::copy(), boost::end, boost::xpressive::regex_constants::format_no_copy, boost::xpressive::basic_regex< BidiIter >::regex_id(), and boost::xpressive::detail::regex_replace_impl().

template<typename Char , typename Formatter >

std::basic_string<typename remove_const<Char>::type> boost::xpressive::regex_replace	(	typename mpl::identity< Char >::type *	str,
		basic_regex< Char * > const &	re,
		Formatter const &	format,
		regex_constants::match_flag_type	flags = `regex_constants::match_default`,
		typename disable_if< detail::is_char_ptr< Formatter > >::type *	= `0`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::xpressive::regex_constants::format_no_copy, boost::xpressive::basic_regex< BidiIter >::regex_id(), boost::xpressive::detail::regex_replace_impl(), str, and boost::detail::type.

template<typename BidiContainer , typename BidiIter >

BidiContainer boost::xpressive::regex_replace	(	BidiContainer &	str,
		basic_regex< BidiIter > const &	re,
		typename iterator_value< BidiIter >::type const *	format,
		regex_constants::match_flag_type	flags = `regex_constants::match_default`,
		typename disable_if< detail::is_char_ptr< BidiContainer > >::type *	= `0`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::asio::begin, boost::filesystem::detail::copy(), boost::end, boost::xpressive::regex_constants::format_no_copy, boost::xpressive::basic_regex< BidiIter >::regex_id(), and boost::xpressive::detail::regex_replace_impl().

template<typename BidiContainer , typename BidiIter >

BidiContainer boost::xpressive::regex_replace	(	BidiContainer const &	str,
		basic_regex< BidiIter > const &	re,
		typename iterator_value< BidiIter >::type const *	format,
		regex_constants::match_flag_type	flags = `regex_constants::match_default`,
		typename disable_if< detail::is_char_ptr< BidiContainer > >::type *	= `0`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::asio::begin, boost::filesystem::detail::copy(), boost::end, boost::xpressive::regex_constants::format_no_copy, boost::xpressive::basic_regex< BidiIter >::regex_id(), and boost::xpressive::detail::regex_replace_impl().

template<typename Char >

std::basic_string<typename remove_const<Char>::type> boost::xpressive::regex_replace	(	typename mpl::identity< Char >::type *	str,
		basic_regex< Char * > const &	re,
		typename add_const< Char >::type *	format,
		regex_constants::match_flag_type	flags = `regex_constants::match_default`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::xpressive::regex_constants::format_no_copy, boost::xpressive::basic_regex< BidiIter >::regex_id(), boost::xpressive::detail::regex_replace_impl(), str, and boost::detail::type.

template<typename BidiIter >

bool boost::xpressive::regex_search	(	typename mpl::identity< BidiIter >::type	begin,
		typename mpl::identity< BidiIter >::type	end,
		match_results< BidiIter > &	what,
		basic_regex< BidiIter > const &	re,
		regex_constants::match_flag_type	flags = `regex_constants::match_default`
	)

inline

Determines whether there is some sub-sequence within [begin,end) that matches the regular expression re.

Precondition: Type BidiIter meets the requirements of a Bidirectional Iterator (24.1.4).; [begin,end) denotes a valid iterator range.

Parameters

begin	The beginning of the sequence
end	The end of the sequence
what	The `match_results` struct into which the sub_matches will be written
re	The regular expression object to use
flags	Optional match flags, used to control how the expression is matched against the sequence. (See `match_flag_type`.)

Returns: true if a match is found, false otherwise

Exceptions

regex_error on stack exhaustion

References boost::xpressive::basic_regex< BidiIter >::regex_id(), and boost::xpressive::detail::regex_search_impl().

template<typename BidiIter >

bool boost::xpressive::regex_search	(	typename mpl::identity< BidiIter >::type	begin,
		typename mpl::identity< BidiIter >::type	end,
		basic_regex< BidiIter > const &	re,
		regex_constants::match_flag_type	flags = `regex_constants::match_default`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::xpressive::basic_regex< BidiIter >::regex_id(), boost::xpressive::detail::regex_search_impl(), and boost::archive::what().

template<typename Char >

bool boost::xpressive::regex_search	(	typename mpl::identity< Char >::type *	begin,
		match_results< Char * > &	what,
		basic_regex< Char * > const &	re,
		regex_constants::match_flag_type	flags = `regex_constants::match_default`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::xpressive::basic_regex< BidiIter >::regex_id(), boost::xpressive::detail::regex_search_impl(), and boost::detail::type.

template<typename BidiRange , typename BidiIter >

bool boost::xpressive::regex_search	(	BidiRange &	rng,
		match_results< BidiIter > &	what,
		basic_regex< BidiIter > const &	re,
		regex_constants::match_flag_type	flags = `regex_constants::match_default`,
		typename disable_if< detail::is_char_ptr< BidiRange > >::type *	= `0`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::asio::begin, boost::end, boost::xpressive::basic_regex< BidiIter >::regex_id(), and boost::xpressive::detail::regex_search_impl().

template<typename BidiRange , typename BidiIter >

bool boost::xpressive::regex_search	(	BidiRange const &	rng,
		match_results< BidiIter > &	what,
		basic_regex< BidiIter > const &	re,
		regex_constants::match_flag_type	flags = `regex_constants::match_default`,
		typename disable_if< detail::is_char_ptr< BidiRange > >::type *	= `0`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::asio::begin, boost::end, boost::xpressive::basic_regex< BidiIter >::regex_id(), and boost::xpressive::detail::regex_search_impl().

template<typename Char >

bool boost::xpressive::regex_search	(	typename mpl::identity< Char >::type *	begin,
		basic_regex< Char * > const &	re,
		regex_constants::match_flag_type	flags = `regex_constants::match_default`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::xpressive::basic_regex< BidiIter >::regex_id(), boost::xpressive::detail::regex_search_impl(), boost::detail::type, and boost::archive::what().

template<typename BidiRange , typename BidiIter >

bool boost::xpressive::regex_search	(	BidiRange &	rng,
		basic_regex< BidiIter > const &	re,
		regex_constants::match_flag_type	flags = `regex_constants::match_default`,
		typename disable_if< detail::is_char_ptr< BidiRange > >::type *	= `0`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::asio::begin, boost::end, boost::xpressive::basic_regex< BidiIter >::regex_id(), boost::xpressive::detail::regex_search_impl(), and boost::archive::what().

template<typename BidiRange , typename BidiIter >

bool boost::xpressive::regex_search	(	BidiRange const &	rng,
		basic_regex< BidiIter > const &	re,
		regex_constants::match_flag_type	flags = `regex_constants::match_default`,
		typename disable_if< detail::is_char_ptr< BidiRange > >::type *	= `0`
	)

inline

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::asio::begin, boost::end, boost::xpressive::basic_regex< BidiIter >::regex_id(), boost::xpressive::detail::regex_search_impl(), and boost::archive::what().

template<unsigned int Min, unsigned int Max, typename Expr >

proto::result_of::make_expr< detail::generic_quant_tag<Min, Max> , proto::default_domain , Expr const &>::type const boost::xpressive::repeat ( Expr const & expr )

Repeat a sub-expression multiple times.

There are two forms of the repeat<>() function template. To match a sub-expression N times, use repeat<N>(expr). To match a sub-expression from M to N times, use repeat<M,N>(expr).

The repeat<>() function creates a greedy quantifier. To make the quantifier non-greedy, apply the unary minus operator, as in -repeat<M,N>(expr).

Parameters

expr	The sub-expression to repeat.

References boost::proto::make_expr(), and boost::ref().

template<unsigned int Count, typename Expr2 >

proto::result_of::make_expr< detail::generic_quant_tag<Count, Count> , proto::default_domain , Expr2 const &>::type const boost::xpressive::repeat ( Expr2 const & expr2 )

This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.

References boost::proto::make_expr(), and boost::ref().

template<typename Skip >

detail::skip_directive<Skip> boost::xpressive::skip ( Skip const & skip )

Specify which characters to skip when matching a regex.

skip() instructs the regex engine to skip certain characters when matching a regex. It is most useful for writing regexes that ignore whitespace. For instance, the following specifies a regex that skips whitespace and punctuation:

// A sentence is one or more words separated by whitespace
// and punctuation.
sregex word = +alpha;
sregex sentence = skip(set[_s | punct])( +word );

The way it works in the above example is to insert keep(*set[_s | punct]) before each primitive within the regex. A "primitive" includes terminals like strings, character sets and nested regexes. A final *set[_s | punct] is added to the end of the regex. The regex sentence specified above is equivalent to the following:

sregex sentence = +( keep(*set[_s | punct]) >> word )

>> *set[_s | punct];

Attention: Skipping does not affect how nested regexes are handled because they are treated atomically. String literals are also treated atomically; that is, no skipping is done within a string literal. So skip(_s)("this that") is not the same as skip(_s)("this" >> as_xpr("that")). The first will only match when there is only one space between "this" and "that". The second will skip any and all whitespace between "this" and "that".

Parameters

skip	A regex that specifies which characters to skip.

template<typename T , typename A >

detail::make_function::impl<op::static_cast_<T> const, A const &>::result_type const boost::xpressive::static_cast_ ( A const & a )

static_cast_ is a lazy funtion for statically casting a parameter to a different type.

Template Parameters

T	The type to which to statically cast the parameter.

Parameters

a	The lazy value to statically cast.

Returns: A lazy object that, when evaluated, statically casts its argument to the desired type.

References boost::a.

template<typename BidiIter >

void boost::xpressive::swap	(	basic_regex< BidiIter > &	left,
		basic_regex< BidiIter > &	right
	)

inline

Swaps the contents of two basic_regex objects.

Parameters

left	The first basic_regex object.
right	The second basic_regex object.

Attention: This is a shallow swap that does not do reference tracking. If you embed a basic_regex object by reference in another regular expression and then swap its contents with another basic_regex object, the change will not be visible to the enclosing regular expression. It is done this way to ensure that swap() cannot throw.

Exceptions

nothrow

References boost::xpressive::basic_regex< BidiIter >::swap().

Referenced by boost::re_detail::named_subexpressions::name::swap().

template<typename T >

value<T> const boost::xpressive::val ( T const & t )

Helper for constructing value<> objects.

Returns: value<T>(t)

References boost::flyweights::t.

Referenced by boost::xpressive::op::as< T >::operator()(), boost::xpressive::op::static_cast_< T >::operator()(), boost::xpressive::op::dynamic_cast_< T >::operator()(), boost::xpressive::op::const_cast_< T >::operator()(), boost::xpressive::c_regex_traits< Char >::value(), and boost::xpressive::cpp_regex_traits< Char >::value().

Variable Documentation

proto::terminal<detail::any_matcher>::type const boost::xpressive::_ = {{}}

Matches any one character.

Match any character, similar to '.' in perl syntax with the /s modifier. '_' matches any one character, including the newline.

Attention: To match any character except the newline, use ~_n

proto::terminal<detail::assert_word_boundary>::type const boost::xpressive::_b = {{}}

Word boundary assertion.

'_b' matches the zero-width sub-sequence at the beginning or the end of a word. It is equivalent to (bow | eow). The regex traits are used to determine what constitutes a word character. To match a non-word boundary, use ~_b.

Attention: _b is like \b in perl. ~_b is like \B in perl.

proto::terminal<detail::posix_charset_placeholder>::type const boost::xpressive::_d = {{"d", false}}

Matches a digit character.

'_d' matches a single digit character. The regex traits are used to determine which characters are digits. Use ~_d to match a character that is not a digit character.

Attention: _d is like \d in perl. ~_d is like \D in perl.

Referenced by boost::escape_dot_string().

detail::logical_newline_xpression const boost::xpressive::_ln = {{}}

Matches a logical newline sequence.

'_ln' matches a logical newline sequence. This can be any character in the line separator class, as determined by the regex traits, or the '\r\n' sequence. For the purpose of back-tracking, '\r\n' is treated as a unit. To match any one character that is not a logical newline, use ~_ln.

proto::terminal<char>::type const boost::xpressive::_n = {'\n'}

Matches a literal newline character, '\n'.

'_n' matches a single newline character, '\n'. Use ~_n to match a character that is not a newline.

Attention: ~_n is like '.' in perl without the /s modifier.

proto::terminal<detail::posix_charset_placeholder>::type const boost::xpressive::_s = {{"s", false}}

Matches a space character.

'_s' matches a single space character. The regex traits are used to determine which characters are space characters. Use ~_s to match a character that is not a space character.

Attention: _s is like \s in perl. ~_s is like \S in perl.

proto::terminal<detail::posix_charset_placeholder>::type const boost::xpressive::_w = {{"w", false}}

Matches a word character.

'_w' matches a single word character. The regex traits are used to determine which characters are word characters. Use ~_w to match a character that is not a word character.

Attention: _w is like \w in perl. ~_w is like \W in perl.

Referenced by boost::escape_dot_string().

proto::terminal<detail::attribute_placeholder<mpl::int_<1> > >::type const boost::xpressive::a1 = {{}}

Referenced by boost::allocate_shared(), boost::allocate_shared_noinit(), boost::re_detail::basic_regex_creator< charT, traits >::append_set(), boost::lambda::cast_action< static_cast_action< T > >::apply(), boost::lambda::cast_action< dynamic_cast_action< T > >::apply(), boost::lambda::cast_action< const_cast_action< T > >::apply(), boost::lambda::cast_action< reinterpret_cast_action< T > >::apply(), boost::lambda::typeid_action::apply(), boost::geometry::strategy::intersection::relate_cartesian_segments< Policy, CalculationType >::apply(), boost::lambda::sizeof_action::apply(), BOOST_MEM_FN_NAME(), boost::spirit::type_of::action_concatenator< Action1, Action2 >::concatenate(), boost::lambda::do_while_loop(), boost::lambda::for_loop(), boost::phoenix::function_equal_impl(), boost::math::detail::gamma_imp(), boost::io::group(), boost::detail::heap_new(), boost::lambda::if_then(), boost::lambda::if_then_else(), boost::lambda::if_then_else_return(), boost::intersects(), boost::lambda::ll_const_cast(), boost::lambda::ll_dynamic_cast(), boost::lambda::ll_reinterpret_cast(), boost::lambda::ll_sizeof(), boost::lambda::ll_static_cast(), boost::lambda::ll_typeid(), boost::make_shared(), boost::make_shared_noinit(), boost::phoenix::detail::compare::operator()(), boost::numeric::odeint::detail::fusion_maximum< Value >::operator()(), boost::accumulators::extractor< Feature >::operator()(), boost::numeric::odeint::compute_operations::scale_sum_swap2< Fac1, Fac2 >::operator()(), boost::lambda::delete_ptr::operator()(), boost::lambda::delete_array::operator()(), boost::numeric::odeint::default_operations::maximum< Value >::operator()(), boost::phoenix::operator<<(), boost::phoenix::operator>>(), boost::polygon::orientation(), boost::math::prime(), boost::lambda::switch_statement(), boost::lambda::throw_exception(), boost::lambda::try_catch(), and boost::lambda::while_loop().

proto::terminal<detail::attribute_placeholder<mpl::int_<2> > >::type const boost::xpressive::a2 = {{}}

Referenced by boost::allocate_shared(), boost::allocate_shared_noinit(), boost::re_detail::basic_regex_creator< charT, traits >::append_set(), BOOST_MEM_FN_NAME(), boost::spirit::type_of::action_concatenator< Action1, Action2 >::concatenate(), boost::numeric::odeint::runge_kutta_dopri5< State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step_impl(), boost::numeric::odeint::runge_kutta_cash_karp54_classic< State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step_impl(), boost::lambda::do_while_loop(), boost::math::detail::float_distance_imp(), boost::lambda::for_loop(), boost::phoenix::function_equal_impl(), boost::math::detail::gamma_imp(), boost::io::group(), boost::detail::heap_new(), boost::lambda::if_then(), boost::lambda::if_then_else(), boost::lambda::if_then_else_return(), boost::make_shared(), boost::make_shared_noinit(), boost::numeric::odeint::detail::fusion_maximum< Value >::operator()(), boost::numeric::odeint::compute_operations::scale_sum_swap2< Fac1, Fac2 >::operator()(), boost::numeric::odeint::default_operations::maximum< Value >::operator()(), boost::polygon::orientation(), boost::math::prime(), boost::lambda::try_catch(), and boost::lambda::while_loop().

proto::terminal<detail::attribute_placeholder<mpl::int_<3> > >::type const boost::xpressive::a3 = {{}}

Referenced by BOOST_MEM_FN_NAME(), boost::numeric::odeint::runge_kutta_dopri5< State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step_impl(), boost::numeric::odeint::runge_kutta_cash_karp54_classic< State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step_impl(), boost::lambda::for_loop(), boost::io::group(), boost::detail::heap_new(), boost::lambda::if_then_else(), boost::lambda::if_then_else_return(), boost::polygon::orientation(), boost::math::prime(), boost::geometry::strategy::centroid::bashein_detmer< Point, PointOfSegment, CalculationType >::result(), and boost::lambda::try_catch().

proto::terminal<detail::attribute_placeholder<mpl::int_<4> > >::type const boost::xpressive::a4 = {{}}

Referenced by BOOST_MEM_FN_NAME(), boost::numeric::odeint::runge_kutta_dopri5< State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step_impl(), boost::numeric::odeint::runge_kutta_cash_karp54_classic< State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step_impl(), boost::lambda::for_loop(), boost::io::group(), boost::detail::heap_new(), and boost::lambda::try_catch().

proto::terminal<detail::attribute_placeholder<mpl::int_<5> > >::type const boost::xpressive::a5 = {{}}

Referenced by BOOST_MEM_FN_NAME(), boost::numeric::odeint::runge_kutta_dopri5< State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step_impl(), boost::numeric::odeint::runge_kutta_cash_karp54_classic< State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step_impl(), boost::io::group(), and boost::lambda::try_catch().

proto::terminal<detail::attribute_placeholder<mpl::int_<6> > >::type const boost::xpressive::a6 = {{}}

Referenced by BOOST_MEM_FN_NAME(), boost::numeric::odeint::runge_kutta_cash_karp54_classic< State, Value, Deriv, Time, Algebra, Operations, Resizer >::do_step_impl(), boost::io::group(), and boost::lambda::try_catch().

proto::terminal<detail::attribute_placeholder<mpl::int_<7> > >::type const boost::xpressive::a7 = {{}}

Referenced by BOOST_MEM_FN_NAME(), boost::io::group(), and boost::lambda::try_catch().

proto::terminal<detail::attribute_placeholder<mpl::int_<8> > >::type const boost::xpressive::a8 = {{}}

Referenced by BOOST_MEM_FN_NAME(), boost::io::group(), and boost::lambda::try_catch().

proto::terminal<detail::attribute_placeholder<mpl::int_<9> > >::type const boost::xpressive::a9 = {{}}

Referenced by boost::io::group(), and boost::lambda::try_catch().

proto::terminal<detail::posix_charset_placeholder>::type const boost::xpressive::alnum = {{"alnum", false}}

Matches an alpha-numeric character.

The regex traits are used to determine which characters are alpha-numeric. To match any character that is not alpha-numeric, use ~alnum.

Attention: alnum is equivalent to /[[:alnum:]]/ in perl. ~alnum is equivalent to /[[:^alnum:]]/ in perl.

proto::terminal<detail::posix_charset_placeholder>::type const boost::xpressive::alpha = {{"alpha", false}}

Matches an alphabetic character.

The regex traits are used to determine which characters are alphabetic. To match any character that is not alphabetic, use ~alpha.

Attention: alpha is equivalent to /[[:alpha:]]/ in perl. ~alpha is equivalent to /[[:^alpha:]]/ in perl.

Referenced by boost::escape_dot_string().

proto::functional::as_expr const boost::xpressive::as_xpr = {}

Makes a literal into a regular expression.

Use as_xpr() to turn a literal into a regular expression. For instance, "foo" >> "bar" will not compile because both operands to the right-shift operator are const char*, and no such operator exists. Use as_xpr("foo") >> "bar" instead.

You can use as_xpr() with character literals in addition to string literals. For instance, as_xpr('a') will match an 'a'. You can also complement a character literal, as with ~as_xpr('a'). This will match any one character that is not an 'a'.

Referenced by boost::escape_dot_string().

function<op::at>::type const boost::xpressive::at = {{}}

at is a lazy PolymorphicFunctionObject for indexing into a sequence in an xpressive semantic action.

function<op::back>::type const boost::xpressive::back = {{}}

back is a lazy PolymorphicFunctionObject for fetching the back element of a sequence in an xpressive semantic action.

Referenced by boost::range_detail::sub_range_base< ForwardRange, bidirectional_traversal_tag >::back(), boost::detail::depth_first_visit_impl(), boost::xpressive::detail::ignore_unused_regex_actions(), boost::iostreams::detail::chain_base< Self, Ch, Tr, Alloc, Mode >::pop(), boost::wave::util::VectorStringStorage< E, A >::resize(), boost::detail::undir_dfv_impl(), boost::uninitialized_move(), and boost::wave::util::VectorStringStorage< E, A >::VectorStringStorage().

proto::terminal<detail::posix_charset_placeholder>::type const boost::xpressive::blank = {{"blank", false}}

Matches a blank (horizonal white-space) character.

The regex traits are used to determine which characters are blank characters. To match any character that is not blank, use ~blank.

Attention: blank is equivalent to /[[:blank:]]/ in perl. ~blank is equivalent to /[[:^blank:]]/ in perl.

proto::terminal<detail::assert_bol_placeholder>::type const boost::xpressive::bol = {{}}

Beginning of line assertion.

'bol' matches the zero-width sub-sequence immediately following a logical newline sequence. The regex traits is used to determine what constitutes a logical newline sequence.

Referenced by boost::spirit::lex::lexertl::detail::data< Iterator, mpl::true_, HasState, TokenValue >::lookahead(), boost::spirit::lex::lexertl::detail::static_data< Iterator, mpl::true_, HasState, TokenValue >::lookahead(), boost::spirit::lex::lexertl::detail::data< Iterator, mpl::true_, HasState, boost::optional< TokenValue > >::lookahead(), boost::spirit::lex::lexertl::detail::static_data< Iterator, mpl::true_, HasState, boost::optional< TokenValue > >::lookahead(), boost::spirit::lex::lexertl::basic_iterator_tokeniser< Iterator >::next(), boost::spirit::lex::lexertl::detail::data< Iterator, mpl::false_, mpl::false_, TokenValue >::reset_bol(), and boost::spirit::lex::lexertl::detail::static_data< Iterator, mpl::false_, mpl::false_, TokenValue >::reset_bol().

proto::terminal<detail::assert_bos_matcher>::type const boost::xpressive::bos = {{}}

Beginning of sequence assertion.

For the character sequence [begin, end), 'bos' matches the zero-width sub-sequence [begin, begin).

Referenced by boost::detail::push_relabel< Graph, EdgeCapacityMap, ResidualCapacityEdgeMap, ReverseEdgeMap, VertexIndexMap, FlowValue >::convert_preflow_to_flow().

proto::terminal<detail::assert_word_begin>::type const boost::xpressive::bow = {{}}

Beginning of word assertion.

'bow' matches the zero-width sub-sequence immediately following a non-word character and preceeding a word character. The regex traits are used to determine what constitutes a word character.

proto::terminal<detail::check_tag>::type const boost::xpressive::check = {{}}

For adding user-defined assertions to your regular expressions.

Parameters

t	The UnaryPredicate object or Boolean semantic action.

A {user_s_guide.semantic_actions_and_user_defined_assertions.user_defined_assertions,user-defined assertion} is a kind of semantic action that evaluates a Boolean lambda and, if it evaluates to false, causes the match to fail at that location in the string. This will cause backtracking, so the match may ultimately succeed.

To use check() to specify a user-defined assertion in a regex, use the following syntax:

sregex s = (_d >> _d)[check( XXX )]; // XXX is a custom assertion

The assertion is evaluated with a sub_match<> object that delineates what part of the string matched the sub-expression to which the assertion was attached.

check() can be used with an ordinary predicate that takes a sub_match<> object as follows:

// A predicate that is true IFF a sub-match is
// either 3 or 6 characters long.
struct three_or_six
{
    bool operator()(ssub_match const &sub) const
    {
        return sub.length() == 3 || sub.length() == 6;
    }
};
// match words of 3 characters or 6 characters.
sregex rx = (bow >> +_w >> eow)[ check(three_or_six()) ] ;

Alternately, check() can be used to define inline custom assertions with the same syntax as is used to define semantic actions. The following code is equivalent to above:

// match words of 3 characters or 6 characters.

sregex rx = (bow >> +_w >> eow)[ check(length(_)==3 || length(_)==6) ] ;

Within a custom assertion, _ is a placeholder for the sub_match<> That delineates the part of the string matched by the sub-expression to which the custom assertion was attached.

Referenced by boost::python::converter::extract_object_manager< T >::check(), boost::intrusive::treap_impl< ValueTraits, VoidOrKeyComp, VoidOrPrioComp, SizeType, ConstantTimeSize, HeaderHolder >::check(), boost::intrusive::bstree_impl< ValueTraits, Compare, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder >::check(), boost::python::converter::object_manager_value_arg_from_python< T >::convertible(), boost::python::detail::downcast(), boost::python::downcast(), boost::python::detail::upcaster< false >::execute(), boost::iostreams::detail::bzip2_compressor_impl< Alloc >::filter(), boost::iostreams::detail::bzip2_decompressor_impl< Alloc >::filter(), boost::iostreams::detail::zlib_compressor_impl< Alloc >::filter(), boost::iostreams::detail::zlib_decompressor_impl< Alloc >::filter(), boost::iterators::forward_iterator_test(), boost::xpressive::detail::ignore_unused_regex_actions(), boost::polygon::insert_vertex_half_edge_45_pair_into_vector(), boost::python::converter::detail::object_manager_ref_check(), and boost::python::converter::detail::reject_raw_object_ptr().

proto::terminal<detail::posix_charset_placeholder>::type const boost::xpressive::cntrl = {{"cntrl", false}}

Matches a control character.

The regex traits are used to determine which characters are control characters. To match any character that is not a control character, use ~cntrl.

Attention: cntrl is equivalent to /[[:cntrl:]]/ in perl. ~cntrl is equivalent to /[[:^cntrl:]]/ in perl.

proto::terminal<detail::posix_charset_placeholder>::type const boost::xpressive::digit = {{"digit", false}}

Matches a digit character.

The regex traits are used to determine which characters are digits. To match any character that is not a digit, use ~digit.

Attention: digit is equivalent to /[[:digit:]]/ in perl. ~digit is equivalent to /[[:^digit:]]/ in perl.

proto::terminal<detail::assert_eol_placeholder>::type const boost::xpressive::eol = {{}}

End of line assertion.

'eol' matches the zero-width sub-sequence immediately preceeding a logical newline sequence. The regex traits is used to determine what constitutes a logical newline sequence.

proto::terminal<detail::assert_eos_matcher>::type const boost::xpressive::eos = {{}}

End of sequence assertion.

For the character sequence [begin, end), 'eos' matches the zero-width sub-sequence [end, end).

Attention: Unlike the perl end of sequence assertion $, 'eos' will not match at the position [end-1, end-1) if *(end-1) is '\n'. To get that behavior, use (!_n >> eos).

Referenced by boost::gregorian::operator>>().

proto::terminal<detail::assert_word_end>::type const boost::xpressive::eow = {{}}

End of word assertion.

'eow' matches the zero-width sub-sequence immediately following a word character and preceeding a non-word character. The regex traits are used to determine what constitutes a word character.

proto::terminal<detail::epsilon_matcher>::type const boost::xpressive::epsilon = {{}}

INTERNAL ONLY (for backwards compatibility)

function<op::first>::type const boost::xpressive::first = {{}}

first is a lazy PolymorphicFunctionObject for accessing the first element of a std::pair<> in an xpressive semantic action.

function<op::front>::type const boost::xpressive::front = {{}}

front is a lazy PolymorphicFunctionObject for fetching the front element of a sequence in an xpressive semantic action.

Referenced by boost::wave::util::VectorStringStorage< E, A >::append(), boost::lockfree::spsc_queue< T, A0, A1 >::front(), boost::xpressive::detail::ignore_unused_regex_actions(), boost::spirit::lex::lexertl::basic_iterator_tokeniser< Iterator >::next(), boost::accumulators::impl::rolling_moment_impl< N, Sample >::operator()(), boost::accumulators::impl::immediate_rolling_mean_impl< Sample >::operator()(), boost::graph::distributed::neighboring_tiles_force_pairs< PositionMap >::operator()(), boost::iostreams::detail::chain_base< Self, Ch, Tr, Alloc, Mode >::read(), boost::iostreams::detail::chain_base< Self, Ch, Tr, Alloc, Mode >::seek(), and boost::iostreams::detail::chain_base< Self, Ch, Tr, Alloc, Mode >::write().

proto::terminal<detail::posix_charset_placeholder>::type const boost::xpressive::graph = {{"graph", false}}

Matches a graph character.

The regex traits are used to determine which characters are graphable. To match any character that is not graphable, use ~graph.

Attention: graph is equivalent to /[[:graph:]]/ in perl. ~graph is equivalent to /[[:^graph:]]/ in perl.

unsigned int const boost::xpressive::inf = UINT_MAX-1

For infinite repetition of a sub-expression.

Magic value used with the repeat<>() function template to specify an unbounded repeat. Use as: repeat<17, inf>('a'). The equivalent in perl is /a{17,}/.

Referenced by boost::all_mean_geodesics(), boost::multiprecision::backends::cpp_dec_float< Digits10, ExponentType, Allocator >::calculate_inv(), boost::detail::dijkstra_no_color_map_dispatch2(), boost::multiprecision::backends::cpp_dec_float< Digits10, ExponentType, Allocator >::div_unsigned_long_long(), boost::floyd_warshall_all_pairs_shortest_paths(), boost::detail::floyd_warshall_init_dispatch(), boost::detail::floyd_warshall_noninit_dispatch(), boost::multi_index::detail::ordered_index< KeyFromValue, Compare, SuperMeta, TagList, Category >::insert_(), boost::multi_index::detail::ordered_index< KeyFromValue, Compare, SuperMeta, TagList, Category >::modify_(), boost::multi_index::detail::ordered_index< KeyFromValue, Compare, SuperMeta, TagList, Category >::modify_rollback_(), boost::multiprecision::backends::cpp_dec_float< Digits10, ExponentType, Allocator >::mul_unsigned_long_long(), boost::multiprecision::backends::cpp_dec_float< Digits10, ExponentType, Allocator >::operator*=(), boost::multiprecision::backends::cpp_dec_float< Digits10, ExponentType, Allocator >::operator+=(), boost::multiprecision::backends::cpp_dec_float< Digits10, ExponentType, Allocator >::operator=(), boost::multi_index::detail::ordered_index< KeyFromValue, Compare, SuperMeta, TagList, Category >::replace_(), boost::graph::distributed::delta_stepping_impl< Graph, PredecessorMap, DistanceMap, EdgeWeightMap >::run(), boost::graph::parallel::detail::betweenness_centrality_delta_stepping_impl< Graph, DistanceMap, IncomingMap, EdgeWeightMap, PathCountMap >::run(), and boost::transitive_closure().

function<op::insert>::type const boost::xpressive::insert = {{}}

insert is a lazy PolymorphicFunctionObject for inserting a value or a range of values into a sequence in an xpressive semantic action.

Referenced by boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::_add(), boost::wave::util::VectorStringStorage< E, A >::append(), boost::wave::util::flex_string< E, T, A, Storage >::append(), boost::xpressive::detail::ignore_unused_regex_actions(), boost::icl::map< DomainT, CodomainT, Traits, Compare, Combine, Section, Alloc >::insert(), boost::attribute_set::insert(), boost::ptr_multiset_adapter< Key, boost::unordered_multiset< void *, void_ptr_indirect_fun< Hash, Key >, void_ptr_indirect_fun< Pred, Key >, Allocator >, CloneAllocator, false >::insert(), boost::wave::util::flex_string< E, T, A, Storage >::insert(), boost::numeric::ublas::mapped_matrix< T, L, A >::insert_element(), boost::iterative_bit_vector_dominator_tree(), boost::algorithm::join(), boost::algorithm::join_if(), boost::numeric::ublas::mapped_matrix< T, L, A >::operator()(), boost::numeric::ublas::mapped_vector< T, A >::ref(), and boost::wave::util::VectorStringStorage< E, A >::VectorStringStorage().

function<op::length>::type const boost::xpressive::length = {{}}

length is a lazy PolymorphicFunctionObject for computing the length of a xpressive::sub_match<> in an xpressive semantic action.

Referenced by boost::xpressive::detail::ignore_unused_regex_actions().

detail::let_<proto::terminal<detail::let_tag>::type> const boost::xpressive::let = {{{}}}

For binding local variables to placeholders in semantic actions when constructing a regex_iterator or a regex_token_iterator.

Parameters

args	A set of argument bindings, where each argument binding is an assignment expression, the left hand side of which must be an instance of `placeholder<X>` for some `X`, and the right hand side is an lvalue of type `X`.

xpressive::let() serves the same purpose as match_results::let(); that is, it binds a placeholder to a local value. The purpose is to allow a regex with semantic actions to be defined that refers to objects that do not yet exist. Rather than referring directly to an object, a semantic action can refer to a placeholder, and the value of the placeholder can be specified later with a let expression. The let expression created with let() is passed to the constructor of either regex_iterator or regex_token_iterator.

See the section {user_s_guide.semantic_actions_and_user_defined_assertions.referring_to_non_local_variables, "Referring to Non-Local Variables"} in the Users' Guide for more discussion.

Example:

// Define a placeholder for a map object:
placeholder<std::map<std::string, int> > _map;
// Match a word and an integer, separated by =>,
// and then stuff the result into a std::map<>
sregex pair = ( (s1= +_w) >> "=>" >> (s2= +_d) )
    [ _map[s1] = as<int>(s2) ];
// The string to parse
std::string str("aaa=>1 bbb=>23 ccc=>456");
// Here is the actual map to fill in:
std::map<std::string, int> result;
// Create a regex_iterator to find all the matches
sregex_iterator it(str.begin(), str.end(), pair, let(_map=result));
sregex_iterator end;
// step through all the matches, and fill in
// the result map
while(it != end)
    ++it;
std::cout << result["aaa"] << '\n';
std::cout << result["bbb"] << '\n';
std::cout << result["ccc"] << '\n';

The above code displays:

1
23
456

Referenced by boost::xpressive::detail::ignore_unused_regex_actions().

proto::terminal<detail::posix_charset_placeholder>::type const boost::xpressive::lower = {{"lower", false}}

Matches a lower-case character.

The regex traits are used to determine which characters are lower-case. To match any character that is not a lower-case character, use ~lower.

Attention: lower is equivalent to /[[:lower:]]/ in perl. ~lower is equivalent to /[[:^lower:]]/ in perl.

function<op::make_pair>::type const boost::xpressive::make_pair = {{}}

make_pair is a lazy PolymorphicFunctionObject for making a std::pair<> in an xpressive semantic action.

function<op::matched>::type const boost::xpressive::matched = {{}}

matched is a lazy PolymorphicFunctionObject for accessing the matched member of a xpressive::sub_match<> in an xpressive semantic action.

Referenced by boost::re_detail::copy_results(), boost::xpressive::detail::ignore_unused_regex_actions(), boost::xpressive::match_results< BidiIter >::operator bool_type(), boost::logic::operator>>(), boost::spirit::x3::eol_parser::parse(), boost::spirit::qi::eol_parser::parse(), boost::spirit::lex::lexertl::position_token< Iterator, mpl::vector<>, HasState, Idtype >::value(), and boost::spirit::lex::lexertl::position_token< Iterator, mpl::vector0<>, HasState, Idtype >::value().

proto::terminal<detail::epsilon_matcher>::type const boost::xpressive::nil = {{}}

Successfully matches nothing.

Successfully matches a zero-width sequence. nil always succeeds and never consumes any characters.

function<op::pop>::type const boost::xpressive::pop = {{}}

pop is a lazy PolymorphicFunctionObject for popping the top element from a sequence in an xpressive semantic action.

Referenced by boost::wave::util::if_block_stack::exit_if_block(), boost::xpressive::detail::ignore_unused_regex_actions(), boost::heap::d_ary_heap< T, A0, A1, A2, A3, A4, A5 >::pop(), and boost::lockfree::spsc_queue< T, A0, A1 >::pop().

function<op::pop_back>::type const boost::xpressive::pop_back = {{}}

pop_back is a lazy PolymorphicFunctionObject for popping the back element from a sequence in an xpressive semantic action.

Referenced by boost::xpressive::detail::ignore_unused_regex_actions().

function<op::pop_front>::type const boost::xpressive::pop_front = {{}}

pop_front is a lazy PolymorphicFunctionObject for popping the front element from a sequence in an xpressive semantic action.

Referenced by boost::xpressive::detail::ignore_unused_regex_actions(), and boost::spirit::fixed_size_queue< T, N >::serve().

proto::terminal<detail::posix_charset_placeholder>::type const boost::xpressive::print = {{"print", false}}

Matches a printable character.

The regex traits are used to determine which characters are printable. To match any character that is not printable, use ~print.

Attention: print is equivalent to /[[:print:]]/ in perl. ~print is equivalent to /[[:^print:]]/ in perl.

proto::terminal<detail::posix_charset_placeholder>::type const boost::xpressive::punct = {{"punct", false}}

Matches a punctuation character.

The regex traits are used to determine which characters are punctuation. To match any character that is not punctuation, use ~punct.

Attention: punct is equivalent to /[[:punct:]]/ in perl. ~punct is equivalent to /[[:^punct:]]/ in perl.

function<op::push>::type const boost::xpressive::push = {{}}

push is a lazy PolymorphicFunctionObject for pushing a value into a container in an xpressive semantic action.

Referenced by boost::wave::util::if_block_stack::enter_if_block(), boost::xpressive::detail::ignore_unused_regex_actions(), boost::sync_queue< ValueType >::push(), boost::iostreams::pipeline< Pipeline, Component >::push(), boost::heap::skew_heap< T, A0, A1, A2, A3, A4, A5, A6 >::push(), boost::heap::d_ary_heap< T, A0, A1, A2, A3, A4, A5 >::push(), and boost::lockfree::spsc_queue< T, A0, A1 >::push().

function<op::push_back>::type const boost::xpressive::push_back = {{}}

push_back is a lazy PolymorphicFunctionObject for pushing a value into a container in an xpressive semantic action.

function<op::push_front>::type const boost::xpressive::push_front = {{}}

push_front is a lazy PolymorphicFunctionObject for pushing a value into a container in an xpressive semantic action.

Referenced by boost::xpressive::detail::ignore_unused_regex_actions(), boost::intrusive::sgtree_algorithms< NodeTraits >::push_front(), boost::intrusive::avltree_algorithms< NodeTraits >::push_front(), boost::intrusive::rbtree_algorithms< NodeTraits >::push_front(), boost::intrusive::splaytree_algorithms< NodeTraits >::push_front(), boost::intrusive::sgtree_impl< ValueTraits, Compare, SizeType, FloatingPoint, HeaderHolder >::push_front(), boost::intrusive::treap_impl< ValueTraits, VoidOrKeyComp, VoidOrPrioComp, SizeType, ConstantTimeSize, HeaderHolder >::push_front(), and boost::intrusive::bstree_impl< ValueTraits, Compare, SizeType, ConstantTimeSize, RbTreeAlgorithms, HeaderHolder >::push_front().

unsigned int const boost::xpressive::repeat_max = UINT_MAX-1

INTERNAL ONLY (for backwards compatibility)

boost::xpressive::mark_tag::proto_base_expr const boost::xpressive::s0 = {{ 0 }}

Sub-match placeholder, like $& in Perl.

Referenced by boost::math::detail::beta_small_b_large_a_series(), boost::random::linear_feedback_shift_engine< UIntType, w, k, q, s >::BOOST_RANDOM_DETAIL_ARITHMETIC_CONSTRUCTOR(), boost::random::linear_feedback_shift_engine< UIntType, w, k, q, s >::BOOST_RANDOM_DETAIL_ARITHMETIC_SEED(), boost::math::detail::ibeta_series(), and boost::xpressive::detail::ignore_unused_regex_primitives().

boost::xpressive::mark_tag::proto_base_expr const boost::xpressive::s1 = {{ 1 }}

Sub-match placeholder, like $1 in perl.

To create a sub-match, assign a sub-expression to the sub-match placeholder. For instance, (s1= _) will match any one character and remember which character was matched in the 1st sub-match. Later in the pattern, you can refer back to the sub-match. For instance, (s1= _) >> s1 will match any character, and then match the same character again.

After a successful regex_match() or regex_search(), the sub-match placeholders can be used to index into the match_results<> object to retrieve the Nth sub-match.

boost::xpressive::mark_tag::proto_base_expr const boost::xpressive::s2 = {{ 2 }}

boost::xpressive::mark_tag::proto_base_expr const boost::xpressive::s3 = {{ 3 }}

Referenced by boost::re_detail::basic_regex_creator< charT, traits >::append_set(), boost::RegexTraitsConcept< traits >::constraints(), boost::xpressive::detail::ignore_unused_regex_primitives(), boost::math::kurtosis(), and boost::math::skewness().

boost::xpressive::mark_tag::proto_base_expr const boost::xpressive::s4 = {{ 4 }}

Referenced by boost::xpressive::detail::ignore_unused_regex_primitives(), and boost::math::kurtosis().

boost::xpressive::mark_tag::proto_base_expr const boost::xpressive::s5 = {{ 5 }}

Referenced by boost::xpressive::detail::ignore_unused_regex_primitives().

boost::xpressive::mark_tag::proto_base_expr const boost::xpressive::s6 = {{ 6 }}

Referenced by boost::xpressive::detail::ignore_unused_regex_primitives().

boost::xpressive::mark_tag::proto_base_expr const boost::xpressive::s7 = {{ 7 }}

Referenced by boost::xpressive::detail::ignore_unused_regex_primitives().

boost::xpressive::mark_tag::proto_base_expr const boost::xpressive::s8 = {{ 8 }}

Referenced by boost::xpressive::detail::ignore_unused_regex_primitives().

boost::xpressive::mark_tag::proto_base_expr const boost::xpressive::s9 = {{ 9 }}

Referenced by boost::xpressive::detail::ignore_unused_regex_primitives().

function<op::second>::type const boost::xpressive::second = {{}}

second is a lazy PolymorphicFunctionObject for accessing the second element of a std::pair<> in an xpressive semantic action.

Referenced by boost::xpressive::detail::ignore_unused_regex_actions(), boost::xpressive::sub_match< BidiIter >::length(), boost::xpressive::sub_match< BidiIter >::operator string_type(), and boost::xpressive::sub_match< BidiIter >::str().

proto::terminal<detail::self_placeholder>::type const boost::xpressive::self = {{}}

Reference to the current regex object.

Useful when constructing recursive regular expression objects. The 'self' identifier is a short-hand for the current regex object. For instance, sregex rx = '(' >> (self | nil) >> ')'; will create a regex object that matches balanced parens such as "((()))".

detail::set_initializer_type const boost::xpressive::set = {{}}

Used to create character sets.

There are two ways to create character sets with the 'set' identifier. The easiest is to create a comma-separated list of the characters in the set, as in (set= 'a','b','c'). This set will match 'a', 'b', or 'c'. The other way is to define the set as an argument to the set subscript operator. For instance, set[ 'a' | range('b','c') | digit ] will match an 'a', 'b', 'c' or a digit character.

To complement a set, apply the '~' operator. For instance, ~(set= 'a','b','c') will match any character that is not an 'a', 'b', or 'c'.

Sets can be composed of other, possibly complemented, sets. For instance, set[ ~digit | ~(set= 'a','b','c') ].

Referenced by boost::polygon::assign(), boost::numeric::interval< T, Policies >::assign(), boost::serialization::load(), boost::numeric::interval< T, Policies >::operator+=(), boost::numeric::interval< T, Policies >::operator-=(), boost::python::api::proxy< Policies >::operator=(), boost::dynamic_bitset< Block, Allocator >::push_back(), boost::iostreams::detail::conversion_buffer< Codecvt, Alloc >::reset(), and boost::dynamic_bitset< Block, Allocator >::test_set().

proto::terminal<detail::posix_charset_placeholder>::type const boost::xpressive::space = {{"space", false}}

Matches a space character.

The regex traits are used to determine which characters are space characters. To match any character that is not white-space, use ~space.

Attention: space is equivalent to /[[:space:]]/ in perl. ~space is equivalent to /[[:^space:]]/ in perl.

function<op::str>::type const boost::xpressive::str = {{}}

str is a lazy PolymorphicFunctionObject for converting a xpressive::sub_match<> to a std::basic_string<> in an xpressive semantic action.

Referenced by boost::xpressive::detail::ignore_unused_regex_actions(), regex_replace(), and boost::xpressive::cpp_regex_traits< Char >::value().

function<op::top>::type const boost::xpressive::top = {{}}

top is a lazy PolymorphicFunctionObject for accessing the top element from a stack in an xpressive semantic action.

Referenced by boost::wave::util::if_block_stack::enter_elif_block(), boost::wave::util::if_block_stack::enter_else_block(), boost::wave::util::if_block_stack::get_enclosing_status(), boost::wave::util::if_block_stack::get_some_part_status(), boost::wave::util::if_block_stack::get_status(), boost::xpressive::detail::ignore_unused_regex_actions(), boost::wave::util::if_block_stack::is_inside_elsepart(), boost::wave::util::if_block_stack::is_inside_ifpart(), boost::wave::context< IteratorT, LexIteratorT, InputPolicyT, HooksT, DerivedT >::pop_iteration_context(), and boost::heap::d_ary_heap< T, A0, A1, A2, A3, A4, A5 >::top().

function<op::unwrap_reference>::type const boost::xpressive::unwrap_reference = {{}}

unwrap_reference is a lazy PolymorphicFunctionObject for unwrapping a boost::reference_wrapper<> in an xpressive semantic action.

Referenced by boost::xpressive::detail::ignore_unused_regex_actions().

proto::terminal<detail::posix_charset_placeholder>::type const boost::xpressive::upper = {{"upper", false}}

Matches an upper-case character.

The regex traits are used to determine which characters are upper-case. To match any character that is not upper-case, use ~upper.

Attention: upper is equivalent to /[[:upper:]]/ in perl. ~upper is equivalent to /[[:^upper:]]/ in perl.

proto::terminal<detail::posix_charset_placeholder>::type const boost::xpressive::xdigit = {{"xdigit", false}}

Matches a hexadecimal digit character.

The regex traits are used to determine which characters are hex digits. To match any character that is not a hex digit, use ~xdigit.

Attention: xdigit is equivalent to /[[:xdigit:]]/ in perl. ~xdigit is equivalent to /[[:^xdigit:]]/ in perl.

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

Function Documentation

Variable Documentation