Boost C++ Libraries Home Libraries People FAQ More

PrevUpHomeNext

Reference

Header <boost/xpressive/basic_regex.hpp>
Header <boost/xpressive/match_results.hpp>
Header <boost/xpressive/regex_actions.hpp>
Header <boost/xpressive/regex_algorithms.hpp>
Header <boost/xpressive/regex_compiler.hpp>
Header <boost/xpressive/regex_constants.hpp>
Header <boost/xpressive/regex_error.hpp>
Header <boost/xpressive/regex_iterator.hpp>
Header <boost/xpressive/regex_primitives.hpp>
Header <boost/xpressive/regex_token_iterator.hpp>
Header <boost/xpressive/regex_traits.hpp>
Header <boost/xpressive/sub_match.hpp>
Header <boost/xpressive/traits/c_regex_traits.hpp>
Header <boost/xpressive/traits/cpp_regex_traits.hpp>
Header <boost/xpressive/traits/null_regex_traits.hpp>
Header <boost/xpressive/xpressive.hpp>
Header <boost/xpressive/xpressive_dynamic.hpp>
Header <boost/xpressive/xpressive_fwd.hpp>
Header <boost/xpressive/xpressive_static.hpp>
Header <boost/xpressive/xpressive_typeof.hpp>

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


  
    template<typename BidiIter> struct basic_regex;
    template<typename BidiIter> 
       (basic_regex< , basic_regex< );
  }
}

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.


  
    template<typename BidiIter> struct match_results;
    template<typename BidiIter> struct regex_id_filter_predicate;
  }
}

