| Home | Libraries | People | FAQ | More

### Header <boost/xpressive/regex_primitives.hpp>

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, Expr const & >::type const
          optional(Expr const &);
        template<unsigned int Min, unsigned int Max, typename Expr>
          unspecified repeat(Expr const &);

        // This is an overloaded member function, provided for convenience. It differs from the above function only in what argument(s) it accepts.
        template<unsigned int Count, typename Expr2>
          unspecified repeat(Expr2 const & expr2);
        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 &);
      }
    }