Contains the definition of the basic_regex<> class template and its associated helper functions.

namespace boost {
  namespace xpressive {
    template<typename BidiIter> struct basic_regex;
    template<typename BidiIter> 
      void swap(basic_regex< BidiIter > &, basic_regex< BidiIter > &);
  }
}

Contains the definition of the match_results type and associated helpers. The match_results type holds the results of a regex_match() or regex_search() operation.

namespace boost {
  namespace xpressive {
    template<typename BidiIter> struct match_results;
    template<typename BidiIter> struct regex_id_filter_predicate;
  }
}

Defines the syntax elements of xpressive's action expressions.

namespace boost {
  namespace xpressive {
    template<typename PolymorphicFunctionObject> struct function;
    template<typename T> struct local;
    template<typename T, int I = 0> struct placeholder;
    template<typename T> struct reference;
    template<typename T> struct value;

    function< op::at >::type const at;    // at is a lazy PolymorphicFunctionObject for indexing into a sequence in an xpressive semantic action. 
    function< op::push >::type const push;    // push is a lazy PolymorphicFunctionObject for pushing a value into a container in an xpressive semantic action. 
    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. 
    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. 
    function< op::pop >::type const pop;    // pop is a lazy PolymorphicFunctionObject for popping the top element from a sequence in an xpressive semantic action. 
    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. 
    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. 
    function< op::top >::type const top;    // top is a lazy PolymorphicFunctionObject for accessing the top element from a stack in an xpressive semantic action. 
    function< op::back >::type const back;    // back is a lazy PolymorphicFunctionObject for fetching the back element of a sequence in an xpressive semantic action. 
    function< op::front >::type const front;    // front is a lazy PolymorphicFunctionObject for fetching the front element of a sequence in an xpressive semantic action. 
    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. 
    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. 
    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. 
    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. 
    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. 
    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. 
    function< op::make_pair >::type const make_pair;    // make_pair is a lazy PolymorphicFunctionObject for making a std::pair<> in an xpressive semantic action. 
    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. 
    template<typename T, typename A> unspecified as(A const &);
    template<typename T, typename A> unspecified static_cast_(A const &);
    template<typename T, typename A> unspecified dynamic_cast_(A const &);
    template<typename T, typename A> unspecified const_cast_(A const &);
    template<typename T> value< T > const val(T const &);
    template<typename T> reference< T > const ref(T &);
    template<typename T> reference< T const > const cref(T const &);
    template<typename T> unspecified check(T const &);
    template<typename... ArgBindings> unspecified let(ArgBindings const &...);
    template<typename T, typename ... Args> 
      unspecified construct(Args const &...);
    namespace op {
      template<typename T> struct as;
      struct at;
      struct back;
      template<typename T> struct const_cast_;
      template<typename T> struct construct;
      template<typename T> struct dynamic_cast_;
      struct first;
      struct front;
      struct insert;
      struct length;
      struct make_pair;
      struct matched;
      struct pop;
      struct pop_back;
      struct pop_front;
      struct push;
      struct push_back;
      struct push_front;
      struct second;
      template<typename T> struct static_cast_;
      struct str;
      template<typename Except> struct throw_;
      struct top;
      struct unwrap_reference;
    }
  }
}

Contains the regex_match(), regex_search() and regex_replace() algorithms.