Defines the syntax elements of xpressive's action expressions.


  
    template<typename PolymorphicFunctionObject> struct function;
    template<typename T> struct local;
    template<typename T,  I = > struct placeholder;
    template<typename T> struct reference;
    template<typename T> struct value;

    function< op::at >:: at;    // at is a lazy PolymorphicFunctionObject for indexing into a sequence in an xpressive semantic action. 
    function< op::push >:: push;    // push is a lazy PolymorphicFunctionObject for pushing a value into a container in an xpressive semantic action. 
    function< op::push_back >:: push_back;    // push_back is a lazy PolymorphicFunctionObject for pushing a value into a container in an xpressive semantic action. 
    function< op::push_front >:: push_front;    // push_front is a lazy PolymorphicFunctionObject for pushing a value into a container in an xpressive semantic action. 
    function< op::pop >:: pop;    // pop is a lazy PolymorphicFunctionObject for popping the top element from a sequence in an xpressive semantic action. 
    function< op::pop_back >:: 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 >:: pop_front;    // pop_front is a lazy PolymorphicFunctionObject for popping the front element from a sequence in an xpressive semantic action. 
    function< op::top >:: top;    // top is a lazy PolymorphicFunctionObject for accessing the top element from a stack in an xpressive semantic action. 
    function< op::back >:: back;    // back is a lazy PolymorphicFunctionObject for fetching the back element of a sequence in an xpressive semantic action. 
    function< op::front >:: front;    // front is a lazy PolymorphicFunctionObject for fetching the front element of a sequence in an xpressive semantic action. 
    function< op::first >:: first;    // first is a lazy PolymorphicFunctionObject for accessing the first element of a std::pair<> in an xpressive semantic action. 
    function< op::second >:: second;    // second is a lazy PolymorphicFunctionObject for accessing the second element of a std::pair<> in an xpressive semantic action. 
    function< op::matched >:: matched;    // matched is a lazy PolymorphicFunctionObject for accessing the matched member of a xpressive::sub_match<> in an xpressive semantic action. 
    function< op::length >:: length;    // length is a lazy PolymorphicFunctionObject for computing the length of a xpressive::sub_match<> in an xpressive semantic action. 
    function< op::str >:: 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 >:: 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 >:: make_pair;    // make_pair is a lazy PolymorphicFunctionObject for making a std::pair<> in an xpressive semantic action. 
    function< op::unwrap_reference >:: unwrap_reference;    // unwrap_reference is a lazy PolymorphicFunctionObject for unwrapping a boost::reference_wrapper<> in an xpressive semantic action. 
    template<typename T, typename A>  ();
    template<typename T, typename A>  ();
    template<typename T, typename A>  ();
    template<typename T, typename A>  ();
    template<typename T> value<  ();
    template<typename T> reference<  ();
    template<typename T> reference<  ();
    template<typename T>  ();
    template< ArgBindings>  ();
    template<typename T,  Args> 
       ();
    
      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.


  
    template<typename BidiIter> 
       (, , match_results< , 
                       basic_regex< , 
                        = );
    template<typename BidiIter> 
       (, , basic_regex< , 
                        = );
    template<typename Char> 
       (, match_results< , 
                       basic_regex< , 
                        = );
    template<typename BidiRange, typename BidiIter> 
       (, match_results< , 
                       basic_regex< , 
                        = ,  = );
    template<typename BidiRange, typename BidiIter> 
       (, match_results< , 
                       basic_regex< , 
                        = ,  = );
    template<typename Char> 
       (, basic_regex< , 
                        = );
    template<typename BidiRange, typename BidiIter> 
       (, basic_regex< , 
                        = ,  = );
    template<typename BidiRange, typename BidiIter> 
       (, basic_regex< , 
                        = ,  = );
    template<typename BidiIter> 
       (, , match_results< , 
                        basic_regex< , 
                         = );
    template<typename BidiIter> 
       (, , basic_regex< , 
                         = );
    template<typename Char> 
       (, match_results< , 
                        basic_regex< , 
                         = );
    template<typename BidiRange, typename BidiIter> 
       (, match_results< , 
                        basic_regex< , 
                         = ,  = );
    template<typename BidiRange, typename BidiIter> 
       (, match_results< , 
                        basic_regex< , 
                         = ,  = );
    template<typename Char> 
       (, basic_regex< , 
                         = );
    template<typename BidiRange, typename BidiIter> 
       (, basic_regex< , 
                         = ,  = );
    template<typename BidiRange, typename BidiIter> 
       (, basic_regex< , 
                         = ,  = );
    template<typename OutIter, typename BidiIter, typename Formatter> 
       (, , , 
                            basic_regex< , 
                            , 
                             = , 
                             = );
    template<typename OutIter, typename BidiIter> 
       (, , , 
                            basic_regex< , 
                            , 
                             = );
    template<typename BidiContainer, typename BidiIter, typename Formatter> 
       
      (, basic_regex< , 
                    ,  = , 
                     = );
    template<typename BidiContainer, typename BidiIter, typename Formatter> 
       
      (, basic_regex< , 
                    ,  = , 
                     = );
    template<typename Char, typename Formatter> 
       
      (, basic_regex< , , 
                     = ,  = );
    template<typename BidiContainer, typename BidiIter> 
       
      (, basic_regex< , 
                    , 
                     = ,  = );
    template<typename BidiContainer, typename BidiIter> 
       
      (, basic_regex< , 
                    , 
                     = ,  = );
    template<typename Char> 
       
      (, basic_regex< , 
                    , 
                     = );
  }
}

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


  
    template<typename BidiIter, typename RegexTraits, typename CompilerTraits> 
      struct regex_compiler;
  }
}

Contains definitions for the syntax_option_type, match_flag_type and error_type enumerations.


  
    
      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)

  
    struct regex_error;
  }
}

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


  
    template<typename BidiIter> struct regex_iterator;
  }
}

