Boost C++ Libraries Home Libraries People FAQ More

PrevUpHomeNext

Struct template basic_regex

boost::xpressive::basic_regex — Class template basic_regex<> is a class for holding a compiled regular expression.

Synopsis

// In header: <boost/xpressive/basic_regex.hpp>

template<typename BidiIter> 
struct basic_regex {
  // types
  typedef                             ;
  typedef     ;    
  typedef     ;   
  typedef                          ;  
  typedef  ;    

  // construct/copy/destruct
  ();
  (basic_regex< );
  template<typename Expr> ();
  basic_regex<  (basic_regex< );
  template<typename Expr> basic_regex<  ();

  // public member functions
   () ;
   () ;
   (basic_regex< );

  // public static functions
  template<typename InputIter> 
    basic_regex<  
    (, ,  = );
  template<typename InputRange> 
    basic_regex<  
    (,  = );
  basic_regex<  
  (,  = );
  basic_regex<  
  (, , );

  // public data members
  static  ECMAScript;
  static  icase;
  static  nosubs;
  static  optimize;
  static  collate;
  static  single_line;
  static  not_dot_null;
  static  not_dot_newline;
  static  ignore_white_space;
};

Description

basic_regex public construct/copy/destruct

  1. ();

    Postconditions:

    regex_id() == 0

    Postconditions:

    mark_count() == 0

  2. (basic_regex<  that);

    Parameters:

    that

    The basic_regex object to copy.

    Postconditions:

    regex_id() == that.regex_id()

    Postconditions:

    mark_count() == that.mark_count()

  3. template<typename Expr> ( expr);

    Construct from a static regular expression.

    Parameters:

    expr

    The static regular expression

    Requires:

    Expr is the type of a static regular expression.

    Postconditions:

    regex_id() != 0

    Postconditions:

    mark_count() >= 0

  4. basic_regex<  (basic_regex<  that);

    Parameters:

    that

    The basic_regex object to copy.

    Postconditions:

    regex_id() == that.regex_id()

    Postconditions:

    mark_count() == that.mark_count()

    Returns:

    *this

  5. template<typename Expr> basic_regex<  ( expr);

    Construct from a static regular expression.

    Parameters:

    expr

    The static regular expression.

    Requires:

    Expr is the type of a static regular expression.

    Postconditions:

    regex_id() != 0

    Postconditions:

    mark_count() >= 0

    Returns:

    *this

    Throws:

    std::bad_alloc on out of memory

basic_regex public member functions

  1.  () ;

    Returns the count of capturing sub-expressions in this regular expression

  2.  () ;

    Returns a token which uniquely identifies this regular expression.

  3.  (basic_regex<  that);

    Swaps the contents of this basic_regex object with another.

    [Note] Note

    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.

    Parameters:

    that

    The other basic_regex object.

    Throws:

    Will not throw.

basic_regex public static functions

  1. template<typename InputIter> 
      basic_regex<  
      ( begin,  end,  flags = );

    Factory method for building a regex object from a range of characters. Equivalent to regex_compiler< BidiIter >().compile(begin, end, flags);

    Parameters:

    begin

    The beginning of a range of characters representing the regular expression to compile.

    end

    The end of a range of characters representing the regular expression to compile.

    flags

    Optional bitmask that determines how the pat string is interpreted. (See syntax_option_type.)

    Requires:

    [begin,end) is a valid range.

    Requires:

    The range of characters specified by [begin,end) contains a valid string-based representation of a regular expression.

    Returns:

    A basic_regex object corresponding to the regular expression represented by the character range.

    Throws:

    regex_error when the range of characters has invalid regular expression syntax.
  2. template<typename InputRange> 
      basic_regex<  
      ( pat,  flags = );

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

  3. basic_regex<  
    ( begin,  flags = );

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

  4. basic_regex<  
    ( begin,  len,  flags);

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


PrevUpHomeNext