namespace boost {
  namespace xpressive {
    template<typename BidiIter> 
      bool regex_match(BidiIter, BidiIter, match_results< BidiIter > &, 
                       basic_regex< BidiIter > const &, 
                       regex_constants::match_flag_type = regex_constants::match_default);
    template<typename BidiIter> 
      bool regex_match(BidiIter, BidiIter, basic_regex< BidiIter > const &, 
                       regex_constants::match_flag_type = regex_constants::match_default);
    template<typename Char> 
      bool regex_match(Char *, match_results< Char * > &, 
                       basic_regex< Char * > const &, 
                       regex_constants::match_flag_type = regex_constants::match_default);
    template<typename BidiRange, typename BidiIter> 
      bool regex_match(BidiRange &, match_results< BidiIter > &, 
                       basic_regex< BidiIter > const &, 
                       regex_constants::match_flag_type = regex_constants::match_default, 
                       unspecified = 0);
    template<typename BidiRange, typename BidiIter> 
      bool regex_match(BidiRange const &, match_results< BidiIter > &, 
                       basic_regex< BidiIter > const &, 
                       regex_constants::match_flag_type = regex_constants::match_default, 
                       unspecified = 0);
    template<typename Char> 
      bool regex_match(Char *, basic_regex< Char * > const &, 
                       regex_constants::match_flag_type = regex_constants::match_default);
    template<typename BidiRange, typename BidiIter> 
      bool regex_match(BidiRange &, basic_regex< BidiIter > const &, 
                       regex_constants::match_flag_type = regex_constants::match_default, 
                       unspecified = 0);
    template<typename BidiRange, typename BidiIter> 
      bool regex_match(BidiRange const &, basic_regex< BidiIter > const &, 
                       regex_constants::match_flag_type = regex_constants::match_default, 
                       unspecified = 0);
    template<typename BidiIter> 
      bool regex_search(BidiIter, BidiIter, match_results< BidiIter > &, 
                        basic_regex< BidiIter > const &, 
                        regex_constants::match_flag_type = regex_constants::match_default);
    template<typename BidiIter> 
      bool regex_search(BidiIter, BidiIter, basic_regex< BidiIter > const &, 
                        regex_constants::match_flag_type = regex_constants::match_default);
    template<typename Char> 
      bool regex_search(Char *, match_results< Char * > &, 
                        basic_regex< Char * > const &, 
                        regex_constants::match_flag_type = regex_constants::match_default);
    template<typename BidiRange, typename BidiIter> 
      bool regex_search(BidiRange &, match_results< BidiIter > &, 
                        basic_regex< BidiIter > const &, 
                        regex_constants::match_flag_type = regex_constants::match_default, 
                        unspecified = 0);
    template<typename BidiRange, typename BidiIter> 
      bool regex_search(BidiRange const &, match_results< BidiIter > &, 
                        basic_regex< BidiIter > const &, 
                        regex_constants::match_flag_type = regex_constants::match_default, 
                        unspecified = 0);
    template<typename Char> 
      bool regex_search(Char *, basic_regex< Char * > const &, 
                        regex_constants::match_flag_type = regex_constants::match_default);
    template<typename BidiRange, typename BidiIter> 
      bool regex_search(BidiRange &, basic_regex< BidiIter > const &, 
                        regex_constants::match_flag_type = regex_constants::match_default, 
                        unspecified = 0);
    template<typename BidiRange, typename BidiIter> 
      bool regex_search(BidiRange const &, basic_regex< BidiIter > const &, 
                        regex_constants::match_flag_type = regex_constants::match_default, 
                        unspecified = 0);
    template<typename OutIter, typename BidiIter, typename Formatter> 
      OutIter regex_replace(OutIter, BidiIter, BidiIter, 
                            basic_regex< BidiIter > const &, 
                            Formatter const &, 
                            regex_constants::match_flag_type = regex_constants::match_default, 
                            unspecified = 0);
    template<typename OutIter, typename BidiIter> 
      OutIter regex_replace(OutIter, BidiIter, BidiIter, 
                            basic_regex< BidiIter > const &, 
                            typename iterator_value< BidiIter >::type const *, 
                            regex_constants::match_flag_type = regex_constants::match_default);
    template<typename BidiContainer, typename BidiIter, typename Formatter> 
      BidiContainer 
      regex_replace(BidiContainer &, basic_regex< BidiIter > const &, 
                    Formatter const &, 
                    regex_constants::match_flag_type = regex_constants::match_default, 
                    unspecified = 0);
    template<typename BidiContainer, typename BidiIter, typename Formatter> 
      BidiContainer 
      regex_replace(BidiContainer const &, basic_regex< BidiIter > const &, 
                    Formatter const &, 
                    regex_constants::match_flag_type = regex_constants::match_default, 
                    unspecified = 0);
    template<typename Char, typename Formatter> 
      std::basic_string< typename remove_const< Char >::type > 
      regex_replace(Char *, basic_regex< Char * > const &, Formatter const &, 
                    regex_constants::match_flag_type = regex_constants::match_default, 
                    unspecified = 0);
    template<typename BidiContainer, typename BidiIter> 
      BidiContainer 
      regex_replace(BidiContainer &, basic_regex< BidiIter > const &, 
                    typename iterator_value< BidiIter >::type const *, 
                    regex_constants::match_flag_type = regex_constants::match_default, 
                    unspecified = 0);
    template<typename BidiContainer, typename BidiIter> 
      BidiContainer 
      regex_replace(BidiContainer const &, basic_regex< BidiIter > const &, 
                    typename iterator_value< BidiIter >::type const *, 
                    regex_constants::match_flag_type = regex_constants::match_default, 
                    unspecified = 0);
    template<typename Char> 
      std::basic_string< typename remove_const< Char >::type > 
      regex_replace(Char *, basic_regex< Char * > const &, 
                    typename add_const< Char >::type *, 
                    regex_constants::match_flag_type = regex_constants::match_default);
  }
}

