| Home | Libraries | People | FAQ | More

## Struct template regex_token_iterator

boost::xpressive::regex_token_iterator

## Synopsis

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

    template<typename BidiIter>
    struct regex_token_iterator {
      // types
      typedef basic_regex< BidiIter >          regex_type;
      typedef iterator_value< BidiIter >::type char_type;
      typedef sub_match< BidiIter >            value_type;
      typedef std::ptrdiff_t                   difference_type;
      typedef value_type const *               pointer;
      typedef value_type const &               reference;
      typedef std::forward_iterator_tag        iterator_category;

      // construct/copy/destruct
      regex_token_iterator();
      regex_token_iterator(BidiIter, BidiIter, basic_regex< BidiIter > const &);
      template<typename LetExpr>
        regex_token_iterator(BidiIter, BidiIter, basic_regex< BidiIter > const &,
                             unspecified);
      template<typename Subs>
        regex_token_iterator(BidiIter, BidiIter, basic_regex< BidiIter > const &,
                             Subs const &,
                             regex_constants::match_flag_type = regex_constants::match_default);
      template<typename Subs, typename LetExpr>
        regex_token_iterator(BidiIter, BidiIter, basic_regex< BidiIter > const &,
                             Subs const &, unspecified,
                             regex_constants::match_flag_type = regex_constants::match_default);
      regex_token_iterator(regex_token_iterator< BidiIter > const &);
      regex_token_iterator< BidiIter > &
      operator=(regex_token_iterator< BidiIter > const &);

      // public member functions
      value_type const & operator*() const;
      value_type const * operator->() const;
      regex_token_iterator< BidiIter > & operator++();
      regex_token_iterator< BidiIter > operator++(int);
    };

## Description

### `regex_token_iterator` public construct/copy/destruct

1.     regex_token_iterator();

   Postconditions: | `*this` is the end of sequence iterator.

2.     regex_token_iterator(BidiIter begin, BidiIter end,
                            basic_regex< BidiIter > const & rex);

   Parameters: |
   `begin` | The beginning of the character range to search.
   `end` | The end of the character range to search.
   `rex` | The regex pattern to search for.
   Requires: | ``[begin,end) is a valid range.

3.     template<typename LetExpr>
         regex_token_iterator(BidiIter begin, BidiIter end,
                              basic_regex< BidiIter > const & rex, unspecified args);

   Parameters: |
   `args` | A let() expression with argument bindings for semantic actions.
   `begin` | The beginning of the character range to search.
   `end` | The end of the character range to search.
   `rex` | The regex pattern to search for.
   Requires: | ``[begin,end) is a valid range.

4.     template<typename Subs>
         regex_token_iterator(BidiIter begin, BidiIter end,
                              basic_regex< BidiIter > const & rex,
                              Subs const & subs,
                              regex_constants::match_flag_type flags = regex_constants::match_default);

   Parameters: |
   `begin` | The beginning of the character range to search.
   `end` | The end of the character range to search.
   `flags` | Optional match flags, used to control how the expression is matched against the sequence. (See match_flag_type.)
   `rex` | The regex pattern to search for.
   `subs` | A range of integers designating sub-matches to be treated as tokens.
   Requires: | ``[begin,end) is a valid range. `subs` is either an integer greater or equal to -1, or else an array or non-empty `std::vector<>` of such integers.

5.     template<typename Subs, typename LetExpr>
         regex_token_iterator(BidiIter begin, BidiIter end,
                              basic_regex< BidiIter > const & rex,
                              Subs const & subs, unspecified args,
                              regex_constants::match_flag_type flags = regex_constants::match_default);

   Parameters: |
   `args` | A let() expression with argument bindings for semantic actions.
   `begin` | The beginning of the character range to search.
   `end` | The end of the character range to search.
   `flags` | Optional match flags, used to control how the expression is matched against the sequence. (See match_flag_type.)
   `rex` | The regex pattern to search for.
   `subs` | A range of integers designating sub-matches to be treated as tokens.
   Requires: | ``[begin,end) is a valid range. `subs` is either an integer greater or equal to -1, or else an array or non-empty `std::vector<>` of such integers.

6.     regex_token_iterator(regex_token_iterator< BidiIter > const & that);

   Postconditions: | `*this == that`

7.     regex_token_iterator< BidiIter > &
       operator=(regex_token_iterator< BidiIter > const & that);

   Postconditions: | `*this == that`

### `regex_token_iterator` public member functions

1.     value_type const & operator*() const;

2.     value_type const * operator->() const;

3.     regex_token_iterator< BidiIter > & operator++();

   If N == -1 then sets *this equal to the end of sequence iterator. Otherwise if N+1 < subs.size(), then increments N and sets result equal to ((subs[N] == -1) ? value_type(what.prefix().str()) : value_type(what[subs[N]].str())). Otherwise if what.prefix().first != what[0].second and if the element match_prev_avail is not set in flags then sets it. Then locates the next match as if by calling regex_search(what[0].second, end, what, *pre, flags), with the following variation: in the event that the previous match found was of zero length (what[0].length() == 0) then attempts to find a non-zero length match starting at what[0].second, only if that fails and provided what[0].second != suffix().second does it look for a (possibly zero length) match starting from what[0].second + 1. If such a match is found then sets N equal to zero, and sets result equal to ((subs[N] == -1) ? value_type(what.prefix().str()) : value_type(what[subs[N]].str())). Otherwise if no further matches were found, then let last_end be the endpoint of the last match that was found. Then if last_end != end and subs[0] == -1 sets N equal to -1 and sets result equal to value_type(last_end, end). Otherwise sets *this equal to the end of sequence iterator.

4.     regex_token_iterator< BidiIter > operator++(int);