31 Regular expressions library [re]

31.12 Regular expression iterators [re.iter]

31.12.1 Class template regex_­iterator [re.regiter]

Шаблон класса regex_­iterator - это адаптер итератора. Он представляет новое представление существующей последовательности итератора, перечисляя все вхождения регулярного выражения в этой последовательности. A regex_­iterator использует regex_­search для поиска последовательных совпадений регулярных выражений в последовательности, из которой оно было построено. После того, как итератор построен и каждый раз operator++ используется, итератор находит и сохраняет значение match_­results<BidirectionalIterator>. Если достигается конец последовательности (regex_­search возвращается false), итератор становится равным значению итератора конца последовательности. Конструктор по умолчанию создает объект-итератор конца последовательности, который является единственным допустимым итератором, который можно использовать для конечного условия. Результат для operator* итератора конца последовательности не определен. Для любого другого значения итератораmatch_­results<BidirectionalIterator>& возвращается константа . Результат для operator-> итератора конца последовательности не определен. Для любого другого итератора const match_­results<BidirectionalIterator>* возвращается значение a . Нельзя хранить вещи в regex_­iterators. Два итератора конца последовательности всегда равны. Итератор конца последовательности не равен итератору конца последовательности. Два итератора без конца последовательности равны, если они построены из одних и тех же аргументов.

namespace std {
  template <class BidirectionalIterator,
            class charT = typename iterator_traits<BidirectionalIterator>::value_type,
            class traits = regex_traits<charT>>
    class regex_iterator {
    public:
      using regex_type        = basic_regex<charT, traits>;
      using iterator_category = forward_iterator_tag;
      using value_type        = match_results<BidirectionalIterator>;
      using difference_type   = ptrdiff_t;
      using pointer           = const value_type*;
      using reference         = const value_type&;

      regex_iterator();
      regex_iterator(BidirectionalIterator a, BidirectionalIterator b,
                     const regex_type& re,
                     regex_constants::match_flag_type m = regex_constants::match_default);
      regex_iterator(BidirectionalIterator, BidirectionalIterator,
                     const regex_type&&,
                     regex_constants::match_flag_type = regex_constants::match_default) = delete;
      regex_iterator(const regex_iterator&);
      regex_iterator& operator=(const regex_iterator&);
      bool operator==(const regex_iterator&) const;
      bool operator!=(const regex_iterator&) const;
      const value_type& operator*() const;
      const value_type* operator->() const;
      regex_iterator& operator++();
      regex_iterator operator++(int);

    private:
      BidirectionalIterator                begin;  // exposition only
      BidirectionalIterator                end;    // exposition only
      const regex_type*                    pregex; // exposition only
      regex_constants::match_flag_type     flags;  // exposition only
      match_results<BidirectionalIterator> match;  // exposition only
    };
}

Объект типа, regex_­iterator который не является итератором конца последовательности, содержит zero-length match if match[0].matched == true и match[0].first == match[0].second. [ Note: Например, это может произойти , когда часть регулярного выражения , которые соответствовали состоит только из утверждения (например '^', '$', '\b', '\B'). ] end note

31.12.1.1 regex_­iterator constructors [re.regiter.cnstr]

regex_iterator();

Effects: Создает итератор конца последовательности.

regex_iterator(BidirectionalIterator a, BidirectionalIterator b, const regex_type& re, regex_constants::match_flag_type m = regex_constants::match_default);

Effects: Инициализация begin и end к a и b, соответственно, наборы pregex к &re, наборы flags для m, а затем вызывает regex_­search(begin, end, match, *pregex, flags). Если этот вызов возвращает false конструктор, он устанавливает *this итератор конца последовательности.

31.12.1.2 regex_­iterator comparisons [re.regiter.comp]

bool operator==(const regex_iterator& right) const;

Returns: true если *this и right являются итераторами конца последовательности, или если выполняются все следующие условия:

  • begin == right.begin,

  • end == right.end,

  • pregex == right.pregex,

  • flags == right.flags, а также

  • match[0] == right.match[0];

иначе false.

bool operator!=(const regex_iterator& right) const;

Returns: !(*this == right).

31.12.1.3 regex_­iterator indirection [re.regiter.deref]

const value_type& operator*() const;

Returns: match.

const value_type* operator->() const;

Returns: &match.

31.12.1.4 regex_­iterator increment [re.regiter.incr]

regex_iterator& operator++();

Effects: Создает локальную переменную start типа BidirectionalIterator и инициализирует ее значением match[0].second.

Если итератор содержит совпадение нулевой длины, а start == end оператор устанавливает *this итератор конца последовательности и возвращается *this.

В противном случае, если итератор содержит совпадение нулевой длины, оператор вызывает:

regex_search(start, end, match, *pregex,
             flags | regex_constants::match_not_null | regex_constants::match_continuous)

Если вызов вернул, true оператор вернется *this. В противном случае оператор увеличивает start и продолжает работу, как если бы последнее совпадение не было совпадением нулевой длины.

Если самый последний матч не был матч нулевой длины, оператор устанавливает flags на flags | regex_­constants​::​match_­prev_­avail и вызовы regex_­search(start, end, match, *pregex, flags). Если вызов возвращает false набор итераторов в итератор *this конца последовательности. Затем итератор возвращается *this.

Во всех случаях, когда вызов regex_­search возвращается true, match.prefix().first должно быть равно предыдущему значению match[0].second, и для каждого индекса i в полуоткрытом диапазоне, [0, match.size()) для которого match[i].matched есть true, match.position(i) должно возвращаться distance(begin, match[i].​first).

[ Note: Это означает, что это match.position(i) дает смещение от начала целевой последовательности, которое часто не совпадает с смещением от последовательности, переданной в вызове regex_­search. ] end note

Не указано, как реализация вносит эти корректировки.

[ Note: Это означает, что компилятор может вызвать функцию поиска, зависящую от реализации, и в этом случае определенная пользователем специализация regex_­search не будет вызываться. ] end note

regex_iterator operator++(int);

Effects: Как будто по:

regex_iterator tmp = *this;
++(*this);
return tmp;