Contains the definition of regex_compiler, a factory for building regex objects from strings.

namespace boost {
  namespace xpressive {
    template<typename BidiIter, typename RegexTraits, typename CompilerTraits> 
      struct regex_compiler;
  }
}

Contains definitions for the syntax_option_type, match_flag_type and error_type enumerations.

namespace boost {
  namespace xpressive {
    namespace regex_constants {
      enum syntax_option_type;
      enum match_flag_type;
      enum error_type;
    }
  }
}

Contains the definition of the regex_error exception class.

BOOST_XPR_ENSURE_(pred, code, msg)

namespace boost {
  namespace xpressive {
    struct regex_error;
  }
}

Contains the definition of the regex_iterator type, an STL-compatible iterator for stepping through all the matches in a sequence.

namespace boost {
  namespace xpressive {
    template<typename BidiIter> struct regex_iterator;
  }
}

Contains the syntax elements for writing static regular expressions.

namespace boost {
  namespace xpressive {
    struct mark_tag;

    unsigned int const inf;    // For infinite repetition of a sub-expression. 
    unspecified nil;    // Successfully matches nothing. 
    unspecified alnum;    // Matches an alpha-numeric character. 
    unspecified alpha;    // Matches an alphabetic character. 
    unspecified blank;    // Matches a blank (horizonal white-space) character. 
    unspecified cntrl;    // Matches a control character. 
    unspecified digit;    // Matches a digit character. 
    unspecified graph;    // Matches a graph character. 
    unspecified lower;    // Matches a lower-case character. 
    unspecified print;    // Matches a printable character. 
    unspecified punct;    // Matches a punctuation character. 
    unspecified space;    // Matches a space character. 
    unspecified upper;    // Matches an upper-case character. 
    unspecified xdigit;    // Matches a hexadecimal digit character. 
    unspecified bos;    // Beginning of sequence assertion. 
    unspecified eos;    // End of sequence assertion. 
    unspecified bol;    // Beginning of line assertion. 
    unspecified eol;    // End of line assertion. 
    unspecified bow;    // Beginning of word assertion. 
    unspecified eow;    // End of word assertion. 
    unspecified _b;    // Word boundary assertion. 
    unspecified _w;    // Matches a word character. 
    unspecified _d;    // Matches a digit character. 
    unspecified _s;    // Matches a space character. 
    proto::terminal< char >::type const _n;    // Matches a literal newline character, '\n'. 
    unspecified _ln;    // Matches a logical newline sequence. 
    unspecified _;    // Matches any one character. 
    unspecified self;    // Reference to the current regex object. 
    unspecified set;    // Used to create character sets. 
    mark_tag const s0;    // Sub-match placeholder, like $& in Perl. 
    mark_tag const s1;    // Sub-match placeholder, like $1 in perl. 
    mark_tag const s2;
    mark_tag const s3;
    mark_tag const s4;
    mark_tag const s5;
    mark_tag const s6;
    mark_tag const s7;
    mark_tag const s8;
    mark_tag const s9;
    unspecified a1;
    unspecified a2;
    unspecified a3;
    unspecified a4;
    unspecified a5;
    unspecified a6;
    unspecified a7;
    unspecified a8;
    unspecified a9;
    template<typename Expr> unspecified icase(Expr const &);
    template<typename Literal> unspecified as_xpr(Literal const &);
    template<typename BidiIter> 
      proto::terminal< reference_wrapper< basic_regex< BidiIter >const > >::type const 
      by_ref(basic_regex< BidiIter > const &);
    template<typename Char> unspecified range(Char, Char);
    template<typename Expr> 
      proto::result_of::make_expr< proto::tag::logical_not, proto::default_domain, Exprconst & >::type const 
      optional(Expr const &);
    template<unsigned int Min, unsigned int Max, typename Expr> 
      unspecified repeat(Expr const &);
    template<unsigned int Count, typename Expr2> 
      unspecified repeat(Expr2 const &);
    template<typename Expr> unspecified keep(Expr const &);
    template<typename Expr> unspecified before(Expr const &);
    template<typename Expr> unspecified after(Expr const &);
    template<typename Locale> unspecified imbue(Locale const &);
    template<typename Skip> unspecified skip(Skip const &);
  }
}