Contains the syntax elements for writing static regular expressions.


  
    struct mark_tag;

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

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


  
    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.


  
    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


  
    template<typename BidiIter> struct sub_match;
    template<typename BidiIter>  (sub_match< );
    template<typename BidiIter> 
       (sub_match< );
    template<typename BidiIter>  (sub_match< );
    template<typename BidiIter> 
       (sub_match< );
    template<typename BidiIter, typename Char, typename Traits> 
       
      (, 
                 sub_match< );
    template<typename BidiIter> 
       (sub_match<  lhs, 
                      sub_match<  rhs);
    template<typename BidiIter> 
       (sub_match<  lhs, 
                      sub_match<  rhs);
    template<typename BidiIter> 
       (sub_match<  lhs, 
                     sub_match<  rhs);
    template<typename BidiIter> 
       (sub_match<  lhs, 
                      sub_match<  rhs);
    template<typename BidiIter> 
       (sub_match<  lhs, 
                      sub_match<  rhs);
    template<typename BidiIter> 
       (sub_match<  lhs, 
                     sub_match<  rhs);
    template<typename BidiIter> 
       ( lhs, 
                      sub_match<  rhs);
    template<typename BidiIter> 
       ( lhs, 
                      sub_match<  rhs);
    template<typename BidiIter> 
       ( lhs, 
                     sub_match<  rhs);
    template<typename BidiIter> 
       ( lhs, 
                     sub_match<  rhs);
    template<typename BidiIter> 
       ( lhs, 
                      sub_match<  rhs);
    template<typename BidiIter> 
       ( lhs, 
                      sub_match<  rhs);
    template<typename BidiIter> 
       (sub_match<  lhs, 
                       rhs);
    template<typename BidiIter> 
       (sub_match<  lhs, 
                       rhs);
    template<typename BidiIter> 
       (sub_match<  lhs, 
                      rhs);
    template<typename BidiIter> 
       (sub_match<  lhs, 
                      rhs);
    template<typename BidiIter> 
       (sub_match<  lhs, 
                       rhs);
    template<typename BidiIter> 
       (sub_match<  lhs, 
                       rhs);
    template<typename BidiIter> 
       ( lhs, 
                      sub_match<  rhs);
    template<typename BidiIter> 
       ( lhs, 
                      sub_match<  rhs);
    template<typename BidiIter> 
       ( lhs, 
                     sub_match<  rhs);
    template<typename BidiIter> 
       ( lhs, 
                     sub_match<  rhs);
    template<typename BidiIter> 
       ( lhs, 
                      sub_match<  rhs);
    template<typename BidiIter> 
       ( lhs, 
                      sub_match<  rhs);
    template<typename BidiIter> 
       (sub_match<  lhs, 
                       rhs);
    template<typename BidiIter> 
       (sub_match<  lhs, 
                       rhs);
    template<typename BidiIter> 
       (sub_match<  lhs, 
                      rhs);
    template<typename BidiIter> 
       (sub_match<  lhs, 
                      rhs);
    template<typename BidiIter> 
       (sub_match<  lhs, 
                       rhs);
    template<typename BidiIter> 
       (sub_match<  lhs, 
                       rhs);
    template<typename BidiIter> 
      sub_match<  
      (sub_match<  lhs, 
                sub_match<  rhs);
    template<typename BidiIter> 
      sub_match<  
      (sub_match<  lhs, 
                 rhs);
    template<typename BidiIter> 
      sub_match<  
      ( lhs, 
                sub_match<  rhs);
    template<typename BidiIter> 
      sub_match<  
      (sub_match<  lhs, 
                 rhs);
    template<typename BidiIter> 
      sub_match<  
      ( lhs, 
                sub_match<  rhs);
    template<typename BidiIter> 
      sub_match<  
      (sub_match<  lhs, 
                sub_match<  rhs);
    template<typename BidiIter> 
      sub_match<  
      (sub_match<  lhs, 
                sub_match<  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.


  
    template<typename Char> struct c_regex_traits;

    template<> struct has_fold_case<>;
  }
}

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.


  
    template<typename Char> struct cpp_regex_traits;

    template<> struct has_fold_case<>;
  }
}

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.


  
    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

  
    template<typename RegexTraits> struct compiler_traits;

    typedef  ;
    typedef basic_regex<  ;
    typedef basic_regex<  ;
    typedef basic_regex<  ;
    typedef basic_regex<  ;
    typedef sub_match<  ;
    typedef sub_match<  ;
    typedef sub_match<  ;
    typedef sub_match<  ;
    typedef regex_compiler<  ;
    typedef regex_compiler<  ;
    typedef regex_compiler<  ;
    typedef regex_compiler<  ;
    typedef regex_iterator<  ;
    typedef regex_iterator<  ;
    typedef regex_iterator<  ;
    typedef regex_iterator<  ;
    typedef regex_token_iterator<  ;
    typedef regex_token_iterator<  ;
    typedef regex_token_iterator<  ;
    typedef regex_token_iterator<  ;
    typedef match_results<  ;
    typedef match_results<  ;
    typedef match_results<  ;
    typedef match_results<  ;
    typedef regex_id_filter_predicate<  ;
    typedef regex_id_filter_predicate<  ;
    typedef regex_id_filter_predicate<  ;
    typedef regex_id_filter_predicate<  ;
    
    }
  }
}

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.


PrevUpHomeNext