Contains the definition of regex_token_iterator, and STL-compatible iterator for tokenizing a string using a regular expression.

namespace boost {
  namespace xpressive {
    template<typename BidiIter> struct regex_token_iterator;
  }
}

Includes the C regex traits or the CPP regex traits header file depending on the BOOST_XPRESSIVE_USE_C_TRAITS macro.

namespace boost {
  namespace xpressive {
    template<typename Traits> struct has_fold_case;
    template<typename Char, typename Impl> struct regex_traits;
    struct regex_traits_version_1_tag;
    struct regex_traits_version_2_tag;
  }
}

Contains the definition of the class template sub_match<> and associated helper functions

namespace boost {
  namespace xpressive {
    template<typename BidiIter> struct sub_match;
    template<typename BidiIter> BidiIter range_begin(sub_match< BidiIter > &);
    template<typename BidiIter> 
      BidiIter range_begin(sub_match< BidiIter > const &);
    template<typename BidiIter> BidiIter range_end(sub_match< BidiIter > &);
    template<typename BidiIter> 
      BidiIter range_end(sub_match< BidiIter > const &);
    template<typename BidiIter, typename Char, typename Traits> 
      std::basic_ostream< Char, Traits > & 
      operator<<(std::basic_ostream< Char, Traits > &, 
                 sub_match< BidiIter > const &);
    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);
  }
}

Contains the definition of the c_regex_traits<> template, which is a wrapper for the C locale functions that can be used to customize the behavior of static and dynamic regexes.

namespace boost {
  namespace xpressive {
    template<typename Char> struct c_regex_traits;

    template<> struct has_fold_case<c_regex_traits< char >>;
  }
}

Contains the definition of the cpp_regex_traits<> template, which is a wrapper for std::locale that can be used to customize the behavior of static and dynamic regexes.

namespace boost {
  namespace xpressive {
    template<typename Char> struct cpp_regex_traits;

    template<> struct has_fold_case<cpp_regex_traits< char >>;
  }
}

Contains the definition of the null_regex_traits<> template, which is a stub regex traits implementation that can be used by static and dynamic regexes for searching non-character data.

namespace boost {
  namespace xpressive {
    template<typename Elem> struct null_regex_traits;
  }
}

Includes all of xpressive including support for both static and dynamic regular expressions.

Includes everything you need to write and use dynamic regular expressions.

Forward declarations for all of xpressive's public data types.

BOOST_XPRESSIVE_HAS_MS_STACK_GUARD

namespace boost {
  namespace xpressive {
    template<typename RegexTraits> struct compiler_traits;

    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;
    namespace op {
    }
  }
}

Includes everything you need to write static regular expressions and use them.

Type registrations so that xpressive can be used with the Boost.Typeof library.